pake-cli 3.12.0 → 3.13.0

package/README.md

@@ -7,7 +7,7 @@
 <div align="center">
     <a href="https://twitter.com/HiTw93" target="_blank">
     <img alt="twitter" src="https://img.shields.io/badge/follow-Tw93-red?style=flat-square&logo=Twitter"></a>
-    <a href="https://t.me/+GclQS9ZnxyI2ODQ1" target="_blank">
+    <a href="https://t.me/+9f9gf4ZrFSQ2OWVl" target="_blank">
     <img alt="telegram" src="https://img.shields.io/badge/chat-telegram-blueviolet?style=flat-square&logo=Telegram"></a>
     <a href="https://github.com/tw93/Pake/releases" target="_blank">
     <img alt="GitHub downloads" src="https://img.shields.io/github/downloads/tw93/Pake/total.svg?style=flat-square"></a>
@@ -19,7 +19,7 @@
 
 ## Features
 
-- 🎐 **Lightweight**: Nearly 20 times smaller than Electron packages, typically around 5M
+- 🎐 **Lightweight**: Installer is nearly 20 times smaller than Electron packages, typically under 10M on disk
 - 🚀 **Fast**: Built with Rust Tauri, much faster than traditional JS frameworks with lower memory usage
 - ⚡ **Easy to use**: One-command packaging via CLI or online building, no complex configuration needed
 - 📦 **Feature-rich**: Supports shortcuts, immersive windows, drag & drop, style customization, ad removal

package/dist/cli.js

@@ -10,17 +10,17 @@ import os from 'os';
 import { execa, execaSync } from 'execa';
 import crypto from 'crypto';
 import ora from 'ora';
-import fs from 'fs/promises';
+import fs from 'fs';
+import fs$1 from 'fs/promises';
 import { dir } from 'tmp-promise';
 import { fileTypeFromBuffer } from 'file-type';
 import icongen from 'icon-gen';
 import sharp from 'sharp';
 import * as psl from 'psl';
 import { InvalidArgumentError, program as program$1, Option } from 'commander';
-import fs$1 from 'fs';
 
 var name = "pake-cli";
