// IPC wrappers for dual-slot runtime. Secrets never leave Rust. use desktop_protocol::TransportKind; use secrecy::SecretString; use serde::Deserialize; use serde_json::Value; use tauri::State; use tracing::{info, warn}; use super::{ ConnectionRuntimeStatus, DualSlotRuntime, RuntimeCommandError, SlotActivationRequest, SlotKind, SlotRuntimeSnapshot, }; use crate::credentials::{CredentialCommandError, load_profile_secret}; use crate::database::ApplicationDatabase; use crate::secure_store::WindowsCredentialStore; #[derive(Debug, Deserialize)] #[serde(rename_all = "camelCase", deny_unknown_fields)] pub struct ProbeConnectionSlotRequest { pub slot: SlotKind, pub profile_id: String, } #[derive(Debug, Deserialize)] #[serde(rename_all = "camelCase", deny_unknown_fields)] pub struct DisconnectConnectionSlotRequest { pub slot: SlotKind, } #[derive(Debug, Deserialize)] #[serde(rename_all = "camelCase", deny_unknown_fields)] pub struct SendConnectionSlotMessageRequest { pub slot: SlotKind, pub message: String, } #[derive(Debug, Deserialize)] #[serde(rename_all = "camelCase", deny_unknown_fields)] pub struct DrainConnectionRuntimeEventsRequest { pub limit: Option, } #[derive(Debug, Deserialize)] #[serde(rename_all = "camelCase", deny_unknown_fields)] pub struct LoadChatMessagesRequest { pub profile_id: String, pub server_instance_id: String, pub session_id: String, pub limit: Option, } #[tauri::command] pub async fn connection_runtime_status( runtime: State<'_, DualSlotRuntime>, ) -> Result { Ok(runtime.status().await) } /// Starts profiles explicitly marked for startup connection. /// /// Each slot is attempted independently. A failure is retained in that slot's /// runtime snapshot and does not prevent the other configured slot from being attempted. pub async fn auto_connect_configured_slots( database: &ApplicationDatabase, runtime: &DualSlotRuntime, ) { let profiles = match database.list_profiles() { Ok(profiles) => profiles, Err(error) => { warn!(error = %error, "startup auto-connect could not read profiles"); return; } }; for profile in profiles.into_iter().filter(|profile| profile.auto_connect) { let Some(active_slot) = profile.auto_connect_slot else { warn!(profile_id = %profile.id, "startup auto-connect skipped profile without a slot"); continue; }; let slot = match active_slot { desktop_protocol::ActiveSlotKind::Companion => SlotKind::Companion, desktop_protocol::ActiveSlotKind::Operations => SlotKind::Operations, }; let profile_id = profile.id.clone(); let activation = match startup_activation_request(database, &profile, slot) { Ok(request) => request, Err(error) => { warn!(profile_id = %profile_id, slot = ?slot, error = %error, "startup auto-connect skipped"); continue; } }; match runtime.activate_slot(activation).await { Ok(snapshot) => info!( profile_id = %profile_id, slot = ?slot, state = ?snapshot.state, "startup auto-connect completed" ), Err(error) => warn!( profile_id = %profile_id, slot = ?slot, error = %error, "startup auto-connect failed" ), } } } fn startup_activation_request( database: &ApplicationDatabase, profile: &desktop_protocol::ConnectionProfile, slot: SlotKind, ) -> Result { let secret = load_profile_secret(database, &WindowsCredentialStore, &profile.id).map_err( |error: CredentialCommandError| RuntimeCommandError { code: error.code, message: error.message, }, )?; match profile.transport_kind { TransportKind::AstrBotOpenApi => { let secret = secret.ok_or(RuntimeCommandError { code: "credentialMissing", message: "Enroll an API key before probing an AstrBot profile.", })?; let api_key = String::from_utf8(secret.secret().to_vec()).map_err(|_| RuntimeCommandError { code: "credentialInvalid", message: "Stored API key is not valid UTF-8.", })?; let remote_username = profile.remote_username.clone().ok_or(RuntimeCommandError { code: "validationFailed", message: "AstrBot profiles require remote_username.", })?; Ok(SlotActivationRequest { profile_id: profile.id.clone(), slot, base_url: profile.base_url.clone(), transport: TransportKind::AstrBotOpenApi, api_key: Some(SecretString::from(api_key)), bearer_token: None, remote_username: Some(remote_username), session_id: profile.sticky_session_id.clone(), expected_server_instance_id: profile.server_instance_id.clone(), }) } TransportKind::DesktopV1 => { let bearer = secret.and_then(|value| { String::from_utf8(value.secret().to_vec()) .ok() .map(SecretString::from) }); let expected = profile .server_instance_id .clone() .ok_or(RuntimeCommandError { code: "validationFailed", message: "Desktop gateway profiles require server_instance_id before probe.", })?; Ok(SlotActivationRequest { profile_id: profile.id.clone(), slot, base_url: profile.base_url.clone(), transport: TransportKind::DesktopV1, api_key: None, bearer_token: bearer, remote_username: None, session_id: None, expected_server_instance_id: Some(expected), }) } } } #[tauri::command] pub async fn drain_connection_runtime_events( database: State<'_, ApplicationDatabase>, runtime: State<'_, DualSlotRuntime>, request: DrainConnectionRuntimeEventsRequest, ) -> Result, RuntimeCommandError> { let events = runtime.drain_events(request.limit.unwrap_or(64)).await; for event in &events { persist_runtime_event(&database, event); } Ok(events) } #[tauri::command] pub async fn load_chat_messages( database: State<'_, ApplicationDatabase>, request: LoadChatMessagesRequest, ) -> Result, RuntimeCommandError> { database .list_chat_messages( &request.profile_id, &request.server_instance_id, &request.session_id, request.limit.unwrap_or(100), ) .map_err(|_| RuntimeCommandError { code: "databaseUnavailable", message: "Chat history is unavailable.", }) } fn persist_runtime_event(database: &ApplicationDatabase, event: &super::BoundGatewayEvent) { let Some(session_id) = event.session_id.as_deref() else { return; }; let Some((role, content, streaming, message_id)) = (match event.event_type.as_str() { "message.delta" => Some(( "assistant", event .payload .get("delta") .and_then(Value::as_str) .unwrap_or_default(), true, event .message_id .as_deref() .unwrap_or(event.event_id.as_str()), )), "message.completed" => Some(( "assistant", event .payload .get("content") .and_then(Value::as_str) .unwrap_or_default(), false, event .message_id .as_deref() .unwrap_or(event.event_id.as_str()), )), "message.proactive" => Some(( "assistant", event .payload .get("content") .and_then(Value::as_str) .unwrap_or_default(), false, event.event_id.as_str(), )), "error" => Some(( "system", event .payload .get("message") .and_then(Value::as_str) .unwrap_or("Connection error"), false, event.event_id.as_str(), )), _ => None, }) else { return; }; let slot = match event.slot { SlotKind::Companion => "companion", SlotKind::Operations => "operations", }; let _ = database.upsert_chat_message( "local-default", &event.profile_id, slot, &event.server_instance_id, None, session_id, message_id, role, content, streaming, event.event_type == "error", ); } #[tauri::command] pub async fn probe_connection_slot( database: State<'_, ApplicationDatabase>, runtime: State<'_, DualSlotRuntime>, request: ProbeConnectionSlotRequest, ) -> Result { let profile = database .profile(&request.profile_id) .map_err(|_| RuntimeCommandError { code: "databaseUnavailable", message: "The local profile database is unavailable.", })? .ok_or(RuntimeCommandError { code: "notFound", message: "The connection profile no longer exists.", })?; if profile.transport_kind != TransportKind::AstrBotOpenApi && profile.transport_kind != TransportKind::DesktopV1 { return Err(RuntimeCommandError { code: "validationFailed", message: "Unsupported transport kind.", }); } let secret = load_profile_secret(&database, &WindowsCredentialStore, &profile.id).map_err( |error: CredentialCommandError| RuntimeCommandError { code: error.code, message: error.message, }, )?; let activation = match profile.transport_kind { TransportKind::AstrBotOpenApi => { let secret = secret.ok_or(RuntimeCommandError { code: "credentialMissing", message: "Enroll an API key before probing an AstrBot profile.", })?; let api_key = String::from_utf8(secret.secret().to_vec()).map_err(|_| RuntimeCommandError { code: "credentialInvalid", message: "Stored API key is not valid UTF-8.", })?; let remote_username = profile.remote_username.clone().ok_or(RuntimeCommandError { code: "validationFailed", message: "AstrBot profiles require remote_username.", })?; SlotActivationRequest { profile_id: profile.id.clone(), slot: request.slot, base_url: profile.base_url.clone(), transport: TransportKind::AstrBotOpenApi, api_key: Some(SecretString::from(api_key)), bearer_token: None, remote_username: Some(remote_username), session_id: profile.sticky_session_id.clone(), expected_server_instance_id: profile.server_instance_id.clone(), } } TransportKind::DesktopV1 => { let bearer = secret.and_then(|value| { String::from_utf8(value.secret().to_vec()) .ok() .map(SecretString::from) }); let expected = profile .server_instance_id .clone() .ok_or(RuntimeCommandError { code: "validationFailed", message: "Desktop gateway profiles require server_instance_id before probe.", })?; SlotActivationRequest { profile_id: profile.id.clone(), slot: request.slot, base_url: profile.base_url.clone(), transport: TransportKind::DesktopV1, api_key: None, bearer_token: bearer, remote_username: None, session_id: None, expected_server_instance_id: Some(expected), } } }; let snapshot = runtime.activate_slot(activation).await?; // Persist observed identity / sticky session without exposing secrets. if let Ok(Some(mut stored)) = database.profile(&request.profile_id) { let mut dirty = false; if stored.server_instance_id.is_none() && let Some(server_instance_id) = snapshot.server_instance_id.clone() { stored.server_instance_id = Some(server_instance_id); dirty = true; } if let Some(session_id) = snapshot.active_session_id.clone() && stored.sticky_session_id.as_deref() != Some(session_id.as_str()) { stored.sticky_session_id = Some(session_id); dirty = true; } if dirty { let _ = database.update_profile(&stored); } } Ok(snapshot) } #[tauri::command] pub async fn disconnect_connection_slot( runtime: State<'_, DualSlotRuntime>, request: DisconnectConnectionSlotRequest, ) -> Result<(), RuntimeCommandError> { runtime.deactivate_slot(request.slot).await } #[tauri::command] pub async fn cancel_connection_slot_message( runtime: State<'_, DualSlotRuntime>, request: DisconnectConnectionSlotRequest, ) -> Result<(), RuntimeCommandError> { runtime.cancel_slot_message(request.slot).await } #[tauri::command] pub async fn send_connection_slot_message( database: State<'_, ApplicationDatabase>, runtime: State<'_, DualSlotRuntime>, request: SendConnectionSlotMessageRequest, ) -> Result { let status = runtime.status().await; let snapshot = match request.slot { SlotKind::Companion => status.companion, SlotKind::Operations => status.operations, }; if let (Some(profile_id), Some(server_instance_id), Some(session_id)) = ( snapshot.profile_id.as_deref(), snapshot.server_instance_id.as_deref(), snapshot.active_session_id.as_deref(), ) { let slot = match request.slot { SlotKind::Companion => "companion", SlotKind::Operations => "operations", }; let _ = database.upsert_chat_message( "local-default", profile_id, slot, server_instance_id, None, session_id, &format!("local-{}", uuid::Uuid::new_v4()), "user", &request.message, false, false, ); } runtime .send_slot_message(request.slot, request.message) .await }