fix: confirm desktop close behavior before hiding to tray

src-tauri/capabilities/default.json

@@ -2,7 +2,7 @@
   "$schema": "../gen/schemas/desktop-schema.json",
   "identifier": "main-capability",
   "description": "Default IPC capability for the main window and loopback dashboard origin.",
-  "windows": ["main"],
+  "windows": ["main", "close-confirm"],
   "local": true,
   "remote": {
     "urls": ["http://127.0.0.1:*", "http://localhost:*"]

src-tauri/src/app_runtime.rs

@@ -4,8 +4,9 @@ use tauri::{
 };
 
 use crate::{
-    app_runtime_events, append_desktop_log, append_startup_log, bridge, lifecycle, startup_task,
-    tray, window, BackendState, DEFAULT_SHELL_LOCALE, DESKTOP_LOG_FILE, STARTUP_MODE_ENV,
+    app_runtime_events, append_desktop_log, append_shutdown_log, append_startup_log, bridge,
+    close_behavior, lifecycle, startup_task, tray, window, BackendState, DEFAULT_SHELL_LOCALE,
+    DESKTOP_LOG_FILE, STARTUP_MODE_ENV,
 };
 
 fn configure_plugins(builder: Builder<tauri::Wry>) -> Builder<tauri::Wry> {
@@ -22,24 +23,54 @@ fn configure_window_events(builder: Builder<tauri::Wry>) -> Builder<tauri::Wry>
     builder.on_window_event(|window, event| {
         let is_quitting = window.app_handle().state::<BackendState>().is_quitting();
         let action = match &event {
-            WindowEvent::CloseRequested { .. } => app_runtime_events::main_window_action(
-                window.label(),
-                is_quitting,
-                false,
-                true,
-                false,
-            ),
+            WindowEvent::CloseRequested { .. } => {
+                let packaged_root_dir = crate::runtime_paths::default_packaged_root_dir();
+                let saved_close_action =
+                    close_behavior::read_cached_close_action(packaged_root_dir.as_deref());
+
+                app_runtime_events::main_window_action(
+                    window.label(),
+                    is_quitting,
+                    false,
+                    true,
+                    false,
+                    saved_close_action,
+                )
+            }
             WindowEvent::Focused(false) => app_runtime_events::main_window_action(
                 window.label(),
                 is_quitting,
                 matches!(window.is_minimized(), Ok(true)),
                 false,
                 true,
+                None,
             ),
             _ => app_runtime_events::MainWindowAction::None,
         };
 
         match action {
+            app_runtime_events::MainWindowAction::ShowClosePrompt => {
+                if let WindowEvent::CloseRequested { api, .. } = event {
+                    api.prevent_close();
+                }
+                append_desktop_log(
+                    "main window close requested without saved preference; close prompt pending",
+                );
+                if let Err(error) = window::close_confirm::show_close_confirm_window(
+                    window.app_handle(),
+                    DEFAULT_SHELL_LOCALE,
+                    append_desktop_log,
+                ) {
+                    append_desktop_log(&format!(
+                        "failed to open close confirm prompt window: {error}"
+                    ));
+                    window::actions::hide_main_window(
+                        window.app_handle(),
+                        DEFAULT_SHELL_LOCALE,
+                        append_desktop_log,
+                    );
+                }
+            }
             app_runtime_events::MainWindowAction::PreventCloseAndHide => {
                 if let WindowEvent::CloseRequested { api, .. } = event {
                     api.prevent_close();
@@ -50,6 +81,12 @@ fn configure_window_events(builder: Builder<tauri::Wry>) -> Builder<tauri::Wry>
                     append_desktop_log,
                 );
             }
+            app_runtime_events::MainWindowAction::ExitApplication => {
+                let state = window.app_handle().state::<BackendState>();
+                state.mark_quitting();
+                append_shutdown_log("main window close requested with saved exit preference");
+                window.app_handle().exit(0);
+            }
             app_runtime_events::MainWindowAction::HideIfMinimized => {
                 window::actions::hide_main_window(
                     window.app_handle(),
@@ -170,6 +207,7 @@ pub(crate) fn run() {
             crate::bridge::commands::desktop_bridge_restart_backend,
             crate::bridge::commands::desktop_bridge_stop_backend,
             crate::bridge::commands::desktop_bridge_open_external_url,
+            crate::bridge::commands::desktop_bridge_submit_close_prompt,
             crate::bridge::commands::desktop_bridge_check_app_update,
             crate::bridge::commands::desktop_bridge_install_app_update
         ])

src-tauri/src/app_runtime_events.rs

@@ -1,9 +1,13 @@
 use tauri::{webview::PageLoadEvent, RunEvent};
 
+use crate::close_behavior::CloseAction;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum MainWindowAction {
     None,
+    ShowClosePrompt,
     PreventCloseAndHide,
+    ExitApplication,
     HideIfMinimized,
 }
 
@@ -29,6 +33,7 @@ pub(crate) fn main_window_action(
     minimized_on_focus_lost: bool,
     is_close_requested: bool,
     is_focus_lost: bool,
+    saved_close_action: Option<CloseAction>,
 ) -> MainWindowAction {
     if window_label != "main" {
         return MainWindowAction::None;
@@ -38,7 +43,11 @@ pub(crate) fn main_window_action(
         return if is_quitting {
             MainWindowAction::None
         } else {
-            MainWindowAction::PreventCloseAndHide
+            match saved_close_action {
+                Some(CloseAction::Tray) => MainWindowAction::PreventCloseAndHide,
+                Some(CloseAction::Exit) => MainWindowAction::ExitApplication,
+                None => MainWindowAction::ShowClosePrompt,
+            }
         };
     }
 
@@ -93,6 +102,7 @@ mod tests {
         main_window_action, page_load_action, run_event_action, MainWindowAction, PageLoadAction,
         RunEventAction,
     };
+    use crate::close_behavior::CloseAction;
     use tauri::{webview::PageLoadEvent, RunEvent};
 
     #[cfg(target_os = "macos")]
@@ -101,23 +111,39 @@ mod tests {
     #[test]
     fn main_window_action_ignores_non_main_windows() {
         assert_eq!(
-            main_window_action("settings", false, false, true, false),
+            main_window_action("settings", false, false, true, false, None),
             MainWindowAction::None
         );
     }
 
     #[test]
-    fn main_window_action_hides_on_close_when_not_quitting() {
+    fn main_window_action_prompts_when_no_saved_close_preference_exists() {
+        assert_eq!(
+            main_window_action("main", false, false, true, false, None),
+            MainWindowAction::ShowClosePrompt
+        );
+    }
+
+    #[test]
+    fn main_window_action_hides_on_close_when_saved_preference_is_tray() {
         assert_eq!(
-            main_window_action("main", false, false, true, false),
+            main_window_action("main", false, false, true, false, Some(CloseAction::Tray)),
             MainWindowAction::PreventCloseAndHide
         );
     }
 
+    #[test]
+    fn main_window_action_exits_on_close_when_saved_preference_is_exit() {
+        assert_eq!(
+            main_window_action("main", false, false, true, false, Some(CloseAction::Exit)),
+            MainWindowAction::ExitApplication
+        );
+    }
+
     #[test]
     fn main_window_action_hides_on_minimized_focus_loss() {
         assert_eq!(
-            main_window_action("main", false, true, false, true),
+            main_window_action("main", false, true, false, true, None),
             MainWindowAction::HideIfMinimized
         );
     }

src-tauri/src/bridge/commands.rs

@@ -13,9 +13,10 @@ use crate::bridge::updater_types::{
     map_update_channel_ok, map_update_check_error, map_update_install_error, map_update_install_ok,
     DesktopAppUpdateChannelResult, DesktopAppUpdateCheckResult, DesktopAppUpdateResult,
 };
+use crate::close_behavior::{self, CloseAction};
 use crate::{
     append_desktop_log, restart_backend_flow, runtime_paths, shell_locale, tray, update_channel,
-    BackendBridgeResult, BackendBridgeState, BackendState, DEFAULT_SHELL_LOCALE,
+    window, BackendBridgeResult, BackendBridgeState, BackendState, DEFAULT_SHELL_LOCALE,
 };
 
 fn resolve_update_channel(app_handle: &AppHandle) -> update_channel::UpdateChannel {
@@ -160,6 +161,11 @@ fn parse_openable_url(raw_url: &str) -> Result<Url, String> {
     }
 }
 
+fn parse_close_prompt_action(raw_action: &str) -> Result<CloseAction, String> {
+    close_behavior::parse_close_action(raw_action)
+        .ok_or_else(|| "Invalid close action. Expected 'tray' or 'exit'.".to_string())
+}
+
 #[cfg(target_os = "macos")]
 fn open_url_with_system_browser(url: &str) -> Result<(), String> {
     Command::new("open")
@@ -287,6 +293,68 @@ pub(crate) fn desktop_bridge_open_external_url(url: String) -> BackendBridgeResu
     }
 }
 
+#[tauri::command]
+pub(crate) fn desktop_bridge_submit_close_prompt(
+    app_handle: AppHandle,
+    action: String,
+    remember: bool,
+) -> BackendBridgeResult {
+    let action = match parse_close_prompt_action(&action) {
+        Ok(action) => action,
+        Err(error) => {
+            return BackendBridgeResult {
+                ok: false,
+                reason: Some(error),
+            };
+        }
+    };
+
+    if remember {
+        let packaged_root_dir = runtime_paths::default_packaged_root_dir();
+        if let Err(error) =
+            close_behavior::write_cached_close_action(Some(action), packaged_root_dir.as_deref())
+        {
+            append_desktop_log(&format!(
+                "failed to persist remembered close action; continuing with selected action: {error}"
+            ));
+        }
+    }
+
+    match action {
+        CloseAction::Tray => {
+            window::actions::hide_main_window(
+                &app_handle,
+                DEFAULT_SHELL_LOCALE,
+                append_desktop_log,
+            );
+            if let Some(prompt_window) = app_handle.get_webview_window("close-confirm") {
+                if let Err(error) = prompt_window.close() {
+                    let reason = format!("Failed to close close confirm prompt window: {error}");
+                    append_desktop_log(&reason);
+                    return BackendBridgeResult {
+                        ok: false,
+                        reason: Some(reason),
+                    };
+                }
+            }
+
+            BackendBridgeResult {
+                ok: true,
+                reason: None,
+            }
+        }
+        CloseAction::Exit => {
+            let state = app_handle.state::<BackendState>();
+            state.mark_quitting();
+            app_handle.exit(0);
+            BackendBridgeResult {
+                ok: true,
+                reason: None,
+            }
+        }
+    }
+}
+
 #[tauri::command]
 pub(crate) fn desktop_bridge_set_shell_locale(
     app_handle: AppHandle,
@@ -470,6 +538,20 @@ mod tests {
         );
     }
 
+    #[test]
+    fn parse_close_prompt_action_accepts_supported_values() {
+        assert_eq!(parse_close_prompt_action("tray"), Ok(CloseAction::Tray));
+        assert_eq!(parse_close_prompt_action("exit"), Ok(CloseAction::Exit));
+    }
+
+    #[test]
+    fn parse_close_prompt_action_rejects_invalid_values() {
+        assert_eq!(
+            parse_close_prompt_action("minimize"),
+            Err("Invalid close action. Expected 'tray' or 'exit'.".to_string())
+        );
+    }
+
     #[test]
     fn updater_check_manual_download_mode_only_reports_reason_without_forced_update_flag() {
         let result = crate::bridge::updater_types::map_manual_download_no_update_result(