kz-server 0.1.0

JWT verification, CEL policies, and HTTP/MCP server for keyzero
Documentation
use crate::config::Bundle;
use crate::error::AgentError;
use crate::pipeline::{Pipeline, ResolveRequest};
use axum::extract::State;
use axum::http::{HeaderMap, StatusCode};
use axum::response::IntoResponse;
use axum::routing::{get, post};
use axum::{Json, Router};
use serde_json::json;
use std::sync::Arc;

struct AppState {
    pipeline: Pipeline,
    bundle_version: String,
}

/// Build an axum Router with /healthz and /v1/resolve routes.
pub async fn build_router(bundle: Bundle) -> crate::error::Result<Router> {
    let bundle_version = bundle.version.clone();
    let pipeline = Pipeline::new(bundle).await?;
    let state = Arc::new(AppState {
        pipeline,
        bundle_version,
    });
    let app = Router::new()
        .route("/healthz", get(healthz))
        .route("/v1/resolve", post(resolve))
        .with_state(state);
    Ok(app)
}

async fn healthz(State(state): State<Arc<AppState>>) -> impl IntoResponse {
    (
        StatusCode::OK,
        Json(json!({
            "status": "ok",
            "bundle_loaded": true,
            "bundle_version": state.bundle_version
        })),
    )
}

async fn resolve(
    State(state): State<Arc<AppState>>,
    headers: HeaderMap,
    Json(request): Json<ResolveRequest>,
) -> impl IntoResponse {
    // Extract Bearer token from Authorization header
    let token = match extract_bearer_token(&headers) {
        Some(t) => t,
        None => {
            return (
                StatusCode::UNAUTHORIZED,
                Json(json!({
                    "error": "invalid_token",
                    "message": "Missing or malformed Authorization header. Expected: Bearer <token>"
                })),
            );
        }
    };

    match state.pipeline.resolve(&token, &request).await {
        Ok(response) => {
            if response.allowed {
                (
                    StatusCode::OK,
                    Json(serde_json::to_value(response).unwrap()),
                )
            } else {
                (
                    StatusCode::FORBIDDEN,
                    Json(serde_json::to_value(response).unwrap()),
                )
            }
        }
        Err(AgentError::UnknownResource(resource)) => (
            StatusCode::NOT_FOUND,
            Json(json!({
                "error": "unknown_resource",
                "message": format!("Resource not found: {resource}")
            })),
        ),
        Err(AgentError::JwtVerification(ref msg)) => {
            tracing::warn!(error = %msg, "JWT verification failed");
            (
                StatusCode::UNAUTHORIZED,
                Json(json!({
                    "error": "invalid_token",
                    "message": "authentication failed"
                })),
            )
        }
        Err(AgentError::Jwt(ref e)) => {
            tracing::warn!(error = %e, "JWT decode error");
            (
                StatusCode::UNAUTHORIZED,
                Json(json!({
                    "error": "invalid_token",
                    "message": "authentication failed"
                })),
            )
        }
        Err(e) => {
            tracing::error!(error = %e, "internal error during resolve");
            (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(json!({
                    "error": "internal_error",
                    "message": "an internal error occurred"
                })),
            )
        }
    }
}

fn extract_bearer_token(headers: &HeaderMap) -> Option<String> {
    let auth_header = headers.get("authorization")?.to_str().ok()?;
    let token = auth_header.strip_prefix("Bearer ")?;
    if token.is_empty() {
        return None;
    }
    Some(token.to_string())
}