fix

Author: synle

.github/workflows/cleanup-artifacts.yml

@@ -6,9 +6,9 @@ on:
   workflow_dispatch:
     inputs:
       keep_last:
-        description: 'Number of successful artifacts to keep'
+        description: 'Number of successful builds to keep artifacts from'
         required: false
-        default: '3'
+        default: '1'
         type: number
       keep_runs_days:
         description: 'Delete runs older than N days'
@@ -24,7 +24,7 @@ jobs:
         uses: actions/github-script@v7
         with:
           script: |
-            const KEEP_LAST = ${{ github.event.inputs.keep_last || 3 }};
+            const KEEP_LAST = ${{ github.event.inputs.keep_last || 1 }};
             const KEEP_RUNS_DAYS = ${{ github.event.inputs.keep_runs_days || 30 }};
             const cutoffDate = new Date(Date.now() - KEEP_RUNS_DAYS * 24 * 60 * 60 * 1000);
 
@@ -59,8 +59,12 @@ jobs:
             const failed = artifacts
               .filter(a => !successRunIds.has(a.workflow_run?.id));
 
+            // Group successful artifacts by run, keep all artifacts from the last N runs
+            const runIds = [...new Set(successful.map(a => a.workflow_run?.id))];
+            const keepRunIds = new Set(runIds.slice(0, KEEP_LAST));
+
             const toDelete = [
-              ...successful.slice(KEEP_LAST),
+              ...successful.filter(a => !keepRunIds.has(a.workflow_run?.id)),
               ...failed,
             ];
 
@@ -73,7 +77,7 @@ jobs:
               });
             }
 
-            console.log(`\nArtifacts — Kept: ${Math.min(KEEP_LAST, successful.length)}, Deleted: ${toDelete.length}`);
+            console.log(`\nArtifacts — Kept runs: ${keepRunIds.size}, Deleted artifacts: ${toDelete.length}`);
 
             // --- Cleanup Draft Releases ---
             console.log(`\n=== Draft Release Cleanup ===\n`);

src-tauri/src/lib.rs

@@ -22,6 +22,11 @@ pub struct AppState {
     pub preferences: std::sync::Mutex<config::Preferences>,
     pub last_tray_rect: std::sync::Mutex<Option<tauri::Rect>>,
     pub sidecar_child: std::sync::Mutex<Option<CommandChild>>,
+    /// True while we're waiting for the window to gain focus after being shown.
+    /// Blocks spurious `Focused(false)` events that fire before `Focused(true)`
+    /// (a known issue on Linux/X11 and some Windows configurations).
+    /// Cleared when `Focused(true)` fires, so subsequent focus-loss auto-hides normally.
+    pub expect_focus_gain: std::sync::Mutex<bool>,
 }
 
 /// Find an available port starting from the default.
@@ -250,6 +255,7 @@ pub fn run() {
             preferences: std::sync::Mutex::new(preferences.clone()),
             last_tray_rect: std::sync::Mutex::new(None),
             sidecar_child: std::sync::Mutex::new(None),
+            expect_focus_gain: std::sync::Mutex::new(false),
         })
         .invoke_handler(tauri::generate_handler![
             display::get_monitors,
@@ -334,8 +340,25 @@ pub fn run() {
                 let app_handle = app.handle().clone();
                 window.on_window_event(move |event| {
                     match event {
+                        tauri::WindowEvent::Focused(true) => {
+                            // Window gained focus: clear the flag so future focus-loss hides normally.
+                            if let Some(state) = app_handle.try_state::<AppState>() {
+                                if let Ok(mut e) = state.expect_focus_gain.lock() {
+                                    *e = false;
+                                }
+                            }
+                        }
                         tauri::WindowEvent::Focused(false) => {
-                            let _ = win_clone.hide();
+                            // Skip hide if we're still waiting for the window to gain focus.
+                            // On Linux/X11 a spurious Focused(false) fires before Focused(true)
+                            // right after show(); the boolean flag blocks that false positive.
+                            let expecting = app_handle
+                                .try_state::<AppState>()
+                                .and_then(|s| s.expect_focus_gain.lock().ok().map(|e| *e))
+                                .unwrap_or(false);
+                            if !expecting {
+                                let _ = win_clone.hide();
+                            }
                         }
                         tauri::WindowEvent::Resized(_) => {
                             if win_clone.is_visible().unwrap_or(false) {

src-tauri/src/tray.rs

@@ -27,6 +27,28 @@ fn http_get_then_emit(url: String, app: AppHandle, event: &'static str) {
     });
 }
 
+/// Shows the popup window, emits refresh events, and sets focus.
+/// Used by both the tray left-click handler and the "Show Window" menu item.
+/// Sets `expect_focus_gain` so the focus-loss handler won't hide us until
+/// the window actually receives `Focused(true)`.
+fn show_popup_window(app: &AppHandle) {
+    if let Some(window) = app.get_webview_window("main") {
+        // Set flag so the focus-loss handler won't hide us until the window actually
+        // receives Focused(true). This suppresses the spurious Focused(false) that
+        // fires on Linux/X11 (and occasionally Windows) before focus arrives.
+        if let Some(state) = app.try_state::<crate::AppState>() {
+            if let Ok(mut e) = state.expect_focus_gain.lock() {
+                *e = true;
+            }
+        }
+        let _ = window.show();
+        let _ = window.set_focus();
+        let _ = app.emit("monitors-changed", ());
+        let _ = app.emit("dark-mode-changed", ());
+        let _ = app.emit("volume-changed", ());
+    }
+}
+
 /// Builds the system tray icon, context menu, and event handlers.
 /// Handles left-click (toggle popup) and menu actions (dark/light mode, profiles, debug, quit).
 pub fn setup_tray(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>> {
@@ -38,6 +60,7 @@ pub fn setup_tray(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>
         }
     };
 
+    let show_window = MenuItemBuilder::with_id("show_window", "Show Window").build(app)?;
     let dark_mode = MenuItemBuilder::with_id("dark_mode", "Dark Mode").build(app)?;
     let light_mode = MenuItemBuilder::with_id("light_mode", "Light Mode").build(app)?;
 
@@ -93,6 +116,8 @@ pub fn setup_tray(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>
     let quit = MenuItemBuilder::with_id("quit", "Quit").build(app)?;
 
     let menu = MenuBuilder::new(app)
+        .item(&show_window)
+        .separator()
         .items(&[&dark_mode, &light_mode])
         .separator()
         .item(&profiles_submenu)
@@ -110,6 +135,9 @@ pub fn setup_tray(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>
         .menu(&menu)
         .show_menu_on_left_click(false)
         .on_menu_event(move |app, event| match event.id().as_ref() {
+            "show_window" => {
+                show_popup_window(app);
+            }
             "bridge" => {
                 let url = base_url();
                 let _ = open::that(&url);
@@ -207,12 +235,7 @@ pub fn setup_tray(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>
                                 );
                             }
                         }
-                        let _ = window.show();
-                        let _ = window.set_focus();
-                        // Emit refresh events so frontend fetches latest monitor/dark-mode/volume state
-                        let _ = app.emit("monitors-changed", ());
-                        let _ = app.emit("dark-mode-changed", ());
-                        let _ = app.emit("volume-changed", ());
+                        show_popup_window(app);
                     }
                 }
             }