-var version = "3.12.0";
+var version = "3.13.0";
 var description = "🤱🏻 Turn any webpage into a desktop app with one command. 🤱🏻 一键打包网页生成轻量桌面应用。";
 var engines = {
 	node: ">=18.0.0"
@@ -230,6 +230,93 @@ const { platform: platform$1 } = process;
 const IS_MAC = platform$1 === 'darwin';
 const IS_WIN = platform$1 === 'win32';
 const IS_LINUX = platform$1 === 'linux';
+// Distro IDs / ID_LIKE families that ship an RPM-based package manager.
+const RPM_FAMILY_IDS = new Set([
+    'rhel',
+    'fedora',
+    'centos',
+    'rocky',
+    'almalinux',
+    'ol', // Oracle Linux
+    'oracle',
+    'amzn', // Amazon Linux
+    'mariner',
+    'azurelinux',
+    'suse',
+    'opensuse',
+    'opensuse-leap',
+    'opensuse-tumbleweed',
+    'sles',
+]);
+// Distro IDs / ID_LIKE families that ship a DEB-based package manager.
+const DEB_FAMILY_IDS = new Set([
+    'debian',
+    'ubuntu',
+    'linuxmint',
+    'pop',
+    'elementary',
+    'kali',
+    'raspbian',
+    'devuan',
+]);
+// Parse the shell-style key=value pairs of an /etc/os-release file, stripping
+// the optional surrounding quotes around values.
+function parseOsRelease(content) {
+    const fields = {};
+    for (const rawLine of content.split('\n')) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const separator = line.indexOf('=');
+        if (separator === -1)
+            continue;
+        const key = line.slice(0, separator).trim();
+        let value = line.slice(separator + 1).trim();
+        if (value.length >= 2 &&
+            ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'")))) {
+            value = value.slice(1, -1);
+        }
+        if (key)
+            fields[key] = value;
+    }
+    return fields;
+}
+// Detect the package family from /etc/os-release. The distro's own ID wins over
+// ID_LIKE hints, and an unknown distro falls back to 'deb' to preserve Pake's
+// historical default. Accepts content directly so the decision is unit-testable
+// without a real /etc/os-release.
+function detectLinuxPackageFamily(osReleaseContent) {
+    let content = osReleaseContent;
+    if (content === undefined) {
+        try {
+            content = fs.readFileSync('/etc/os-release', 'utf-8');
+        }
+        catch {
+            return 'deb';
+        }
+    }
+    const fields = parseOsRelease(content);
+    const id = (fields.ID ?? '').toLowerCase().trim();
+    const idLike = (fields.ID_LIKE ?? '')
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(Boolean);
+    for (const token of [id, ...idLike]) {
+        if (DEB_FAMILY_IDS.has(token))
+            return 'deb';
+        if (RPM_FAMILY_IDS.has(token))
+            return 'rpm';
+    }
+    return 'deb';
+}
+// Default Linux bundle targets, chosen by the host distro's package family so
+// RPM-based distros (Fedora/RHEL/Oracle/Rocky/Alma/openSUSE) get a native .rpm
+// instead of a .deb their package manager cannot install. AppImage stays as a
+// universal fallback in both cases.
+function getDefaultLinuxTargets() {
+    return detectLinuxPackageFamily() === 'rpm' ? 'rpm,appimage' : 'deb,appimage';
+}
 
 async function shellExec(command, timeout = 300000, env) {
     try {
@@ -339,7 +426,7 @@ function checkRustInstalled() {
 async function combineFiles(files, output) {
     const contents = await Promise.all(files.map(async (file) => {
         if (file.endsWith('.css')) {
-            const fileContent = await fs.readFile(file, 'utf-8');
+            const fileContent = await fs$1.readFile(file, 'utf-8');
             return `window.addEventListener('DOMContentLoaded', (_event) => {
         const css = ${JSON.stringify(fileContent)};
         const style = document.createElement('style');
@@ -347,12 +434,12 @@ async function combineFiles(files, output) {
         document.head.appendChild(style);
       });`;
         }
-        const fileContent = await fs.readFile(file);
+        const fileContent = await fs$1.readFile(file);
         return ("window.addEventListener('DOMContentLoaded', (_event) => { " +
             fileContent +
             ' });');
     }));
-    await fs.writeFile(output, contents.join('\n'));
+    await fs$1.writeFile(output, contents.join('\n'));
     return files;
 }
 
@@ -1272,7 +1359,9 @@ class MacBuilder extends BaseBuilder {
         this.buildArch = validArchs.includes(options.targets || '')
             ? options.targets
             : 'auto';
-        if (options.iterativeBuild ||
+        // `app` is a valid macOS bundle target (see merge.ts); honour it explicitly.
+        if (options.targets === 'app' ||
+            options.iterativeBuild ||
             options.install ||
             process.env.PAKE_CREATE_APP === '1') {
             this.buildFormat = 'app';
@@ -1442,20 +1531,47 @@ class LinuxBuilder extends BaseBuilder {
             throw new Error(`No valid Linux target in "${this.options.targets}". Valid targets: ${LINUX_TARGET_TYPES.join(', ')}.`);
         }
         const useTemporaryDebForZst = needsTemporaryDebForZst(targets);
+        // With a single explicit target, fail fast. With multiple targets (the
+        // distro-aware default, or an explicit comma list) keep building the rest
+        // when one fails, so a usable installer is still produced, e.g. AppImage
+        // survives a .deb bundler abort on RPM-based distros.
+        const isolateFailures = targets.length > 1;
+        const failed = [];
+        let firstError = null;
         for (const target of targets) {
             this.currentBuildType = target;
-            if (target === 'zst') {
-                if (useTemporaryDebForZst) {
-                    await this.buildAndCopy(url, 'deb', false);
+            try {
+                if (target === 'zst') {
+                    if (useTemporaryDebForZst) {
+                        await this.buildAndCopy(url, 'deb', false);
+                    }
+                    await this.createArchPackageFromDeb({
+                        removeSourceDeb: useTemporaryDebForZst,
+                    });
+                }
+                else {
+                    await this.buildAndCopy(url, target);
                 }
-                await this.createArchPackageFromDeb({
-                    removeSourceDeb: useTemporaryDebForZst,
-                });
             }
-            else {
-                await this.buildAndCopy(url, target);
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                if (!isolateFailures) {
+                    throw err;
+                }
+                if (!firstError) {
+                    firstError = err;
+                }
+                failed.push(target);
+                logger.warn(`✼ Failed to build "${target}" target: ${err.message.split('\n')[0]}`);
             }
         }
+        // Every requested target failed: surface the first real error.
+        if (firstError && failed.length === targets.length) {
+            throw firstError;
+        }
+        if (failed.length > 0) {
+            logger.warn(`✼ Skipped failed Linux targets: ${failed.join(', ')}. Other formats built successfully.`);
+        }
     }
     async ensureArchPackagingTools() {
         const requiredTools = [
@@ -2567,7 +2683,7 @@ const DEFAULT_PAKE_OPTIONS = {
     targets: (() => {
         switch (process.platform) {
             case 'linux':
-                return 'deb,appimage';
+                return getDefaultLinuxTargets();
             case 'darwin':
                 return 'dmg';
             case 'win32':
@@ -2619,7 +2735,7 @@ function validateNumberInput(value) {
     return parsedValue;
 }
 function validateUrlInput(url) {
-    const isFile = fs$1.existsSync(url);
+    const isFile = fs.existsSync(url);
     if (!isFile) {
         try {
             return normalizeUrl(url);
@@ -2685,7 +2801,7 @@ ${green('|_|   \\__,_|_|\\_\\___|  can turn any webpage into a desktop app with
         .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')
+        .addOption(new Option('--dark-mode', 'Force app to use dark mode (supports macOS, Windows, and Linux)')
         .default(DEFAULT_PAKE_OPTIONS.darkMode)
         .hideHelp())
         .addOption(new Option('--disabled-web-shortcuts', 'Disabled webPage shortcuts')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pake-cli",
-  "version": "3.12.0",
+  "version": "3.13.0",
   "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.12.0"
+version = "3.13.0"
 dependencies = [
  "objc2",
  "objc2-app-kit",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pake"
-version = "3.12.0"
+version = "3.13.0"
 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

@@ -7,7 +7,6 @@ use tauri::http::Method;
 use tauri::{command, AppHandle, Manager, Url, WebviewWindow};
 use tauri_plugin_http::reqwest::{ClientBuilder, Request};
 
-#[cfg(target_os = "macos")]
 use tauri::Theme;
 
 static BADGE_COUNT: AtomicI64 = AtomicI64::new(0);
@@ -183,40 +182,24 @@ pub fn set_dock_badge_label(app: AppHandle, label: Option<String>) -> Result<(),
 
 #[command]
 pub async fn update_theme_mode(app: AppHandle, mode: String) {
-    #[cfg(target_os = "macos")]
-    {
-        if let Some(window) = app.get_webview_window("pake") {
-            let theme = if mode == "dark" {
-                Theme::Dark
-            } else {
-                Theme::Light
-            };
-            let _ = window.set_theme(Some(theme));
-        }
-    }
-    #[cfg(not(target_os = "macos"))]
-    {
-        let _ = app;
-        let _ = mode;
+    if let Some(window) = app.get_webview_window("pake") {
+        let theme = if mode == "dark" {
+            Theme::Dark
+        } else {
+            Theme::Light
+        };
+        let _ = window.set_theme(Some(theme));
     }
 }
 
+// Apply native WebView zoom (WKWebView pageZoom / WebView2 ZoomFactor / WebKitGTK
+// zoom level) instead of CSS hacks. CSS `transform: scale` and `html.style.zoom`
+// break complex SPAs like ChatGPT (fixed positioning shifts, unrepainted layers);
+// native zoom recalculates layout the same way a browser does for Cmd/Ctrl +/-.
 #[command]
-#[allow(unreachable_code)]
-pub fn clear_cache_and_restart(app: AppHandle) -> Result<(), String> {
-    if let Some(window) = app.get_webview_window("pake") {
-        match window.clear_all_browsing_data() {
-            Ok(_) => {
-                // Clear all browsing data successfully
-                app.restart();
-                Ok(())
-            }
-            Err(e) => {
-                eprintln!("Failed to clear browsing data: {}", e);
-                Err(format!("Failed to clear browsing data: {}", e))
-            }
-        }
-    } else {
-        Err("Main window not found".to_string())
-    }
+pub fn set_zoom(window: WebviewWindow, percent: f64) -> Result<(), String> {
+    let factor = (percent / 100.0).clamp(0.3, 2.0);
+    window
+        .set_zoom(factor)
+        .map_err(|e| format!("Failed to set zoom: {}", e))
 }

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

@@ -1,6 +1,4 @@
-// Menu functionality is only used on macOS
-#![cfg(target_os = "macos")]
-
+// Menu functionality is only used on macOS; the module is gated in app/mod.rs.
 use crate::app::window::open_additional_window_safe;
 use tauri::menu::{AboutMetadata, Menu, MenuItem, PredefinedMenuItem, Submenu};
 use tauri::{AppHandle, Manager, Wry};
@@ -308,7 +306,7 @@ pub fn handle_menu_click(app_handle: &AppHandle, id: &str) {
         }
         "clear_cache_restart" => {
             if let Some(window) = app_handle.get_webview_window("pake") {
-                if let Ok(_) = window.clear_all_browsing_data() {
+                if window.clear_all_browsing_data().is_ok() {
                     app_handle.restart();
                 }
             }

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

@@ -61,13 +61,18 @@ pub fn set_system_tray(
                 }
             }
             "quit" => {
-                let _ = app.save_window_state(StateFlags::all());
+                let flags = if _init_fullscreen {
+                    StateFlags::all()
+                } else {
+                    StateFlags::all() & !StateFlags::FULLSCREEN
+                };
+                let _ = app.save_window_state(flags);
                 app.exit(0);
             }
             _ => (),
         })
-        .on_tray_icon_event(move |tray, event| match event {
-            TrayIconEvent::Click { button, .. } => {
+        .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);
@@ -84,7 +89,6 @@ pub fn set_system_tray(
                     }
                 }
             }
-            _ => {}
         });
 
     let resolved_icon = if tray_icon_path.is_empty() {

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

@@ -12,8 +12,10 @@ use tauri::{
     AppHandle, Config, Manager, Url, WebviewUrl, WebviewWindow, WebviewWindowBuilder,
 };
 
+use tauri::Theme;
+
 #[cfg(target_os = "macos")]
-use tauri::{Theme, TitleBarStyle};
+use tauri::TitleBarStyle;
 
 #[cfg(target_os = "windows")]
 fn build_proxy_browser_arg(url: &Url) -> Option<String> {
@@ -344,6 +346,14 @@ fn build_window(
 
     let mut parsed_proxy_url: Option<Url> = None;
 
+    // Default to following the system theme (None), only force dark when explicitly set.
+    // Computed once; the matching platform block below is the sole consumer.
+    let theme = if window_config.dark_mode {
+        Some(Theme::Dark)
+    } else {
+        None // Follow system theme
+    };
+
     // Platform-specific configuration must be set before proxy on Windows/Linux
     #[cfg(target_os = "macos")]
     {
@@ -353,20 +363,13 @@ fn build_window(
             TitleBarStyle::Visible
         };
         window_builder = window_builder.title_bar_style(title_bar_style);
-
-        // Default to following system theme (None), only force dark when explicitly set
-        let theme = if window_config.dark_mode {
-            Some(Theme::Dark)
-        } else {
-            None // Follow system theme
-        };
         window_builder = window_builder.theme(theme);
     }
 
     // Windows and Linux: set data_directory before proxy_url
     #[cfg(not(target_os = "macos"))]
     {
-        window_builder = window_builder.data_directory(_data_dir).theme(None);
+        window_builder = window_builder.data_directory(_data_dir).theme(theme);
 
         if !config.proxy_url.is_empty() {
             if let Ok(proxy_url) = Url::from_str(&config.proxy_url) {

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

@@ -11,19 +11,13 @@ const shortcuts = {
 };
 
 function setZoom(zoom) {
-  const html = document.getElementsByTagName("html")[0];
-  const body = document.body;
-  const zoomValue = parseFloat(zoom) / 100;
-  const isWindows = /windows/i.test(navigator.userAgent);
-
-  if (isWindows) {
-    body.style.transform = `scale(${zoomValue})`;
-    body.style.transformOrigin = "top left";
-    body.style.width = `${100 / zoomValue}%`;
-    body.style.height = `${100 / zoomValue}%`;
-  } else {
-    html.style.zoom = zoom;
-    window.dispatchEvent(new Event("resize"));
+  // Use native WebView zoom (WKWebView pageZoom / WebView2 ZoomFactor) instead of
+  // CSS hacks. `transform: scale` and `html.style.zoom` break complex SPAs like
+  // ChatGPT: the page shifts right on Windows and parts of the UI stop repainting
+  // on macOS. Native zoom recalculates layout exactly like a browser does.
+  const invoke = window.__TAURI__?.core?.invoke;
+  if (invoke) {
+    invoke("set_zoom", { percent: parseFloat(zoom) }).catch(() => {});
   }
 
   window.localStorage.setItem("htmlZoom", zoom);

package/src-tauri/src/lib.rs

@@ -16,11 +16,13 @@ const PAKE_LINUX_WEBKIT_SAFE_MODE: &str = "PAKE_LINUX_WEBKIT_SAFE_MODE";
 const WEBKIT_DISABLE_DMABUF_RENDERER: &str = "WEBKIT_DISABLE_DMABUF_RENDERER";
 #[cfg(target_os = "linux")]
 const WEBKIT_DISABLE_COMPOSITING_MODE: &str = "WEBKIT_DISABLE_COMPOSITING_MODE";
+#[cfg(target_os = "linux")]
+const GDK_BACKEND: &str = "GDK_BACKEND";
 
 use app::{
     invoke::{
-        clear_cache_and_restart, clear_dock_badge, download_file, increment_dock_badge,
-        send_notification, set_dock_badge, set_dock_badge_label, update_theme_mode,
+        clear_dock_badge, download_file, increment_dock_badge, send_notification, set_dock_badge,
+        set_dock_badge_label, set_zoom, update_theme_mode,
     },
     setup::{set_global_shortcut, set_system_tray},
     window::{open_additional_window_safe, set_window, MultiWindowState},
@@ -66,6 +68,34 @@ fn should_enable_linux_webkit_safe_mode_from_values(
     !is_niri_session
 }
 
+#[cfg(any(target_os = "linux", test))]
+fn should_force_wayland_gdk_backend(
+    gdk_backend: Option<&str>,
+    wayland_display: Option<&str>,
+    display: Option<&str>,
+) -> bool {
+    // Respect an explicit user choice.
+    if is_non_empty_env_value(gdk_backend) {
+        return false;
+    }
+
+    // On pure Wayland compositors without XWayland (e.g. Niri), $DISPLAY is unset
+    // and GTK defaults to the X11 backend, which aborts with "Failed to initialize
+    // GTK". Wayland is then the only viable backend, so forcing it is safe.
+    is_non_empty_env_value(wayland_display) && !is_non_empty_env_value(display)
+}
+
+#[cfg(target_os = "linux")]
+fn apply_linux_gdk_backend() {
+    if should_force_wayland_gdk_backend(
+        std::env::var(GDK_BACKEND).ok().as_deref(),
+        std::env::var("WAYLAND_DISPLAY").ok().as_deref(),
+        std::env::var("DISPLAY").ok().as_deref(),
+    ) {
+        std::env::set_var(GDK_BACKEND, "wayland");
+    }
+}
+
 #[cfg(target_os = "linux")]
 fn apply_linux_webkit_runtime_flags() {
     let safe_mode = std::env::var(PAKE_LINUX_WEBKIT_SAFE_MODE).ok();
@@ -103,7 +133,10 @@ fn apply_linux_webkit_runtime_flags() {
 
 pub fn run_app() {
     #[cfg(target_os = "linux")]
-    apply_linux_webkit_runtime_flags();
+    {
+        apply_linux_gdk_backend();
+        apply_linux_webkit_runtime_flags();
+    }
 
     let (pake_config, tauri_config) = get_pake_config();
     let tauri_app = tauri::Builder::default();
@@ -122,7 +155,9 @@ pub fn run_app() {
             StateFlags::FULLSCREEN
         } else {
             // Prevent flickering on the first open.
-            StateFlags::all() & !StateFlags::VISIBLE
+            // Exclude FULLSCREEN so a prior --fullscreen build's persisted state
+            // doesn't force fullscreen on a rebuild without --fullscreen.
+            StateFlags::all() & !StateFlags::VISIBLE & !StateFlags::FULLSCREEN
         })
         .build();
 
@@ -159,7 +194,7 @@ pub fn run_app() {
             set_dock_badge_label,
             clear_dock_badge,
             update_theme_mode,
-            clear_cache_and_restart,
+            set_zoom,
         ])
         .setup(move |app| {
             app.manage(MultiWindowState::new(
@@ -329,4 +364,45 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn forces_wayland_backend_on_pure_wayland() {
+        assert!(should_force_wayland_gdk_backend(
+            None,
+            Some("wayland-0"),
+            None
+        ));
+    }
+
+    #[test]
+    fn forces_wayland_backend_when_display_is_blank() {
+        assert!(should_force_wayland_gdk_backend(
+            None,
+            Some("wayland-0"),
+            Some("   ")
+        ));
+    }
+
+    #[test]
+    fn keeps_default_backend_when_x11_display_present() {
+        assert!(!should_force_wayland_gdk_backend(
+            None,
+            Some("wayland-0"),
+            Some(":0")
+        ));
+    }
+
+    #[test]
+    fn keeps_default_backend_without_wayland_display() {
+        assert!(!should_force_wayland_gdk_backend(None, None, None));
+    }
+
+    #[test]
+    fn respects_explicit_gdk_backend_override() {
+        assert!(!should_force_wayland_gdk_backend(
+            Some("x11"),
+            Some("wayland-0"),
+            None
+        ));
+    }
 }

package/src-tauri/tauri.conf.json

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