kz-server 0.3.0

JWT verification, CEL policies, and HTTP/MCP server for keyzero
Documentation
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";

// ---------------------------------------------------------------------------
// CLI types
// ---------------------------------------------------------------------------

#[derive(Debug, Subcommand)]
pub enum ServerCommand {
    /// Start the keyzero server (HTTP, MCP, or proxy mode)
    Start {
        /// Path to the bundle YAML file
        #[arg(long)]
        bundle: PathBuf,
        /// Listen address (host:port)
        #[arg(long, default_value = "0.0.0.0:8080")]
        listen: String,
        /// Run as MCP server over stdio
        #[arg(long, conflicts_with = "proxy")]
        mcp: bool,
        /// Run as credential-swapping proxy
        #[arg(long, conflicts_with = "mcp")]
        proxy: bool,
    },
    /// Validate a bundle file (compile policies, check resolver references)
    Check {
        /// Path to the bundle YAML file
        #[arg(long)]
        bundle: PathBuf,
    },
}

// ---------------------------------------------------------------------------
// Dispatch
// ---------------------------------------------------------------------------

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),
    }
}

// ---------------------------------------------------------------------------
// start
// ---------------------------------------------------------------------------

async fn start(bundle_path: PathBuf, listen: String, mcp: bool, proxy: bool) -> Result<()> {
    let bundle = Bundle::load(&bundle_path)?;

    if mcp {
        // MCP mode: stdio transport
        let pipeline = Pipeline::new(bundle).await?;
        serve_mcp(Arc::new(pipeline)).await?;
    } else if proxy {
        // Proxy mode: credential-swapping reverse 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 {
        // Default HTTP mode
        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(())
}

// ---------------------------------------------------------------------------
// check
// ---------------------------------------------------------------------------

fn check(bundle_path: PathBuf) -> Result<()> {
    let bundle = Bundle::load(&bundle_path)?;

    // 1. Compile all CEL policies
    let _engine = PolicyEngine::new(&bundle.policies)?;
    println!(
        "  {} policies compiled successfully",
        bundle.policies.len()
    );

    // 2. Verify each resource's resolver references a known backend
    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()
        )))
    }
}