pake-cli 3.15.4 → 3.15.6

package/README.md

@@ -202,7 +202,7 @@ Use Pake (npm i -g pake-cli) to package webpages as desktop apps. Read https://u
 
 ## Development
 
-Requires Rust `>=1.85` and Node `>=22` (recommended LTS; `>=18` also works). For detailed installation guide, see [Tauri documentation](https://v2.tauri.app/start/prerequisites/). If unfamiliar with development environment, use the CLI tool instead.
+Requires Rust `>=1.85` and Node `>=22` (recommended LTS; `>=20` also works). For detailed installation guide, see [Tauri documentation](https://v2.tauri.app/start/prerequisites/). If unfamiliar with development environment, use the CLI tool instead.
 
 ```bash
 # Install dependencies

package/dist/cli.js

@@ -20,10 +20,10 @@ import * as psl from 'psl';
 import { InvalidArgumentError, program as program$1, Option } from 'commander';
 
 var name = "pake-cli";
-var version = "3.15.4";
+var version = "3.15.6";
 var description = "🤱🏻 Turn any webpage into a desktop app with one command. 🤱🏻 一键打包网页生成轻量桌面应用。";
 var engines = {
-	node: ">=18.0.0"
+	node: ">=20.0.0"
 };
 var packageManager = "pnpm@10.26.2";
 var bin = {
@@ -78,14 +78,14 @@ var dependencies = {
 	chalk: "^5.6.2",
 	commander: "^14.0.3",
 	execa: "^9.6.1",
-	"file-type": "^21.3.0",
+	"file-type": "^21.3.4",
 	"fs-extra": "^11.3.3",
 	"icon-gen": "^5.0.0",
 	loglevel: "^1.9.2",
 	ora: "^9.3.0",
 	prompts: "^2.4.2",
 	psl: "^1.15.0",
-	sharp: "^0.34.5",
+	sharp: "^0.35.0",
 	"tmp-promise": "^3.0.3",
 	"update-notifier": "^7.3.1"
 };
@@ -111,8 +111,9 @@ var devDependencies = {
 };
 var pnpm = {
 	overrides: {
-		sharp: "^0.34.5",
-		"@img/sharp-libvips-darwin-arm64": "1.2.4"
+		sharp: "^0.35.0",
+		"@img/sharp-libvips-darwin-arm64": "1.3.0",
+		tmp: "0.2.7"
 	},
 	onlyBuiltDependencies: [
 		"esbuild",

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "pake-cli",
-  "version": "3.15.4",
+  "version": "3.15.6",
   "description": "🤱🏻 Turn any webpage into a desktop app with one command. 🤱🏻 一键打包网页生成轻量桌面应用。",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "packageManager": "pnpm@10.26.2",
   "bin": {
@@ -58,14 +58,14 @@
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "execa": "^9.6.1",
-    "file-type": "^21.3.0",
+    "file-type": "^21.3.4",
     "fs-extra": "^11.3.3",
     "icon-gen": "^5.0.0",
     "loglevel": "^1.9.2",
     "ora": "^9.3.0",
     "prompts": "^2.4.2",
     "psl": "^1.15.0",
-    "sharp": "^0.34.5",
+    "sharp": "^0.35.0",
     "tmp-promise": "^3.0.3",
     "update-notifier": "^7.3.1"
   },
@@ -91,8 +91,9 @@
   },
   "pnpm": {
     "overrides": {
-      "sharp": "^0.34.5",
-      "@img/sharp-libvips-darwin-arm64": "1.2.4"
+      "sharp": "^0.35.0",
+      "@img/sharp-libvips-darwin-arm64": "1.3.0",
+      "tmp": "0.2.7"
     },
     "onlyBuiltDependencies": [
       "esbuild",

package/src-tauri/Cargo.lock

@@ -2564,7 +2564,7 @@ dependencies = [
 
 [[package]]
 name = "pake"
-version = "3.15.4"
+version = "3.15.6"
 dependencies = [
  "block2",
  "dispatch",
@@ -2584,6 +2584,8 @@ dependencies = [
  "tauri-plugin-single-instance",
  "tauri-plugin-window-state",
  "tokio",
+ "webkit2gtk",
+ "webview2-com",
  "windows-sys 0.61.2",
 ]
 
@@ -3042,9 +3044,9 @@ dependencies = [
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.13"
+version = "0.11.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31"
+checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098"
 dependencies = [
  "bytes",
  "getrandom 0.3.4",
@@ -3072,7 +3074,7 @@ dependencies = [
  "once_cell",
  "socket2",
  "tracing",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pake"
-version = "3.15.4"
+version = "3.15.6"
 description = "🤱🏻 Turn any webpage into a desktop app with Rust."
 authors = ["Tw93"]
 license = "GPL-3.0-or-later"
@@ -42,12 +42,20 @@ objc2 = "0.6"
 objc2-app-kit = { version = "0.3", features = ["NSApplication", "NSDockTile"] }
 objc2-foundation = { version = "0.3", features = ["NSString"] }
 
+[target.'cfg(target_os = "linux")'.dependencies]
+# Used for native WebKitGTK go_back/go_forward on error pages (no page JS).
+# Version and features must match what wry resolves, or PlatformWebview::inner
+# hands back a WebView from a different crate instance.
+webkit2gtk = { version = "=2.0.2", features = ["v2_38"] }
+
 [target.'cfg(windows)'.dependencies]
 windows-sys = { version = "0.61.2", features = [
   "Win32_Foundation",
   "Win32_UI_Shell",
   "Win32_UI_WindowsAndMessaging",
 ] }
+# Used for native WebView2 GoBack/GoForward on error pages (no page JS).
+webview2-com = "0.38"
 
 [features]
 # this feature is used for development builds from development cli

package/src-tauri/src/app/invoke.rs

@@ -1,3 +1,4 @@
+use crate::app::navigation::{history_step, reload_window};
 use crate::util::{
     check_file_or_append, get_download_message_with_lang, sanitize_download_filename, show_toast,
     MessageType,
@@ -8,6 +9,7 @@ use std::str::FromStr;
 use std::sync::atomic::{AtomicI64, Ordering};
 use tauri::http::Method;
 use tauri::{command, AppHandle, Manager, Url, WebviewWindow};
+use tauri_plugin_http::reqwest::header::{HeaderValue, COOKIE};
 use tauri_plugin_http::reqwest::{ClientBuilder, Request};
 
 use tauri::Theme;
@@ -82,10 +84,30 @@ pub struct NotificationParams {
     icon: String,
 }
 
-#[command]
-pub async fn download_file(app: AppHandle, params: DownloadFileParams) -> Result<(), String> {
-    let window: WebviewWindow = app.get_webview_window("pake").ok_or("Window not found")?;
+/// Build a Cookie header from the webview session so authenticated downloads
+/// match what the page itself would request. Best-effort: missing cookies
+/// fall through to an anonymous request.
+fn cookie_header_for_url(window: &WebviewWindow, url: &Url) -> Option<HeaderValue> {
+    let cookies = window.cookies_for_url(url.clone()).ok()?;
+    if cookies.is_empty() {
+        return None;
+    }
+    let header = cookies
+        .iter()
+        .map(|cookie| format!("{}={}", cookie.name(), cookie.value()))
+        .collect::<Vec<_>>()
+        .join("; ");
+    HeaderValue::from_str(&header).ok()
+}
 
+#[command]
+pub async fn download_file(
+    window: WebviewWindow,
+    app: AppHandle,
+    params: DownloadFileParams,
+) -> Result<(), String> {
+    // Toast on the calling window (secondary windows included), not a hard-coded
+    // main-window label. Tauri injects the invoker as `window`.
     show_toast(
         &window,
         &get_download_message_with_lang(MessageType::Start, params.language.clone()),
@@ -108,14 +130,27 @@ pub async fn download_file(app: AppHandle, params: DownloadFileParams) -> Result
 
     let url = Url::from_str(&params.url).map_err(|e| format!("Invalid URL: {}", e))?;
 
-    let request = Request::new(Method::GET, url);
+    let mut request = Request::new(Method::GET, url.clone());
+    if let Some(cookie_header) = cookie_header_for_url(&window, &url) {
+        request.headers_mut().insert(COOKIE, cookie_header);
+    }
 
     let response = client.execute(request).await;
 
     match response {
         Ok(mut res) => {
+            // Transport success is not download success: 403/404 HTML error pages
+            // must not be written as files or toasted as successful downloads.
+            if !res.status().is_success() {
+                show_toast(
+                    &window,
+                    &get_download_message_with_lang(MessageType::Failure, params.language),
+                );
+                return Err(format!("Download failed with HTTP status {}", res.status()));
+            }
+
             let mut file =
-                File::create(file_path).map_err(|e| format!("Failed to create file: {}", e))?;
+                File::create(&file_path).map_err(|e| format!("Failed to create file: {}", e))?;
 
             while let Some(chunk) = res
                 .chunk()
@@ -185,12 +220,12 @@ pub fn set_dock_badge_label(app: AppHandle, label: Option<String>) -> Result<(),
 
 #[command]
 pub async fn update_theme_mode(app: AppHandle, mode: String) {
-    if let Some(window) = app.get_webview_window("pake") {
-        let theme = if mode == "dark" {
-            Theme::Dark
-        } else {
-            Theme::Light
-        };
+    let theme = if mode == "dark" {
+        Theme::Dark
+    } else {
+        Theme::Light
+    };
+    for window in app.webview_windows().values() {
         let _ = window.set_theme(Some(theme));
     }
 }
@@ -206,3 +241,27 @@ pub fn set_zoom(window: WebviewWindow, percent: f64) -> Result<(), String> {
         .set_zoom(factor)
         .map_err(|e| format!("Failed to set zoom: {}", e))
 }
+
+/// Native navigation for injected shortcuts (Linux/Windows Ctrl+R / [ / ]).
+/// Blank error pages have no JS context, so page `history` / `location` calls
+/// are no-ops; these use the platform webview API instead.
+#[command]
+pub fn webview_navigate(window: WebviewWindow, action: String) -> Result<(), String> {
+    match action.as_str() {
+        "reload" => {
+            reload_window(&window);
+            Ok(())
+        }
+        "back" => {
+            history_step(&window, true);
+            Ok(())
+        }
+        "forward" => {
+            history_step(&window, false);
+            Ok(())
+        }
+        other => Err(format!(
+            "Unknown webview_navigate action '{other}' (expected reload|back|forward)"
+        )),
+    }
+}

package/src-tauri/src/app/menu.rs

@@ -1,5 +1,8 @@
 // Menu functionality is only used on macOS; the module is gated in app/mod.rs.
+use crate::app::navigation::{history_step, reload_window};
 use crate::app::window::{open_additional_window_safe, MultiWindowState};
+use std::io::Write;
+use std::process::{Command, Stdio};
 use tauri::menu::{AboutMetadata, Menu, MenuItem, PredefinedMenuItem, Submenu};
 use tauri::{AppHandle, Manager, WebviewWindow, Wry};
 use tauri_plugin_opener::OpenerExt;
@@ -254,6 +257,18 @@ fn focused_webview_window(app_handle: &AppHandle) -> Option<WebviewWindow> {
         .or_else(|| windows.get("pake").cloned())
 }
 
+/// Copy text via pbcopy so it works when the page has no JS context (error
+/// shells) and when the Clipboard API is blocked by the site CSP.
+fn copy_text_to_pasteboard(text: &str) {
+    let Ok(mut child) = Command::new("pbcopy").stdin(Stdio::piped()).spawn() else {
+        return;
+    };
+    if let Some(stdin) = child.stdin.as_mut() {
+        let _ = stdin.write_all(text.as_bytes());
+    }
+    let _ = child.wait();
+}
+
 pub fn handle_menu_click(app_handle: &AppHandle, id: &str) {
     match id {
         "new_window" => {
@@ -266,7 +281,8 @@ pub fn handle_menu_click(app_handle: &AppHandle, id: &str) {
         }
         "reload" => {
             if let Some(window) = focused_webview_window(app_handle) {
-                let _ = window.eval("window.location.reload()");
+                // Native reload works on blank error pages where eval cannot.
+                reload_window(&window);
             }
         }
         "toggle_devtools" => {
@@ -296,12 +312,12 @@ pub fn handle_menu_click(app_handle: &AppHandle, id: &str) {
         }
         "go_back" => {
             if let Some(window) = focused_webview_window(app_handle) {
-                let _ = window.eval("window.history.back()");
+                history_step(&window, true);
             }
         }
         "go_forward" => {
             if let Some(window) = focused_webview_window(app_handle) {
-                let _ = window.eval("window.history.forward()");
+                history_step(&window, false);
             }
         }
         "go_home" => {
@@ -321,7 +337,11 @@ pub fn handle_menu_click(app_handle: &AppHandle, id: &str) {
         }
         "copy_url" => {
             if let Some(window) = focused_webview_window(app_handle) {
-                let _ = window.eval("navigator.clipboard.writeText(window.location.href)");
+                // Prefer the native webview URL so copy still works on error
+                // pages that have no document.location / clipboard API.
+                if let Ok(url) = window.url() {
+                    copy_text_to_pasteboard(url.as_str());
+                }
             }
         }
         "paste_and_match_style" => {

package/src-tauri/src/app/mod.rs

@@ -4,5 +4,6 @@ pub mod config;
 pub mod invoke;
 #[cfg(target_os = "macos")]
 pub mod menu;
+pub mod navigation;
 pub mod setup;
 pub mod window;

package/src-tauri/src/app/navigation.rs

@@ -0,0 +1,83 @@
+//! Cross-platform webview navigation that does not depend on page JS.
+//! Blank error shells have no JS context, so `eval("history.back()")` and
+//! `location.reload()` are dead exactly when the user is stuck.
+
+use tauri::WebviewWindow;
+
+/// Reload the current document via the native webview API.
+pub fn reload_window(window: &WebviewWindow) {
+    if let Err(error) = window.reload() {
+        eprintln!("[Pake] Failed to reload webview: {error}");
+    }
+}
+
+/// Step the webview history without requiring a live page JS context.
+pub fn history_step(window: &WebviewWindow, back: bool) {
+    let stepped = window.with_webview(move |webview| {
+        history_step_platform(&webview, back);
+    });
+
+    if stepped.is_err() {
+        // Last resort when with_webview is unavailable (rare). Still fails on
+        // blank error shells, but preserves SPA history when the page is live.
+        let script = if back {
+            "window.history.back()"
+        } else {
+            "window.history.forward()"
+        };
+        if let Err(error) = window.eval(script) {
+            eprintln!("[Pake] Failed to step webview history: {error}");
+        }
+    }
+}
+
+#[cfg(target_os = "macos")]
+fn history_step_platform(webview: &tauri::webview::PlatformWebview, back: bool) {
+    use objc2::msg_send;
+    use objc2::runtime::AnyObject;
+
+    let ptr = webview.inner() as *mut AnyObject;
+    if ptr.is_null() {
+        return;
+    }
+    unsafe {
+        if back {
+            let _: *mut AnyObject = msg_send![ptr, goBack];
+        } else {
+            let _: *mut AnyObject = msg_send![ptr, goForward];
+        }
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn history_step_platform(webview: &tauri::webview::PlatformWebview, back: bool) {
+    use webkit2gtk::WebViewExt;
+
+    let gtk_webview = webview.inner();
+    if back {
+        gtk_webview.go_back();
+    } else {
+        gtk_webview.go_forward();
+    }
+}
+
+#[cfg(windows)]
+fn history_step_platform(webview: &tauri::webview::PlatformWebview, back: bool) {
+    use webview2_com::Microsoft::Web::WebView2::Win32::ICoreWebView2Controller;
+
+    let controller = webview.controller();
+    unsafe {
+        // ICoreWebView2Controller::CoreWebView2 returns the underlying browser.
+        let Ok(core) = controller.CoreWebView2() else {
+            return;
+        };
+        if back {
+            let _ = core.GoBack();
+        } else {
+            let _ = core.GoForward();
+        }
+    }
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "linux", windows)))]
+fn history_step_platform(_webview: &tauri::webview::PlatformWebview, _back: bool) {}

package/src-tauri/src/app/setup.rs

@@ -1,10 +1,13 @@
-use crate::app::window::{open_additional_window_safe, reapply_window_icon};
+use crate::app::window::{
+    hide_all_app_windows, open_additional_window_safe, show_all_app_windows, toggle_all_app_windows,
+};
+use crate::cancel_startup_reveal;
 use std::str::FromStr;
-use std::sync::{Arc, Mutex};
+use std::sync::{atomic::AtomicBool, Arc, Mutex};
 use std::time::{Duration, Instant};
 use tauri::{
     menu::{MenuBuilder, MenuItemBuilder},
-    tray::{TrayIconBuilder, TrayIconEvent},
+    tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent},
     AppHandle, Manager,
 };
 use tauri_plugin_global_shortcut::{GlobalShortcutExt, Shortcut};
@@ -16,6 +19,7 @@ pub fn set_system_tray(
     tray_icon_path: &str,
     _init_fullscreen: bool,
     allow_multi_window: bool,
+    startup_revealed: Arc<AtomicBool>,
 ) -> tauri::Result<()> {
     if !show_system_tray {
         app.remove_tray_by_id("pake-tray");
@@ -42,6 +46,8 @@ pub fn set_system_tray(
 
     app.app_handle().remove_tray_by_id("pake-tray");
 
+    let menu_revealed = startup_revealed.clone();
+    let click_revealed = startup_revealed;
     let mut tray_builder = TrayIconBuilder::new()
         .menu(&menu)
         .on_menu_event(move |app, event| match event.id().as_ref() {
@@ -49,20 +55,13 @@ pub fn set_system_tray(
                 open_additional_window_safe(app);
             }
             "hide_app" => {
-                if let Some(window) = app.get_webview_window("pake") {
-                    let _ = window.minimize();
-                }
+                // Hide every webview (main + multi-window clones), not only "pake".
+                cancel_startup_reveal(&menu_revealed);
+                hide_all_app_windows(app);
             }
             "show_app" => {
-                if let Some(window) = app.get_webview_window("pake") {
-                    let _ = window.show();
-                    reapply_window_icon(&window);
-                    #[cfg(target_os = "linux")]
-                    if _init_fullscreen && !window.is_fullscreen().unwrap_or(false) {
-                        let _ = window.set_fullscreen(true);
-                        let _ = window.set_focus();
-                    }
-                }
+                cancel_startup_reveal(&menu_revealed);
+                show_all_app_windows(app, _init_fullscreen);
             }
             "quit" => {
                 let flags = if _init_fullscreen {
@@ -76,22 +75,19 @@ pub fn set_system_tray(
             _ => (),
         })
         .on_tray_icon_event(move |tray, event| {
-            if let TrayIconEvent::Click { button, .. } = event {
-                if button == tauri::tray::MouseButton::Left {
-                    if let Some(window) = tray.app_handle().get_webview_window("pake") {
-                        let is_visible = window.is_visible().unwrap_or(false);
-                        if is_visible {
-                            let _ = window.hide();
-                        } else {
-                            let _ = window.show();
-                            reapply_window_icon(&window);
-                            let _ = window.set_focus();
-                            #[cfg(target_os = "linux")]
-                            if _init_fullscreen && !window.is_fullscreen().unwrap_or(false) {
-                                let _ = window.set_fullscreen(true);
-                            }
-                        }
-                    }
+            if let TrayIconEvent::Click {
+                button,
+                button_state,
+                ..
+            } = event
+            {
+                // Windows emits Click twice per physical click (Down then Up).
+                // Reacting to both runs the toggle twice, so a hidden window is
+                // shown and immediately re-hidden and the tray looks dead (#1343).
+                if button == MouseButton::Left && button_state == MouseButtonState::Up {
+                    // Any tray toggle claims visibility control from startup reveal.
+                    cancel_startup_reveal(&click_revealed);
+                    toggle_all_app_windows(tray.app_handle(), _init_fullscreen);
                 }
             }
         });
@@ -120,6 +116,7 @@ pub fn set_global_shortcut(
     app: &AppHandle,
     shortcut: String,
     _init_fullscreen: bool,
+    startup_revealed: Arc<AtomicBool>,
 ) -> tauri::Result<()> {
     if shortcut.is_empty() {
         return Ok(());
@@ -139,6 +136,7 @@ pub fn set_global_shortcut(
         tauri_plugin_global_shortcut::Builder::new()
             .with_handler({
                 let last_triggered = Arc::clone(&last_triggered);
+                let startup_revealed = startup_revealed.clone();
                 move |app, event, _shortcut| {
                     let Ok(mut last_triggered) = last_triggered.lock() else {
                         return;
@@ -149,20 +147,8 @@ pub fn set_global_shortcut(
                     *last_triggered = Instant::now();
 
                     if shortcut_hotkey.eq(event) {
-                        if let Some(window) = app.get_webview_window("pake") {
-                            let is_visible = window.is_visible().unwrap_or(false);
-                            if is_visible {
-                                let _ = window.hide();
-                            } else {
-                                let _ = window.show();
-                                reapply_window_icon(&window);
-                                let _ = window.set_focus();
-                                #[cfg(target_os = "linux")]
-                                if _init_fullscreen && !window.is_fullscreen().unwrap_or(false) {
-                                    let _ = window.set_fullscreen(true);
-                                }
-                            }
-                        }
+                        cancel_startup_reveal(&startup_revealed);
+                        toggle_all_app_windows(app, _init_fullscreen);
                     }
                 }
             })

package/src-tauri/src/app/window.rs

@@ -186,15 +186,21 @@ fn open_requested_window(
     Ok(window)
 }
 
+/// Open a multi-window clone of the home app. The window is built hidden and
+/// revealed on its first real page load (see `lib.rs` on_page_load) so Cmd+N
+/// does not flash an empty shell the way the main window used to.
 pub fn open_additional_window_safe(app: &AppHandle) {
     #[cfg(target_os = "windows")]
     {
         let app_handle = app.clone();
         std::thread::spawn(move || {
             if let Ok(window) = open_additional_window(&app_handle) {
-                let _ = window.show();
-                reapply_window_icon(&window);
-                let _ = window.set_focus();
+                // Fallback if PageLoadEvent::Finished never arrives.
+                let fallback = window.clone();
+                tauri::async_runtime::spawn(async move {
+                    tokio::time::sleep(tokio::time::Duration::from_millis(3_000)).await;
+                    reveal_built_window(&fallback);
+                });
             }
         });
     }
@@ -202,13 +208,79 @@ pub fn open_additional_window_safe(app: &AppHandle) {
     #[cfg(not(target_os = "windows"))]
     {
         if let Ok(window) = open_additional_window(app) {
-            let _ = window.show();
-            reapply_window_icon(&window);
-            let _ = window.set_focus();
+            let fallback = window.clone();
+            tauri::async_runtime::spawn(async move {
+                tokio::time::sleep(tokio::time::Duration::from_millis(3_000)).await;
+                reveal_built_window(&fallback);
+            });
         }
     }
 }
 
+/// Show a window that was built hidden once content is ready (or the fallback
+/// timer fires). No-ops when already visible so page-load and fallback can race.
+pub fn reveal_built_window(window: &WebviewWindow) {
+    if window.is_visible().unwrap_or(true) {
+        return;
+    }
+    let _ = window.show();
+    reapply_window_icon(window);
+    let _ = window.set_focus();
+}
+
+/// True when any Pake webview window is currently on screen.
+///
+/// A minimized window does not count. Windows keeps `IsWindowVisible` true while
+/// a window is iconic, and `hide_on_close` minimizes before hiding, so treating
+/// minimized as visible makes the tray toggle hide an already-invisible window
+/// instead of restoring it (#1343).
+pub fn any_app_window_visible(app: &AppHandle) -> bool {
+    app.webview_windows().values().any(|window| {
+        window.is_visible().unwrap_or(false) && !window.is_minimized().unwrap_or(false)
+    })
+}
+
+/// Hide every webview window (main + multi-window clones). Used by tray Hide
+/// and the activation shortcut so secondary windows are not left on screen.
+pub fn hide_all_app_windows(app: &AppHandle) {
+    for window in app.webview_windows().values() {
+        let _ = window.hide();
+    }
+}
+
+/// Show every webview window, reassert icons, and focus the main window.
+pub fn show_all_app_windows(app: &AppHandle, init_fullscreen: bool) {
+    let windows = app.webview_windows();
+    for window in windows.values() {
+        let _ = window.unminimize();
+        let _ = window.show();
+        reapply_window_icon(window);
+        #[cfg(target_os = "linux")]
+        if init_fullscreen && !window.is_fullscreen().unwrap_or(false) {
+            let _ = window.set_fullscreen(true);
+        }
+    }
+    #[cfg(not(target_os = "linux"))]
+    let _ = init_fullscreen;
+
+    if let Some(main) = windows.get("pake") {
+        let _ = main.set_focus();
+    } else if let Some(any) = windows.values().next() {
+        let _ = any.set_focus();
+    }
+}
+
+/// Tray-click / activation-shortcut toggle: hide all if anything is visible,
+/// otherwise show all. Cancels startup reveal when the caller has already done
+/// so; this helper only touches visibility.
+pub fn toggle_all_app_windows(app: &AppHandle, init_fullscreen: bool) {
+    if any_app_window_visible(app) {
+        hide_all_app_windows(app);
+    } else {
+        show_all_app_windows(app, init_fullscreen);
+    }
+}
+
 fn build_window_with_label(
     app: &AppHandle,
     config: &PakeConfig,
@@ -553,7 +625,7 @@ fn build_window(
     // catching it here is independent of the page CSP and the IPC channel.
     {
         let download_handle = app.clone();
-        window_builder = window_builder.on_download(move |_webview, event| match event {
+        window_builder = window_builder.on_download(move |webview, event| match event {
             DownloadEvent::Requested { url, destination } => {
                 match download_handle.path().download_dir() {
                     Ok(download_dir) => {
@@ -585,7 +657,12 @@ fn build_window(
                 path: _,
                 success,
             } => {
-                if let Some(window) = download_handle.get_webview_window("pake") {
+                // Toast on the window that started the download (including
+                // secondary multi-window labels), not a hard-coded "pake".
+                let toast_window = download_handle
+                    .get_webview_window(webview.label())
+                    .or_else(|| download_handle.get_webview_window("pake"));
+                if let Some(window) = toast_window {
                     let message_type = if success {
                         MessageType::Success
                     } else {

package/src-tauri/src/inject/event.js

@@ -1,11 +1,35 @@
+// Prefer native webview navigation over page JS so Ctrl+R / [ / ] still work
+// on blank error shells (no JS context). Falls back to history/location when
+// the IPC bridge is unavailable.
+function nativeNavigate(action) {
+  const invoke = window.__TAURI__?.core?.invoke;
+  if (invoke) {
+    invoke("webview_navigate", { action }).catch(() => {
+      fallbackNavigate(action);
+    });
+    return;
+  }
+  fallbackNavigate(action);
+}
+
+function fallbackNavigate(action) {
+  if (action === "reload") {
+    window.location.reload();
+  } else if (action === "back") {
+    window.history.back();
+  } else if (action === "forward") {
+    window.history.forward();
+  }
+}
+
 const shortcuts = {
-  "[": () => window.history.back(),
-  "]": () => window.history.forward(),
+  "[": () => nativeNavigate("back"),
+  "]": () => nativeNavigate("forward"),
   "-": () => zoomOut(),
   "=": () => zoomIn(),
   "+": () => zoomIn(),
   0: () => setZoom("100%"),
-  r: () => window.location.reload(),
+  r: () => nativeNavigate("reload"),
   ArrowUp: () => scrollTo(0, 0),
   ArrowDown: () => scrollTo(0, document.body.scrollHeight),
 };
@@ -370,34 +394,12 @@ const DOWNLOADABLE_FILE_EXTENSIONS = {
     "apk",
     "ipa",
   ],
-  data: [
-    "json",
-    "xml",
-    "csv",
-    "sql",
-    "db",
-    "sqlite",
-    "yaml",
-    "yml",
-    "toml",
-    "ini",
-    "cfg",
-    "conf",
-    "log",
-  ],
-  code: [
-    "js",
-    "ts",
-    "jsx",
-    "tsx",
-    "css",
-    "scss",
-    "sass",
-    "less",
-    "sh",
-    "bat",
-    "ps1",
-  ],
+  // Navigable web formats (json/xml/js/css/html and friends) are intentionally
+  // omitted: documentation and SPA content negotiation often serve them as
+  // in-app pages. Real file downloads still match via the download attribute,
+  // ?download / ?attachment, or binary extensions below.
+  data: ["csv", "sql", "db", "sqlite"],
+  scripts: ["sh", "bat", "ps1"],
   fonts: ["ttf", "otf", "woff", "woff2", "eot"],
   design: ["ai", "psd", "sketch", "fig", "xd"],
   system: [
@@ -446,13 +448,12 @@ const PREVIEWABLE_MEDIA_EXTENSIONS = [
   "m4a",
 ];
 
-const DOWNLOAD_PATH_PATTERNS = [
-  "/download/",
-  "/files/",
-  "/attachments/",
-  "/assets/",
-  "/dist/",
-];
+// Path fragments that often host real file downloads. Keep this list narrow:
+// SPA roots such as "/assets/", "/dist/", "/files/", "/releases/", and
+// "/attachments/" have already been mistaken for downloads in the wild.
+// Prefer real file extensions, the download attribute, or ?download /
+// ?attachment query hints whenever possible.
+const DOWNLOAD_PATH_PATTERNS = ["/download/"];
 
 // Language detection utilities
 function getUserLanguage() {
@@ -528,6 +529,52 @@ function isDownloadableFile(url) {
   }
 }
 
+// Public suffixes where the registrable domain needs more than two labels.
+// Not exhaustive; covers common packaging targets that last-two-label
+// matching would collapse incorrectly (e.g. amazon.co.uk vs evil.co.uk,
+// or every *.github.io site into one "domain").
+const MULTI_PART_PUBLIC_SUFFIXES = [
+  "co.uk",
+  "org.uk",
+  "ac.uk",
+  "gov.uk",
+  "com.au",
+  "net.au",
+  "org.au",
+  "co.jp",
+  "ne.jp",
+  "or.jp",
+  "co.kr",
+  "co.in",
+  "com.br",
+  "com.cn",
+  "com.tw",
+  "com.hk",
+  "com.sg",
+  "github.io",
+  "gitlab.io",
+  "pages.dev",
+];
+
+function getRootDomain(hostname) {
+  const normalized = String(hostname || "").toLowerCase();
+  if (!normalized) {
+    return "";
+  }
+
+  const parts = normalized.split(".").filter(Boolean);
+  if (parts.length <= 1) {
+    return normalized;
+  }
+
+  const lastTwo = parts.slice(-2).join(".");
+  if (MULTI_PART_PUBLIC_SUFFIXES.includes(lastTwo) && parts.length >= 3) {
+    return parts.slice(-3).join(".");
+  }
+
+  return lastTwo;
+}
+
 function normalizeAnchorHref(rawHref) {
   return typeof rawHref === "string" ? rawHref.trim() : "";
 }
@@ -661,8 +708,11 @@ document.addEventListener("DOMContentLoaded", () => {
   const isSpecialDownload = (url) =>
     ["blob", "data"].some((protocol) => url.startsWith(protocol));
 
-  const isDownloadRequired = (url, anchorElement, e) =>
-    anchorElement.download || e.metaKey || e.ctrlKey || isDownloadableFile(url);
+  // Cmd/Ctrl+click is a browser "open related" gesture, not "save as".
+  // Only the download attribute and downloadable-file heuristics force a
+  // download; modifiers must not rewrite ordinary navigation.
+  const isDownloadRequired = (url, anchorElement, _e) =>
+    Boolean(anchorElement.download) || isDownloadableFile(url);
 
   const handleExternalLink = (url) => {
     // Don't try to open blob: or data: URLs with shell
@@ -686,12 +736,8 @@ document.addEventListener("DOMContentLoaded", () => {
 
       if (linkUrl.hostname === currentUrl.hostname) return true;
 
-      // Extract root domain (e.g., bilibili.com from www.bilibili.com)
-      const getRootDomain = (hostname) => {
-        const parts = hostname.split(".");
-        return parts.length >= 2 ? parts.slice(-2).join(".") : hostname;
-      };
-
+      // e.g. www.bilibili.com and m.bilibili.com share bilibili.com;
+      // amazon.co.uk must not share a root with evil.co.uk.
       return (
         getRootDomain(currentUrl.hostname) === getRootDomain(linkUrl.hostname)
       );

package/src-tauri/src/lib.rs

@@ -2,14 +2,20 @@
 mod app;
 mod util;
 
-use tauri::Manager;
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
+use tauri::{webview::PageLoadEvent, Manager, Url, WebviewWindow};
 use tauri_plugin_window_state::Builder as WindowStatePlugin;
 use tauri_plugin_window_state::StateFlags;
 
 #[cfg(target_os = "macos")]
 use std::time::Duration;
 
-const WINDOW_SHOW_DELAY: u64 = 50;
+// Fallback when PageLoadEvent::Finished never arrives (offline / stalled).
+// Deliberately longer than a paint tick so the normal path can win first.
+const STARTUP_WINDOW_FALLBACK_DELAY: u64 = 3_000;
 #[cfg(target_os = "linux")]
 const PAKE_LINUX_WEBKIT_SAFE_MODE: &str = "PAKE_LINUX_WEBKIT_SAFE_MODE";
 #[cfg(target_os = "linux")]
@@ -22,13 +28,65 @@ const GDK_BACKEND: &str = "GDK_BACKEND";
 use app::{
     invoke::{
         clear_dock_badge, download_file, increment_dock_badge, send_notification, set_dock_badge,
-        set_dock_badge_label, set_zoom, update_theme_mode,
+        set_dock_badge_label, set_zoom, update_theme_mode, webview_navigate,
     },
     setup::{set_global_shortcut, set_system_tray},
-    window::{open_additional_window_safe, reapply_window_icon, set_window, MultiWindowState},
+    window::{
+        open_additional_window_safe, reapply_window_icon, reveal_built_window, set_window,
+        MultiWindowState,
+    },
 };
 use util::get_pake_config;
 
+/// Placeholder documents used before the real target URL navigates (e.g. macOS
+/// cert-bypass starts on about:blank). Revealing on these would reintroduce the
+/// blank-window flash the page-load gate is meant to prevent.
+fn is_placeholder_startup_url(url: &Url) -> bool {
+    url.scheme().eq_ignore_ascii_case("about")
+}
+
+/// First automatic reveal wins. Returns true if the caller should show the window.
+fn claim_startup_reveal(revealed: &AtomicBool) -> bool {
+    !revealed.swap(true, Ordering::AcqRel)
+}
+
+/// User took control of main-window visibility (tray, shortcut, dock, second
+/// instance, hide-on-close). Drop any pending page-load / fallback reveal so a
+/// slow cold start cannot re-open a window the user just hid.
+pub(crate) fn cancel_startup_reveal(revealed: &AtomicBool) {
+    revealed.store(true, Ordering::Release);
+}
+
+fn reveal_startup_window(window: WebviewWindow, init_fullscreen: bool, revealed: &Arc<AtomicBool>) {
+    if !claim_startup_reveal(revealed) {
+        return;
+    }
+
+    tauri::async_runtime::spawn(async move {
+        let _ = window.show();
+        reapply_window_icon(&window);
+
+        // Fixed: Linux fullscreen issue with virtual keyboard
+        #[cfg(target_os = "linux")]
+        {
+            if init_fullscreen {
+                let _ = window.set_fullscreen(true);
+                // Ensure webview maintains focus for input after fullscreen
+                let _ = window.set_focus();
+            } else {
+                // Fix: Ubuntu 24.04/GNOME window buttons non-functional until resize (#1122)
+                // The window manager needs time to process the MapWindow event before
+                // accepting focus requests. Without this, decorations remain non-interactive.
+                tokio::time::sleep(tokio::time::Duration::from_millis(30)).await;
+                let _ = window.set_focus();
+            }
+        }
+
+        #[cfg(not(target_os = "linux"))]
+        let _ = init_fullscreen;
+    });
+}
+
 #[cfg(any(target_os = "linux", test))]
 fn is_disabled_env_value(value: &str) -> bool {
     matches!(
@@ -149,6 +207,7 @@ pub fn run_app() {
     let multi_instance = pake_config.multi_instance;
     let multi_window = pake_config.multi_window;
     let _enable_find = pake_config.windows[0].enable_find;
+    let startup_window_revealed = Arc::new(AtomicBool::new(false));
 
     let window_state_plugin = WindowStatePlugin::default()
         .with_state_flags(if init_fullscreen {
@@ -172,11 +231,13 @@ pub fn run_app() {
 
     // Only add single instance plugin if multiple instances are not allowed
     if !multi_instance {
+        let instance_revealed = startup_window_revealed.clone();
         app_builder = app_builder.plugin(tauri_plugin_single_instance::init(
             move |app, _args, _cwd| {
                 if multi_window {
                     open_additional_window_safe(app);
                 } else if let Some(window) = app.get_webview_window("pake") {
+                    cancel_startup_reveal(&instance_revealed);
                     let _ = window.unminimize();
                     let _ = window.show();
                     reapply_window_icon(&window);
@@ -186,6 +247,49 @@ pub fn run_app() {
         ));
     }
 
+    // Reveal hidden windows after the first real document finishes loading so
+    // slow WKWebView cold starts do not expose an empty but interactive shell.
+    // - Main label "pake": once-only latch + start_to_tray opt-out.
+    // - Secondary multi-window labels ("pake-N"): reveal if still hidden (Cmd+N).
+    // start_to_tray keeps the main window hidden until the user opens it.
+    {
+        let page_load_revealed = startup_window_revealed.clone();
+        app_builder = app_builder.on_page_load(move |webview, payload| {
+            if !matches!(payload.event(), PageLoadEvent::Finished) {
+                return;
+            }
+            // Skip about:blank (and other about: placeholders) used by the macOS
+            // cert-bypass path before the real target URL navigates.
+            if is_placeholder_startup_url(payload.url()) {
+                return;
+            }
+
+            let label = webview.label();
+            if label == "pake" {
+                if start_to_tray {
+                    return;
+                }
+                if let Some(window) = webview.app_handle().get_webview_window("pake") {
+                    reveal_startup_window(window, init_fullscreen, &page_load_revealed);
+                }
+                return;
+            }
+
+            // Multi-window clones (pake-1, pake-2, …) built hidden by
+            // open_additional_window_safe.
+            if label.starts_with("pake-") {
+                if let Some(window) = webview.app_handle().get_webview_window(label) {
+                    reveal_built_window(&window);
+                }
+            }
+        });
+    }
+
+    // Clone before setup moves the Arc into tray / shortcut / fallback handlers.
+    let close_revealed = startup_window_revealed.clone();
+    #[cfg(target_os = "macos")]
+    let reopen_revealed = startup_window_revealed.clone();
+
     app_builder
         .invoke_handler(tauri::generate_handler![
             download_file,
@@ -196,6 +300,7 @@ pub fn run_app() {
             clear_dock_badge,
             update_theme_mode,
             set_zoom,
+            webview_navigate,
         ])
         .setup(move |app| {
             app.manage(MultiWindowState::new(
@@ -222,34 +327,30 @@ pub fn run_app() {
                 &pake_config.system_tray_path,
                 init_fullscreen,
                 multi_window,
+                startup_window_revealed.clone(),
+            )?;
+            set_global_shortcut(
+                app.app_handle(),
+                activation_shortcut,
+                init_fullscreen,
+                startup_window_revealed.clone(),
             )?;
-            set_global_shortcut(app.app_handle(), activation_shortcut, init_fullscreen)?;
 
             // Show window after state restoration to prevent position flashing
-            // Unless start_to_tray is enabled, then keep it hidden
+            // once its first page finishes. A fallback keeps offline or stalled
+            // pages reachable without exposing a blank webview during normal startup.
             if !start_to_tray {
                 let window_clone = window.clone();
                 tauri::async_runtime::spawn(async move {
-                    tokio::time::sleep(tokio::time::Duration::from_millis(WINDOW_SHOW_DELAY)).await;
-                    let _ = window_clone.show();
-                    reapply_window_icon(&window_clone);
-
-                    // Fixed: Linux fullscreen issue with virtual keyboard
-                    #[cfg(target_os = "linux")]
-                    {
-                        if init_fullscreen {
-                            let _ = window_clone.set_fullscreen(true);
-                            // Ensure webview maintains focus for input after fullscreen
-                            let _ = window_clone.set_focus();
-                        } else {
-                            // Fix: Ubuntu 24.04/GNOME window buttons non-functional until resize (#1122)
-                            // The window manager needs time to process the MapWindow event before
-                            // accepting focus requests. Without this, decorations remain non-interactive.
-                            tokio::time::sleep(tokio::time::Duration::from_millis(30)).await;
-                            let _ = window_clone.set_focus();
-                        }
-                    }
+                    tokio::time::sleep(tokio::time::Duration::from_millis(
+                        STARTUP_WINDOW_FALLBACK_DELAY,
+                    ))
+                    .await;
+                    reveal_startup_window(window_clone, init_fullscreen, &startup_window_revealed);
                 });
+            } else {
+                // Tray/shortcut already hold clones that cancel user-driven toggles.
+                drop(startup_window_revealed);
             }
 
             Ok(())
@@ -257,6 +358,8 @@ pub fn run_app() {
         .on_window_event(move |_window, _event| {
             if let tauri::WindowEvent::CloseRequested { api, .. } = _event {
                 if hide_on_close && _window.label() == "pake" {
+                    // User dismissed the window; do not let startup reveal reopen it.
+                    cancel_startup_reveal(&close_revealed);
                     // Hide window when hide_on_close is enabled (regardless of tray status)
                     let window = _window.clone();
                     tauri::async_runtime::spawn(async move {
@@ -291,7 +394,7 @@ pub fn run_app() {
             eprintln!("[Pake] Fatal error while building Tauri application: {error}");
             std::process::exit(1);
         })
-        .run(|_app, _event| {
+        .run(move |_app, _event| {
             // Handle macOS dock icon click to reopen hidden window
             #[cfg(target_os = "macos")]
             if let tauri::RunEvent::Reopen {
@@ -301,6 +404,7 @@ pub fn run_app() {
             {
                 if !has_visible_windows {
                     if let Some(window) = _app.get_webview_window("pake") {
+                        cancel_startup_reveal(&reopen_revealed);
                         let _ = window.show();
                         reapply_window_icon(&window);
                         let _ = window.set_focus();
@@ -318,6 +422,46 @@ pub fn run() {
 mod tests {
     use super::*;
 
+    #[test]
+    fn placeholder_startup_urls_cover_about_blank() {
+        let blank: Url = "about:blank".parse().unwrap();
+        let srcdoc: Url = "about:srcdoc".parse().unwrap();
+        let https: Url = "https://github.com/".parse().unwrap();
+        let tauri: Url = "tauri://localhost/".parse().unwrap();
+
+        assert!(is_placeholder_startup_url(&blank));
+        assert!(is_placeholder_startup_url(&srcdoc));
+        assert!(!is_placeholder_startup_url(&https));
+        assert!(!is_placeholder_startup_url(&tauri));
+    }
+
+    #[test]
+    fn first_claim_wins_startup_reveal() {
+        let revealed = AtomicBool::new(false);
+        assert!(claim_startup_reveal(&revealed));
+        assert!(!claim_startup_reveal(&revealed));
+    }
+
+    #[test]
+    fn user_show_then_hide_blocks_automatic_startup_reveal() {
+        // Slow page load: user opens from tray/shortcut, then hides again.
+        // Page-load finish and the 3s fallback must not reopen the window.
+        let revealed = AtomicBool::new(false);
+        cancel_startup_reveal(&revealed); // explicit show
+        cancel_startup_reveal(&revealed); // explicit hide
+        assert!(
+            !claim_startup_reveal(&revealed),
+            "automatic reveal must stay cancelled after user visibility control"
+        );
+    }
+
+    #[test]
+    fn cancel_before_any_claim_blocks_reveal() {
+        let revealed = AtomicBool::new(false);
+        cancel_startup_reveal(&revealed);
+        assert!(!claim_startup_reveal(&revealed));
+    }
+
     #[test]
     fn linux_webkit_safe_mode_stays_on_by_default() {
         assert!(should_enable_linux_webkit_safe_mode_from_values(

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "productName": "Weekly",
   "identifier": "com.pake.weekly",
-  "version": "3.15.4",
+  "version": "3.15.6",
   "app": {
     "withGlobalTauri": true,
     "trayIcon": {