pake-cli 3.16.2 → 3.16.4

package/dist/cli.js

@@ -19,7 +19,7 @@ import * as psl from 'psl';
 import { InvalidArgumentError, program as program$1, Option } from 'commander';
 
 var name = "pake-cli";
-var version = "3.16.2";
+var version = "3.16.4";
 var description = "🤱🏻 Turn any webpage into a desktop app with one command. 🤱🏻 一键打包网页生成轻量桌面应用。";
 var engines = {
 	node: ">=20.9.0"
@@ -538,15 +538,8 @@ async function acquireBuildCache(targetDirectory) {
 async function enterBuildWorkspace() {
     const previousTarget = process.env.CARGO_TARGET_DIR;
     const targetDirectory = path.resolve(packageDirectory, previousTarget || 'src-tauri/target');
-    const release = await acquireBuildCache(targetDirectory);
-    let directory;
-    try {
-        directory = await createBuildWorkspace(packageDirectory);
-    }
-    catch (error) {
-        await release();
-        throw error;
-    }
+    const directory = await createBuildWorkspace(packageDirectory);
+    let release;
     setBuildDirectory(directory);
     process.env.CARGO_TARGET_DIR = targetDirectory;
     const leave = async () => {
@@ -567,7 +560,7 @@ async function enterBuildWorkspace() {
         }
         finally {
             try {
-                await release();
+                await release?.();
             }
             catch (error) {
                 logger.warn(`Could not release the compilation cache lock: ${String(error)}`);
@@ -578,7 +571,11 @@ async function enterBuildWorkspace() {
         await leave();
         throwIfBuildCancelled();
     }
-    return leave;
+    return Object.assign(leave, {
+        async lockCache() {
+            release = await acquireBuildCache(targetDirectory);
+        },
+    });
 }
 
 async function terminateBuildTree(pid) {
@@ -1663,9 +1660,14 @@ class BaseBuilder {
         await shellExec({ executable: packageManager, args });
     }
     async buildAndCopy(url, target, logSuccess = true) {
-        const { name = 'pake-app' } = this.options;
+        await this.prepareBuild(url);
+        await this.runBuildCommand(this.getBuildCommand(await detectPackageManager()), target);
+        await this.copyBuildArtifacts(target, logSuccess);
+    }
+    async prepareBuild(url) {
         await mergeConfig(url, this.options, structuredClone(tauriConfig));
-        const packageManager = await detectPackageManager();
+    }
+    async runBuildCommand(buildCommand, target) {
         // Build app
         const buildSpinner = getSpinner('Building app...');
         buildSpinner.stop();
@@ -1684,7 +1686,6 @@ class BaseBuilder {
         if (isLinuxAppImage && !buildEnv.NO_STRIP && this.options.debug) {
             logger.warn('⚠ AppImage strip step can fail on glibc 2.38+; Pake will auto-retry with NO_STRIP=1.');
         }
-        const buildCommand = this.getBuildCommand(packageManager);
         const buildTimeout = getBuildTimeout();
         try {
             await shellExec(buildCommand, buildTimeout, resolveExecEnv());
@@ -1711,6 +1712,9 @@ class BaseBuilder {
                 throw retryError;
             }
         }
+    }
+    async copyBuildArtifacts(target, logSuccess = true) {
+        const { name = 'pake-app' } = this.options;
         // With --no-bundle there is no installer to copy; surface the raw
         // executable the build produced instead.
         if (this.options.bundle === false) {
@@ -2083,6 +2087,7 @@ class LinuxBuilder extends BaseBuilder {
     constructor(options) {
         super(options);
         this.currentBuildType = '';
+        this.compiled = false;
         const target = options.targets || 'deb';
         if (target.includes('-arm64')) {
             this.buildFormat = target.replace('-arm64', '');
@@ -2118,6 +2123,8 @@ class LinuxBuilder extends BaseBuilder {
         return `${name}_${version}_${arch}`;
     }
     async build(url) {
+        this.compiled = false;
+        this.currentBuildType = '';
         // --no-bundle: build the executable once with no per-format packaging loop.
         if (this.options.bundle === false) {
             await this.buildAndCopy(url, 'deb');
@@ -2128,6 +2135,13 @@ 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);
+        if (targets.length > 1) {
+            await this.prepareBuild(url);
+            const command = this.getBuildCommand(await detectPackageManager());
+            command.args.push('--no-bundle');
+            await this.runBuildCommand(command, 'compile');
+            this.compiled = true;
+        }
         // 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
@@ -2293,7 +2307,24 @@ post_remove() {
     // Override buildAndCopy to ensure currentBuildType is synced if called directly, though the loop above handles it most of the time.
     async buildAndCopy(url, target, logSuccess = true) {
         this.currentBuildType = target;
-        await super.buildAndCopy(url, target, logSuccess);
+        if (!this.compiled) {
+            await super.buildAndCopy(url, target, logSuccess);
+            return;
+        }
+        const packageManager = await detectPackageManager();
+        const args = ['run', 'tauri'];
+        if (packageManager === 'npm')
+            args.push('--');
+        args.push('bundle', '--config', path.join('src-tauri', '.pake', 'tauri.conf.json'));
+        args.push('--bundles', target, '--features', this.getBuildFeatures().join(','));
+        if (this.options.debug)
+            args.push('--debug');
+        if (this.options.debug || target === 'appimage' || process.env.PAKE_VERBOSE)
+            args.push('--verbose');
+        if (this.buildArch === 'arm64')
+            args.push('--target', this.getTauriTarget('arm64', 'linux'));
+        await this.runBuildCommand({ executable: packageManager, args }, target);
+        await this.copyBuildArtifacts(target, logSuccess);
     }
     getBuildCommand(packageManager = 'pnpm') {
         const configPath = path.join('src-tauri', '.pake', 'tauri.conf.json');
@@ -3847,7 +3878,8 @@ program.action(async (urlArg, options) => {
         }
         endCancellation = beginBuildCancellation();
         phase = 'prepare';
-        leaveWorkspace = await enterBuildWorkspace();
+        const workspace = await enterBuildWorkspace();
+        leaveWorkspace = workspace;
         phase = 'input';
         const appOptions = await handleOptions(options, url);
         throwIfBuildCancelled();
@@ -3857,6 +3889,8 @@ program.action(async (urlArg, options) => {
         await builder.prepare();
         throwIfBuildCancelled();
         phase = 'build';
+        await workspace.lockCache();
+        throwIfBuildCancelled();
         await builder.build(url);
         throwIfBuildCancelled();
         await leaveWorkspace();

package/package.json

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

package/src-tauri/Cargo.lock

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

package/src-tauri/Cargo.toml

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

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

@@ -405,6 +405,27 @@ fn build_window(
         ))
     })?;
 
+    let restored_url = if label == "pake"
+        && window_config.url_type == "web"
+        && !window_config.incognito
+    {
+        match app.path().app_data_dir() {
+            Ok(directory) => match crate::util::read_last_url(&directory.join("last-url.txt")) {
+                Ok(url) => url,
+                Err(error) => {
+                    eprintln!("[Pake] Could not read the last URL: {error}");
+                    None
+                }
+            },
+            Err(error) => {
+                eprintln!("[Pake] Could not locate the last URL: {error}");
+                None
+            }
+        }
+    } else {
+        None
+    };
+
     // On macOS both HTTP Basic auth and certificate bypass use the same
     // navigation-delegate proxy. Start on a neutral page so the proxy is in
     // place before the target can issue its first authentication challenge.
@@ -413,11 +434,15 @@ fn build_window(
         && window_config.url_type == "web"
         && (config.basic_auth || window_config.ignore_certificate_errors)
     {
-        Url::parse(&window_config.url).ok()
+        restored_url
+            .clone()
+            .or_else(|| Url::parse(&window_config.url).ok())
     } else {
         None
     };
 
+    let url = restored_url.map(WebviewUrl::External).unwrap_or(url);
+
     // The delegate must be installed before the first TLS challenge. Start on
     // a neutral page, then navigate from the with_webview callback below.
     #[cfg(target_os = "macos")]
@@ -821,6 +846,20 @@ fn build_window(
     Ok(window)
 }
 
+pub fn save_last_url(app: &AppHandle) {
+    let Some(window) = app.get_webview_window("pake") else {
+        return;
+    };
+    let result = (|| -> Result<(), Box<dyn std::error::Error>> {
+        let path = app.path().app_data_dir()?.join("last-url.txt");
+        crate::util::write_last_url(&path, &window.url()?)?;
+        Ok(())
+    })();
+    if let Err(error) = result {
+        eprintln!("[Pake] Could not save the last URL: {error}");
+    }
+}
+
 #[cfg(all(test, target_os = "windows"))]
 mod proxy_arg_tests {
     use super::*;

package/src-tauri/src/lib.rs

@@ -32,8 +32,8 @@ use app::{
     },
     setup::{set_global_shortcut, set_system_tray},
     window::{
-        open_additional_window_safe, reapply_window_icon, reveal_built_window, set_window,
-        MultiWindowState,
+        open_additional_window_safe, reapply_window_icon, reveal_built_window, save_last_url,
+        set_window, MultiWindowState,
     },
 };
 use util::get_pake_config;
@@ -201,6 +201,8 @@ pub fn run_app() {
 
     let show_system_tray = pake_config.show_system_tray();
     let hide_on_close = pake_config.windows[0].hide_on_close;
+    let remember_url =
+        pake_config.windows[0].url_type == "web" && !pake_config.windows[0].incognito;
     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
@@ -357,6 +359,9 @@ pub fn run_app() {
         })
         .on_window_event(move |_window, _event| {
             if let tauri::WindowEvent::CloseRequested { api, .. } = _event {
+                if remember_url && _window.label() == "pake" {
+                    save_last_url(_window.app_handle());
+                }
                 if hide_on_close && _window.label() == "pake" {
                     // User dismissed the window; do not let startup reveal reopen it.
                     cancel_startup_reveal(&close_revealed);
@@ -395,6 +400,9 @@ pub fn run_app() {
             std::process::exit(1);
         })
         .run(move |_app, _event| {
+            if remember_url && matches!(&_event, tauri::RunEvent::Exit) {
+                save_last_url(_app);
+            }
             // Handle macOS dock icon click to reopen hidden window
             #[cfg(target_os = "macos")]
             if let tauri::RunEvent::Reopen {

package/src-tauri/src/util.rs

@@ -48,6 +48,26 @@ pub fn get_data_dir(app: &AppHandle, package_name: String) -> std::io::Result<Pa
     Ok(data_dir)
 }
 
+pub fn read_last_url(path: &Path) -> std::io::Result<Option<tauri::Url>> {
+    match std::fs::read_to_string(path) {
+        Ok(value) => Ok(tauri::Url::parse(&value)
+            .ok()
+            .filter(|url| matches!(url.scheme(), "http" | "https"))),
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(None),
+        Err(error) => Err(error),
+    }
+}
+
+pub fn write_last_url(path: &Path, url: &tauri::Url) -> std::io::Result<()> {
+    if matches!(url.scheme(), "http" | "https") {
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        std::fs::write(path, url.as_str())?;
+    }
+    Ok(())
+}
+
 /// Both native and IPC downloads use the trusted, packaged configuration.
 pub fn get_download_dir(app: &AppHandle) -> Result<PathBuf, String> {
     let state = app
@@ -257,6 +277,25 @@ mod tests {
         dir
     }
 
+    #[test]
+    fn last_url_round_trip_preserves_full_address() {
+        let path = temp_path("state/last-url.txt");
+        assert_eq!(read_last_url(&path).unwrap(), None);
+        for address in [
+            "https://acme.example/projects/42?view=board#activity",
+            "https://login.example/callback?code=example#result",
+        ] {
+            let url = tauri::Url::parse(address).unwrap();
+            write_last_url(&path, &url).unwrap();
+            assert_eq!(read_last_url(&path).unwrap(), Some(url));
+        }
+        write_last_url(&path, &tauri::Url::parse("about:blank").unwrap()).unwrap();
+        assert!(read_last_url(&path).unwrap().is_some());
+        std::fs::write(&path, "invalid URL").unwrap();
+        assert_eq!(read_last_url(&path).unwrap(), None);
+        fs::remove_dir_all(path.parent().unwrap().parent().unwrap()).unwrap();
+    }
+
     #[test]
     fn expand_download_dir_preserves_absolute_paths_without_home() {
         let absolute = temp_path("My Downloads");

package/src-tauri/tauri.conf.json

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