pake-cli 3.15.4 → 3.15.5

package/dist/cli.js

@@ -20,7 +20,7 @@ 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.5";
 var description = "🤱🏻 Turn any webpage into a desktop app with one command. 🤱🏻 一键打包网页生成轻量桌面应用。";
 var engines = {
 	node: ">=18.0.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pake-cli",
-  "version": "3.15.4",
+  "version": "3.15.5",
   "description": "🤱🏻 Turn any webpage into a desktop app with one command. 🤱🏻 一键打包网页生成轻量桌面应用。",
   "engines": {
     "node": ">=18.0.0"

package/src-tauri/Cargo.lock

@@ -2564,7 +2564,7 @@ dependencies = [
 
 [[package]]
 name = "pake"
-version = "3.15.4"
+version = "3.15.5"
 dependencies = [
  "block2",
  "dispatch",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pake"
-version = "3.15.4"
+version = "3.15.5"
 description = "🤱🏻 Turn any webpage into a desktop app with Rust."
 authors = ["Tw93"]
 license = "GPL-3.0-or-later"

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

@@ -114,8 +114,18 @@ pub async fn download_file(app: AppHandle, params: DownloadFileParams) -> Result
 
     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()

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

@@ -1,6 +1,7 @@
 use crate::app::window::{open_additional_window_safe, reapply_window_icon};
+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},
@@ -16,6 +17,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 +44,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() {
@@ -50,11 +54,13 @@ pub fn set_system_tray(
             }
             "hide_app" => {
                 if let Some(window) = app.get_webview_window("pake") {
+                    cancel_startup_reveal(&menu_revealed);
                     let _ = window.minimize();
                 }
             }
             "show_app" => {
                 if let Some(window) = app.get_webview_window("pake") {
+                    cancel_startup_reveal(&menu_revealed);
                     let _ = window.show();
                     reapply_window_icon(&window);
                     #[cfg(target_os = "linux")]
@@ -79,6 +85,8 @@ pub fn set_system_tray(
             if let TrayIconEvent::Click { button, .. } = event {
                 if button == tauri::tray::MouseButton::Left {
                     if let Some(window) = tray.app_handle().get_webview_window("pake") {
+                        // Any tray toggle claims visibility control from startup reveal.
+                        cancel_startup_reveal(&click_revealed);
                         let is_visible = window.is_visible().unwrap_or(false);
                         if is_visible {
                             let _ = window.hide();
@@ -120,6 +128,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 +148,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;
@@ -150,6 +160,7 @@ pub fn set_global_shortcut(
 
                     if shortcut_hotkey.eq(event) {
                         if let Some(window) = app.get_webview_window("pake") {
+                            cancel_startup_reveal(&startup_revealed);
                             let is_visible = window.is_visible().unwrap_or(false);
                             if is_visible {
                                 let _ = window.hide();

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

@@ -446,13 +446,12 @@ const PREVIEWABLE_MEDIA_EXTENSIONS = [
   "m4a",
 ];
 
-const DOWNLOAD_PATH_PATTERNS = [
-  "/download/",
-  "/files/",
-  "/attachments/",
-  "/assets/",
-  "/dist/",
-];
+// Path fragments that often host real file downloads. Do not add broad static
+// asset roots such as "/assets/" or "/dist/": many SPAs use those as in-app
+// routes (e.g. MEXC /assets/future) and would be intercepted as downloads.
+// Extensionless links under these paths still match; prefer real extensions,
+// download attributes, or ?download / ?attachment query hints when possible.
+const DOWNLOAD_PATH_PATTERNS = ["/download/", "/files/", "/attachments/"];
 
 // Language detection utilities
 function getUserLanguage() {

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")]
@@ -29,6 +35,55 @@ use app::{
 };
 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 +204,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 +228,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 +244,35 @@ pub fn run_app() {
         ));
     }
 
+    // Reveal the main window after the first real document finishes loading so
+    // slow WKWebView cold starts do not expose an empty but interactive shell.
+    // start_to_tray keeps the window hidden for the whole session until the user
+    // opens it from the tray / shortcut.
+    if !start_to_tray {
+        let page_load_revealed = startup_window_revealed.clone();
+        app_builder = app_builder.on_page_load(move |webview, payload| {
+            if webview.label() != "pake" {
+                return;
+            }
+            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;
+            }
+            if let Some(window) = webview.app_handle().get_webview_window("pake") {
+                reveal_startup_window(window, init_fullscreen, &page_load_revealed);
+            }
+        });
+    }
+
+    // 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,
@@ -222,34 +309,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 +340,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 +376,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 +386,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 +404,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.5",
   "app": {
     "withGlobalTauri": true,
     "trayIcon": {