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