feat: Add auto-start and system tray functionality (WIP)

- Add tauri-plugin-autostart for launch at startup
- Implement close-to-tray behavior with window event handler
- Add startup settings commands (get/update)
- Create Switch UI component
- Add Settings UI for auto-launch, start minimized, and close-to-tray
- Support --hidden flag for background startup

Note: Has compilation error in mcpmux-core to be fixed after merge

Author: Mohammod Al Amin Ashik

Cargo.lock

@@ -20,6 +20,7 @@ tauri-plugin-opener = "2"
 tauri-plugin-single-instance = "2"
 tauri-plugin-deep-link = "2"
 tauri-plugin-updater = "2"
+tauri-plugin-autostart = "2"
 serde.workspace = true
 serde_json.workspace = true
 tokio.workspace = true

apps/desktop/src-tauri/Cargo.toml

@@ -16,6 +16,7 @@ pub mod server;
 pub mod server_discovery;
 pub mod server_feature;
 pub mod server_manager;
+pub mod settings;
 pub mod space;
 
 // Re-export commands for convenience
@@ -31,4 +32,5 @@ pub use server::*;
 pub use server_discovery::*;
 pub use server_feature::*;
 pub use server_manager::*;
+pub use settings::*;
 pub use space::*;

apps/desktop/src-tauri/src/commands/mod.rs

@@ -0,0 +1,118 @@
+//! Settings commands for auto-start and system tray behavior
+
+use serde::{Deserialize, Serialize};
+use tauri::State;
+use tauri_plugin_autostart::AutoLaunchManager;
+use tracing::{debug, error, info};
+
+use crate::state::AppState;
+
+/// Startup and system tray settings
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StartupSettings {
+    /// Whether to launch the app at system startup
+    pub auto_launch: bool,
+    /// Whether to start minimized to tray
+    pub start_minimized: bool,
+    /// Whether to minimize to tray instead of closing
+    pub close_to_tray: bool,
+}
+
+impl Default for StartupSettings {
+    fn default() -> Self {
+        Self {
+            auto_launch: false,
+            start_minimized: false,
+            close_to_tray: true, // Default to close-to-tray behavior
+        }
+    }
+}
+
+/// Get current startup settings
+#[tauri::command]
+pub async fn get_startup_settings(
+    app_state: State<'_, AppState>,
+    manager: State<'_, AutoLaunchManager>,
+) -> Result<StartupSettings, String> {
+    debug!("[Settings] Getting startup settings");
+
+    let settings_repo = &app_state.settings_repository;
+
+    // Get auto-launch status from the OS
+    let auto_launch = manager
+        .is_enabled()
+        .await
+        .map_err(|e| format!("Failed to check auto-launch status: {}", e))?;
+
+    // Get other settings from database
+    let start_minimized = settings_repo
+        .get("startup.start_minimized")
+        .await
+        .map_err(|e| format!("Failed to get start_minimized setting: {}", e))?
+        .map(|v| v == "true")
+        .unwrap_or(false);
+
+    let close_to_tray = settings_repo
+        .get("ui.close_to_tray")
+        .await
+        .map_err(|e| format!("Failed to get close_to_tray setting: {}", e))?
+        .map(|v| v == "true")
+        .unwrap_or(true); // Default to true
+
+    Ok(StartupSettings {
+        auto_launch,
+        start_minimized,
+        close_to_tray,
+    })
+}
+
+/// Update startup settings
+#[tauri::command]
+pub async fn update_startup_settings(
+    settings: StartupSettings,
+    app_state: State<'_, AppState>,
+    manager: State<'_, AutoLaunchManager>,
+) -> Result<(), String> {
+    info!("[Settings] Updating startup settings: {:?}", settings);
+
+    let settings_repo = &app_state.settings_repository;
+
+    // Update auto-launch in OS
+    if settings.auto_launch {
+        manager
+            .enable()
+            .await
+            .map_err(|e| format!("Failed to enable auto-launch: {}", e))?;
+        info!("[Settings] Auto-launch enabled");
+    } else {
+        manager
+            .disable()
+            .await
+            .map_err(|e| format!("Failed to disable auto-launch: {}", e))?;
+        info!("[Settings] Auto-launch disabled");
+    }
+
+    // Update other settings in database
+    settings_repo
+        .set(
+            "startup.start_minimized",
+            &settings.start_minimized.to_string(),
+        )
+        .await
+        .map_err(|e| format!("Failed to save start_minimized setting: {}", e))?;
+
+    settings_repo
+        .set("ui.close_to_tray", &settings.close_to_tray.to_string())
+        .await
+        .map_err(|e| format!("Failed to save close_to_tray setting: {}", e))?;
+
+    info!("[Settings] Startup settings updated successfully");
+    Ok(())
+}
+
+/// Check if app should start hidden (for auto-launch with --hidden flag)
+pub fn should_start_hidden() -> bool {
+    let args: Vec<String> = std::env::args().collect();
+    args.contains(&"--hidden".to_string())
+}

