feat(window):save window state before handling close requests

Author: kev1n77

Cargo.toml

@@ -178,6 +178,7 @@ tauri-plugin-notification = "2.3"
 tauri-plugin-updater = "2.10"
 tauri-plugin-global-shortcut = "2.3"
 tauri-plugin-single-instance = "2.4"
+tauri-plugin-window-state = "2.4"
 tauri-build = { version = "2.6", features = [] }
 
 # Desktop support

src/apps/desktop/Cargo.toml

@@ -42,6 +42,7 @@ tauri-plugin-notification = { workspace = true }
 tauri-plugin-updater = { workspace = true }
 tauri-plugin-global-shortcut = { workspace = true }
 tauri-plugin-single-instance = { workspace = true }
+tauri-plugin-window-state = { workspace = true }
 # Keep Tauri's transitive time resolution on the known-good release in CI,
 # where the root Cargo.lock is intentionally ignored.
 time = { workspace = true }

src/apps/desktop/src/api/system_api.rs

@@ -196,6 +196,7 @@ pub struct RestartAppRequest {}
 pub async fn restart_app(app: AppHandle, request: RestartAppRequest) -> Result<(), String> {
     let _ = request;
     crate::crash_diagnostics::mark_clean_shutdown("restart_app");
+    crate::save_main_window_state(&app);
     crate::perform_process_exit_cleanup();
     app.restart();
     Ok(())

src/apps/desktop/src/lib.rs

@@ -28,6 +28,7 @@ use std::sync::{
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 use tauri::Emitter;
 use tauri::Manager;
+use tauri_plugin_window_state::{AppHandleExt, StateFlags};
 
 // Re-export API
 pub use api::*;
@@ -250,6 +251,16 @@ fn handle_secondary_launch(app: &tauri::AppHandle) {
     }
 }
 
+fn main_window_state_flags() -> StateFlags {
+    StateFlags::SIZE | StateFlags::POSITION | StateFlags::MAXIMIZED | StateFlags::FULLSCREEN
+}
+
+pub(crate) fn save_main_window_state(app: &tauri::AppHandle) {
+    if let Err(error) = app.save_window_state(main_window_state_flags()) {
+        log::warn!("Failed to save main window state: {}", error);
+    }
+}
+
 #[tauri::command]
 async fn webdriver_bridge_result(request: WebdriverBridgeResultRequest) -> Result<(), String> {
     log::debug!("webdriver_bridge_result command invoked");
@@ -446,6 +457,12 @@ pub async fn run() {
         )
         .plugin(tauri_plugin_notification::init())
         .plugin(tauri_plugin_updater::Builder::new().build())
+        .plugin(
+            tauri_plugin_window_state::Builder::default()
+                .with_state_flags(main_window_state_flags())
+                .with_filter(|label| label == "main")
+                .build(),
+        )
         .manage(app_state)
         .manage(desktop_runtime)
         .manage(coordinator_state)
@@ -836,6 +853,12 @@ pub async fn run() {
         })
         .on_window_event({
             move |window, event| {
+                if window.label() == "main"
+                    && matches!(event, tauri::WindowEvent::CloseRequested { .. })
+                {
+                    save_main_window_state(window.app_handle());
+                }
+
                 if let tauri::WindowEvent::CloseRequested { api: _api, .. } = event {
                     if window.label() == "main" {
                         #[cfg(target_os = "macos")]

src/apps/desktop/src/theme.rs

@@ -1,8 +1,6 @@
 //! Theme System
 
 use std::sync::{OnceLock, RwLock};
-#[cfg(target_os = "windows")]
-use std::time::Duration;
 use std::time::Instant;
 
 use bitfun_core::infrastructure::try_get_path_manager_arc;
@@ -20,109 +18,13 @@ const AGENT_COMPANION_WINDOW_MAX_WIDTH: f64 = 360.0;
 const AGENT_COMPANION_WINDOW_MAX_HEIGHT: f64 = 240.0;
 const AGENT_COMPANION_WINDOW_MARGIN: i32 = 64;
 const AGENT_COMPANION_WINDOW_EDGE_MARGIN: f64 = 8.0;
-#[cfg(target_os = "windows")]
-const WINDOWS_STARTUP_MAXIMIZE_SHOW_WAIT_MAX: Duration = Duration::from_millis(150);
-#[cfg(target_os = "windows")]
-const WINDOWS_STARTUP_MAXIMIZE_SHOW_WAIT_MIN: Duration = Duration::from_millis(16);
-#[cfg(target_os = "windows")]
-const WINDOWS_STARTUP_MAXIMIZE_SHOW_WAIT_POLL: Duration = Duration::from_millis(8);
-
 static AGENT_COMPANION_WINDOW_OPS: OnceLock<tokio::sync::Mutex<()>> = OnceLock::new();
 static AGENT_COMPANION_WINDOW_LAST_POSITION: OnceLock<RwLock<Option<tauri::LogicalPosition<f64>>>> =
     OnceLock::new();
 static STARTUP_THEME_BOOTSTRAP_MANIFEST: OnceLock<StartupThemeBootstrapManifest> = OnceLock::new();
 
 const STARTUP_THEME_BOOTSTRAP_JSON: &str = include_str!("generated/startup_theme_bootstrap.json");
 
-#[cfg(target_os = "windows")]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum WindowsMaximizeShowWaitAction {
-    Ready,
-    Sleep(Duration),
-    TimedOut,
-}
-
-#[cfg(target_os = "windows")]
-fn windows_maximize_show_wait_action(
-    is_maximized: Option<bool>,
-    elapsed: Duration,
-) -> WindowsMaximizeShowWaitAction {
-    if is_maximized == Some(true) && elapsed >= WINDOWS_STARTUP_MAXIMIZE_SHOW_WAIT_MIN {
-        return WindowsMaximizeShowWaitAction::Ready;
-    }
-
-    if elapsed >= WINDOWS_STARTUP_MAXIMIZE_SHOW_WAIT_MAX {
-        return WindowsMaximizeShowWaitAction::TimedOut;
-    }
-
-    let target_wait = if is_maximized == Some(true) {
-        WINDOWS_STARTUP_MAXIMIZE_SHOW_WAIT_MIN
-    } else {
-        WINDOWS_STARTUP_MAXIMIZE_SHOW_WAIT_MAX
-    };
-    WindowsMaximizeShowWaitAction::Sleep(
-        target_wait
-            .saturating_sub(elapsed)
-            .min(WINDOWS_STARTUP_MAXIMIZE_SHOW_WAIT_POLL),
-    )
-}
-
-#[cfg(target_os = "windows")]
-fn read_windows_maximize_state(
-    window: &tauri::WebviewWindow,
-    logged_error: &mut bool,
-) -> Option<bool> {
-    match window.is_maximized() {
-        Ok(is_maximized) => Some(is_maximized),
-        Err(error) => {
-            if !*logged_error {
-                warn!(
-                    "Failed to read main window maximize state during startup show wait: {}",
-                    error
-                );
-                *logged_error = true;
-            }
-            None
-        }
-    }
-}
-
-#[cfg(target_os = "windows")]
-fn wait_for_windows_maximize_before_show(window: &tauri::WebviewWindow) -> &'static str {
-    let started_at = Instant::now();
-    let mut logged_error = false;
-
-    loop {
-        match windows_maximize_show_wait_action(
-            read_windows_maximize_state(window, &mut logged_error),
-            started_at.elapsed(),
-        ) {
-            WindowsMaximizeShowWaitAction::Ready => return "ready",
-            WindowsMaximizeShowWaitAction::TimedOut => return "timeout",
-            WindowsMaximizeShowWaitAction::Sleep(duration) => std::thread::sleep(duration),
-        }
-    }
-}
-
-#[cfg(target_os = "windows")]
-async fn wait_for_windows_maximize_before_show_async(
-    window: &tauri::WebviewWindow,
-) -> &'static str {
-    let started_at = Instant::now();
-    let mut logged_error = false;
-
-    loop {
-        match windows_maximize_show_wait_action(
-            read_windows_maximize_state(window, &mut logged_error),
-            started_at.elapsed(),
-        ) {
-            WindowsMaximizeShowWaitAction::Ready => return "ready",
-            WindowsMaximizeShowWaitAction::TimedOut => return "timeout",
-            WindowsMaximizeShowWaitAction::Sleep(duration) => tokio::time::sleep(duration).await,
-        }
-    }
-}
-
 fn agent_companion_window_ops() -> &'static tokio::sync::Mutex<()> {
     AGENT_COMPANION_WINDOW_OPS.get_or_init(|| tokio::sync::Mutex::new(()))
 }
@@ -575,6 +477,7 @@ pub fn create_main_window(
     let mut builder = tauri::WebviewWindowBuilder::new(app_handle, "main", main_url)
         .title("BitFun")
         .inner_size(1200.0, 800.0)
+        .center()
         .resizable(true)
         .fullscreen(false)
         .visible(false)
@@ -660,34 +563,6 @@ fn show_main_window_for_startup(
     total_started_at: Instant,
     startup_trace: &DesktopStartupTrace,
 ) {
-    #[cfg(target_os = "windows")]
-    {
-        let step_started_at = Instant::now();
-        if let Err(error) = window.maximize() {
-            warn!("Failed to maximize main window during startup: {}", error);
-        } else {
-            startup_trace.record_elapsed_step("native_window", "windows_maximize", step_started_at);
-            debug!(
-                "Main window startup show step completed: step=maximize duration_ms={} since_create_start_ms={}",
-                step_started_at.elapsed().as_millis(),
-                total_started_at.elapsed().as_millis()
-            );
-        }
-        let show_delay_started_at = Instant::now();
-        let show_wait_outcome = wait_for_windows_maximize_before_show(window);
-        startup_trace.record_elapsed_step(
-            "native_window",
-            "windows_show_after_maximize_wait",
-            show_delay_started_at,
-        );
-        debug!(
-            "Main window startup show step completed: step=wait_for_maximize_state outcome={} duration_ms={} since_create_start_ms={}",
-            show_wait_outcome,
-            show_delay_started_at.elapsed().as_millis(),
-            total_started_at.elapsed().as_millis()
-        );
-    }
-
     let show_started_at = Instant::now();
     if let Err(error) = window.show() {
         warn!("Failed to show main window during startup: {}", error);
@@ -1012,29 +887,6 @@ pub async fn hide_agent_companion_desktop_pet(app: tauri::AppHandle) -> Result<(
 pub async fn show_main_window(app: tauri::AppHandle) -> Result<(), String> {
     let total_started_at = Instant::now();
     if let Some(main_window) = app.get_webview_window("main") {
-        #[cfg(target_os = "windows")]
-        {
-            // Work around Windows startup flicker: avoid creating the native window
-            // in maximized mode, and maximize it right before showing instead.
-            let step_started_at = Instant::now();
-            main_window.maximize().map_err(|e| {
-                error!("Failed to maximize main window: {}", e);
-                format!("Failed to maximize main window: {}", e)
-            })?;
-            debug!(
-                "Main window show step completed: step=maximize duration_ms={}",
-                step_started_at.elapsed().as_millis()
-            );
-
-            let wait_started_at = Instant::now();
-            let show_wait_outcome = wait_for_windows_maximize_before_show_async(&main_window).await;
-            debug!(
-                "Main window show step completed: step=wait_for_maximize_state outcome={} duration_ms={}",
-                show_wait_outcome,
-                wait_started_at.elapsed().as_millis()
-            );
-        }
-
         let step_started_at = Instant::now();
         main_window.show().map_err(|e| {
             error!("Failed to show main window: {}", e);
@@ -1071,44 +923,3 @@ pub async fn show_main_window(app: tauri::AppHandle) -> Result<(), String> {
     );
     Ok(())
 }
-
-#[cfg(test)]
-mod tests {
-    #[cfg(target_os = "windows")]
-    use super::*;
-
-    #[cfg(target_os = "windows")]
-    #[test]
-    fn windows_maximize_show_wait_releases_when_maximized() {
-        assert_eq!(
-            windows_maximize_show_wait_action(Some(true), Duration::ZERO),
-            WindowsMaximizeShowWaitAction::Sleep(WINDOWS_STARTUP_MAXIMIZE_SHOW_WAIT_POLL)
-        );
-        assert_eq!(
-            windows_maximize_show_wait_action(Some(true), WINDOWS_STARTUP_MAXIMIZE_SHOW_WAIT_MIN),
-            WindowsMaximizeShowWaitAction::Ready
-        );
-    }
-
-    #[cfg(target_os = "windows")]
-    #[test]
-    fn windows_maximize_show_wait_polls_until_max_wait() {
-        assert_eq!(
-            windows_maximize_show_wait_action(Some(false), Duration::from_millis(20)),
-            WindowsMaximizeShowWaitAction::Sleep(WINDOWS_STARTUP_MAXIMIZE_SHOW_WAIT_POLL)
-        );
-        assert_eq!(
-            windows_maximize_show_wait_action(None, Duration::from_millis(148)),
-            WindowsMaximizeShowWaitAction::Sleep(Duration::from_millis(2))
-        );
-    }
-
-    #[cfg(target_os = "windows")]
-    #[test]
-    fn windows_maximize_show_wait_times_out_at_original_bound() {
-        assert_eq!(
-            windows_maximize_show_wait_action(Some(false), WINDOWS_STARTUP_MAXIMIZE_SHOW_WAIT_MAX),
-            WindowsMaximizeShowWaitAction::TimedOut
-        );
-    }
-}

src/web-ui/src/app/startup/startupPerformanceContract.test.ts

@@ -168,18 +168,21 @@ describe('startup performance contract', () => {
     );
   });
 
-  it('keeps Windows startup show wait state-driven instead of fixed-delay only', () => {
+  it('centers the first main window and persists geometry before close handling', () => {
     const desktopThemeSource = readSource('../../../../apps/desktop/src/theme.rs');
-
-    expect(desktopThemeSource).toContain('WINDOWS_STARTUP_MAXIMIZE_SHOW_WAIT_MAX');
-    expect(desktopThemeSource).toContain('WINDOWS_STARTUP_MAXIMIZE_SHOW_WAIT_MIN');
-    expect(desktopThemeSource).toContain('WINDOWS_STARTUP_MAXIMIZE_SHOW_WAIT_POLL');
-    expect(desktopThemeSource).toContain('windows_maximize_show_wait_action');
-    expect(desktopThemeSource).toContain('window.is_maximized()');
-    expect(desktopThemeSource).toContain('windows_show_after_maximize_wait');
-    expect(desktopThemeSource).not.toContain(
-      'std::thread::sleep(std::time::Duration::from_millis(150))'
-    );
+    const desktopLibSource = readSource('../../../../apps/desktop/src/lib.rs');
+    const windowEventStart = desktopLibSource.indexOf('.on_window_event({');
+    const invokeHandlerStart = desktopLibSource.indexOf('.invoke_handler(', windowEventStart);
+    const windowEventSource = desktopLibSource.slice(windowEventStart, invokeHandlerStart);
+
+    expect(desktopThemeSource).toContain('.inner_size(1200.0, 800.0)\n        .center()');
+    expect(desktopThemeSource).not.toContain('windows_maximize_show_wait_action');
+    expect(desktopLibSource).toContain('tauri_plugin_window_state::Builder::default()');
+    expect(desktopLibSource).toContain('.with_filter(|label| label == "main")');
+    expect(windowEventStart).toBeGreaterThan(-1);
+    expect(invokeHandlerStart).toBeGreaterThan(windowEventStart);
+    expect(windowEventSource).toContain('matches!(event, tauri::WindowEvent::CloseRequested { .. })');
+    expect(windowEventSource).toContain('save_main_window_state(window.app_handle())');
   });
 
   it('keeps system tray creation out of the synchronous Tauri setup path', () => {