use std::{ collections::{HashSet, VecDeque}, sync::atomic::{AtomicU8, AtomicU64, Ordering}, }; use desktop_protocol::{ AcceptedMessage, CapabilityLimits, EventMetadata, GatewayEvent, GatewayEventBody, PROTOCOL_VERSION, ServerCapabilities, }; use tokio::sync::{Mutex, RwLock, broadcast, watch}; use uuid::Uuid; use crate::{AuthMode, MockGatewayConfig, MockInstanceKind, MockScenario}; pub(crate) const FIXED_TIMESTAMP: &str = "2030-01-01T00:00:00Z"; struct SessionTokens { access: String, refresh: String, } pub(crate) struct AppState { pub(crate) instance: MockInstanceKind, pub(crate) server_instance_id: String, pub(crate) display_name: String, pub(crate) capabilities: ServerCapabilities, replay_capacity: usize, sequence: AtomicU64, request_sequence: AtomicU64, auth_mode: AtomicU8, tokens: RwLock>, event_sender: broadcast::Sender, disconnect_sender: watch::Sender, replay_buffer: Mutex>, acknowledged_event_ids: Mutex>, } impl AppState { pub(crate) fn new(config: &MockGatewayConfig) -> Self { let (event_sender, _) = broadcast::channel(config.replay_capacity.max(16)); let (disconnect_sender, _) = watch::channel(0_u64); let initial_auth_mode = if config.scenario == MockScenario::AuthReject { AuthMode::Reject } else { AuthMode::Accept }; Self { instance: config.instance, server_instance_id: config.instance.server_instance_id(), display_name: config.instance.display_name().to_owned(), capabilities: capabilities_for(config.instance), replay_capacity: config.replay_capacity.max(1), sequence: AtomicU64::new(0), request_sequence: AtomicU64::new(0), auth_mode: AtomicU8::new(auth_mode_value(initial_auth_mode)), tokens: RwLock::new(None), event_sender, disconnect_sender, replay_buffer: Mutex::new(VecDeque::with_capacity(config.replay_capacity.max(1))), acknowledged_event_ids: Mutex::new(HashSet::new()), } } pub(crate) fn set_auth_mode(&self, mode: AuthMode) { self.auth_mode .store(auth_mode_value(mode), Ordering::Release); } pub(crate) fn auth_is_rejected(&self) -> bool { self.auth_mode.load(Ordering::Acquire) == auth_mode_value(AuthMode::Reject) } pub(crate) async fn issue_tokens(&self) -> (String, String) { let tokens = SessionTokens { access: format!("mock-session-{}", Uuid::new_v4()), refresh: format!("mock-refresh-{}", Uuid::new_v4()), }; let response = (tokens.access.clone(), tokens.refresh.clone()); *self.tokens.write().await = Some(tokens); response } pub(crate) async fn refresh_tokens(&self, presented_refresh: &str) -> Option<(String, String)> { let matches = self .tokens .read() .await .as_ref() .is_some_and(|tokens| tokens.refresh == presented_refresh); if matches && !self.auth_is_rejected() { Some(self.issue_tokens().await) } else { None } } pub(crate) async fn is_authorized(&self, presented_access: Option<&str>) -> bool { if self.auth_is_rejected() { return false; } let Some(presented_access) = presented_access else { return false; }; self.tokens .read() .await .as_ref() .is_some_and(|tokens| tokens.access == presented_access) } pub(crate) fn create_event( &self, body: GatewayEventBody, request_id: Option, conversation_id: Option, message_id: Option, ) -> GatewayEvent { let sequence = self.sequence.fetch_add(1, Ordering::Relaxed) + 1; let mut metadata = EventMetadata::new( format!("{}-event-{sequence:06}", self.instance.slug()), self.server_instance_id.clone(), FIXED_TIMESTAMP, sequence, ); metadata.request_id = request_id; metadata.conversation_id = conversation_id; metadata.message_id = message_id; GatewayEvent::new(metadata, body) } pub(crate) async fn publish(&self, event: GatewayEvent) { let mut replay = self.replay_buffer.lock().await; replay.push_back(event.clone()); while replay.len() > self.replay_capacity { replay.pop_front(); } drop(replay); let _ = self.event_sender.send(event); } pub(crate) fn broadcast_duplicate(&self, event: &GatewayEvent) { let _ = self.event_sender.send(event.clone()); } pub(crate) async fn replay_event(&self, event_id: &str) -> bool { let event = self .replay_buffer .lock() .await .iter() .find(|event| event.metadata.event_id == event_id) .cloned(); if let Some(event) = event { self.broadcast_duplicate(&event); true } else { false } } pub(crate) async fn events_after(&self, last_event_id: Option<&str>) -> Vec { let Some(last_event_id) = last_event_id else { return Vec::new(); }; let replay = self.replay_buffer.lock().await; let Some(index) = replay .iter() .position(|event| event.metadata.event_id == last_event_id) else { return Vec::new(); }; replay.iter().skip(index + 1).cloned().collect() } pub(crate) fn subscribe_events(&self) -> broadcast::Receiver { self.event_sender.subscribe() } pub(crate) fn subscribe_disconnects(&self) -> watch::Receiver { self.disconnect_sender.subscribe() } pub(crate) fn disconnect_streams(&self) { let next = self.disconnect_sender.borrow().wrapping_add(1); let _ = self.disconnect_sender.send(next); } pub(crate) async fn acknowledge(&self, event_id: String) { self.acknowledged_event_ids.lock().await.insert(event_id); } pub(crate) async fn acknowledged_event_ids(&self) -> Vec { let mut values: Vec<_> = self .acknowledged_event_ids .lock() .await .iter() .cloned() .collect(); values.sort(); values } pub(crate) fn accept_message(&self) -> AcceptedMessage { let sequence = self.request_sequence.fetch_add(1, Ordering::Relaxed) + 1; AcceptedMessage { request_id: format!("{}-request-{sequence:06}", self.instance.slug()), message_id: format!("{}-message-{sequence:06}", self.instance.slug()), accepted_at: FIXED_TIMESTAMP.to_owned(), } } } fn auth_mode_value(mode: AuthMode) -> u8 { match mode { AuthMode::Accept => 0, AuthMode::Reject => 1, } } fn capabilities_for(instance: MockInstanceKind) -> ServerCapabilities { let mut features = vec![ "auth.refresh".to_owned(), "chat.text".to_owned(), "events.ack".to_owned(), "events.sse".to_owned(), ]; let local_action_tools = match instance { MockInstanceKind::Companion => { features.push("messages.proactive".to_owned()); Vec::new() } MockInstanceKind::Operations => { features.push("local-actions.proposals".to_owned()); features.push("diagnostics.readonly".to_owned()); vec!["query_recent_event_logs".to_owned()] } }; ServerCapabilities { protocol_versions: vec![PROTOCOL_VERSION.to_owned()], features, local_action_tools, limits: CapabilityLimits { max_event_bytes: 262_144, max_message_bytes: 65_536, replay_window_events: 256, max_active_connections: 2, }, } }