apps/desktop/src-tauri/src/commands/settings.rs

@@ -189,6 +189,10 @@ pub fn run() {
     tauri::Builder::default()
         .plugin(tauri_plugin_opener::init())
         .plugin(tauri_plugin_deep_link::init())
+        .plugin(tauri_plugin_autostart::init(
+            tauri_plugin_autostart::MacosLauncher::LaunchAgent,
+            Some(vec!["--hidden"]), // Start minimized to tray
+        ))
         .plugin(tauri_plugin_single_instance::init(|app, args, cwd| {
             // This callback is called when a second instance is launched
             info!("Second instance detected, focusing existing window");
@@ -517,6 +521,53 @@ pub fn run() {
             // Setup system tray
             tray::setup_tray(app.handle())?;
 
+            // Setup window close event handler for close-to-tray behavior
+            if let Some(main_window) = app.get_webview_window("main") {
+                let app_handle = app.handle().clone();
+                let settings_repo = app_state.settings_repository.clone();
+                
+                main_window.on_window_event(move |event| {
+                    if let tauri::WindowEvent::CloseRequested { api, .. } = event {
+                        // Check if close-to-tray is enabled
+                        let app_handle_clone = app_handle.clone();
+                        let settings_clone = settings_repo.clone();
+                        
+                        tauri::async_runtime::spawn(async move {
+                            match settings_clone.get("ui.close_to_tray").await {
+                                Ok(Some(value)) if value == "true" => {
+                                    // Close to tray - hide window instead of closing
+                                    info!("[Window] Close requested, hiding to tray");
+                                    if let Some(window) = app_handle_clone.get_webview_window("main") {
+                                        let _ = window.hide();
+                                    }
+                                }
+                                Ok(Some(value)) if value == "false" => {
+                                    // Actually close the app
+                                    info!("[Window] Close requested, exiting app");
+                                    app_handle_clone.exit(0);
+                                }
+                                _ => {
+                                    // Default behavior: close to tray
+                                    info!("[Window] Close requested (default), hiding to tray");
+                                    if let Some(window) = app_handle_clone.get_webview_window("main") {
+                                        let _ = window.hide();
+                                    }
+                                }
+                            }
+                        });
+                        
+                        // Always prevent default close to handle it asynchronously
+                        api.prevent_close();
+                    }
+                });
+
+                // Check if app should start hidden (auto-launch with --hidden flag)
+                if commands::should_start_hidden() {
+                    info!("[Window] Starting hidden (--hidden flag present)");
+                    let _ = main_window.hide();
+                }
+            }
+
             // Register deep link handler for when app receives URLs
             #[cfg(desktop)]
             {
@@ -644,6 +695,9 @@ pub fn run() {
             // App log commands
             get_logs_path,
             open_logs_folder,
+            // Startup settings commands
+            commands::get_startup_settings,
+            commands::update_startup_settings,
         ])
         .run(tauri::generate_context!())
         .expect("error while running McpMux application");