fix: window state persistence and login-item toggle desync (v0.5.4)

Author: VariableThe

AUDIT_LOG.md

@@ -2,6 +2,20 @@
 
 This log tracks all significant changes, updates, and versions in the PaperCache project.
 
+## 2026-06-25 - (Uncommitted)
+**Change:** fix: window state persistence and login-item toggle desync (v0.5.4)
+
+**Details/Why:**
+Two bug fixes for window state and settings reliability:
+
+1. **Window position/size not persisting across restarts**: The `tauri-plugin-window-state` v2.4.1's `on_window_ready` fires before the macOS display server is ready, causing `available_monitors()` to return empty and the saved position to be silently discarded. Fixed with a two-pronged approach: (a) `lib.rs:107-140` spawns a background thread that sleeps 300ms then dispatches `restore_state` + direct file read via `run_on_main_thread` — ensures display server is ready; (b) `commands/system.rs:33-73` new `restore_window_state` command reads `.window-state.json` directly and calls `set_position`/`set_size`, bypassing the plugin's intersection check as a fallback. Both tray "Quit" and Settings "Quit" now call `app.save_window_state()` explicitly before `app.exit(0)`.
+
+2. **Launch-at-startup toggle desync with macOS System Settings**: The toggle only read from `localStorage`, so removing PaperCache from System Settings left it permanently stuck on. Fixed by adding `get_launch_at_startup` Tauri command (`system.rs:96-98`) that queries `app.autolaunch().is_enabled()`, bridged to frontend via `api.ts`/`types.d.ts`. `Settings.tsx:52-59` runs `getLaunchAtStartup()` on mount to sync toggle and `localStorage` with real OS state.
+
+**Files changed:** `src-tauri/src/commands/system.rs`, `src-tauri/src/tray.rs`, `src-tauri/src/lib.rs`, `src/App.tsx:56`, `src/Settings.tsx:48-61`, `src/Settings.test.tsx`, `src/types.d.ts`, `src/api.ts`, `CHANGELOG.md`.
+
+---
+
 ## 2026-06-24 - (Uncommitted)
 **Change:** feat: graph view rebuilt, Windows focus-loss fix, Cmd+/ shortcuts, welcome revamp (v0.5.3)
 

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable, user-facing changes to PaperCache will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [v0.5.4] - 2026-06-25
+
+### Fixed
+- **Window position/size now persists across restarts**: The window-state plugin's `on_window_ready` fires before the macOS display server is ready, causing `available_monitors()` to return empty and the saved position to be silently discarded. Fixed by deferring window-state restoration via a background thread + `run_on_main_thread` 300ms after `setup()` completes, bypassing the plugin's monitor-intersection check with a direct file read. Both the tray "Quit" and Settings "Quit" buttons now explicitly save window state before exit.
+- **Login-item toggle stays in sync with macOS System Settings**: The launch-at-startup toggle only read from `localStorage`, so removing PaperCache from System Settings left the toggle permanently stuck in the checked state. Fixed by adding a `get_launch_at_startup` Tauri command that queries the actual OS login-item state via `app.autolaunch().is_enabled()`, and syncing the toggle with the real OS state on every Settings mount.
+
 ## [v0.5.3] - 2026-06-24
 
 ### Added

src-tauri/src/commands/system.rs

@@ -1,5 +1,6 @@
 use tauri::{AppHandle, Manager, WebviewWindow};
 use tauri_plugin_opener::OpenerExt;
+use tauri_plugin_window_state::{AppHandleExt, StateFlags};
 
 #[tauri::command]
 pub fn close_window(window: WebviewWindow) -> Result<(), String> {
@@ -28,8 +29,44 @@ pub fn toggle_window(app: &AppHandle) {
     }
 }
 
