kz-server 0.3.0

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

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

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

async fn healthz(State(state): State<Arc<AppState>>) -> impl IntoResponse {
    Json(serde_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>,
) -> Response {
    let token = match extract_bearer_token(&headers) {
        Some(t) => t,
        None => {
            return (
                StatusCode::UNAUTHORIZED,
                Json(serde_json::json!({"error": "missing or invalid authorization header"})),
            )
                .into_response()
        }
    };
    match state.pipeline.resolve(&token, &request).await {
        Ok(response) => (
            StatusCode::OK,
            Json(serde_json::to_value(response).unwrap()),
        )
            .into_response(),
        Err(ServerError::Jwt(msg)) => (
            StatusCode::UNAUTHORIZED,
            Json(serde_json::json!({"error": "invalid_token", "message": msg})),
        )
            .into_response(),
        Err(ServerError::UnknownRef(r)) => (
            StatusCode::NOT_FOUND,
            Json(serde_json::json!({"error": "unknown_ref", "ref": r})),
        )
            .into_response(),
        Err(ServerError::PathTraversal(p)) => (
            StatusCode::BAD_REQUEST,
            Json(serde_json::json!({"error": "invalid_ref", "ref": p})),
        )
            .into_response(),
        Err(e) => {
            tracing::error!(error = %e, "internal error during resolve");
            (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(serde_json::json!({"error": "internal_error"})),
            )
                .into_response()
        }
    }
}