pake-cli 3.11.4 → 3.11.6

package/src-tauri/pake.json

@@ -20,6 +20,7 @@
       "start_to_tray": false,
       "force_internal_navigation": false,
       "internal_url_regex": "",
+      "enable_find": false,
       "new_window": false
     }
   ],

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

@@ -26,6 +26,8 @@ pub struct WindowConfig {
     pub force_internal_navigation: bool,
     #[serde(default)]
     pub internal_url_regex: String,
+    #[serde(default)]
+    pub enable_find: bool,
     #[serde(default = "default_zoom")]
     pub zoom: u32,
     #[serde(default)]

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

@@ -2,6 +2,7 @@ use crate::util::{check_file_or_append, get_download_message_with_lang, show_toa
 use std::fs::{self, File};
 use std::io::Write;
 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::{ClientBuilder, Request};
@@ -9,6 +10,62 @@ use tauri_plugin_http::reqwest::{ClientBuilder, Request};
 #[cfg(target_os = "macos")]
 use tauri::Theme;
 
+static BADGE_COUNT: AtomicI64 = AtomicI64::new(0);
+const MAX_BADGE_COUNT: i64 = 99_999;
+const MAX_BADGE_LABEL_CHARS: usize = 16;
+
+fn normalize_badge_count(count: Option<i64>) -> Option<i64> {
+    count.filter(|n| (1..=MAX_BADGE_COUNT).contains(n))
+}
+
+fn normalize_badge_label(label: Option<&str>) -> Result<Option<String>, String> {
+    let Some(label) = label.map(str::trim).filter(|label| !label.is_empty()) else {
+        return Ok(None);
+    };
+
+    if label.chars().count() > MAX_BADGE_LABEL_CHARS {
+        return Err(format!(
+            "Badge label must be {MAX_BADGE_LABEL_CHARS} characters or fewer"
+        ));
+    }
+
+    Ok(Some(label.to_string()))
+}
+
+fn apply_badge(app: &AppHandle, count: Option<i64>) -> Result<(), String> {
+    let label = normalize_badge_count(count).map(|n| n.to_string());
+    apply_badge_label(app, label.as_deref())
+}
+
+#[cfg(target_os = "macos")]
+fn apply_badge_label(app: &AppHandle, label: Option<&str>) -> Result<(), String> {
+    use objc2::MainThreadMarker;
+    use objc2_app_kit::NSApplication;
+    use objc2_foundation::NSString;
+
+    let label = label.map(str::to_owned);
+    app.run_on_main_thread(move || {
+        let Some(mtm) = MainThreadMarker::new() else {
+            return;
+        };
+        let dock_tile = NSApplication::sharedApplication(mtm).dockTile();
+        let ns_label = label.as_deref().map(NSString::from_str);
+        dock_tile.setBadgeLabel(ns_label.as_deref());
+    })
+    .map_err(|e| format!("Failed to dispatch dock badge update: {e}"))
+}
+
+#[cfg(not(target_os = "macos"))]
+fn apply_badge_label(app: &AppHandle, label: Option<&str>) -> Result<(), String> {
+    let window = app
+        .get_webview_window("pake")
+        .ok_or("Main window not found")?;
+    let count = label.and_then(|s| s.parse::<i64>().ok());
+    window
+        .set_badge_count(count)
+        .map_err(|e| format!("Failed to set badge count: {e}"))
+}
+
 #[derive(serde::Deserialize)]
 pub struct DownloadFileParams {
     url: String,
@@ -144,6 +201,34 @@ pub fn send_notification(app: AppHandle, params: NotificationParams) -> Result<(
     Ok(())
 }
 
+#[command]
+pub fn set_dock_badge(app: AppHandle, count: Option<i64>) -> Result<(), String> {
+    let normalized = normalize_badge_count(count);
+    BADGE_COUNT.store(normalized.unwrap_or(0), Ordering::SeqCst);
+    apply_badge(&app, normalized)
+}
+
+#[command]
+pub fn increment_dock_badge(app: AppHandle) -> Result<(), String> {
+    let current = BADGE_COUNT.load(Ordering::SeqCst);
+    let next = current.saturating_add(1).clamp(1, MAX_BADGE_COUNT);
+    BADGE_COUNT.store(next, Ordering::SeqCst);
+    apply_badge(&app, Some(next))
+}
+
+#[command]
+pub fn clear_dock_badge(app: AppHandle) -> Result<(), String> {
+    BADGE_COUNT.store(0, Ordering::SeqCst);
+    apply_badge(&app, None)
+}
+
+#[command]
+pub fn set_dock_badge_label(app: AppHandle, label: Option<String>) -> Result<(), String> {
+    BADGE_COUNT.store(0, Ordering::SeqCst);
+    let label = normalize_badge_label(label.as_deref())?;
+    apply_badge_label(&app, label.as_deref())
+}
+
 #[command]
 pub async fn update_theme_mode(app: AppHandle, mode: String) {
     #[cfg(target_os = "macos")]

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

@@ -6,24 +6,36 @@ use tauri::menu::{AboutMetadata, Menu, MenuItem, PredefinedMenuItem, Submenu};
 use tauri::{AppHandle, Manager, Wry};
 use tauri_plugin_opener::OpenerExt;
 
-pub fn get_menu(app: &AppHandle<Wry>, allow_multi_window: bool) -> tauri::Result<Menu<Wry>> {
+pub fn set_app_menu(
+    app: &AppHandle<Wry>,
+    allow_multi_window: bool,
+    enable_find: bool,
+) -> tauri::Result<()> {
     let pake_version = env!("CARGO_PKG_VERSION");
     let pake_menu_item_title = format!("Built with Pake V{}", pake_version);
 
+    let window_submenu = window_menu(app)?;
+
     let menu = Menu::with_items(
         app,
         &[
             &app_menu(app)?,
             &file_menu(app, allow_multi_window)?,
-            &edit_menu(app)?,
+            &edit_menu(app, enable_find)?,
             &view_menu(app)?,
             &navigation_menu(app)?,
-            &window_menu(app)?,
+            &window_submenu,
             &help_menu(app, &pake_menu_item_title)?,
         ],
     )?;
 
-    Ok(menu)
+    app.set_menu(menu)?;
+
+    // AppKit injects Move & Resize, Fill, Center, Full Screen Tile, and
+    // window-cycling once the submenu is registered as the windows menu.
+    window_submenu.set_as_windows_menu_for_nsapp()?;
+
+    Ok(())
 }
 
 fn app_menu(app: &AppHandle<Wry>) -> tauri::Result<Submenu<Wry>> {
@@ -69,7 +81,7 @@ fn file_menu(app: &AppHandle<Wry>, allow_multi_window: bool) -> tauri::Result<Su
     Ok(file_menu)
 }
 
-fn edit_menu(app: &AppHandle<Wry>) -> tauri::Result<Submenu<Wry>> {
+fn edit_menu(app: &AppHandle<Wry>, enable_find: bool) -> tauri::Result<Submenu<Wry>> {
     let edit_menu = Submenu::new(app, "Edit", true)?;
     edit_menu.append(&PredefinedMenuItem::undo(app, None)?)?;
     edit_menu.append(&PredefinedMenuItem::redo(app, None)?)?;
@@ -86,6 +98,30 @@ fn edit_menu(app: &AppHandle<Wry>) -> tauri::Result<Submenu<Wry>> {
     )?)?;
     edit_menu.append(&PredefinedMenuItem::select_all(app, None)?)?;
     edit_menu.append(&PredefinedMenuItem::separator(app)?)?;
+    if enable_find {
+        edit_menu.append(&MenuItem::with_id(
+            app,
+            "find",
+            "Find",
+            true,
+            Some("CmdOrCtrl+F"),
+        )?)?;
+        edit_menu.append(&MenuItem::with_id(
+            app,
+            "find_next",
+            "Find Next",
+            true,
+            Some("CmdOrCtrl+G"),
+        )?)?;
+        edit_menu.append(&MenuItem::with_id(
+            app,
+            "find_previous",
+            "Find Previous",
+            true,
+            Some("CmdOrCtrl+Shift+G"),
+        )?)?;
+        edit_menu.append(&PredefinedMenuItem::separator(app)?)?;
+    }
     edit_menu.append(&MenuItem::with_id(
         app,
         "copy_url",
@@ -255,6 +291,21 @@ pub fn handle_menu_click(app_handle: &AppHandle, id: &str) {
                 let _ = window.eval("triggerPasteAsPlainText()");
             }
         }
+        "find" => {
+            if let Some(window) = app_handle.get_webview_window("pake") {
+                let _ = window.eval("window.pakeFind?.open()");
+            }
+        }
+        "find_next" => {
+            if let Some(window) = app_handle.get_webview_window("pake") {
+                let _ = window.eval("window.pakeFind?.next()");
+            }
+        }
+        "find_previous" => {
+            if let Some(window) = app_handle.get_webview_window("pake") {
+                let _ = window.eval("window.pakeFind?.previous()");
+            }
+        }
         "clear_cache_restart" => {
             if let Some(window) = app_handle.get_webview_window("pake") {
                 if let Ok(_) = window.clear_all_browsing_data() {

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

@@ -119,49 +119,54 @@ pub fn set_global_shortcut(
     let app_handle = app.clone();
     let shortcut_hotkey = match Shortcut::from_str(&shortcut) {
         Ok(s) => s,
-        Err(_) => return Ok(()),
+        Err(error) => {
+            eprintln!("[Pake] Invalid activation shortcut '{shortcut}': {error}");
+            return Ok(());
+        }
     };
     let last_triggered = Arc::new(Mutex::new(Instant::now()));
 
-    app_handle
-        .plugin(
-            tauri_plugin_global_shortcut::Builder::new()
-                .with_handler({
-                    let last_triggered = Arc::clone(&last_triggered);
-                    move |app, event, _shortcut| {
-                        let Ok(mut last_triggered) = last_triggered.lock() else {
-                            return;
-                        };
-                        if Instant::now().duration_since(*last_triggered)
-                            < Duration::from_millis(300)
-                        {
-                            return;
-                        }
-                        *last_triggered = Instant::now();
+    if let Err(error) = app_handle.plugin(
+        tauri_plugin_global_shortcut::Builder::new()
+            .with_handler({
+                let last_triggered = Arc::clone(&last_triggered);
+                move |app, event, _shortcut| {
+                    let Ok(mut last_triggered) = last_triggered.lock() else {
+                        return;
+                    };
+                    if Instant::now().duration_since(*last_triggered) < Duration::from_millis(300) {
+                        return;
+                    }
+                    *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();
-                                    let _ = window.set_focus();
-                                    #[cfg(target_os = "linux")]
-                                    if _init_fullscreen && !window.is_fullscreen().unwrap_or(false)
-                                    {
-                                        let _ = window.set_fullscreen(true);
-                                    }
+                    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();
+                                let _ = window.set_focus();
+                                #[cfg(target_os = "linux")]
+                                if _init_fullscreen && !window.is_fullscreen().unwrap_or(false) {
+                                    let _ = window.set_fullscreen(true);
                                 }
                             }
                         }
                     }
-                })
-                .build(),
-        )
-        .expect("Failed to set global shortcut");
+                }
+            })
+            .build(),
+    ) {
+        eprintln!(
+            "[Pake] Failed to register global shortcut plugin '{shortcut}': {error}; continuing without it."
+        );
+        return Ok(());
+    }
 
-    let _ = app.global_shortcut().register(shortcut_hotkey);
+    if let Err(error) = app.global_shortcut().register(shortcut_hotkey) {
+        eprintln!("[Pake] Failed to bind global shortcut '{shortcut}': {error}");
+    }
 
     Ok(())
 }

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

@@ -50,8 +50,12 @@ impl MultiWindowState {
     }
 }
 
-pub fn set_window(app: &AppHandle, config: &PakeConfig, tauri_config: &Config) -> WebviewWindow {
-    build_window_with_label(app, config, tauri_config, "pake").expect("Failed to build window")
+pub fn set_window(
+    app: &AppHandle,
+    config: &PakeConfig,
+    tauri_config: &Config,
+) -> tauri::Result<WebviewWindow> {
+    build_window_with_label(app, config, tauri_config, "pake")
 }
 
 pub fn open_additional_window(app: &AppHandle) -> tauri::Result<WebviewWindow> {
@@ -122,10 +126,12 @@ fn build_window_with_label(
     tauri_config: &Config,
     label: &str,
 ) -> tauri::Result<WebviewWindow> {
-    let window_config = config
-        .windows
-        .first()
-        .expect("At least one window configuration is required");
+    let window_config = config.windows.first().ok_or_else(|| {
+        tauri::Error::Io(std::io::Error::new(
+            std::io::ErrorKind::InvalidData,
+            "pake.json must define at least one window configuration",
+        ))
+    })?;
     let url = match window_config.url_type.as_str() {
         "web" => {
             let parsed = window_config.url.parse().map_err(|err| {
@@ -177,12 +183,14 @@ fn build_window(
         .product_name
         .clone()
         .unwrap_or_else(|| "pake".to_string());
-    let _data_dir = get_data_dir(app, package_name);
+    let _data_dir = get_data_dir(app, package_name).map_err(tauri::Error::Io)?;
 
-    let window_config = config
-        .windows
-        .first()
-        .expect("At least one window configuration is required");
+    let window_config = config.windows.first().ok_or_else(|| {
+        tauri::Error::Io(std::io::Error::new(
+            std::io::ErrorKind::InvalidData,
+            "pake.json must define at least one window configuration",
+        ))
+    })?;
 
     let user_agent = config.user_agent.get();
 
@@ -273,10 +281,15 @@ fn build_window(
         });
     }
 
-    // Add initialization scripts
+    // Add initialization scripts. Order matters: pakeConfig must land before
+    // any script that reads it (e.g. fullscreen polyfill checks for an opt-out
+    // flag), and toast must register `window.pakeToast` before Rust code
+    // calls show_toast().
     window_builder = window_builder
         .initialization_script(&config_script)
-        .initialization_script(include_str!("../inject/component.js"))
+        .initialization_script(include_str!("../inject/find.js"))
+        .initialization_script(include_str!("../inject/toast.js"))
+        .initialization_script(include_str!("../inject/fullscreen.js"))
         .initialization_script(include_str!("../inject/event.js"))
         .initialization_script(include_str!("../inject/style.js"))
         .initialization_script(include_str!("../inject/theme_refresh.js"))
@@ -391,7 +404,9 @@ fn build_window(
     }
 
     if let Some(features) = new_window_features {
-        // macOS popup webviews must reuse the opener webview configuration.
+        // Reuse only opener-provided position/size on macOS; sharing the opener
+        // WKWebViewConfiguration triggers duplicate WKScriptMessageHandler
+        // registrations on macOS 26+ and crashes the app (issue #1194).
         #[cfg(target_os = "macos")]
         {
             if let Some(position) = features.position() {
@@ -402,9 +417,7 @@ fn build_window(
                 window_builder = window_builder.inner_size(size.width, size.height);
             }
 
-            window_builder = window_builder
-                .with_webview_configuration(features.opener().target_configuration.clone())
-                .focused(true);
+            window_builder = window_builder.focused(true);
         }
 
         #[cfg(not(target_os = "macos"))]
@@ -417,3 +430,37 @@ fn build_window(
 
     window_builder.build()
 }
+
+#[cfg(all(test, target_os = "windows"))]
+mod proxy_arg_tests {
+    use super::*;
+
+    fn parse(url: &str) -> Url {
+        Url::from_str(url).unwrap()
+    }
+
+    #[test]
+    fn http_url_with_explicit_port() {
+        let arg = build_proxy_browser_arg(&parse("http://127.0.0.1:7890")).unwrap();
+        assert_eq!(arg, "--proxy-server=http://127.0.0.1:7890");
+    }
+
+    #[test]
+    fn http_url_uses_default_port_when_missing() {
+        let arg = build_proxy_browser_arg(&parse("http://proxy.local")).unwrap();
+        assert_eq!(arg, "--proxy-server=http://proxy.local:80");
+    }
+
+    #[test]
+    fn socks5_url_uses_default_port_when_missing() {
+        let arg = build_proxy_browser_arg(&parse("socks5://proxy.local")).unwrap();
+        assert_eq!(arg, "--proxy-server=socks5://proxy.local:1080");
+    }
+
+    #[test]
+    fn https_scheme_is_not_supported_yet() {
+        // https proxies fall back to platform proxy_url; we only emit a CLI arg
+        // for http/socks5 today.
+        assert!(build_proxy_browser_arg(&parse("https://proxy.local:8443")).is_none());
+    }
+}

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

@@ -1025,10 +1025,46 @@ document.addEventListener("DOMContentLoaded", () => {
   });
 });
 
-document.addEventListener("DOMContentLoaded", function () {
+// Bridge the Web Notification + Web Badging APIs to Pake's Rust commands so
+// pages running inside the webview can drive the macOS dock badge (and
+// taskbar badge on Linux/Windows). Installs synchronously instead of waiting
+// for DOMContentLoaded so feature-detection on Notification/setAppBadge
+// returns the polyfill before site scripts run.
+(function () {
+  const invoke = window.__TAURI__?.core?.invoke;
+  if (!invoke) return;
+
   let permVal = "granted";
   let lastNotifTime = 0;
   let lastNotif = null;
+  // Pages that drive the badge directly via setAppBadge own its lifecycle;
+  // notifications-driven counts auto-clear on the next user interaction.
+  let pageManagedBadge = false;
+  let autoBadgeActive = false;
+
+  const normalizeBadgeCount = (count) => {
+    if (typeof count !== "number" || !Number.isFinite(count)) {
+      throw new TypeError("Badge count must be a finite number.");
+    }
+    const normalized = Math.floor(count);
+    return normalized > 0 ? Math.min(normalized, 99999) : null;
+  };
+  const setBadge = (count) => {
+    pageManagedBadge = true;
+    autoBadgeActive = false;
+    return invoke("set_dock_badge", { count }).catch(() => {});
+  };
+  const clearBadge = () => invoke("clear_dock_badge").catch(() => {});
+  const setLabel = (label) => {
+    pageManagedBadge = true;
+    autoBadgeActive = false;
+    return invoke("set_dock_badge_label", { label }).catch(() => {});
+  };
+  const incrementAutoBadge = () => {
+    if (pageManagedBadge) return Promise.resolve();
+    autoBadgeActive = true;
+    return invoke("increment_dock_badge").catch(() => {});
+  };
 
   window.addEventListener("focus", () => {
     if (lastNotif?.onclick && Date.now() - lastNotifTime < 5000) {
@@ -1037,11 +1073,17 @@ document.addEventListener("DOMContentLoaded", function () {
     }
   });
 
-  window.Notification = function (title, options) {
-    const { invoke } = window.__TAURI__.core;
+  const clearAutoBadge = () => {
+    if (pageManagedBadge || !autoBadgeActive) return;
+    autoBadgeActive = false;
+    clearBadge();
+  };
+  document.addEventListener("click", clearAutoBadge, true);
+  document.addEventListener("keydown", clearAutoBadge, true);
+
+  const wrappedNotification = function (title, options) {
     const body = options?.body || "";
     let icon = options?.icon || "";
-
     if (icon.startsWith("/")) {
       icon = window.location.origin + icon;
     }
@@ -1056,24 +1098,68 @@ document.addEventListener("DOMContentLoaded", function () {
 
     lastNotifTime = Date.now();
     lastNotif = notif;
-
-    invoke("send_notification", { params: { title, body, icon } }).then(() => {
-      if (notif.onshow) notif.onshow(new Event("show"));
-    });
+    invoke("send_notification", { params: { title, body, icon } })
+      .then(() => incrementAutoBadge())
+      .then(() => {
+        if (notif.onshow) notif.onshow(new Event("show"));
+      });
 
     return notif;
   };
 
-  window.Notification.requestPermission = async () => "granted";
-
-  Object.defineProperty(window.Notification, "permission", {
+  wrappedNotification.requestPermission = async () => "granted";
+  Object.defineProperty(wrappedNotification, "permission", {
     enumerable: true,
     get: () => permVal,
     set: (v) => {
       permVal = v;
     },
   });
-});
+
+  try {
+    Object.defineProperty(window, "Notification", {
+      configurable: true,
+      writable: true,
+      value: wrappedNotification,
+    });
+  } catch (_) {}
+
+  // Web Badging API: https://wicg.github.io/badging/
+  // setAppBadge() with no argument shows an indicator dot; with a number,
+  // shows the count (0 clears). clearAppBadge() removes the badge entirely.
+  const setAppBadge = (count) => {
+    if (count === undefined) return setLabel("•");
+    let normalized;
+    try {
+      normalized = normalizeBadgeCount(count);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    if (normalized === null) {
+      pageManagedBadge = false;
+      autoBadgeActive = false;
+      return clearBadge();
+    }
+    return setBadge(normalized);
+  };
+  const clearAppBadge = () => {
+    pageManagedBadge = false;
+    autoBadgeActive = false;
+    return clearBadge();
+  };
+  try {
+    Object.defineProperty(navigator, "setAppBadge", {
+      configurable: true,
+      writable: true,
+      value: setAppBadge,
+    });
+    Object.defineProperty(navigator, "clearAppBadge", {
+      configurable: true,
+      writable: true,
+      value: clearAppBadge,
+    });
+  } catch (_) {}
+})();
 
 function setDefaultZoom() {
   const htmlZoom = window.localStorage.getItem("htmlZoom");