pake-cli 3.4.0 → 3.4.2

package/dist/cli.js

@@ -23,7 +23,7 @@ import sharp from 'sharp';
 import * as psl from 'psl';
 
 var name = "pake-cli";
-var version = "3.4.0";
+var version = "3.4.2";
 var description = "🤱🏻 Turn any webpage into a desktop app with one command. 🤱🏻 一键打包网页生成轻量桌面应用。";
 var engines = {
 	node: ">=18.0.0"
@@ -201,11 +201,13 @@ const IS_MAC = platform$1 === 'darwin';
 const IS_WIN = platform$1 === 'win32';
 const IS_LINUX = platform$1 === 'linux';
 
-async function shellExec(command, timeout = 300000, env, showOutput = false) {
+async function shellExec(command, timeout = 300000, env) {
     try {
         const { exitCode } = await execa(command, {
             cwd: npmDirectory,
-            stdio: showOutput ? 'inherit' : ['inherit', 'pipe', 'inherit'],
+            // Use 'inherit' to show all output directly to user in real-time.
+            // This ensures linuxdeploy and other tool outputs are visible during builds.
+            stdio: 'inherit',
             shell: true,
             timeout,
             env: env ? { ...process.env, ...env } : process.env,
@@ -219,15 +221,35 @@ async function shellExec(command, timeout = 300000, env, showOutput = false) {
             throw new Error(`Command timed out after ${timeout}ms: "${command}". Try increasing timeout or check network connectivity.`);
         }
         let errorMsg = `Error occurred while executing command "${command}". Exit code: ${exitCode}. Details: ${errorMessage}`;
+        // Provide helpful guidance for common Linux AppImage build failures
+        // caused by strip tool incompatibility with modern glibc (2.38+)
+        const lowerError = errorMessage.toLowerCase();
         if (process.platform === 'linux' &&
-            (errorMessage.includes('linuxdeploy') ||
-                errorMessage.includes('appimage') ||
-                errorMessage.includes('strip'))) {
+            (lowerError.includes('linuxdeploy') ||
+                lowerError.includes('appimage') ||
+                lowerError.includes('strip'))) {
             errorMsg +=
-                '\n\nLinux AppImage build error. Try one of these solutions:\n' +
-                    '  1. Run with: NO_STRIP=true pake <url> --targets appimage\n' +
-                    '  2. Use DEB format instead: pake <url> --targets deb\n' +
-                    '  3. See detailed solutions: https://github.com/tw93/Pake/blob/main/docs/faq.md';
+                '\n\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n' +
+                    'Linux AppImage Build Failed\n' +
+                    '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n' +
+                    'Cause: Strip tool incompatibility with glibc 2.38+\n' +
+                    '       (affects Debian Trixie, Arch Linux, and other modern distros)\n\n' +
+                    'Quick fix:\n' +
+                    '  NO_STRIP=1 pake <url> --targets appimage --debug\n\n' +
+                    'Alternatives:\n' +
+                    '  • Use DEB format: pake <url> --targets deb\n' +
+                    '  • Update binutils: sudo apt install binutils (or pacman -S binutils)\n' +
+                    '  • Detailed guide: https://github.com/tw93/Pake/blob/main/docs/faq.md\n' +
+                    '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━';
+            if (lowerError.includes('fuse') ||
+                lowerError.includes('operation not permitted') ||
+                lowerError.includes('/dev/fuse')) {
+                errorMsg +=
+                    '\n\nDocker / Container hint:\n' +
+                        '  AppImage tooling needs access to /dev/fuse. When running inside Docker, add:\n' +
+                        '    --privileged --device /dev/fuse --security-opt apparmor=unconfined\n' +
+                        '  or run on the host directly.';
+            }
         }
         throw new Error(errorMsg);
     }
@@ -351,7 +373,7 @@ async function installRust() {
     const rustInstallScriptForWindows = 'winget install --id Rustlang.Rustup';
     const spinner = getSpinner('Downloading Rust...');
     try {
-        await shellExec(IS_WIN ? rustInstallScriptForWindows : rustInstallScriptForMac, 300000, undefined, true);
+        await shellExec(IS_WIN ? rustInstallScriptForWindows : rustInstallScriptForMac, 300000, undefined);
         spinner.succeed(chalk.green('✔ Rust installed successfully!'));
         ensureRustEnv();
     }
@@ -448,13 +470,14 @@ async function mergeConfig(url, options, tauriConf) {
             await fsExtra.copy(sourcePath, destPath);
         }
     }));
-    const { width, height, fullscreen, hideTitleBar, alwaysOnTop, appVersion, darkMode, disabledWebShortcuts, activationShortcut, userAgent, showSystemTray, systemTrayIcon, useLocalFile, identifier, name, resizable = true, inject, proxyUrl, installerLanguage, hideOnClose, incognito, title, wasm, enableDragDrop, multiInstance, } = options;
+    const { width, height, fullscreen, maximize, hideTitleBar, alwaysOnTop, appVersion, darkMode, disabledWebShortcuts, activationShortcut, userAgent, showSystemTray, systemTrayIcon, useLocalFile, identifier, name, resizable = true, inject, proxyUrl, installerLanguage, hideOnClose, incognito, title, wasm, enableDragDrop, multiInstance, startToTray, } = options;
     const { platform } = process;
     const platformHideOnClose = hideOnClose ?? platform === 'darwin';
     const tauriConfWindowOptions = {
         width,
         height,
         fullscreen,
+        maximize,
         resizable,
         hide_title_bar: hideTitleBar,
         activation_shortcut: activationShortcut,
@@ -466,6 +489,7 @@ async function mergeConfig(url, options, tauriConf) {
         title: title || null,
         enable_wasm: wasm,
         enable_drag_drop: enableDragDrop,
+        start_to_tray: startToTray && showSystemTray,
     };
     Object.assign(tauriConf.pake.windows[0], { url, ...tauriConfWindowOptions });
     tauriConf.productName = name;
@@ -774,10 +798,10 @@ class BaseBuilder {
             logger.info(`✺ Located in China, using ${packageManager}/rsProxy CN mirror.`);
             const projectCnConf = path.join(tauriSrcPath, 'rust_proxy.toml');
             await fsExtra.copy(projectCnConf, projectConf);
-            await shellExec(`cd "${npmDirectory}" && ${packageManager} install${registryOption}${peerDepsOption}`, timeout, buildEnv, this.options.debug);
+            await shellExec(`cd "${npmDirectory}" && ${packageManager} install${registryOption}${peerDepsOption}`, timeout, buildEnv);
         }
         else {
-            await shellExec(`cd "${npmDirectory}" && ${packageManager} install${peerDepsOption}`, timeout, buildEnv, this.options.debug);
+            await shellExec(`cd "${npmDirectory}" && ${packageManager} install${peerDepsOption}`, timeout, buildEnv);
         }
         spinner.succeed(chalk.green('Package installed!'));
         if (!tauriTargetPathExists) {
@@ -802,11 +826,43 @@ class BaseBuilder {
         buildSpinner.stop();
         // Show static message to keep the status visible
         logger.warn('✸ Building app...');
-        const buildEnv = {
-            ...this.getBuildEnvironment(),
-            ...(process.env.NO_STRIP && { NO_STRIP: process.env.NO_STRIP }),
+        const baseEnv = this.getBuildEnvironment();
+        let buildEnv = {
+            ...(baseEnv ?? {}),
+            ...(process.env.NO_STRIP ? { NO_STRIP: process.env.NO_STRIP } : {}),
         };
-        await shellExec(`cd "${npmDirectory}" && ${this.getBuildCommand(packageManager)}`, this.getBuildTimeout(), buildEnv, this.options.debug);
+        const resolveExecEnv = () => Object.keys(buildEnv).length > 0 ? buildEnv : undefined;
+        // Warn users about potential AppImage build failures on modern Linux systems.
+        // The linuxdeploy tool bundled in Tauri uses an older strip tool that doesn't
+        // recognize the .relr.dyn section introduced in glibc 2.38+.
+        if (process.platform === 'linux' && this.options.targets === 'appimage') {
+            if (!buildEnv.NO_STRIP) {
+                logger.warn('⚠ Building AppImage on Linux may fail due to strip incompatibility with glibc 2.38+');
+                logger.warn('⚠ If build fails, retry with: NO_STRIP=1 pake <url> --targets appimage');
+            }
+        }
+        const buildCommand = `cd "${npmDirectory}" && ${this.getBuildCommand(packageManager)}`;
+        const buildTimeout = this.getBuildTimeout();
+        try {
+            await shellExec(buildCommand, buildTimeout, resolveExecEnv());
+        }
+        catch (error) {
+            const shouldRetryWithoutStrip = process.platform === 'linux' &&
+                this.options.targets === 'appimage' &&
+                !buildEnv.NO_STRIP &&
+                this.isLinuxDeployStripError(error);
+            if (shouldRetryWithoutStrip) {
+                logger.warn('⚠ AppImage build failed during linuxdeploy strip step, retrying with NO_STRIP=1 automatically.');
+                buildEnv = {
+                    ...buildEnv,
+                    NO_STRIP: '1',
+                };
+                await shellExec(buildCommand, buildTimeout, resolveExecEnv());
+            }
+            else {
+                throw error;
+            }
+        }
         // Copy app
         const fileName = this.getFileName();
         const fileType = this.getFileType(target);
@@ -829,6 +885,18 @@ class BaseBuilder {
     getFileType(target) {
         return target;
     }
+    isLinuxDeployStripError(error) {
+        if (!(error instanceof Error) || !error.message) {
+            return false;
+        }
+        const message = error.message.toLowerCase();
+        return (message.includes('linuxdeploy') ||
+            message.includes('failed to run linuxdeploy') ||
+            message.includes('strip:') ||
+            message.includes('unable to recognise the format of the input file') ||
+            message.includes('appimage tool failed') ||
+            message.includes('strip tool'));
+    }
     /**
      * 解析目标架构
      */
@@ -865,6 +933,11 @@ class BaseBuilder {
         if (target) {
             fullCommand += ` --target ${target}`;
         }
+        // Enable verbose output in debug mode to help diagnose build issues.
+        // This provides detailed logs from Tauri CLI and bundler tools.
+        if (this.options.debug) {
+            fullCommand += ' --verbose';
+        }
         return fullCommand;
     }
     /**
@@ -1178,6 +1251,13 @@ class LinuxBuilder extends BaseBuilder {
         if (features.length > 0) {
             fullCommand += ` --features ${features.join(',')}`;
         }
+        // Enable verbose output for AppImage builds when debugging or PAKE_VERBOSE is set.
+        // AppImage builds often fail with minimal error messages from linuxdeploy,
+        // so verbose mode helps diagnose issues like strip failures and missing dependencies.
+        if (this.options.targets === 'appimage' &&
+            (this.options.debug || process.env.PAKE_VERBOSE)) {
+            fullCommand += ' --verbose';
+        }
         return fullCommand;
     }
     getBasePath() {
@@ -1227,6 +1307,7 @@ const DEFAULT_PAKE_OPTIONS = {
     height: 780,
     width: 1200,
     fullscreen: false,
+    maximize: false,
     hideTitleBar: false,
     alwaysOnTop: false,
     appVersion: '1.0.0',
@@ -1249,6 +1330,7 @@ const DEFAULT_PAKE_OPTIONS = {
     enableDragDrop: false,
     keepBinary: false,
     multiInstance: false,
+    startToTray: false,
 };
 
 async function checkUpdateTips() {
@@ -1731,6 +1813,9 @@ program
     .addOption(new Option('--always-on-top', 'Always on the top level')
     .default(DEFAULT_PAKE_OPTIONS.alwaysOnTop)
     .hideHelp())
+    .addOption(new Option('--maximize', 'Start window maximized')
+    .default(DEFAULT_PAKE_OPTIONS.maximize)
+    .hideHelp())
     .addOption(new Option('--dark-mode', 'Force Mac app to use dark mode')
     .default(DEFAULT_PAKE_OPTIONS.darkMode)
     .hideHelp())
@@ -1774,6 +1859,9 @@ program
     .addOption(new Option('--multi-instance', 'Allow multiple app instances')
     .default(DEFAULT_PAKE_OPTIONS.multiInstance)
     .hideHelp())
+    .addOption(new Option('--start-to-tray', 'Start app minimized to tray')
+    .default(DEFAULT_PAKE_OPTIONS.startToTray)
+    .hideHelp())
     .addOption(new Option('--installer-language <string>', 'Installer language')
     .default(DEFAULT_PAKE_OPTIONS.installerLanguage)
     .hideHelp())

package/package.json

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

package/src-tauri/.pake/pake.json

@@ -16,6 +16,8 @@
             "incognito": false,
             "enable_wasm": false,
             "enable_drag_drop": false,
+            "maximize": false,
+            "start_to_tray": false,
             "title": null
         }
     ],

package/src-tauri/pake.json

@@ -15,7 +15,9 @@
       "hide_on_close": true,
       "incognito": false,
       "enable_wasm": false,
-      "enable_drag_drop": false
+      "enable_drag_drop": false,
+      "maximize": false,
+      "start_to_tray": false
     }
   ],
   "user_agent": {

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

@@ -5,6 +5,7 @@ pub struct WindowConfig {
     pub url: String,
     pub hide_title_bar: bool,
     pub fullscreen: bool,
+    pub maximize: bool,
     pub width: f64,
     pub height: f64,
     pub resizable: bool,
@@ -18,6 +19,7 @@ pub struct WindowConfig {
     pub title: Option<String>,
     pub enable_wasm: bool,
     pub enable_drag_drop: bool,
+    pub start_to_tray: bool,
 }
 
 #[derive(Debug, Serialize, Deserialize)]

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

@@ -3,13 +3,17 @@ use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 use tauri::{
     menu::{MenuBuilder, MenuItemBuilder},
-    tray::TrayIconBuilder,
+    tray::{TrayIconBuilder, TrayIconEvent},
     AppHandle, Manager,
 };
 use tauri_plugin_global_shortcut::{GlobalShortcutExt, Shortcut};
 use tauri_plugin_window_state::{AppHandleExt, StateFlags};
 
-pub fn set_system_tray(app: &AppHandle, show_system_tray: bool) -> tauri::Result<()> {
+pub fn set_system_tray(
+    app: &AppHandle,
+    show_system_tray: bool,
+    tray_icon_path: &str,
+) -> tauri::Result<()> {
     if !show_system_tray {
         app.remove_tray_by_id("pake-tray");
         return Ok(());
@@ -44,7 +48,34 @@ pub fn set_system_tray(app: &AppHandle, show_system_tray: bool) -> tauri::Result
             }
             _ => (),
         })
-        .icon(app.default_window_icon().unwrap().clone())
+        .on_tray_icon_event(|tray, event| match event {
+            TrayIconEvent::Click { button, .. } => {
+                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 {
+                            window.hide().unwrap();
+                        } else {
+                            window.show().unwrap();
+                            window.set_focus().unwrap();
+                        }
+                    }
+                }
+            }
+            _ => {}
+        })
+        .icon(if tray_icon_path.is_empty() {
+            app.default_window_icon()
+                .unwrap_or_else(|| panic!("Failed to get default window icon"))
+                .clone()
+        } else {
+            tauri::image::Image::from_path(tray_icon_path).unwrap_or_else(|_| {
+                // If custom tray icon fails to load, fallback to default
+                app.default_window_icon()
+                    .unwrap_or_else(|| panic!("Failed to get default window icon"))
+                    .clone()
+            })
+        })
         .build(app)?;
 
     tray.set_icon_as_template(false)?;

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

@@ -6,6 +6,22 @@ use tauri::{App, Config, Url, WebviewUrl, WebviewWindow, WebviewWindowBuilder};
 #[cfg(target_os = "macos")]
 use tauri::{Theme, TitleBarStyle};
 
+#[cfg(target_os = "windows")]
+fn build_proxy_browser_arg(url: &Url) -> Option<String> {
+    let host = url.host_str()?;
+    let scheme = url.scheme();
+    let port = url.port().or_else(|| match scheme {
+        "http" => Some(80),
+        "socks5" => Some(1080),
+        _ => None,
+    })?;
+
+    match scheme {
+        "http" | "socks5" => Some(format!("--proxy-server={scheme}://{host}:{port}")),
+        _ => None,
+    }
+}
+
 pub fn set_window(app: &mut App, config: &PakeConfig, tauri_config: &Config) -> WebviewWindow {
     let package_name = tauri_config.clone().product_name.unwrap();
     let _data_dir = get_data_dir(app.handle(), package_name);
@@ -43,6 +59,7 @@ pub fn set_window(app: &mut App, config: &PakeConfig, tauri_config: &Config) ->
         .user_agent(user_agent)
         .resizable(window_config.resizable)
         .fullscreen(window_config.fullscreen)
+        .maximized(window_config.maximize)
         .inner_size(window_config.width, window_config.height)
         .always_on_top(window_config.always_on_top)
         .incognito(window_config.incognito);
@@ -59,20 +76,36 @@ pub fn set_window(app: &mut App, config: &PakeConfig, tauri_config: &Config) ->
         .initialization_script(include_str!("../inject/style.js"))
         .initialization_script(include_str!("../inject/custom.js"));
 
+    #[cfg(target_os = "windows")]
+    let mut windows_browser_args = String::from("--disable-features=msWebOOUI,msPdfOOUI,msSmartScreenProtection --disable-blink-features=AutomationControlled");
+
+    #[cfg(all(not(target_os = "windows"), not(target_os = "macos")))]
+    let mut linux_browser_args = String::from("--disable-blink-features=AutomationControlled");
+
     if window_config.enable_wasm {
-        window_builder = window_builder
-            .additional_browser_args("--enable-features=SharedArrayBuffer")
-            .additional_browser_args("--enable-unsafe-webgpu");
-    }
+        #[cfg(target_os = "windows")]
+        {
+            windows_browser_args.push_str(" --enable-features=SharedArrayBuffer");
+            windows_browser_args.push_str(" --enable-unsafe-webgpu");
+        }
 
-    if !config.proxy_url.is_empty() {
-        if let Ok(proxy_url) = Url::from_str(&config.proxy_url) {
-            window_builder = window_builder.proxy_url(proxy_url);
-            #[cfg(debug_assertions)]
-            println!("Proxy configured: {}", config.proxy_url);
+        #[cfg(all(not(target_os = "windows"), not(target_os = "macos")))]
+        {
+            linux_browser_args.push_str(" --enable-features=SharedArrayBuffer");
+            linux_browser_args.push_str(" --enable-unsafe-webgpu");
+        }
+
+        #[cfg(target_os = "macos")]
+        {
+            window_builder = window_builder
+                .additional_browser_args("--enable-features=SharedArrayBuffer")
+                .additional_browser_args("--enable-unsafe-webgpu");
         }
     }
 
+    let mut parsed_proxy_url: Option<Url> = None;
+
+    // Platform-specific configuration must be set before proxy on Windows/Linux
     #[cfg(target_os = "macos")]
     {
         let title_bar_style = if window_config.hide_title_bar {
@@ -87,13 +120,46 @@ pub fn set_window(app: &mut App, config: &PakeConfig, tauri_config: &Config) ->
         }
     }
 
-    // Windows and Linux share the same configuration
+    // Windows and Linux: set data_directory before proxy_url
     #[cfg(not(target_os = "macos"))]
     {
-        window_builder = window_builder
-            .data_directory(_data_dir)
-            .additional_browser_args("--disable-blink-features=AutomationControlled")
-            .theme(None);
+        window_builder = window_builder.data_directory(_data_dir).theme(None);
+
+        if !config.proxy_url.is_empty() {
+            if let Ok(proxy_url) = Url::from_str(&config.proxy_url) {
+                parsed_proxy_url = Some(proxy_url.clone());
+                #[cfg(target_os = "windows")]
+                {
+                    if let Some(arg) = build_proxy_browser_arg(&proxy_url) {
+                        windows_browser_args.push(' ');
+                        windows_browser_args.push_str(&arg);
+                    }
+                }
+            }
+        }
+
+        #[cfg(target_os = "windows")]
+        {
+            window_builder = window_builder.additional_browser_args(&windows_browser_args);
+        }
+
+        #[cfg(all(not(target_os = "windows"), not(target_os = "macos")))]
+        {
+            window_builder = window_builder.additional_browser_args(&linux_browser_args);
+        }
+    }
+
+    // Set proxy after platform-specific configs (required for Windows/Linux)
+    if parsed_proxy_url.is_none() && !config.proxy_url.is_empty() {
+        if let Ok(proxy_url) = Url::from_str(&config.proxy_url) {
+            parsed_proxy_url = Some(proxy_url);
+        }
+    }
+
+    if let Some(proxy_url) = parsed_proxy_url {
+        window_builder = window_builder.proxy_url(proxy_url);
+        #[cfg(debug_assertions)]
+        println!("Proxy configured: {}", config.proxy_url);
     }
 
     window_builder.build().expect("Failed to build window")

package/src-tauri/src/lib.rs

@@ -24,6 +24,7 @@ pub fn run_app() {
     let hide_on_close = pake_config.windows[0].hide_on_close;
     let activation_shortcut = pake_config.windows[0].activation_shortcut.clone();
     let init_fullscreen = pake_config.windows[0].fullscreen;
+    let start_to_tray = pake_config.windows[0].start_to_tray && show_system_tray; // Only valid when tray is enabled
     let multi_instance = pake_config.multi_instance;
 
     let window_state_plugin = WindowStatePlugin::default()
@@ -62,15 +63,23 @@ pub fn run_app() {
         ])
         .setup(move |app| {
             let window = set_window(app, &pake_config, &tauri_config);
-            set_system_tray(app.app_handle(), show_system_tray).unwrap();
+            set_system_tray(
+                app.app_handle(),
+                show_system_tray,
+                &pake_config.system_tray_path,
+            )
+            .unwrap();
             set_global_shortcut(app.app_handle(), activation_shortcut).unwrap();
 
             // Show window after state restoration to prevent position flashing
-            let window_clone = window.clone();
-            tauri::async_runtime::spawn(async move {
-                tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
-                window_clone.show().unwrap();
-            });
+            // Unless start_to_tray is enabled, then keep it hidden
+            if !start_to_tray {
+                let window_clone = window.clone();
+                tauri::async_runtime::spawn(async move {
+                    tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
+                    window_clone.show().unwrap();
+                });
+            }
 
             Ok(())
         })