use std::{convert::Infallible, sync::Arc, time::Duration}; use axum::{ Json, Router, extract::{Path, State}, http::{HeaderMap, StatusCode, header::AUTHORIZATION}, response::{ IntoResponse, Response, Sse, sse::{Event, KeepAlive}, }, routing::{get, post}, }; use desktop_protocol::{ AuthLoginRequest, AuthLoginResponse, AuthRefreshRequest, EventAcknowledgement, FinishReason, GatewayErrorResponse, GatewayEvent, GatewayEventBody, HealthResponse, LocalActionDecision, LocalActionDecisionKind, LocalActionProgress, MessageCompletedPayload, MessageDeltaPayload, PROTOCOL_VERSION, SendMessageRequest, ServerCapabilities, ServerInfo, ToolResult, }; use tokio::sync::broadcast::error::RecvError; use crate::state::{AppState, FIXED_TIMESTAMP}; pub(crate) fn router(state: Arc) -> Router { Router::new() .route("/desktop/v1/health", get(health)) .route("/desktop/v1/server-info", get(server_info)) .route("/desktop/v1/capabilities", get(capabilities)) .route("/desktop/v1/auth/login", post(auth_login)) .route("/desktop/v1/auth/refresh", post(auth_refresh)) .route("/desktop/v1/messages", post(send_message)) .route("/desktop/v1/events/stream", get(event_stream)) .route("/desktop/v1/events/{event_id}/ack", post(acknowledge_event)) .route( "/desktop/v1/local-actions/{action_id}/accepted", post(local_action_accepted), ) .route( "/desktop/v1/local-actions/{action_id}/rejected", post(local_action_rejected), ) .route( "/desktop/v1/local-actions/{action_id}/progress", post(local_action_progress), ) .route( "/desktop/v1/local-actions/{action_id}/result", post(local_action_result), ) .with_state(state) } async fn health(State(state): State>) -> Json { Json(HealthResponse { status: "ok".to_owned(), protocol_version: PROTOCOL_VERSION.to_owned(), server_instance_id: state.server_instance_id.clone(), }) } async fn server_info(State(state): State>) -> Json { Json(ServerInfo { server_instance_id: state.server_instance_id.clone(), display_name: state.display_name.clone(), server_version: "0.1.0-mock".to_owned(), protocol_version: PROTOCOL_VERSION.to_owned(), server_time: FIXED_TIMESTAMP.to_owned(), }) } async fn capabilities(State(state): State>) -> Json { Json(state.capabilities.clone()) } async fn auth_login( State(state): State>, Json(request): Json, ) -> Response { if state.auth_is_rejected() || request.client_id.trim().is_empty() || request.device_id.trim().is_empty() || request.credential.trim().is_empty() { return error_response( StatusCode::UNAUTHORIZED, "auth_rejected", "mock authentication rejected", false, ); } let (access_token, refresh_token) = state.issue_tokens().await; Json(AuthLoginResponse { access_token, refresh_token: Some(refresh_token), expires_in_seconds: 300, }) .into_response() } async fn auth_refresh( State(state): State>, Json(request): Json, ) -> Response { let Some((access_token, refresh_token)) = state.refresh_tokens(&request.refresh_token).await else { return error_response( StatusCode::UNAUTHORIZED, "refresh_rejected", "mock refresh rejected", false, ); }; Json(AuthLoginResponse { access_token, refresh_token: Some(refresh_token), expires_in_seconds: 300, }) .into_response() } async fn send_message( State(state): State>, headers: HeaderMap, Json(request): Json, ) -> Response { if let Err(response) = require_auth(&state, &headers).await { return response; } if request.conversation_id.trim().is_empty() || request.content.trim().is_empty() { return error_response( StatusCode::BAD_REQUEST, "invalid_message", "conversationId and content are required", false, ); } let accepted = state.accept_message(); let reply = match state.instance { crate::MockInstanceKind::Companion => "Deterministic companion response", crate::MockInstanceKind::Operations => "Deterministic operations response", }; let delta = state.create_event( GatewayEventBody::MessageDelta(MessageDeltaPayload { delta: reply.to_owned(), index: 0, }), Some(accepted.request_id.clone()), Some(request.conversation_id.clone()), Some(accepted.message_id.clone()), ); state.publish(delta).await; let completed = state.create_event( GatewayEventBody::MessageCompleted(MessageCompletedPayload { finish_reason: FinishReason::Stop, content: Some(reply.to_owned()), }), Some(accepted.request_id.clone()), Some(request.conversation_id), Some(accepted.message_id.clone()), ); state.publish(completed).await; (StatusCode::ACCEPTED, Json(accepted)).into_response() } async fn event_stream(State(state): State>, headers: HeaderMap) -> Response { if let Err(response) = require_auth(&state, &headers).await { return response; } let last_event_id = headers .get("last-event-id") .and_then(|value| value.to_str().ok()) .map(str::to_owned); let mut events = state.subscribe_events(); let mut disconnects = state.subscribe_disconnects(); let replay = state.events_after(last_event_id.as_deref()).await; let stream = async_stream::stream! { yield Ok::(Event::default().comment("connected")); for event in replay { if let Some(frame) = to_sse_event(&event) { yield Ok::(frame); } } loop { tokio::select! { result = disconnects.changed() => { if result.is_ok() { break; } } result = events.recv() => { match result { Ok(event) => { if let Some(frame) = to_sse_event(&event) { yield Ok::(frame); } } Err(RecvError::Lagged(_)) => continue, Err(RecvError::Closed) => break, } } } } }; Sse::new(stream) .keep_alive( KeepAlive::new() .interval(Duration::from_secs(15)) .text("keep-alive"), ) .into_response() } async fn acknowledge_event( State(state): State>, headers: HeaderMap, Path(event_id): Path, ) -> Response { if let Err(response) = require_auth(&state, &headers).await { return response; } if event_id.trim().is_empty() { return error_response( StatusCode::BAD_REQUEST, "invalid_event_id", "event id is required", false, ); } state.acknowledge(event_id.clone()).await; Json(EventAcknowledgement { event_id, acknowledged: true, }) .into_response() } async fn local_action_accepted( State(state): State>, headers: HeaderMap, Path(action_id): Path, Json(decision): Json, ) -> Response { validate_decision( &state, &headers, &action_id, &decision, LocalActionDecisionKind::Accepted, ) .await } async fn local_action_rejected( State(state): State>, headers: HeaderMap, Path(action_id): Path, Json(decision): Json, ) -> Response { validate_decision( &state, &headers, &action_id, &decision, LocalActionDecisionKind::Rejected, ) .await } async fn validate_decision( state: &AppState, headers: &HeaderMap, action_id: &str, decision: &LocalActionDecision, expected: LocalActionDecisionKind, ) -> Response { if let Err(response) = require_auth(state, headers).await { return response; } if decision.action_id != action_id || decision.decision != expected { return error_response( StatusCode::BAD_REQUEST, "invalid_action_decision", "path and decision payload do not match", false, ); } StatusCode::NO_CONTENT.into_response() } async fn local_action_progress( State(state): State>, headers: HeaderMap, Path(action_id): Path, Json(progress): Json, ) -> Response { if let Err(response) = require_auth(&state, &headers).await { return response; } if progress.action_id != action_id { return error_response( StatusCode::BAD_REQUEST, "invalid_action_progress", "path and progress payload do not match", false, ); } StatusCode::NO_CONTENT.into_response() } async fn local_action_result( State(state): State>, headers: HeaderMap, Path(action_id): Path, Json(result): Json, ) -> Response { if let Err(response) = require_auth(&state, &headers).await { return response; } if result.action_id != action_id { return error_response( StatusCode::BAD_REQUEST, "invalid_action_result", "path and result payload do not match", false, ); } StatusCode::NO_CONTENT.into_response() } async fn require_auth(state: &AppState, headers: &HeaderMap) -> Result<(), Response> { let token = headers .get(AUTHORIZATION) .and_then(|value| value.to_str().ok()) .and_then(|value| value.strip_prefix("Bearer ")) .map(str::to_owned); if state.is_authorized(token.as_deref()).await { Ok(()) } else { Err(error_response( StatusCode::UNAUTHORIZED, "unauthorized", "valid bearer authentication is required", false, )) } } fn to_sse_event(event: &GatewayEvent) -> Option { let data = serde_json::to_string(event).ok()?; Some( Event::default() .id(event.metadata.event_id.clone()) .event(event.event_type()) .data(data), ) } fn error_response(status: StatusCode, code: &str, message: &str, retryable: bool) -> Response { ( status, Json(GatewayErrorResponse { code: code.to_owned(), message: message.to_owned(), retryable, }), ) .into_response() }