use std::path::PathBuf;
use std::sync::Arc;
use clap::Subcommand;
use crate::config::Bundle;
use crate::error::{Result, ServerError};
use crate::mcp::serve_mcp;
use crate::pipeline::Pipeline;
use crate::policy::PolicyEngine;
use crate::proxy::build_proxy_router;
use crate::server::build_router;
const PUBLIC_KEY_ENV: &str = "KEYZERO_PUBLIC_KEY_PATH";
#[derive(Debug, Subcommand)]
pub enum ServerCommand {
Start {
#[arg(long)]
bundle: PathBuf,
#[arg(long, default_value = "0.0.0.0:8080")]
listen: String,
#[arg(long, conflicts_with = "proxy")]
mcp: bool,
#[arg(long, conflicts_with = "mcp")]
proxy: bool,
},
Check {
#[arg(long)]
bundle: PathBuf,
},
}
pub async fn run(cmd: ServerCommand) -> Result<()> {
match cmd {
ServerCommand::Start {
bundle,
listen,
mcp,
proxy,
} => start(bundle, listen, mcp, proxy).await,
ServerCommand::Check { bundle } => check(bundle),
}
}
async fn start(bundle_path: PathBuf, listen: String, mcp: bool, proxy: bool) -> Result<()> {
let bundle = Bundle::load(&bundle_path)?;
if mcp {
let pipeline = Pipeline::new(bundle).await?;
serve_mcp(Arc::new(pipeline)).await?;
} else if proxy {
let public_key_path = std::env::var(PUBLIC_KEY_ENV).map_err(|_| {
ServerError::Config(format!(
"{PUBLIC_KEY_ENV} must be set for proxy mode"
))
})?;
let public_key_pem = std::fs::read_to_string(&public_key_path).map_err(|e| {
ServerError::Config(format!(
"cannot read public key at '{public_key_path}': {e}"
))
})?;
let pipeline = Pipeline::new(bundle.clone()).await?;
let resolvers = pipeline.into_resolvers();
let router = build_proxy_router(bundle, &public_key_pem, resolvers)?;
tracing::info!("proxy listening on {listen}");
let listener = tokio::net::TcpListener::bind(&listen).await.map_err(|e| {
ServerError::Config(format!("cannot bind to {listen}: {e}"))
})?;
axum::serve(listener, router).await?;
} else {
let router = build_router(bundle).await?;
tracing::info!("server listening on {listen}");
let listener = tokio::net::TcpListener::bind(&listen).await.map_err(|e| {
ServerError::Config(format!("cannot bind to {listen}: {e}"))
})?;
axum::serve(listener, router).await?;
}
Ok(())
}
fn check(bundle_path: PathBuf) -> Result<()> {
let bundle = Bundle::load(&bundle_path)?;
let _engine = PolicyEngine::new(&bundle.policies)?;
println!(
" {} policies compiled successfully",
bundle.policies.len()
);
let mut errors = Vec::new();
for resource in &bundle.resources {
if !bundle.backends.contains_key(&resource.resolver) {
errors.push(format!(
"resource '{}' references unknown backend '{}'",
resource.ref_pattern, resource.resolver
));
}
}
if errors.is_empty() {
println!(
" {} resources validated ({} backends)",
bundle.resources.len(),
bundle.backends.len()
);
println!("bundle OK");
Ok(())
} else {
for err in &errors {
eprintln!(" error: {err}");
}
Err(ServerError::Config(format!(
"bundle validation failed with {} error(s)",
errors.len()
)))
}
}