+#[tauri::command]
+pub fn restore_window_state(app: AppHandle) -> Result<(), String> {
+    if let Some(window) = app.get_webview_window("main") {
+        if let Ok(app_dir) = app.path().app_config_dir() {
+            let state_path = app_dir.join(".window-state.json");
+            if let Ok(content) = std::fs::read_to_string(&state_path) {
+                if let Ok(val) = serde_json::from_str::<serde_json::Value>(&content) {
+                    if let Some(main) = val.get("main") {
+                        if let (Some(x), Some(y)) = (
+                            main.get("x").and_then(|v| v.as_i64()),
+                            main.get("y").and_then(|v| v.as_i64()),
+                        ) {
+                            let _ = window.set_position(tauri::PhysicalPosition::new(x as i32, y as i32));
+                        }
+                        if let (Some(w), Some(h)) = (
+                            main.get("width").and_then(|v| v.as_i64()),
+                            main.get("height").and_then(|v| v.as_i64()),
+                        ) {
+                            let _ = window.set_size(tauri::PhysicalSize::new(w as u32, h as u32));
+                        }
+                    }
+                }
+            }
+        }
+        #[cfg(target_os = "macos")]
+        {
+            if let Ok(mut pos) = window.outer_position() {
+                pos.y = pos.y.saturating_sub(28);
+                let _ = window.set_position(tauri::Position::Physical(pos));
+            }
+        }
+    }
+    Ok(())
+}
+
 #[tauri::command]
 pub fn quit_app(app: AppHandle) {
+    let _ = app.save_window_state(StateFlags::POSITION | StateFlags::SIZE);
     app.exit(0);
 }
 
