375 行
11 KiB
Rust
375 行
11 KiB
Rust
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<AppState>) -> 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<Arc<AppState>>) -> Json<HealthResponse> {
|
|
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<Arc<AppState>>) -> Json<ServerInfo> {
|
|
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<Arc<AppState>>) -> Json<ServerCapabilities> {
|
|
Json(state.capabilities.clone())
|
|
}
|
|
|
|
async fn auth_login(
|
|
State(state): State<Arc<AppState>>,
|
|
Json(request): Json<AuthLoginRequest>,
|
|
) -> 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<Arc<AppState>>,
|
|
Json(request): Json<AuthRefreshRequest>,
|
|
) -> 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<Arc<AppState>>,
|
|
headers: HeaderMap,
|
|
Json(request): Json<SendMessageRequest>,
|
|
) -> 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<Arc<AppState>>, 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, Infallible>(Event::default().comment("connected"));
|
|
for event in replay {
|
|
if let Some(frame) = to_sse_event(&event) {
|
|
yield Ok::<Event, Infallible>(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::<Event, Infallible>(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<Arc<AppState>>,
|
|
headers: HeaderMap,
|
|
Path(event_id): Path<String>,
|
|
) -> 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<Arc<AppState>>,
|
|
headers: HeaderMap,
|
|
Path(action_id): Path<String>,
|
|
Json(decision): Json<LocalActionDecision>,
|
|
) -> Response {
|
|
validate_decision(
|
|
&state,
|
|
&headers,
|
|
&action_id,
|
|
&decision,
|
|
LocalActionDecisionKind::Accepted,
|
|
)
|
|
.await
|
|
}
|
|
|
|
async fn local_action_rejected(
|
|
State(state): State<Arc<AppState>>,
|
|
headers: HeaderMap,
|
|
Path(action_id): Path<String>,
|
|
Json(decision): Json<LocalActionDecision>,
|
|
) -> 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<Arc<AppState>>,
|
|
headers: HeaderMap,
|
|
Path(action_id): Path<String>,
|
|
Json(progress): Json<LocalActionProgress>,
|
|
) -> 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<Arc<AppState>>,
|
|
headers: HeaderMap,
|
|
Path(action_id): Path<String>,
|
|
Json(result): Json<ToolResult>,
|
|
) -> 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<Event> {
|
|
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()
|
|
}
|