pub mod auth; pub mod credentials; pub mod database; pub mod diagnostics; pub mod file_transfer; pub mod logging; pub mod networking; pub mod pet; pub mod policy; pub mod profiles; pub mod quick_window; pub mod runtime_guards; pub mod secure_store; pub mod slots; pub mod windows; use database::ApplicationDatabase; use networking::{DualSlotRuntime, auto_connect_configured_slots}; use policy::ConnectionPolicyStatus; use quick_window::{ DEFAULT_HEIGHT, DEFAULT_WIDTH, MAX_HEIGHT, MAX_WIDTH, MIN_HEIGHT, MIN_WIDTH, QUICK_WINDOW_ID, QuickWindowState, }; use runtime_guards::RuntimeGuards; use serde::{Deserialize, Serialize}; use tauri::{ AppHandle, Emitter, Manager, PhysicalPosition, PhysicalSize, WebviewUrl, WebviewWindowBuilder, WindowEvent, menu::{Menu, MenuItem, PredefinedMenuItem}, tray::TrayIconBuilder, window::Color, }; const PET_WINDOW_ID: &str = "desktop-pet"; const SESSION_MARKER_FILE: &str = "session.active"; struct SessionMarker(std::path::PathBuf); #[derive(Debug, Clone, Serialize)] #[serde(rename_all = "camelCase")] struct MonitorInfo { name: Option, left: i32, top: i32, width: u32, height: u32, work_left: i32, work_top: i32, work_width: u32, work_height: u32, scale_factor: f64, is_primary: bool, } #[derive(Debug, Clone, Deserialize)] #[serde(rename_all = "camelCase", deny_unknown_fields)] struct PetWindowPreferences { position_mode: pet::PetPositionMode, monitor_index: Option, always_on_top: bool, game_mode: bool, } #[derive(Debug, Clone, Deserialize)] #[serde(rename_all = "camelCase", deny_unknown_fields)] struct NetworkDiagnosticRequest { host: String, port: u16, timeout_seconds: Option, } #[derive(Debug, Clone, Deserialize)] #[serde(rename_all = "camelCase", deny_unknown_fields)] struct ProcessDiagnosticRequest { process_id: u32, } fn available_monitor_info(app: &AppHandle) -> Result, String> { let window = app .get_webview_window("main") .ok_or_else(|| "main window is unavailable".to_owned())?; let primary_name = window .primary_monitor() .ok() .flatten() .and_then(|monitor| monitor.name().cloned()); window .available_monitors() .map_err(|error| error.to_string()) .map(|monitors| { monitors .into_iter() .map(|monitor| { let area = monitor.work_area(); let position = monitor.position(); let size = monitor.size(); let name = monitor.name().cloned(); MonitorInfo { is_primary: name == primary_name, name, left: position.x, top: position.y, width: size.width, height: size.height, work_left: area.position.x, work_top: area.position.y, work_width: area.size.width, work_height: area.size.height, scale_factor: monitor.scale_factor(), } }) .collect() }) } fn place_pet_on_monitor( window: &tauri::WebviewWindow, monitor: &MonitorInfo, mode: pet::PetPositionMode, ) -> Result<(), String> { let size = window.outer_size().map_err(|error| error.to_string())?; let pet = pet::MonitorGeometry { left: monitor.left, top: monitor.top, width: monitor.width, height: monitor.height, work_left: monitor.work_left, work_top: monitor.work_top, work_width: monitor.work_width, work_height: monitor.work_height, is_primary: monitor.is_primary, }; let placement = match mode { pet::PetPositionMode::Edge | pet::PetPositionMode::Monitor => { pet::place_at_safe_edge(pet, size.width, size.height, 16) } pet::PetPositionMode::Free | pet::PetPositionMode::FollowMainWindow => return Ok(()), }; window .set_position(PhysicalPosition::new(placement.x, placement.y)) .map_err(|error| error.to_string()) } #[derive(Debug, Clone, Serialize)] #[serde(rename_all = "camelCase")] struct BootstrapStatus { app_version: &'static str, database_schema_version: u32, platform: &'static str, rust_core: &'static str, protocol_version: &'static str, } #[tauri::command] fn open_status_bubble_window(app: AppHandle) -> Result<(), String> { if let Some(window) = app.get_webview_window("status-bubble") { window.show().map_err(|error| error.to_string())?; return Ok(()); } WebviewWindowBuilder::new( &app, "status-bubble", WebviewUrl::App("index.html?view=bubble".into()), ) .title("AstrBot Status") .inner_size(108.0, 108.0) .resizable(false) .decorations(false) .shadow(false) .transparent(true) .background_color(Color(0, 0, 0, 0)) .always_on_top(false) .skip_taskbar(true) .build() .map(|_| ()) .map_err(|error| error.to_string()) } #[tauri::command] fn open_quick_chat_window( app: AppHandle, slot: Option, ) -> Result<(), String> { if let Some(window) = app.get_webview_window(QUICK_WINDOW_ID) { window.show().map_err(|error| error.to_string())?; window.set_focus().map_err(|error| error.to_string())?; return Ok(()); } WebviewWindowBuilder::new( &app, QUICK_WINDOW_ID, WebviewUrl::App(match slot { Some(desktop_protocol::ActiveSlotKind::Companion) => { "index.html?view=quick&slot=companion".into() } Some(desktop_protocol::ActiveSlotKind::Operations) => { "index.html?view=quick&slot=operations".into() } None => "index.html?view=quick".into(), }), ) .title("AstrBot Quick Chat") .inner_size(DEFAULT_WIDTH as f64, DEFAULT_HEIGHT as f64) .min_inner_size(MIN_WIDTH as f64, MIN_HEIGHT as f64) .max_inner_size(MAX_WIDTH as f64, MAX_HEIGHT as f64) .resizable(true) .build() .map_err(|error| error.to_string()) .map(|window| { restore_quick_window_state(&window, &app); }) } fn restore_quick_window_state(window: &tauri::WebviewWindow, app: &AppHandle) { let database = app.state::(); let Ok(Some(state)) = database.load_window_state(QUICK_WINDOW_ID) else { return; }; let state = state.normalized(); let monitor = state .monitor_name .as_deref() .and_then(|name| { window .available_monitors() .ok()? .into_iter() .find(|monitor| monitor.name().map(String::as_str) == Some(name)) }) .or_else(|| window.primary_monitor().ok().flatten()); let Some(monitor) = monitor else { return; }; let area = monitor.work_area(); let state = state.clamp_to_work_area( area.position.x, area.position.y, area.size.width, area.size.height, ); let _ = window.set_size(PhysicalSize::new(state.width, state.height)); let _ = window.set_position(PhysicalPosition::new(state.x, state.y)); } fn save_quick_window_state(window: &tauri::Window, app: &AppHandle) { let Ok(position) = window.outer_position() else { return; }; let Ok(size) = window.inner_size() else { return; }; let monitor_name = window .current_monitor() .ok() .flatten() .and_then(|monitor| monitor.name().cloned()); let state = QuickWindowState { x: position.x, y: position.y, width: size.width, height: size.height, monitor_name, } .normalized(); let database = app.state::(); let _ = database.save_window_state(QUICK_WINDOW_ID, &state); } fn exit_application(app: &AppHandle) { if let Some(marker) = app.try_state::() { let _ = std::fs::remove_file(&marker.0); } app.cleanup_before_exit(); std::process::exit(0); } fn tray_state_label(name: &str, state: desktop_protocol::ConnectionState) -> String { let state = match state { desktop_protocol::ConnectionState::Connected => "在线", desktop_protocol::ConnectionState::Connecting => "连接中", desktop_protocol::ConnectionState::Authenticating => "认证中", desktop_protocol::ConnectionState::Syncing => "同步中", desktop_protocol::ConnectionState::Reconnecting => "重连中", desktop_protocol::ConnectionState::AuthExpired => "需要认证", desktop_protocol::ConnectionState::Disconnected => "未连接", desktop_protocol::ConnectionState::Offline => "离线", desktop_protocol::ConnectionState::ServerUnavailable => "服务不可用", desktop_protocol::ConnectionState::Incompatible => "协议不兼容", desktop_protocol::ConnectionState::CertificateChanged => "证书已变化", desktop_protocol::ConnectionState::FatalError => "连接错误", }; format!("{name}:{state}") } #[tauri::command] fn open_main_window(app: AppHandle) -> Result<(), String> { let window = app .get_webview_window("main") .ok_or_else(|| "main window is unavailable".to_owned())?; window.show().map_err(|error| error.to_string())?; window.set_focus().map_err(|error| error.to_string()) } #[tauri::command] fn open_pet_window(app: AppHandle) -> Result<(), String> { if let Some(window) = app.get_webview_window(PET_WINDOW_ID) { window .set_always_on_top(true) .map_err(|error| error.to_string())?; if let Some(monitor) = available_monitor_info(&app)?.first() { place_pet_on_monitor(&window, monitor, pet::PetPositionMode::Edge)?; } window.show().map_err(|error| error.to_string())?; return Ok(()); } let config = app .config() .app .windows .iter() .find(|window| window.label == PET_WINDOW_ID) .ok_or_else(|| "pet window config is unavailable".to_owned())?; WebviewWindowBuilder::from_config(&app, config) .map_err(|error| error.to_string())? .build() .map(|_| ()) .map_err(|error| error.to_string()) } #[tauri::command] fn list_monitor_geometries(app: AppHandle) -> Result, String> { available_monitor_info(&app) } #[tauri::command] fn set_pet_window_preferences( app: AppHandle, preferences: PetWindowPreferences, ) -> Result<(), String> { let Some(window) = app.get_webview_window(PET_WINDOW_ID) else { return Ok(()); }; window .set_always_on_top(preferences.always_on_top) .map_err(|error| error.to_string())?; let monitors = available_monitor_info(&app)?; let index = preferences .monitor_index .unwrap_or(0) .min(monitors.len().saturating_sub(1)); let mode = if preferences.game_mode { pet::PetPositionMode::Edge } else { preferences.position_mode }; if let Some(monitor) = monitors.get(index) { place_pet_on_monitor(&window, monitor, mode)?; } Ok(()) } #[tauri::command] fn inspect_foreground_window() -> Result { windows::foreground_window::inspect_foreground_window(std::time::Duration::from_secs(60)) .map(|selection| selection.summary()) .map_err(|error| error.to_string()) } #[tauri::command] fn inspect_process( request: ProcessDiagnosticRequest, ) -> Result { windows::process::inspect_process(request.process_id).map_err(|error| error.to_string()) } #[tauri::command] async fn check_network_target( request: NetworkDiagnosticRequest, ) -> Result { diagnostics::network::check_tcp_target(&diagnostics::network::NetworkTarget { host: request.host, port: request.port, timeout: std::time::Duration::from_secs(request.timeout_seconds.unwrap_or(3).min(10)), }) .await .map_err(|error| error.to_string()) } #[tauri::command] fn close_pet_window(app: AppHandle) -> Result<(), String> { if let Some(window) = app.get_webview_window(PET_WINDOW_ID) { window.destroy().map_err(|error| error.to_string())?; } Ok(()) } #[tauri::command] fn show_pet_context_menu(app: AppHandle) -> Result<(), String> { let open_main = MenuItem::with_id( &app, "pet-open-main", "\u{6253}\u{5f00}\u{4e3b}\u{754c}\u{9762}", true, None::<&str>, ) .map_err(|error| error.to_string())?; let open_quick = MenuItem::with_id( &app, "pet-open-quick", "\u{6253}\u{5f00}\u{5feb}\u{6377}\u{804a}\u{5929}", true, None::<&str>, ) .map_err(|error| error.to_string())?; let toggle_game = MenuItem::with_id( &app, "pet-game-mode", "\u{5207}\u{6362}\u{6e38}\u{620f}\u{6a21}\u{5f0f}", true, None::<&str>, ) .map_err(|error| error.to_string())?; let separator = PredefinedMenuItem::separator(&app).map_err(|error| error.to_string())?; let hide_pet = MenuItem::with_id( &app, "pet-hide", "\u{5173}\u{95ed}\u{684c}\u{5ba0}", true, None::<&str>, ) .map_err(|error| error.to_string())?; let quit = MenuItem::with_id( &app, "pet-exit", "\u{5173}\u{95ed}\u{7a0b}\u{5e8f}", true, None::<&str>, ) .map_err(|error| error.to_string())?; let menu = Menu::with_items( &app, &[ &open_main, &open_quick, &toggle_game, &separator, &hide_pet, &quit, ], ) .map_err(|error| error.to_string())?; let window = app .get_webview_window(PET_WINDOW_ID) .or_else(|| app.get_webview_window("main")) .ok_or_else(|| "pet context menu window is unavailable".to_owned())?; window.popup_menu(&menu).map_err(|error| error.to_string()) } #[tauri::command] fn bootstrap_status( database: tauri::State<'_, ApplicationDatabase>, ) -> Result { let database_schema_version = database .schema_version() .map_err(|_| "database status is unavailable".to_owned())?; Ok(BootstrapStatus { app_version: env!("CARGO_PKG_VERSION"), platform: "windows", rust_core: "ready", protocol_version: desktop_protocol::PROTOCOL_VERSION, database_schema_version, }) } #[tauri::command] fn connection_policy_status( database: tauri::State<'_, ApplicationDatabase>, guards: tauri::State<'_, RuntimeGuards>, ) -> Result { let switch = guards .operations_switch_status() .map_err(|_| "operations switch guard is unavailable".to_owned())?; let warnings = policy::list_duplicate_server_instance_warnings(&database) .map_err(|_| "database status is unavailable".to_owned())?; Ok(ConnectionPolicyStatus { operations_switch_locked: switch.locked, active_operations_task_count: switch.active_task_count, duplicate_server_instance_warnings: warnings, }) } pub fn run() { logging::init(); tauri::Builder::default() .plugin(tauri_plugin_single_instance::init(|app, _, _| { if let Some(window) = app.get_webview_window("main") { let _ = window.show(); let _ = window.set_focus(); } })) .on_menu_event(|app, event| match event.id.as_ref() { "pet-open-main" => { let _ = open_main_window(app.clone()); } "pet-open-quick" => { let _ = open_quick_chat_window(app.clone(), None); } "pet-game-mode" => { let _ = app.emit("pet-game-mode-toggle", ()); } "pet-hide" => { let _ = close_pet_window(app.clone()); let _ = app.emit("pet-hide-requested", ()); } "pet-exit" => exit_application(app), _ => {} }) .setup(|app| { let app_data_dir = app.path().app_data_dir()?; std::fs::create_dir_all(&app_data_dir)?; app.manage(ApplicationDatabase::open( app_data_dir.join("astrbot-desktop.sqlite3"), )?); let session_marker = app_data_dir.join(SESSION_MARKER_FILE); if session_marker.exists() { tracing::warn!("previous AstrBot Desktop session ended unexpectedly; local state remains available"); } std::fs::write(&session_marker, std::process::id().to_string())?; app.manage(SessionMarker(session_marker)); app.manage(RuntimeGuards::new()); app.manage(DualSlotRuntime::new()); let startup_handle = app.handle().clone(); tauri::async_runtime::spawn(async move { let database = startup_handle.state::(); let runtime = startup_handle.state::(); auto_connect_configured_slots(&database, &runtime).await; }); let event_handle = app.handle().clone(); tauri::async_runtime::spawn(async move { loop { let runtime = event_handle.state::(); if let Some(event) = runtime.try_recv_event().await { let database = event_handle.state::(); networking::commands::persist_runtime_event(&database, &event); let _ = event_handle.emit("connection-runtime-event", event); } else { tokio::time::sleep(std::time::Duration::from_millis(50)).await; } } }); let show = MenuItem::with_id(app, "show", "打开主界面", true, None::<&str>)?; let quick = MenuItem::with_id(app, "quick", "打开快捷聊天", true, None::<&str>)?; let companion_status = MenuItem::with_id(app, "companion-status", "陪伴:未连接", false, None::<&str>)?; let operations_status = MenuItem::with_id( app, "operations-status", "运维:未连接", false, None::<&str>, )?; let quit = MenuItem::with_id(app, "quit", "退出程序", true, None::<&str>)?; let menu = Menu::with_items( app, &[&show, &quick, &companion_status, &operations_status, &quit], )?; let tray_handle = app.handle().clone(); let companion_status_handle = companion_status.clone(); let operations_status_handle = operations_status.clone(); tauri::async_runtime::spawn(async move { loop { let status = tray_handle.state::().status().await; let _ = companion_status_handle .set_text(tray_state_label("陪伴", status.companion.state)); let _ = operations_status_handle .set_text(tray_state_label("运维", status.operations.state)); tokio::time::sleep(std::time::Duration::from_secs(1)).await; } }); TrayIconBuilder::with_id("main") .menu(&menu) .on_menu_event(|app, event| match event.id.as_ref() { "show" => { if let Some(window) = app.get_webview_window("main") { let _ = window.show(); let _ = window.set_focus(); } } "quick" => { let _ = open_quick_chat_window(app.clone(), None); } "quit" => exit_application(app), _ => {} }) .build(app)?; Ok(()) }) .on_window_event(|window, event| match event { WindowEvent::Moved(_) | WindowEvent::Resized(_) => { if window.label() == QUICK_WINDOW_ID { save_quick_window_state(window, window.app_handle()); } } WindowEvent::CloseRequested { api, .. } => { if window.label() == QUICK_WINDOW_ID { save_quick_window_state(window, window.app_handle()); return; } if window.label() == PET_WINDOW_ID { api.prevent_close(); let _ = window.hide(); return; } api.prevent_close(); let _ = window.hide(); } _ => {} }) .invoke_handler(tauri::generate_handler![ auth::login_profile_jwt, bootstrap_status, open_quick_chat_window, open_main_window, open_status_bubble_window, open_pet_window, close_pet_window, show_pet_context_menu, list_monitor_geometries, set_pet_window_preferences, inspect_foreground_window, inspect_process, check_network_target, connection_policy_status, profiles::list_connection_profiles, profiles::create_connection_profile, profiles::update_connection_profile, profiles::delete_connection_profile, slots::list_connection_slots, slots::assign_connection_slot, slots::clear_connection_slot, credentials::enroll_profile_credential, credentials::clear_profile_credential, networking::commands::connection_runtime_status, networking::commands::drain_connection_runtime_events, networking::commands::load_chat_messages, networking::commands::list_chat_sessions, networking::commands::mark_chat_session_read, networking::commands::probe_connection_slot, networking::commands::disconnect_connection_slot, networking::commands::send_connection_slot_message, networking::commands::connection_slot_capabilities, networking::commands::connection_slot_sessions, networking::commands::switch_connection_slot_session, networking::commands::upload_connection_slot_file, networking::commands::download_connection_slot_attachment, networking::commands::cancel_connection_slot_message, ]) .run(tauri::generate_context!()) .expect("failed to run AstrBot Desktop"); }