@@ -64,6 +101,11 @@ pub fn open_file(app: AppHandle, path: String) -> Result<(), String> {
 
 use tauri_plugin_autostart::ManagerExt;
 
+#[tauri::command]
+pub fn get_launch_at_startup(app: AppHandle) -> Result<bool, String> {
+    app.autolaunch().is_enabled().map_err(|e| e.to_string())
+}
+
 #[tauri::command]
 pub fn set_launch_at_startup(app: AppHandle, enabled: bool) -> Result<(), String> {
     if enabled {

src-tauri/src/lib.rs

@@ -12,6 +12,7 @@ use commands::shortcuts::GlobalShortcutState;
 use commands::notifications::NotificationState;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::Arc;
+use tauri_plugin_window_state::{StateFlags, WindowExt};
 
 pub struct DialogState {
     pub is_open: Arc<AtomicBool>,
@@ -54,18 +55,6 @@ pub fn run() {
 
             use tauri::Manager;
             if let Some(window) = app.get_webview_window("main") {
-                #[cfg(target_os = "macos")]
-                {
-                    crate::macos::set_move_to_active_space(&window);
-                    
-                    // Fix for macOS frameless window walking down on restart
-                    // tauri-plugin-window-state restores position with titlebar offset
-                    if let Ok(mut pos) = window.outer_position() {
-                        pos.y = pos.y.saturating_sub(28);
-                        let _ = window.set_position(tauri::Position::Physical(pos));
-                    }
-                }
-
                 let dialog_state = app.state::<crate::DialogState>();
                 let is_dialog_open = dialog_state.is_open.clone();
                 #[cfg(not(target_os = "macos"))]
@@ -110,6 +99,45 @@ pub fn run() {
                         _ => {}
                     }
                 });
+
+                #[cfg(target_os = "macos")]
+                crate::macos::set_move_to_active_space(&window);
+
+                // Restore window state after event loop is running and display server is ready.
+                // Plugin's on_window_ready fires too early for available_monitors() on macOS.
+                let win = window.clone();
+                std::thread::spawn(move || {
+                    std::thread::sleep(std::time::Duration::from_millis(300));
+                    let _ = win.clone().run_on_main_thread(move || {
+                        let _ = win.restore_state(StateFlags::POSITION | StateFlags::SIZE);
+                        if let Ok(app_dir) = win.app_handle().path().app_config_dir() {
+                            let state_path = app_dir.join(".window-state.json");
+                            if let Ok(content) = std::fs::read_to_string(&state_path) {
+                                if let Ok(val) = serde_json::from_str::<serde_json::Value>(&content) {
+                                    if let Some(main) = val.get("main") {
+                                        if let (Some(x), Some(y)) = (
+                                            main.get("x").and_then(|v| v.as_i64()),
+                                            main.get("y").and_then(|v| v.as_i64()),
+                                        ) {
+                                            let _ = win.set_position(tauri::PhysicalPosition::new(x as i32, y as i32));
+                                        }
+                                        if let (Some(w), Some(h)) = (
+                                            main.get("width").and_then(|v| v.as_i64()),
+                                            main.get("height").and_then(|v| v.as_i64()),
+                                        ) {
+                                            let _ = win.set_size(tauri::PhysicalSize::new(w as u32, h as u32));
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        #[cfg(target_os = "macos")]
+                        if let Ok(mut pos) = win.outer_position() {
+                            pos.y = pos.y.saturating_sub(28);
+                            let _ = win.set_position(tauri::Position::Physical(pos));
+                        }
+                    });
+                });
             } else {
                 eprintln!("WARNING: 'main' window not found during setup");
             }
@@ -132,9 +160,11 @@ pub fn run() {
             commands::fs::set_dialog_open,
             commands::fs::remove_onboarding_files,
             commands::system::close_window,
+            commands::system::restore_window_state,
             commands::system::quit_app,
             commands::system::open_external,
             commands::system::open_file,
+            commands::system::get_launch_at_startup,
             commands::system::set_launch_at_startup,
             commands::system::check_for_updates,
             commands::system::is_hyprland,

src-tauri/src/tray.rs

@@ -28,7 +28,7 @@ pub fn create_tray(app: &App) -> Result<(), Box<dyn std::error::Error>> {
             if event.id == "show_hide" {
                 crate::commands::system::toggle_window(app);
             } else if event.id == "quit" {
-                app.exit(0);
+                crate::commands::system::quit_app(app.clone());
             }
         })
         .on_tray_icon_event(|tray, event| {

src/App.tsx

@@ -53,6 +53,7 @@ function App() {
 
   useEffect(() => {
     window.electronAPI.checkForUpdates()
+    window.electronAPI.restoreWindowState()
     window.electronAPI.isHyprland().then((isHyp) => {
       useAppStore.getState().setIsHyprland(isHyp)
     })

src/Settings.test.tsx

@@ -8,6 +8,7 @@ describe('Settings Component', () => {
     // Mock the electronAPI
     window.electronAPI = {
       ...window.electronAPI,
+      getLaunchAtStartup: vi.fn().mockResolvedValue(false),
       setLaunchAtStartup: vi.fn(),
       updateGlobalShortcut: vi.fn(),
       closeWindow: vi.fn(),

src/Settings.tsx

@@ -50,6 +50,14 @@ export default function Settings({ onClose }: { onClose?: () => void }) {
     localStorage.getItem(SETTINGS_KEYS.LAUNCH_STARTUP) === 'true'
   )
 
+  // Sync launch-at-startup toggle with actual OS state on mount
+  useEffect(() => {
+    window.electronAPI.getLaunchAtStartup().then((enabled) => {
+      setLaunchAtStartup(enabled)
+      localStorage.setItem(SETTINGS_KEYS.LAUNCH_STARTUP, enabled.toString())
+    })
+  }, [])
+
   // Appearance State
   const initialSettings = useSettingsStore.getState()
   const [fontFamily, setFontFamily] = useState(initialSettings.fontFamily)

src/api.ts

@@ -33,10 +33,12 @@ export const tauriApi: ElectronAPI = {
   setApiKey: (key) => invoke('set_api_key', { key }),
   getApiKeyStatus: () => invoke('get_api_key_status'),
   checkForUpdates: () => invoke('check_for_updates'),
+  restoreWindowState: () => invoke('restore_window_state'),
   isHyprland: () => invoke('is_hyprland'),
   onSwipeGesture: () => {
     return () => {}
   },
+  getLaunchAtStartup: () => invoke('get_launch_at_startup'),
   setLaunchAtStartup: (value) => {
     invoke('set_launch_at_startup', { enabled: value })
   },

src/types.d.ts

@@ -18,6 +18,7 @@ export interface ElectronAPI {
   setApiKey: (key: string) => Promise<boolean>
   getApiKeyStatus: () => Promise<boolean>
   checkForUpdates: () => Promise<void>
+  restoreWindowState: () => Promise<void>
   isHyprland: () => Promise<boolean>
   readNote: (id: string) => Promise<string>
   exportNote: (filename: string, content: string) => Promise<boolean>
@@ -32,6 +33,7 @@ export interface ElectronAPI {
   openExternal: (url: string) => void
   openFile: (path: string) => void
   onSwipeGesture: (callback: (direction: string) => void) => () => void
+  getLaunchAtStartup: () => Promise<boolean>
   setLaunchAtStartup: (value: boolean) => void
   updateGlobalShortcut: (action: string, oldShortcut: string, newShortcut: string) => void
   onTriggerNewNote: (callback: () => void) => () => void