use std::{collections::VecDeque, sync::Arc, time::Duration}; use desktop_protocol::{ AstrBotApiEnvelope, AstrBotAttachment, AstrBotCapabilitySnapshot, AstrBotChatRequest, AstrBotConfigListData, AstrBotModelOption, AstrBotSessionListData, AstrBotStreamMapper, AuthenticationType, BoundGatewayEvent, ConnectionState, GatewayEvent, PROTOCOL_VERSION, derive_astrbot_server_instance_id, }; use futures_util::StreamExt; use reqwest::header::{ACCEPT, AUTHORIZATION, HeaderMap, HeaderValue}; use secrecy::{ExposeSecret, SecretString}; use serde_json::{Value, json}; use thiserror::Error; use tokio::sync::{Mutex, mpsc, watch}; use tokio_util::sync::CancellationToken; use super::{GatewayError, SlotKind}; #[derive(Debug, Clone)] pub struct AstrBotClientConfig { pub profile_id: String, pub slot: SlotKind, pub base_url: String, pub api_key: SecretString, /// Remote WebChat username used as session owner identity. pub remote_username: String, pub remote_display_name: Option, pub authentication_type: AuthenticationType, /// Optional sticky session id. When absent, the first chat response supplies one. pub session_id: Option, /// Expected server identity substitute. Empty means accept first observed identity. pub expected_server_instance_id: Option, } #[derive(Debug, Error)] pub enum AstrBotClientError { #[error("astrbot request failed")] Request(#[from] reqwest::Error), #[error("astrbot returned HTTP {0}")] HttpStatus(reqwest::StatusCode), #[error("astrbot api status error: {0}")] ApiStatus(String), #[error("invalid astrbot payload")] Json(#[from] serde_json::Error), #[error("astrbot stream mapping failed: {0}")] Map(String), #[error("server identity changed")] ServerIdentityChanged, #[error("astrbot event channel closed")] ChannelClosed, #[error("invalid configuration: {0}")] InvalidConfig(&'static str), #[error("astrbot credential expired")] CredentialExpired, } impl From for GatewayError { fn from(value: AstrBotClientError) -> Self { match value { AstrBotClientError::Request(error) => GatewayError::Request(error), AstrBotClientError::HttpStatus(status) => GatewayError::HttpStatus(status), AstrBotClientError::Json(error) => GatewayError::Json(error), AstrBotClientError::ServerIdentityChanged => GatewayError::ServerIdentityChanged, AstrBotClientError::ChannelClosed => GatewayError::ChannelClosed, AstrBotClientError::ApiStatus(message) => GatewayError::Adapter(message), AstrBotClientError::Map(message) => GatewayError::Adapter(message), AstrBotClientError::InvalidConfig(message) => GatewayError::Adapter(message.to_owned()), AstrBotClientError::CredentialExpired => { GatewayError::Adapter("AstrBot authentication has expired".into()) } } } } const MAX_DEDUPLICATED_EVENTS: usize = 4_096; #[derive(Default)] struct EventDeduplicator { ids: std::collections::HashSet, order: VecDeque, } impl EventDeduplicator { fn insert(&mut self, event_id: String) -> bool { if !self.ids.insert(event_id.clone()) { return false; } self.order.push_back(event_id); if self.order.len() > MAX_DEDUPLICATED_EVENTS && let Some(expired) = self.order.pop_front() { self.ids.remove(&expired); } true } } #[derive(Clone)] pub struct AstrBotClient { config: AstrBotClientConfig, http: reqwest::Client, seen_event_ids: Arc>, session_id: Arc>>, server_instance_id: Arc>, state_tx: watch::Sender, } impl AstrBotClient { pub fn new(config: AstrBotClientConfig) -> Result { if config.base_url.trim().is_empty() { return Err(AstrBotClientError::InvalidConfig("base_url is required")); } if config.remote_username.trim().is_empty() { return Err(AstrBotClientError::InvalidConfig( "remote_username is required", )); } if config.api_key.expose_secret().trim().is_empty() { return Err(AstrBotClientError::InvalidConfig("api_key is required")); } if config.authentication_type == AuthenticationType::Jwt && jwt_is_expired(config.api_key.expose_secret()) { return Err(AstrBotClientError::CredentialExpired); } let base = config.base_url.trim_end_matches('/').to_owned(); let derived = derive_astrbot_server_instance_id(&base); let initial_identity = config .expected_server_instance_id .clone() .filter(|value| !value.trim().is_empty()) .unwrap_or(derived); let mut headers = HeaderMap::new(); let auth_value = format!("Bearer {}", config.api_key.expose_secret()); headers.insert( AUTHORIZATION, HeaderValue::from_str(&auth_value).map_err(|_| { AstrBotClientError::InvalidConfig("api_key has invalid header chars") })?, ); let http = reqwest::Client::builder() .default_headers(headers) .redirect(reqwest::redirect::Policy::none()) .connect_timeout(Duration::from_secs(5)) .timeout(Duration::from_secs(120)) .build()?; let (state_tx, _) = watch::channel(ConnectionState::Disconnected); let initial_session = config.session_id.clone(); Ok(Self { config: AstrBotClientConfig { base_url: base, ..config }, http, seen_event_ids: Arc::new(Mutex::new(EventDeduplicator::default())), session_id: Arc::new(Mutex::new(initial_session)), server_instance_id: Arc::new(Mutex::new(initial_identity)), state_tx, }) } pub fn state_receiver(&self) -> watch::Receiver { self.state_tx.subscribe() } pub fn server_instance_id_blocking(&self) -> String { self.server_instance_id .try_lock() .map(|guard| guard.clone()) .unwrap_or_else(|_| derive_astrbot_server_instance_id(&self.config.base_url)) } fn set_state(&self, state: ConnectionState) { self.state_tx.send_replace(state); } fn url(&self, path: &str) -> String { format!("{}{}", self.config.base_url, path) } pub async fn probe(&self) -> Result { self.set_state(ConnectionState::Connecting); let response = self .http .get(self.url(&format!( "/api/v1/chat/sessions?username={}&page=1&page_size=1", urlencoding_username(&self.config.remote_username) ))) .send() .await?; if response.status().as_u16() == 401 || response.status().as_u16() == 403 { self.set_state(ConnectionState::AuthExpired); return Err(AstrBotClientError::HttpStatus(response.status())); } if !response.status().is_success() { self.set_state(ConnectionState::ServerUnavailable); return Err(AstrBotClientError::HttpStatus(response.status())); } let envelope: AstrBotApiEnvelope = response.json().await?; if !envelope.is_ok() { self.set_state(ConnectionState::FatalError); return Err(AstrBotClientError::ApiStatus( envelope .message .unwrap_or_else(|| "chat sessions probe failed".into()), )); } self.set_state(ConnectionState::Connected); Ok(json!({ "status": "ok", "protocolVersion": PROTOCOL_VERSION, "transport": "astrbot-openapi", "serverInstanceId": self.server_instance_id.lock().await.clone(), "remoteUsername": self.config.remote_username, "sessionCount": envelope.data.map(|data| data.total.unwrap_or(0)).unwrap_or(0), })) } pub async fn set_session_id(&self, session_id: String) -> Result<(), AstrBotClientError> { if session_id.trim().is_empty() { return Err(AstrBotClientError::InvalidConfig("session_id is required")); } *self.session_id.lock().await = Some(session_id); Ok(()) } pub async fn list_sessions(&self) -> Result { let response = self .http .get(self.url(&format!( "/api/v1/chat/sessions?username={}&page=1&page_size=50", urlencoding_username(&self.config.remote_username) ))) .send() .await?; if !response.status().is_success() { return Err(AstrBotClientError::HttpStatus(response.status())); } let envelope: AstrBotApiEnvelope = response.json().await?; if !envelope.is_ok() { return Err(AstrBotClientError::ApiStatus( envelope .message .unwrap_or_else(|| "list sessions failed".into()), )); } Ok(envelope.data.unwrap_or(AstrBotSessionListData { sessions: Vec::new(), page: Some(1), page_size: Some(50), total: Some(0), })) } pub async fn list_configs(&self) -> Result { let response = self.http.get(self.url("/api/v1/configs")).send().await?; if !response.status().is_success() { return Err(AstrBotClientError::HttpStatus(response.status())); } let envelope: AstrBotApiEnvelope = response.json().await?; if !envelope.is_ok() { return Err(AstrBotClientError::ApiStatus( envelope .message .unwrap_or_else(|| "list configs failed".into()), )); } Ok(envelope.data.unwrap_or(AstrBotConfigListData { configs: Vec::new(), })) } pub async fn capabilities(&self) -> Result { let configs = self.list_configs().await?; let models = configs .configs .into_iter() .map(|config| AstrBotModelOption { id: config.id, name: config.name, is_default: config.is_default, }) .collect::>(); Ok(AstrBotCapabilitySnapshot { transport: "astrbot-openapi".to_owned(), text_chat: true, streaming: true, model_selection: !models.is_empty(), file_upload: true, image_input: true, models, }) } pub async fn upload_file( &self, file_name: &str, mime_type: &str, bytes: Vec, ) -> Result { if file_name.trim().is_empty() || mime_type.trim().is_empty() || bytes.is_empty() { return Err(AstrBotClientError::InvalidConfig( "file_name, mime_type, and file bytes are required", )); } let part = reqwest::multipart::Part::bytes(bytes.clone()) .file_name(file_name.to_owned()) .mime_str(mime_type) .map_err(|_| AstrBotClientError::InvalidConfig("invalid attachment mime type"))?; let form = reqwest::multipart::Form::new().part("file", part); let response = self .http .post(self.url("/api/v1/file")) .multipart(form) .send() .await?; if !response.status().is_success() { return Err(AstrBotClientError::HttpStatus(response.status())); } let envelope: AstrBotApiEnvelope = response.json().await?; if !envelope.is_ok() { return Err(AstrBotClientError::ApiStatus( envelope .message .unwrap_or_else(|| "file upload failed".into()), )); } let data = envelope.data.unwrap_or(Value::Null); let attachment_id = data .get("id") .or_else(|| data.get("file_id")) .or_else(|| data.get("attachment_id")) .and_then(Value::as_str) .ok_or_else(|| AstrBotClientError::Map("upload response has no attachment id".into()))? .to_owned(); Ok(AstrBotAttachment { attachment_id, file_name: file_name.to_owned(), mime_type: mime_type.to_owned(), size_bytes: bytes.len() as u64, url: data .get("url") .and_then(Value::as_str) .map(ToOwned::to_owned), }) } pub async fn send_chat_stream( &self, message: &str, config_id: Option, attachments: Vec, sender: &mpsc::Sender, cancellation: &CancellationToken, ) -> Result, AstrBotClientError> { self.set_state(ConnectionState::Syncing); let session_id = self.session_id.lock().await.clone(); let request = AstrBotChatRequest { message: Value::String(message.to_owned()), session_id: session_id.clone(), conversation_id: None, username: Some(self.config.remote_username.clone()), nickname: self.config.remote_display_name.clone(), config_id, attachments: (!attachments.is_empty()).then_some(attachments), platform_id: None, enable_streaming: Some(true), }; let response = self .http .post(self.url("/api/v1/chat")) .header(ACCEPT, HeaderValue::from_static("text/event-stream")) .json(&request) .send() .await?; if response.status().as_u16() == 401 || response.status().as_u16() == 403 { self.set_state(ConnectionState::AuthExpired); return Err(AstrBotClientError::HttpStatus(response.status())); } if !response.status().is_success() { self.set_state(ConnectionState::ServerUnavailable); return Err(AstrBotClientError::HttpStatus(response.status())); } let server_instance_id = self.server_instance_id.lock().await.clone(); if let Some(expected) = &self.config.expected_server_instance_id && !expected.is_empty() && expected != &server_instance_id { self.set_state(ConnectionState::CertificateChanged); return Err(AstrBotClientError::ServerIdentityChanged); } let mut mapper = AstrBotStreamMapper::new(server_instance_id.clone()); if let Some(existing) = session_id { let seed = serde_json::json!({ "type": "session_id", "data": null, "session_id": existing, }); let _ = mapper.push_line(&format!("data: {seed}")); } let mut stream = response.bytes_stream(); let mut buffer = String::new(); self.set_state(ConnectionState::Connected); loop { tokio::select! { _ = cancellation.cancelled() => { self.set_state(ConnectionState::Disconnected); return Ok(mapper.session_id().map(str::to_owned)); } next = stream.next() => { let Some(next) = next else { break; }; let chunk = next?; buffer.push_str(&String::from_utf8_lossy(&chunk)); while let Some(index) = buffer.find('\n') { let mut line = buffer[..index].to_owned(); buffer.drain(..=index); if line.ends_with('\r') { line.pop(); } let events = mapper .push_line(&line) .map_err(|error| AstrBotClientError::Map(error.to_string()))?; self.dispatch_events(events, sender).await?; } } } } if !buffer.trim().is_empty() { let events = mapper .push_line(buffer.trim_end_matches('\r')) .map_err(|error| AstrBotClientError::Map(error.to_string()))?; self.dispatch_events(events, sender).await?; } let events = mapper.finish_stream(); self.dispatch_events(events, sender).await?; if let Some(session) = mapper.session_id() { *self.session_id.lock().await = Some(session.to_owned()); } self.set_state(ConnectionState::Connected); Ok(self.session_id.lock().await.clone()) } async fn dispatch_events( &self, events: Vec, sender: &mpsc::Sender, ) -> Result<(), AstrBotClientError> { for event in events { if let Some(session_id) = event.metadata.session_id.clone() { *self.session_id.lock().await = Some(session_id); } let event_id = event.metadata.event_id.clone(); let mut seen = self.seen_event_ids.lock().await; if !seen.insert(event_id.clone()) { continue; } drop(seen); let body = serde_json::to_value(&event.body) .map_err(|error| AstrBotClientError::Map(error.to_string()))?; let payload = body.get("payload").cloned().unwrap_or(body); let bound = BoundGatewayEvent { profile_id: self.config.profile_id.clone(), slot: protocol_slot(self.config.slot), event, }; sender .send(super::gateway_client::BoundGatewayEvent { profile_id: bound.profile_id, slot: self.config.slot, event_id, event_type: bound.event.event_type().to_owned(), server_instance_id: bound.event.metadata.server_instance_id.clone(), session_id: bound.event.metadata.session_id.clone(), message_id: bound.event.metadata.message_id.clone(), payload, }) .await .map_err(|_| AstrBotClientError::ChannelClosed)?; } Ok(()) } } fn protocol_slot(slot: SlotKind) -> desktop_protocol::ActiveSlotKind { match slot { SlotKind::Companion => desktop_protocol::ActiveSlotKind::Companion, SlotKind::Operations => desktop_protocol::ActiveSlotKind::Operations, } } fn urlencoding_username(username: &str) -> String { username .chars() .map(|ch| match ch { 'A'..='Z' | 'a'..='z' | '0'..='9' | '-' | '_' | '.' | '~' => ch.to_string(), _ => format!("%{:02X}", ch as u8), }) .collect() } fn jwt_is_expired(token: &str) -> bool { let Some(payload) = token.split('.').nth(1).and_then(decode_base64url) else { return false; }; let Ok(value) = serde_json::from_slice::(&payload) else { return false; }; let Some(exp) = value.get("exp").and_then(Value::as_i64) else { return false; }; exp <= time::OffsetDateTime::now_utc().unix_timestamp() } fn decode_base64url(value: &str) -> Option> { let mut output = Vec::with_capacity(value.len() * 3 / 4); let mut buffer = 0u32; let mut bits = 0u8; for byte in value.bytes() { let digit = match byte { b'A'..=b'Z' => byte - b'A', b'a'..=b'z' => byte - b'a' + 26, b'0'..=b'9' => byte - b'0' + 52, b'-' => 62, b'_' => 63, b'=' => break, _ => return None, }; buffer = (buffer << 6) | u32::from(digit); bits += 6; if bits >= 8 { bits -= 8; output.push((buffer >> bits) as u8); buffer &= (1 << bits) - 1; } } Some(output) } #[cfg(test)] mod tests { use super::*; #[test] fn rejects_empty_api_key_and_username() { let result = AstrBotClient::new(AstrBotClientConfig { profile_id: "p".into(), slot: SlotKind::Companion, base_url: "http://127.0.0.1:1".into(), api_key: SecretString::from(String::new()), remote_username: "user".into(), remote_display_name: None, authentication_type: AuthenticationType::ApiKey, session_id: None, expected_server_instance_id: None, }); assert!(matches!(result, Err(AstrBotClientError::InvalidConfig(_)))); } #[test] fn derives_identity_from_base_url() { let client = AstrBotClient::new(AstrBotClientConfig { profile_id: "p".into(), slot: SlotKind::Companion, base_url: "http://192.168.31.210:26285/".into(), api_key: SecretString::from("abk_test".to_owned()), remote_username: "desktop-companion".into(), remote_display_name: Some("Desktop Companion".into()), authentication_type: AuthenticationType::ApiKey, session_id: Some("s1".into()), expected_server_instance_id: None, }) .expect("client"); assert!(client.server_instance_id_blocking().starts_with("astrbot-")); } #[test] fn detects_expired_jwt_without_logging_or_exposing_the_token() { assert!(jwt_is_expired("e30.eyJleHAiOjF9.signature")); assert!(!jwt_is_expired("not-a-jwt")); } }