use std::fs::OpenOptions;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use mcp_host::prelude::*;
use mcp_host::registry::router::{McpResourceTemplateRouter, McpRouter};
use mcp_host::transport::http::{HttpBearerAuthConfig, HttpTransport, HttpTransportConfig};
use crate::error;
use crate::error::Result;
mod elicit;
mod prompts;
mod resources;
mod tools;
pub struct McpState {
config_path: PathBuf,
}
impl McpState {
fn router() -> std::result::Result<McpRouter<Self>, AppsError> {
Ok(McpRouter::new(
tools::router(),
prompts::router(),
resources::router()?,
McpResourceTemplateRouter::new(),
))
}
}
const INSTRUCTIONS: &str = "Authors and validates blackship jail configuration \
(blackship.toml manifests, Jailfiles) for this FreeBSD host. \
`blackship:///host` is ground truth: FreeBSD version, CPU, memory and what \
jails already claim, disk, networks and free addresses, releases. \
Schemas: `blackship:///schema/{manifest,jailfile}`. \
Writes require operator approval via elicitation; a declined write is final.";
const LOCAL_INSTRUCTIONS: &str = " CLI: `blackship:///man`.";
const LOCAL_ONLY_RESOURCES: [&str; 2] = ["blackship:///man", "blackship:///man.kdl"];
const HTTP_ENDPOINT: &str = "/mcp";
const HTTP_PRINCIPAL: &str = "operator";
pub enum Transport {
Stdio,
Http {
addr: std::net::SocketAddr,
token: Option<String>,
},
}
impl Transport {
pub fn http(addr: &str, token: Option<String>) -> Result<Self> {
let addr: std::net::SocketAddr = addr.parse().map_err(|e| {
error::Error::InvalidArgument(format!(
"--listen expects an address and port such as 127.0.0.1:7340: {e}"
))
})?;
let token = token.filter(|t| !t.is_empty());
if !addr.ip().is_loopback() && token.is_none() {
return Err(error::Error::InvalidArgument(format!(
"refusing to serve MCP on {addr} without authentication: set BLACKSHIP_MCP_TOKEN"
)));
}
Ok(Self::Http { addr, token })
}
}
pub async fn serve(config_path: &Path, transport: Transport) -> Result<()> {
init_logging();
let state = Arc::new(McpState {
config_path: config_path.to_path_buf(),
});
let local = matches!(transport, Transport::Stdio);
let instructions = if local {
format!("{INSTRUCTIONS}{LOCAL_INSTRUCTIONS}")
} else {
INSTRUCTIONS.to_string()
};
let server = Server::builder("blackship", env!("CARGO_PKG_VERSION"))
.with_instructions(instructions)
.with_tools(true)
.with_prompts(true)
.with_resources(true, false)
.build();
let router = McpState::router()
.map_err(|e| error::Error::User(format!("MCP resource registration failed: {e}")))?;
server
.register_router(router, state)
.map_err(|e| error::Error::User(format!("MCP route registration failed: {e}")))?;
if !local {
for uri in LOCAL_ONLY_RESOURCES {
server.resource_manager().remove(uri);
}
}
tracing::info!(
tools = server.tool_registry().list().len(),
resources = server.resource_manager().list().len(),
"blackship MCP server starting"
);
match transport {
Transport::Stdio => server
.run(StdioTransport::new())
.await
.map_err(|e| error::Error::User(format!("MCP server failed: {e}"))),
Transport::Http { addr, token } => serve_http(server, addr, token).await,
}
}
async fn serve_http(
server: Server,
addr: std::net::SocketAddr,
token: Option<String>,
) -> Result<()> {
let bearer_auth = token
.map(|token| HttpBearerAuthConfig::new(token, HTTP_PRINCIPAL))
.transpose()
.map_err(|e| error::Error::InvalidArgument(format!("BLACKSHIP_MCP_TOKEN: {e}")))?
.map(Into::into);
let authenticated = bearer_auth.is_some();
let config = HttpTransportConfig {
bind_addr: addr.to_string(),
endpoint: HTTP_ENDPOINT.to_string(),
localhost_only: addr.ip().is_loopback(),
bearer_auth,
..Default::default()
};
eprintln!(
"blackship MCP listening on http://{addr}{HTTP_ENDPOINT}{}",
if authenticated {
" (bearer token required)"
} else {
""
}
);
tracing::info!(%addr, authenticated, "blackship MCP serving HTTP");
HttpTransport::new(server, config)
.run()
.await
.map_err(|e| error::Error::User(format!("MCP HTTP server failed: {e}")))
}
fn init_logging() {
let dir = crate::manifest::get_xdg_data_dir();
if std::fs::create_dir_all(&dir).is_err() {
return;
}
let Ok(file) = OpenOptions::new()
.create(true)
.append(true)
.open(dir.join("mcp.log"))
else {
return;
};
let filter = tracing_subscriber::EnvFilter::try_from_default_env()
.unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info"));
let _ = tracing_subscriber::fmt()
.with_writer(file)
.with_ansi(false)
.with_env_filter(filter)
.try_init();
}
#[cfg(test)]
mod tests;