use desktop_protocol::{ AstrBotAttachment, AstrBotCapabilitySnapshot, ConnectionState, TransportKind, }; use secrecy::SecretString; use serde::Serialize; use std::{sync::Arc, time::Duration}; use tokio::sync::{Mutex, mpsc}; use super::{ AstrBotClient, AstrBotClientConfig, AstrBotClientError, BoundGatewayEvent, GatewayClient, GatewayClientConfig, GatewayError, SlotKind, }; #[derive(Debug, Clone, Serialize)] #[serde(rename_all = "camelCase")] pub struct SlotRuntimeSnapshot { pub slot: SlotKind, pub profile_id: Option, pub transport: Option, pub state: ConnectionState, pub server_instance_id: Option, pub active_session_id: Option, pub last_error: Option, } #[derive(Debug, Clone, Serialize)] #[serde(rename_all = "camelCase")] pub struct ConnectionRuntimeStatus { pub companion: SlotRuntimeSnapshot, pub operations: SlotRuntimeSnapshot, } #[derive(Debug, Clone)] pub struct SlotActivationRequest { pub profile_id: String, pub slot: SlotKind, pub base_url: String, pub transport: TransportKind, pub api_key: Option, pub bearer_token: Option, pub remote_username: Option, pub remote_display_name: Option, pub authentication_type: desktop_protocol::AuthenticationType, pub session_id: Option, pub expected_server_instance_id: Option, } #[derive(Clone)] enum ActiveClient { Desktop(GatewayClient), AstrBot(AstrBotClient), } struct SlotRuntime { snapshot: SlotRuntimeSnapshot, client: Option, connection_cancellation: Option>, message_cancellation: Option>, generation: u64, } impl SlotRuntime { fn empty(slot: SlotKind) -> Self { Self::empty_with_generation(slot, 0) } fn empty_with_generation(slot: SlotKind, generation: u64) -> Self { Self { snapshot: SlotRuntimeSnapshot { slot, profile_id: None, transport: None, state: ConnectionState::Disconnected, server_instance_id: None, active_session_id: None, last_error: None, }, client: None, connection_cancellation: None, message_cancellation: None, generation, } } } /// In-process dual-slot connection runtime. /// /// Network activation is explicit and Rust-owned. React never receives secrets. pub struct DualSlotRuntime { inner: Arc>, event_tx: mpsc::Sender, event_rx: Mutex>, } struct DualSlotRuntimeInner { companion: SlotRuntime, operations: SlotRuntime, } #[derive(Debug, Clone, Serialize)] #[serde(rename_all = "camelCase")] pub struct RuntimeCommandError { pub code: &'static str, pub message: &'static str, } impl std::fmt::Display for RuntimeCommandError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.write_str(self.message) } } impl std::error::Error for RuntimeCommandError {} impl RuntimeCommandError { pub fn validation(message: &'static str) -> Self { Self { code: "validationFailed", message, } } pub fn unavailable(message: &'static str) -> Self { Self { code: "runtimeUnavailable", message, } } } impl DualSlotRuntime { pub fn new() -> Self { let (event_tx, event_rx) = mpsc::channel(256); Self { inner: Arc::new(Mutex::new(DualSlotRuntimeInner { companion: SlotRuntime::empty(SlotKind::Companion), operations: SlotRuntime::empty(SlotKind::Operations), })), event_tx, event_rx: Mutex::new(event_rx), } } pub async fn status(&self) -> ConnectionRuntimeStatus { let guard = self.inner.lock().await; ConnectionRuntimeStatus { companion: guard.companion.snapshot.clone(), operations: guard.operations.snapshot.clone(), } } pub async fn try_recv_event(&self) -> Option { let mut rx = self.event_rx.lock().await; rx.try_recv().ok() } pub async fn drain_events(&self, limit: usize) -> Vec { let limit = limit.clamp(1, 256); let mut rx = self.event_rx.lock().await; let mut events = Vec::with_capacity(limit); while events.len() < limit { match rx.try_recv() { Ok(event) => events.push(event), Err(_) => break, } } events } pub async fn deactivate_slot(&self, slot: SlotKind) -> Result<(), RuntimeCommandError> { let mut guard = self.inner.lock().await; let runtime = slot_mut(&mut guard, slot); if let Some(cancellation) = runtime.connection_cancellation.take() { cancellation.cancel(); } if let Some(cancellation) = runtime.message_cancellation.take() { cancellation.cancel(); } let generation = runtime.generation.wrapping_add(1); *runtime = SlotRuntime::empty_with_generation(slot, generation); Ok(()) } pub async fn activate_slot( &self, request: SlotActivationRequest, ) -> Result { if request.profile_id.trim().is_empty() { return Err(RuntimeCommandError::validation( "profile_id is required for activation.", )); } if request.base_url.trim().is_empty() { return Err(RuntimeCommandError::validation( "base_url is required for activation.", )); } let mut guard = self.inner.lock().await; let runtime = slot_mut(&mut guard, request.slot); if let Some(cancellation) = runtime.connection_cancellation.take() { cancellation.cancel(); } if let Some(cancellation) = runtime.message_cancellation.take() { cancellation.cancel(); } let generation = runtime.generation.wrapping_add(1); *runtime = SlotRuntime { snapshot: SlotRuntimeSnapshot { slot: request.slot, profile_id: Some(request.profile_id.clone()), transport: Some(request.transport), state: ConnectionState::Connecting, server_instance_id: None, active_session_id: request.session_id.clone(), last_error: None, }, client: None, connection_cancellation: None, message_cancellation: None, generation, }; match request.transport { TransportKind::DesktopV1 => { let expected = request .expected_server_instance_id .clone() .filter(|value| !value.trim().is_empty()) .ok_or_else(|| { RuntimeCommandError::validation( "Desktop gateway activation requires expected_server_instance_id.", ) })?; let client = GatewayClient::new(GatewayClientConfig { profile_id: request.profile_id.clone(), slot: request.slot, base_url: request.base_url.clone(), expected_server_instance_id: expected.clone(), bearer_token: request.bearer_token.clone(), }) .map_err(|_| { RuntimeCommandError::unavailable("Desktop gateway client failed to start.") })?; match client.health().await { Ok(_) => { runtime.snapshot.state = ConnectionState::Connected; runtime.snapshot.server_instance_id = Some(expected); runtime.client = Some(ActiveClient::Desktop(client)); } Err(GatewayError::HttpStatus(status)) if status.as_u16() == 401 => { runtime.snapshot.state = ConnectionState::AuthExpired; runtime.snapshot.last_error = Some("Desktop gateway authentication failed.".into()); return Err(RuntimeCommandError::unavailable( "Desktop gateway authentication failed.", )); } Err(_) => { runtime.snapshot.state = ConnectionState::ServerUnavailable; runtime.snapshot.last_error = Some("Desktop gateway health check failed.".into()); return Err(RuntimeCommandError::unavailable( "Desktop gateway health check failed.", )); } } } TransportKind::AstrBotOpenApi => { let api_key = request.api_key.clone().ok_or_else(|| { RuntimeCommandError::validation("AstrBot activation requires an API key.") })?; let remote_username = request .remote_username .clone() .filter(|value| !value.trim().is_empty()) .ok_or_else(|| { RuntimeCommandError::validation( "AstrBot activation requires remote_username.", ) })?; let client = AstrBotClient::new(AstrBotClientConfig { profile_id: request.profile_id.clone(), slot: request.slot, base_url: request.base_url.clone(), api_key, remote_username, remote_display_name: request.remote_display_name.clone(), authentication_type: request.authentication_type, session_id: request.session_id.clone(), expected_server_instance_id: request.expected_server_instance_id.clone(), }) .map_err(|error| match error { AstrBotClientError::CredentialExpired => RuntimeCommandError { code: "authExpired", message: "AstrBot authentication has expired. Re-login is required.", }, _ => RuntimeCommandError::unavailable("AstrBot client failed to start."), })?; match client.probe().await { Ok(_) => { runtime.snapshot.state = ConnectionState::Connected; runtime.snapshot.server_instance_id = Some(client.server_instance_id_blocking()); runtime.client = Some(ActiveClient::AstrBot(client)); } Err(error) => { runtime.snapshot.state = match error { super::AstrBotClientError::HttpStatus(status) if status.as_u16() == 401 || status.as_u16() == 403 => { ConnectionState::AuthExpired } _ => ConnectionState::ServerUnavailable, }; runtime.snapshot.last_error = Some("AstrBot probe failed.".into()); return Err(RuntimeCommandError::unavailable("AstrBot probe failed.")); } } } } let listener_client = runtime.client.clone(); let connection_cancellation = Arc::new(tokio_util::sync::CancellationToken::new()); runtime.connection_cancellation = Some(connection_cancellation.clone()); let snapshot = runtime.snapshot.clone(); drop(guard); if let Some(client) = listener_client { self.start_connection_listener( request.slot, generation, client, connection_cancellation, ); } Ok(snapshot) } fn start_connection_listener( &self, slot: SlotKind, generation: u64, client: ActiveClient, cancellation: Arc, ) { let inner = Arc::clone(&self.inner); let event_tx = self.event_tx.clone(); let state_client = client.clone(); let state_inner = Arc::clone(&self.inner); let state_cancellation = Arc::clone(&cancellation); tokio::spawn(async move { let mut state_receiver = match state_client { ActiveClient::Desktop(client) => client.state_receiver(), ActiveClient::AstrBot(client) => client.state_receiver(), }; loop { tokio::select! { _ = state_cancellation.cancelled() => break, changed = state_receiver.changed() => { if changed.is_err() { break; } let state = *state_receiver.borrow(); let mut guard = state_inner.lock().await; let runtime = slot_mut(&mut guard, slot); if runtime.generation == generation { runtime.snapshot.state = state; if state == ConnectionState::Connected { runtime.snapshot.last_error = None; } } else { break; } } } } }); tokio::spawn(async move { let result = match client { ActiveClient::Desktop(client) => { client.run_reconnecting(&event_tx, &cancellation).await } ActiveClient::AstrBot(_) => { cancellation.cancelled().await; Ok(()) } }; if let Err(error) = result { let mut guard = inner.lock().await; let runtime = slot_mut(&mut guard, slot); if runtime.generation == generation { runtime.snapshot.last_error = Some(error.to_string()); runtime.snapshot.state = match error { GatewayError::HttpStatus(status) if status.as_u16() == 401 || status.as_u16() == 403 => { ConnectionState::AuthExpired } GatewayError::Protocol(_) | GatewayError::ServerIdentityChanged => { ConnectionState::Incompatible } _ => ConnectionState::FatalError, }; } } }); } pub async fn cancel_slot_message(&self, slot: SlotKind) -> Result<(), RuntimeCommandError> { let guard = self.inner.lock().await; let runtime = slot_ref(&guard, slot); let Some(cancellation) = runtime.message_cancellation.as_ref() else { return Err(RuntimeCommandError::unavailable( "No chat request is active.", )); }; cancellation.cancel(); Ok(()) } pub async fn slot_sessions( &self, slot: SlotKind, ) -> Result { let client = { let guard = self.inner.lock().await; match slot_ref(&guard, slot).client.as_ref() { Some(ActiveClient::AstrBot(client)) => client.clone(), Some(ActiveClient::Desktop(_)) => { return Err(RuntimeCommandError::validation( "Session lists are not available for the desktop mock transport.", )); } None => { return Err(RuntimeCommandError::unavailable( "Activate the connection before loading sessions.", )); } } }; client .list_sessions() .await .map_err(|_| RuntimeCommandError::unavailable("AstrBot sessions are unavailable.")) } pub async fn switch_slot_session( &self, slot: SlotKind, session_id: String, ) -> Result { if session_id.trim().is_empty() { return Err(RuntimeCommandError::validation("session_id is required.")); } let client = { let guard = self.inner.lock().await; match slot_ref(&guard, slot).client.as_ref() { Some(ActiveClient::AstrBot(client)) => client.clone(), Some(ActiveClient::Desktop(_)) => { return Err(RuntimeCommandError::validation( "Session switching is not available for the desktop mock transport.", )); } None => { return Err(RuntimeCommandError::unavailable( "Activate the connection before switching sessions.", )); } } }; client .set_session_id(session_id.clone()) .await .map_err(|_| RuntimeCommandError::validation("The session id is invalid."))?; let mut guard = self.inner.lock().await; let runtime = slot_mut(&mut guard, slot); runtime.snapshot.active_session_id = Some(session_id); Ok(runtime.snapshot.clone()) } pub async fn slot_capabilities( &self, slot: SlotKind, ) -> Result { let client = { let guard = self.inner.lock().await; match slot_ref(&guard, slot).client.as_ref() { Some(ActiveClient::AstrBot(client)) => client.clone(), Some(ActiveClient::Desktop(_)) => { return Err(RuntimeCommandError::validation( "Capabilities are not available for the desktop mock transport.", )); } None => { return Err(RuntimeCommandError::unavailable( "Activate the connection before loading capabilities.", )); } } }; client .capabilities() .await .map_err(|_| RuntimeCommandError::unavailable("AstrBot capabilities are unavailable.")) } pub async fn upload_slot_file( &self, slot: SlotKind, file_name: String, mime_type: String, bytes: Vec, ) -> Result { let client = { let guard = self.inner.lock().await; match slot_ref(&guard, slot).client.as_ref() { Some(ActiveClient::AstrBot(client)) => client.clone(), Some(ActiveClient::Desktop(_)) => { return Err(RuntimeCommandError::validation( "File upload is not available for the desktop mock transport.", )); } None => { return Err(RuntimeCommandError::unavailable( "Activate the connection before uploading a file.", )); } } }; client .upload_file(&file_name, &mime_type, bytes) .await .map_err(|_| RuntimeCommandError::unavailable("AstrBot file upload failed.")) } pub async fn send_slot_message( &self, slot: SlotKind, message: String, config_id: Option, attachments: Vec, ) -> Result { if message.trim().is_empty() { return Err(RuntimeCommandError::validation( "message must not be empty.", )); } // Take the client out so we can await without holding the mutex across network IO. let ( client, profile_id, transport, server_instance_id, session_id, cancellation, generation, ) = { let mut guard = self.inner.lock().await; let runtime = slot_mut(&mut guard, slot); let client = runtime.client.take().ok_or_else(|| { RuntimeCommandError::unavailable("The selected slot is not connected.") })?; let cancellation = Arc::new(tokio_util::sync::CancellationToken::new()); runtime.message_cancellation = Some(cancellation.clone()); runtime.snapshot.state = ConnectionState::Syncing; ( client, runtime.snapshot.profile_id.clone(), runtime.snapshot.transport, runtime.snapshot.server_instance_id.clone(), runtime.snapshot.active_session_id.clone(), cancellation, runtime.generation, ) }; let send_result = match client { ActiveClient::Desktop(client) => { let restored = ActiveClient::Desktop(client); Err(( restored, RuntimeCommandError::unavailable( "Desktop mock chat send is not activated in this runtime path yet.", ), )) } ActiveClient::AstrBot(client) => { let mut attempts = 0; loop { match client .send_chat_stream( &message, config_id.clone(), attachments.clone(), &self.event_tx, &cancellation, ) .await { Ok(_session) if cancellation.is_cancelled() => { break Err(( ActiveClient::AstrBot(client), RuntimeCommandError { code: "cancelled", message: "The chat request was cancelled.", }, )); } Ok(session) => break Ok((ActiveClient::AstrBot(client), session)), Err(AstrBotClientError::HttpStatus(status)) if status.as_u16() == 401 || status.as_u16() == 403 => { break Err(( ActiveClient::AstrBot(client), RuntimeCommandError { code: "authExpired", message: "AstrBot authentication has expired. Re-login is required.", }, )); } Err(error) if should_retry_astrbot(&error) && attempts < 2 => { attempts += 1; let mut guard = self.inner.lock().await; slot_mut(&mut guard, slot).snapshot.state = ConnectionState::Reconnecting; drop(guard); tokio::time::sleep(Duration::from_millis(250 * attempts)).await; } Err(_) => { break Err(( ActiveClient::AstrBot(client), RuntimeCommandError::unavailable("AstrBot chat send failed."), )); } } } } }; let mut guard = self.inner.lock().await; let runtime = slot_mut(&mut guard, slot); if runtime.generation != generation { return Err(RuntimeCommandError { code: "cancelled", message: "The chat request was cancelled because the slot changed.", }); } runtime.message_cancellation = None; match send_result { Ok((client, session)) => { runtime.client = Some(client); runtime.snapshot.profile_id = profile_id; runtime.snapshot.transport = transport; runtime.snapshot.server_instance_id = server_instance_id; runtime.snapshot.active_session_id = session.or(session_id); runtime.snapshot.state = ConnectionState::Connected; runtime.snapshot.last_error = None; Ok(runtime.snapshot.clone()) } Err((client, error)) => { runtime.client = Some(client); runtime.snapshot.profile_id = profile_id; runtime.snapshot.transport = transport; runtime.snapshot.server_instance_id = server_instance_id; runtime.snapshot.active_session_id = session_id; runtime.snapshot.state = if error.code == "authExpired" { ConnectionState::AuthExpired } else if error.code == "cancelled" { ConnectionState::Connected } else { ConnectionState::ServerUnavailable }; runtime.snapshot.last_error = if error.code == "cancelled" { None } else { Some(error.message.to_owned()) }; Err(error) } } } } impl Default for DualSlotRuntime { fn default() -> Self { Self::new() } } fn slot_ref(inner: &DualSlotRuntimeInner, slot: SlotKind) -> &SlotRuntime { match slot { SlotKind::Companion => &inner.companion, SlotKind::Operations => &inner.operations, } } fn should_retry_astrbot(error: &AstrBotClientError) -> bool { match error { AstrBotClientError::Request(_) | AstrBotClientError::ChannelClosed => true, AstrBotClientError::HttpStatus(status) => { status.is_server_error() || status.as_u16() == 408 || status.as_u16() == 429 } _ => false, } } fn slot_mut(inner: &mut DualSlotRuntimeInner, slot: SlotKind) -> &mut SlotRuntime { match slot { SlotKind::Companion => &mut inner.companion, SlotKind::Operations => &mut inner.operations, } } #[cfg(test)] mod tests { use super::*; #[tokio::test] async fn rejects_astrbot_activation_without_username_or_key() { let runtime = DualSlotRuntime::new(); let error = runtime .activate_slot(SlotActivationRequest { profile_id: "11111111-1111-1111-1111-111111111111".into(), slot: SlotKind::Companion, base_url: "http://127.0.0.1:9".into(), transport: TransportKind::AstrBotOpenApi, api_key: None, bearer_token: None, remote_username: None, remote_display_name: None, authentication_type: desktop_protocol::AuthenticationType::DeviceToken, session_id: None, expected_server_instance_id: None, }) .await .expect_err("should fail"); assert_eq!(error.code, "validationFailed"); } #[tokio::test] async fn status_starts_disconnected() { let runtime = DualSlotRuntime::new(); let status = runtime.status().await; assert_eq!(status.companion.state, ConnectionState::Disconnected); assert_eq!(status.operations.state, ConnectionState::Disconnected); } }