pake-cli 3.6.0 → 3.6.2

package/dist/dev.js

@@ -12,44 +12,13 @@ import prompts from 'prompts';
 import ora from 'ora';
 import { fileURLToPath } from 'url';
 import * as psl from 'psl';
+import os from 'os';
 import { execa, execaSync } from 'execa';
 import dns from 'dns';
 import http from 'http';
 import { promisify } from 'util';
 import fs from 'fs';
-
-const DEFAULT_PAKE_OPTIONS = {
-    icon: '',
-    height: 780,
-    width: 1200,
-    fullscreen: false,
-    resizable: true,
-    hideTitleBar: false,
-    alwaysOnTop: false,
-    appVersion: '1.0.0',
-    darkMode: false,
-    disabledWebShortcuts: false,
-    activationShortcut: '',
-    userAgent: '',
-    showSystemTray: false,
-    multiArch: false,
-    targets: 'deb',
-    useLocalFile: false,
-    systemTrayIcon: '',
-    proxyUrl: '',
-    debug: false,
-    inject: [],
-    installerLanguage: 'en-US',
-    hideOnClose: true,
-    incognito: false,
-};
-// Just for cli development
-const DEFAULT_DEV_PAKE_OPTIONS = {
-    ...DEFAULT_PAKE_OPTIONS,
-    url: 'https://weekly.tw93.fun/',
-    name: 'Weekly',
-    hideTitleBar: true,
-};
+import { InvalidArgumentError, program as program$1, Option } from 'commander';
 
 const logger = {
     info(...msg) {
@@ -113,20 +82,90 @@ const IS_MAC = platform$2 === 'darwin';
 const IS_WIN = platform$2 === 'win32';
 const IS_LINUX = platform$2 === 'linux';
 
-// Constants
+function generateSafeFilename(name) {
+    return name
+        .replace(/[<>:"/\\|?*]/g, '_')
+        .replace(/\s+/g, '_')
+        .replace(/\.+$/g, '')
+        .slice(0, 255);
+}
+function getSafeAppName(name) {
+    return generateSafeFilename(name).toLowerCase();
+}
+function generateLinuxPackageName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9\u4e00-\u9fff]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .replace(/-+/g, '-');
+}
+function generateIdentifierSafeName(name) {
+    const cleaned = name.replace(/[^a-zA-Z0-9\u4e00-\u9fff]/g, '').toLowerCase();
+    if (cleaned === '') {
+        const fallback = Array.from(name)
+            .map((char) => {
+            const code = char.charCodeAt(0);
+            if ((code >= 48 && code <= 57) ||
+                (code >= 65 && code <= 90) ||
+                (code >= 97 && code <= 122)) {
+                return char.toLowerCase();
+            }
+            return code.toString(16);
+        })
+            .join('')
+            .slice(0, 50);
+        return fallback || 'pake-app';
+    }
+    return cleaned;
+}
+
 const ICON_CONFIG = {
     minFileSize: 100,
-    downloadTimeout: 10000,
-    supportedFormats: ['png', 'ico', 'jpeg', 'jpg', 'webp'],
+    supportedFormats: ['png', 'ico', 'jpeg', 'jpg', 'webp', 'icns'],
     whiteBackground: { r: 255, g: 255, b: 255 },
+    transparentBackground: { r: 255, g: 255, b: 255, alpha: 0 },
+    downloadTimeout: {
+        ci: 5000,
+        default: 15000,
+    },
 };
-// API Configuration
-const API_TOKENS = {
-    // cspell:disable-next-line
+const PLATFORM_CONFIG = {
+    win: { format: '.ico', sizes: [16, 32, 48, 64, 128, 256] },
+    linux: { format: '.png', size: 512 },
+    macos: { format: '.icns', sizes: [16, 32, 64, 128, 256, 512, 1024] },
+};
+const API_KEYS = {
     logoDev: ['pk_JLLMUKGZRpaG5YclhXaTkg', 'pk_Ph745P8mQSeYFfW2Wk039A'],
-    // cspell:disable-next-line
     brandfetch: ['1idqvJC0CeFSeyp3Yf7', '1idej-yhU_ThggIHFyG'],
 };
+function generateIconPath(appName, isDefault = false) {
+    const safeName = isDefault
+        ? 'icon'
+        : generateSafeFilename(appName).toLowerCase();
+    const baseName = safeName;
+    if (IS_WIN) {
+        return path.join(npmDirectory, 'src-tauri', 'png', `${baseName}_256.ico`);
+    }
+    if (IS_LINUX) {
+        return path.join(npmDirectory, 'src-tauri', 'png', `${baseName}_512.png`);
+    }
+    return path.join(npmDirectory, 'src-tauri', 'icons', `${baseName}.icns`);
+}
+async function copyWindowsIconIfNeeded(convertedPath, appName) {
+    if (!IS_WIN || !convertedPath.endsWith('.ico')) {
+        return convertedPath;
+    }
+    try {
+        const finalIconPath = generateIconPath(appName);
+        await fsExtra.ensureDir(path.dirname(finalIconPath));
+        await fsExtra.copy(convertedPath, finalIconPath);
+        return finalIconPath;
+    }
+    catch (error) {
+        logger.warn(`Failed to copy Windows icon: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        return convertedPath;
+    }
+}
 /**
  * Adds white background to transparent icons only
  */
@@ -141,8 +180,8 @@ async function preprocessIcon(inputPath) {
             create: {
                 width: metadata.width || 512,
                 height: metadata.height || 512,
-                channels: 3,
-                background: ICON_CONFIG.whiteBackground,
+                channels: 4,
+                background: { ...ICON_CONFIG.whiteBackground, alpha: 1 },
             },
         })
             .composite([{ input: inputPath }])
@@ -151,7 +190,57 @@ async function preprocessIcon(inputPath) {
         return outputPath;
     }
     catch (error) {
-        logger.warn(`Failed to add background to icon: ${error.message}`);
+        if (error instanceof Error) {
+            logger.warn(`Failed to add background to icon: ${error.message}`);
+        }
+        return inputPath;
+    }
+}
+/**
+ * Applies macOS squircle mask to icon
+ */
+async function applyMacOSMask(inputPath) {
+    try {
+        const { path: tempDir } = await dir();
+        const outputPath = path.join(tempDir, 'icon-macos-rounded.png');
+        // 1. Create a 1024x1024 rounded rect mask
+        // rx="224" is closer to the smooth Apple squircle look for 1024px
+        const mask = Buffer.from('<svg width="1024" height="1024"><rect x="0" y="0" width="1024" height="1024" rx="224" ry="224" fill="white"/></svg>');
+        // 2. Load input, resize to 1024, apply mask
+        const maskedBuffer = await sharp(inputPath)
+            .resize(1024, 1024, {
+            fit: 'contain',
+            background: { r: 0, g: 0, b: 0, alpha: 0 },
+        })
+            .composite([
+            {
+                input: mask,
+                blend: 'dest-in',
+            },
+        ])
+            .png()
+            .toBuffer();
+        // 3. Resize to 840x840 (~18% padding) to solve "too big" visual issue
+        // Native MacOS icons often leave some breathing room
+        await sharp(maskedBuffer)
+            .resize(840, 840, {
+            fit: 'contain',
+            background: { r: 0, g: 0, b: 0, alpha: 0 },
+        })
+            .extend({
+            top: 92,
+            bottom: 92,
+            left: 92,
+            right: 92,
+            background: { r: 0, g: 0, b: 0, alpha: 0 },
+        })
+            .toFile(outputPath);
+        return outputPath;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            logger.warn(`Failed to apply macOS mask: ${error.message}`);
+        }
         return inputPath;
     }
 }
@@ -166,104 +255,155 @@ async function convertIconFormat(inputPath, appName) {
         const platformOutputDir = path.join(outputDir, 'converted-icons');
         await fsExtra.ensureDir(platformOutputDir);
         const processedInputPath = await preprocessIcon(inputPath);
-        const iconName = appName.toLowerCase();
+        const iconName = generateSafeFilename(appName).toLowerCase();
         // Generate platform-specific format
         if (IS_WIN) {
+            // Support multiple sizes for better Windows compatibility
             await icongen(processedInputPath, platformOutputDir, {
                 report: false,
-                ico: { name: `${iconName}_256`, sizes: [256] },
+                ico: {
+                    name: `${iconName}_256`,
+                    sizes: PLATFORM_CONFIG.win.sizes,
+                },
             });
-            return path.join(platformOutputDir, `${iconName}_256.ico`);
+            return path.join(platformOutputDir, `${iconName}_256${PLATFORM_CONFIG.win.format}`);
         }
         if (IS_LINUX) {
-            const outputPath = path.join(platformOutputDir, `${iconName}_512.png`);
-            await fsExtra.copy(processedInputPath, outputPath);
+            const outputPath = path.join(platformOutputDir, `${iconName}_${PLATFORM_CONFIG.linux.size}${PLATFORM_CONFIG.linux.format}`);
+            // Ensure we convert to proper PNG format with correct size
+            await sharp(processedInputPath)
+                .resize(PLATFORM_CONFIG.linux.size, PLATFORM_CONFIG.linux.size, {
+                fit: 'contain',
+                background: ICON_CONFIG.transparentBackground,
+            })
+                .ensureAlpha()
+                .png()
+                .toFile(outputPath);
             return outputPath;
         }
         // macOS
-        await icongen(processedInputPath, platformOutputDir, {
+        const macIconPath = await applyMacOSMask(processedInputPath);
+        await icongen(macIconPath, platformOutputDir, {
             report: false,
-            icns: { name: iconName, sizes: [16, 32, 64, 128, 256, 512, 1024] },
+            icns: { name: iconName, sizes: PLATFORM_CONFIG.macos.sizes },
         });
-        const outputPath = path.join(platformOutputDir, `${iconName}.icns`);
+        const outputPath = path.join(platformOutputDir, `${iconName}${PLATFORM_CONFIG.macos.format}`);
         return (await fsExtra.pathExists(outputPath)) ? outputPath : null;
     }
     catch (error) {
-        logger.warn(`Icon format conversion failed: ${error.message}`);
+        if (error instanceof Error) {
+            logger.warn(`Icon format conversion failed: ${error.message}`);
+        }
         return null;
     }
 }
-async function handleIcon(options, url) {
-    if (options.icon) {
-        if (options.icon.startsWith('http')) {
-            return downloadIcon(options.icon);
-        }
-        return path.resolve(options.icon);
+/**
+ * Processes downloaded or local icon for platform-specific format
+ */
+async function processIcon(iconPath, appName) {
+    if (!iconPath || !appName)
+        return iconPath;
+    // Check if already in correct platform format
+    const ext = path.extname(iconPath).toLowerCase();
+    const isCorrectFormat = (IS_WIN && ext === '.ico') ||
+        (IS_LINUX && ext === '.png') ||
+        (!IS_WIN && !IS_LINUX && ext === '.icns');
+    if (isCorrectFormat) {
+        return await copyWindowsIconIfNeeded(iconPath, appName);
     }
-    // Try to get favicon from website if URL is provided
-    if (url && url.startsWith('http') && options.name) {
-        const faviconPath = await tryGetFavicon(url, options.name);
-        if (faviconPath)
-            return faviconPath;
+    // Convert to platform format
+    const convertedPath = await convertIconFormat(iconPath, appName);
+    if (convertedPath) {
+        return await copyWindowsIconIfNeeded(convertedPath, appName);
     }
+    return iconPath;
+}
+/**
+ * Gets default icon with platform-specific fallback logic
+ */
+async function getDefaultIcon() {
     logger.info('✼ No icon provided, using default icon.');
-    // For Windows, ensure we have proper fallback handling
     if (IS_WIN) {
-        const defaultIcoPath = path.join(npmDirectory, 'src-tauri/png/icon_256.ico');
+        const defaultIcoPath = generateIconPath('icon', true);
         const defaultPngPath = path.join(npmDirectory, 'src-tauri/png/icon_512.png');
-        // First try default ico
+        // Try default ico first
         if (await fsExtra.pathExists(defaultIcoPath)) {
             return defaultIcoPath;
         }
-        // If ico doesn't exist, try to convert from png
+        // Convert from png if ico doesn't exist
         if (await fsExtra.pathExists(defaultPngPath)) {
             logger.info('✼ Default ico not found, converting from png...');
             try {
                 const convertedPath = await convertIconFormat(defaultPngPath, 'icon');
                 if (convertedPath && (await fsExtra.pathExists(convertedPath))) {
-                    return convertedPath;
+                    return await copyWindowsIconIfNeeded(convertedPath, 'icon');
                 }
             }
             catch (error) {
-                logger.warn(`Failed to convert default png to ico: ${error.message}`);
+                logger.warn(`Failed to convert default png to ico: ${error instanceof Error ? error.message : 'Unknown error'}`);
             }
         }
-        // Last resort: return png path if it exists (Windows can handle png in some cases)
+        // Fallback to png or empty
         if (await fsExtra.pathExists(defaultPngPath)) {
             logger.warn('✼ Using png as fallback for Windows (may cause issues).');
             return defaultPngPath;
         }
-        // If nothing exists, let the error bubble up
-        throw new Error('No default icon found for Windows build');
+        logger.warn('✼ No default icon found, will use pake default.');
+        return '';
     }
+    // Linux and macOS defaults
     const iconPath = IS_LINUX
         ? 'src-tauri/png/icon_512.png'
         : 'src-tauri/icons/icon.icns';
     return path.join(npmDirectory, iconPath);
 }
+/**
+ * Main icon handling function with simplified logic flow
+ */
+async function handleIcon(options, url) {
+    // Handle custom icon (local file or remote URL)
+    if (options.icon) {
+        if (options.icon.startsWith('http')) {
+            const downloadedPath = await downloadIcon(options.icon);
+            if (downloadedPath) {
+                const result = await processIcon(downloadedPath, options.name || '');
+                if (result)
+                    return result;
+            }
+            return '';
+        }
+        // Local file path
+        const resolvedPath = path.resolve(options.icon);
+        const result = await processIcon(resolvedPath, options.name || '');
+        return result || resolvedPath;
+    }
+    // Try favicon from website
+    if (url && options.name) {
+        const faviconPath = await tryGetFavicon(url, options.name);
+        if (faviconPath)
+            return faviconPath;
+    }
+    // Use default icon
+    return await getDefaultIcon();
+}
 /**
  * Generates icon service URLs for a domain
  */
 function generateIconServiceUrls(domain) {
-    const logoDevUrls = API_TOKENS.logoDev
+    const logoDevUrls = API_KEYS.logoDev
         .sort(() => Math.random() - 0.5)
         .map((token) => `https://img.logo.dev/${domain}?token=${token}&format=png&size=256`);
-    const brandfetchUrls = API_TOKENS.brandfetch
+    const brandfetchUrls = API_KEYS.brandfetch
         .sort(() => Math.random() - 0.5)
         .map((key) => `https://cdn.brandfetch.io/${domain}/w/400/h/400?c=${key}`);
     return [
         ...logoDevUrls,
         ...brandfetchUrls,
         `https://logo.clearbit.com/${domain}?size=256`,
-        `https://logo.uplead.com/${domain}`,
         `https://www.google.com/s2/favicons?domain=${domain}&sz=256`,
         `https://favicon.is/${domain}`,
-        `https://icons.duckduckgo.com/ip3/${domain}.ico`,
-        `https://icon.horse/icon/${domain}`,
         `https://${domain}/favicon.ico`,
         `https://www.${domain}/favicon.ico`,
-        `https://${domain}/apple-touch-icon.png`,
-        `https://${domain}/apple-touch-icon-precomposed.png`,
     ];
 }
 /**
@@ -274,9 +414,10 @@ async function tryGetFavicon(url, appName) {
         const domain = new URL(url).hostname;
         const spinner = getSpinner(`Fetching icon from ${domain}...`);
         const serviceUrls = generateIconServiceUrls(domain);
-        // Use shorter timeout for CI environments
         const isCI = process.env.CI === 'true' || process.env.GITHUB_ACTIONS === 'true';
-        const downloadTimeout = isCI ? 5000 : ICON_CONFIG.downloadTimeout;
+        const downloadTimeout = isCI
+            ? ICON_CONFIG.downloadTimeout.ci
+            : ICON_CONFIG.downloadTimeout.default;
         for (const serviceUrl of serviceUrls) {
             try {
                 const faviconPath = await downloadIcon(serviceUrl, false, downloadTimeout);
@@ -284,23 +425,33 @@ async function tryGetFavicon(url, appName) {
                     continue;
                 const convertedPath = await convertIconFormat(faviconPath, appName);
                 if (convertedPath) {
+                    const finalPath = await copyWindowsIconIfNeeded(convertedPath, appName);
                     spinner.succeed(chalk.green('Icon fetched and converted successfully!'));
-                    return convertedPath;
+                    return finalPath;
                 }
             }
             catch (error) {
-                // Log specific errors in CI for debugging
-                if (isCI) {
+                if (error instanceof Error) {
                     logger.debug(`Icon service ${serviceUrl} failed: ${error.message}`);
                 }
+                // Network error handling
+                if ((IS_LINUX || IS_WIN) && error.code === 'ENOTFOUND') {
+                    return null;
+                }
+                // Icon generation error on Windows
+                if (IS_WIN && error instanceof Error && error.message.includes('icongen')) {
+                    return null;
+                }
                 continue;
             }
         }
-        spinner.warn(`✼ No favicon found for ${domain}. Using default.`);
+        spinner.warn(`No favicon found for ${domain}. Using default.`);
         return null;
     }
     catch (error) {
-        logger.warn(`Failed to fetch favicon: ${error.message}`);
+        if (error instanceof Error) {
+            logger.warn(`Failed to fetch favicon: ${error.message}`);
+        }
         return null;
     }
 }
@@ -311,7 +462,7 @@ async function downloadIcon(iconUrl, showSpinner = true, customTimeout) {
     try {
         const response = await axios.get(iconUrl, {
             responseType: 'arraybuffer',
-            timeout: customTimeout || ICON_CONFIG.downloadTimeout,
+            timeout: customTimeout || 10000,
         });
         const iconData = response.data;
         if (!iconData || iconData.byteLength < ICON_CONFIG.minFileSize)
@@ -325,7 +476,7 @@ async function downloadIcon(iconUrl, showSpinner = true, customTimeout) {
     }
     catch (error) {
         if (showSpinner && !(error.response?.status === 404)) {
-            throw error;
+            logger.error('Icon download failed!');
         }
         return null;
     }
@@ -335,15 +486,11 @@ async function downloadIcon(iconUrl, showSpinner = true, customTimeout) {
  */
 async function saveIconFile(iconData, extension) {
     const buffer = Buffer.from(iconData);
-    if (IS_LINUX) {
-        const iconPath = 'png/linux_temp.png';
-        await fsExtra.outputFile(`${npmDirectory}/src-tauri/${iconPath}`, buffer);
-        return iconPath;
-    }
     const { path: tempPath } = await dir();
-    const iconPath = `${tempPath}/icon.${extension}`;
-    await fsExtra.outputFile(iconPath, buffer);
-    return iconPath;
+    // Always save with the original extension first
+    const originalIconPath = path.join(tempPath, `icon.${extension}`);
+    await fsExtra.outputFile(originalIconPath, buffer);
+    return originalIconPath;
 }
 
 // Extracts the domain from a given URL.
@@ -364,6 +511,27 @@ function getDomain(inputUrl) {
         return null;
     }
 }
+// Appends 'https://' protocol to the URL if not present.
+function appendProtocol(inputUrl) {
+    try {
+        new URL(inputUrl);
+        return inputUrl;
+    }
+    catch {
+        return `https://${inputUrl}`;
+    }
+}
+// Normalizes the URL by ensuring it has a protocol and is valid.
+function normalizeUrl(urlToNormalize) {
+    const urlWithProtocol = appendProtocol(urlToNormalize);
+    try {
+        new URL(urlWithProtocol);
+        return urlWithProtocol;
+    }
+    catch (err) {
+        throw new Error(`Your url "${urlWithProtocol}" is invalid: ${err.message}`);
+    }
+}
 
 function resolveAppName(name, platform) {
     const domain = getDomain(name) || 'pake';
@@ -371,8 +539,8 @@ function resolveAppName(name, platform) {
 }
 function isValidName(name, platform) {
     const platformRegexMapping = {
-        linux: /^[a-z0-9][a-z0-9-]*$/,
-        default: /^[a-zA-Z0-9][a-zA-Z0-9- ]*$/,
+        linux: /^[a-z0-9\u4e00-\u9fff][a-z0-9\u4e00-\u9fff-]*$/,
+        default: /^[a-zA-Z0-9\u4e00-\u9fff][a-zA-Z0-9\u4e00-\u9fff- ]*$/,
     };
     const reg = platformRegexMapping[platform] || platformRegexMapping.default;
     return !!name && reg.test(name);
@@ -388,12 +556,10 @@ async function handleOptions(options, url) {
         const namePrompt = await promptText(promptMessage, defaultName);
         name = namePrompt || defaultName;
     }
-    // Handle platform-specific name formatting
     if (name && platform === 'linux') {
-        // Convert to lowercase and replace spaces with dashes for Linux
-        name = name.toLowerCase().replace(/\s+/g, '-');
+        name = generateLinuxPackageName(name);
     }
-    if (!isValidName(name, platform)) {
+    if (name && !isValidName(name, platform)) {
         const LINUX_NAME_ERROR = `✕ Name should only include lowercase letters, numbers, and dashes (not leading dashes). Examples: com-123-xxx, 123pan, pan123, weread, we-read, 123.`;
         const DEFAULT_NAME_ERROR = `✕ Name should only include letters, numbers, dashes, and spaces (not leading dashes and spaces). Examples: 123pan, 123Pan, Pan123, weread, WeRead, WERead, we-read, We Read, 123.`;
         const errorMsg = platform === 'linux' ? LINUX_NAME_ERROR : DEFAULT_NAME_ERROR;
@@ -411,7 +577,8 @@ async function handleOptions(options, url) {
         name,
         identifier: getIdentifier(url),
     };
-    appOptions.icon = await handleIcon(appOptions, url);
+    const iconPath = await handleIcon(appOptions, url);
+    appOptions.icon = iconPath || '';
     return appOptions;
 }
 
@@ -447,7 +614,9 @@ async function shellExec(command, timeout = 300000, env) {
     try {
         const { exitCode } = await execa(command, {
             cwd: npmDirectory,
-            stdio: ['inherit', 'pipe', 'inherit'], // Hide stdout verbose, keep stderr
+            // 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,
@@ -460,7 +629,38 @@ async function shellExec(command, timeout = 300000, env) {
         if (error.timedOut) {
             throw new Error(`Command timed out after ${timeout}ms: "${command}". Try increasing timeout or check network connectivity.`);
         }
-        throw new Error(`Error occurred while executing command "${command}". Exit code: ${exitCode}. Details: ${errorMessage}`);
+        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' &&
+            (lowerError.includes('linuxdeploy') ||
+                lowerError.includes('appimage') ||
+                lowerError.includes('strip'))) {
+            errorMsg +=
+                '\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);
     }
 }
 
@@ -509,6 +709,52 @@ async function isChinaIP(ip, domain) {
     }
 }
 
+function normalizePathForComparison(targetPath) {
+    const normalized = path.normalize(targetPath);
+    return IS_WIN ? normalized.toLowerCase() : normalized;
+}
+function getCargoHomeCandidates() {
+    const candidates = new Set();
+    if (process.env.CARGO_HOME) {
+        candidates.add(process.env.CARGO_HOME);
+    }
+    const homeDir = os.homedir();
+    if (homeDir) {
+        candidates.add(path.join(homeDir, '.cargo'));
+    }
+    if (IS_WIN && process.env.USERPROFILE) {
+        candidates.add(path.join(process.env.USERPROFILE, '.cargo'));
+    }
+    return Array.from(candidates).filter(Boolean);
+}
+function ensureCargoBinOnPath() {
+    const currentPath = process.env.PATH || '';
+    const segments = currentPath.split(path.delimiter).filter(Boolean);
+    const normalizedSegments = new Set(segments.map((segment) => normalizePathForComparison(segment)));
+    const additions = [];
+    let cargoHomeSet = Boolean(process.env.CARGO_HOME);
+    for (const cargoHome of getCargoHomeCandidates()) {
+        const binDir = path.join(cargoHome, 'bin');
+        if (fsExtra.pathExistsSync(binDir) &&
+            !normalizedSegments.has(normalizePathForComparison(binDir))) {
+            additions.push(binDir);
+            normalizedSegments.add(normalizePathForComparison(binDir));
+        }
+        if (!cargoHomeSet && fsExtra.pathExistsSync(cargoHome)) {
+            process.env.CARGO_HOME = cargoHome;
+            cargoHomeSet = true;
+        }
+    }
+    if (additions.length) {
+        const prefix = additions.join(path.delimiter);
+        process.env.PATH = segments.length
+            ? `${prefix}${path.delimiter}${segments.join(path.delimiter)}`
+            : prefix;
+    }
+}
+function ensureRustEnv() {
+    ensureCargoBinOnPath();
+}
 async function installRust() {
     const isActions = process.env.GITHUB_ACTIONS;
     const isInChina = await isChinaDomain('sh.rustup.rs');
@@ -518,16 +764,23 @@ async function installRust() {
     const rustInstallScriptForWindows = 'winget install --id Rustlang.Rustup';
     const spinner = getSpinner('Downloading Rust...');
     try {
-        await shellExec(IS_WIN ? rustInstallScriptForWindows : rustInstallScriptForMac);
+        await shellExec(IS_WIN ? rustInstallScriptForWindows : rustInstallScriptForMac, 300000, undefined);
         spinner.succeed(chalk.green('✔ Rust installed successfully!'));
+        ensureRustEnv();
     }
     catch (error) {
         spinner.fail(chalk.red('✕ Rust installation failed!'));
-        console.error(error.message);
+        if (error instanceof Error) {
+            console.error(error.message);
+        }
+        else {
+            console.error(error);
+        }
         process.exit(1);
     }
 }
 function checkRustInstalled() {
+    ensureCargoBinOnPath();
     try {
         execaSync('rustc', ['--version']);
         return true;
@@ -539,12 +792,16 @@ function checkRustInstalled() {
 
 async function combineFiles(files, output) {
     const contents = files.map((file) => {
-        const fileContent = fs.readFileSync(file);
         if (file.endsWith('.css')) {
-            return ("window.addEventListener('DOMContentLoaded', (_event) => { const css = `" +
-                fileContent +
-                "`; const style = document.createElement('style'); style.innerHTML = css; document.head.appendChild(style); });");
+            const fileContent = fs.readFileSync(file, 'utf-8');
+            return `window.addEventListener('DOMContentLoaded', (_event) => {
+        const css = ${JSON.stringify(fileContent)};
+        const style = document.createElement('style');
+        style.innerHTML = css;
+        document.head.appendChild(style);
+      });`;
         }
+        const fileContent = fs.readFileSync(file);
         return ("window.addEventListener('DOMContentLoaded', (_event) => { " +
             fileContent +
             ' });');
@@ -573,31 +830,42 @@ 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, } = options;
+    const { width, height, fullscreen, maximize, hideTitleBar, alwaysOnTop, appVersion, darkMode, disabledWebShortcuts, activationShortcut, userAgent, showSystemTray, systemTrayIcon, useLocalFile, identifier, name = 'pake-app', resizable = true, inject, proxyUrl, installerLanguage, hideOnClose, incognito, title, wasm, enableDragDrop, multiInstance, startToTray, forceInternalNavigation, zoom, minWidth, minHeight, ignoreCertificateErrors, } = options;
     const { platform } = process;
-    // Set Windows parameters.
+    const platformHideOnClose = hideOnClose ?? platform === 'darwin';
     const tauriConfWindowOptions = {
         width,
         height,
         fullscreen,
+        maximize,
         resizable,
         hide_title_bar: hideTitleBar,
         activation_shortcut: activationShortcut,
         always_on_top: alwaysOnTop,
         dark_mode: darkMode,
         disabled_web_shortcuts: disabledWebShortcuts,
-        hide_on_close: hideOnClose,
+        hide_on_close: platformHideOnClose,
         incognito: incognito,
         title: title || null,
+        enable_wasm: wasm,
+        enable_drag_drop: enableDragDrop,
+        start_to_tray: startToTray && showSystemTray,
+        force_internal_navigation: forceInternalNavigation,
+        zoom,
+        min_width: minWidth,
+        min_height: minHeight,
+        ignore_certificate_errors: ignoreCertificateErrors,
     };
     Object.assign(tauriConf.pake.windows[0], { url, ...tauriConfWindowOptions });
     tauriConf.productName = name;
     tauriConf.identifier = identifier;
     tauriConf.version = appVersion;
+    if (platform === 'linux') {
+        tauriConf.mainBinaryName = `pake-${generateIdentifierSafeName(name)}`;
+    }
     if (platform == 'win32') {
         tauriConf.bundle.windows.wix.language[0] = installerLanguage;
     }
-    //Judge the type of URL, whether it is a file or a website.
     const pathExists = await fsExtra.pathExists(url);
     if (pathExists) {
         logger.warn('✼ Your input might be a local file.');
@@ -639,64 +907,87 @@ async function mergeConfig(url, options, tauriConf) {
         // Remove hardcoded desktop files and regenerate with correct app name
         delete tauriConf.bundle.linux.deb.files;
         // Generate correct desktop file configuration
-        const appNameLower = name.toLowerCase();
-        const identifier = `com.pake.${appNameLower}`;
+        const appNameSafe = getSafeAppName(name);
+        const identifier = `com.pake.${appNameSafe}`;
         const desktopFileName = `${identifier}.desktop`;
         // Create desktop file content
+        // Determine if title contains Chinese characters for Name[zh_CN]
+        const chineseName = title && /[\u4e00-\u9fa5]/.test(title) ? title : null;
         const desktopContent = `[Desktop Entry]
 Version=1.0
 Type=Application
 Name=${name}
+${chineseName ? `Name[zh_CN]=${chineseName}` : ''}
 Comment=${name}
-Exec=${appNameLower}
-Icon=${appNameLower}
+Exec=pake-${appNameSafe}
+Icon=${appNameSafe}_512
 Categories=Network;WebBrowser;
 MimeType=text/html;text/xml;application/xhtml_xml;
 StartupNotify=true
 `;
-        // Write desktop file to assets directory
-        const assetsDir = path.join(npmDirectory, 'src-tauri/assets');
-        const desktopFilePath = path.join(assetsDir, desktopFileName);
-        await fsExtra.ensureDir(assetsDir);
-        await fsExtra.writeFile(desktopFilePath, desktopContent);
+        // Write desktop file to src-tauri/assets directory where Tauri expects it
+        const srcAssetsDir = path.join(npmDirectory, 'src-tauri/assets');
+        const srcDesktopFilePath = path.join(srcAssetsDir, desktopFileName);
+        await fsExtra.ensureDir(srcAssetsDir);
+        await fsExtra.writeFile(srcDesktopFilePath, desktopContent);
         // Set up desktop file in bundle configuration
+        // Use absolute path from src-tauri directory to assets
         tauriConf.bundle.linux.deb.files = {
             [`/usr/share/applications/${desktopFileName}`]: `assets/${desktopFileName}`,
         };
-        const validTargets = ['deb', 'appimage', 'rpm'];
+        const validTargets = [
+            'deb',
+            'appimage',
+            'rpm',
+            'deb-arm64',
+            'appimage-arm64',
+            'rpm-arm64',
+        ];
+        const baseTarget = options.targets.includes('-arm64')
+            ? options.targets.replace('-arm64', '')
+            : options.targets;
         if (validTargets.includes(options.targets)) {
-            tauriConf.bundle.targets = [options.targets];
+            tauriConf.bundle.targets = [baseTarget];
         }
         else {
             logger.warn(`✼ The target must be one of ${validTargets.join(', ')}, the default 'deb' will be used.`);
         }
     }
+    // Set macOS bundle targets (for app vs dmg)
+    if (platform === 'darwin') {
+        const validMacTargets = ['app', 'dmg'];
+        if (validMacTargets.includes(options.targets)) {
+            tauriConf.bundle.targets = [options.targets];
+        }
+    }
     // Set icon.
+    const safeAppName = getSafeAppName(name);
     const platformIconMap = {
         win32: {
             fileExt: '.ico',
-            path: `png/${name.toLowerCase()}_256.ico`,
+            path: `png/${safeAppName}_256.ico`,
             defaultIcon: 'png/icon_256.ico',
             message: 'Windows icon must be .ico and 256x256px.',
         },
         linux: {
             fileExt: '.png',
-            path: `png/${name.toLowerCase()}_512.png`,
+            path: `png/${safeAppName}_512.png`,
             defaultIcon: 'png/icon_512.png',
             message: 'Linux icon must be .png and 512x512px.',
         },
         darwin: {
             fileExt: '.icns',
-            path: `icons/${name.toLowerCase()}.icns`,
+            path: `icons/${safeAppName}.icns`,
             defaultIcon: 'icons/icon.icns',
             message: 'macOS icon must be .icns type.',
         },
     };
     const iconInfo = platformIconMap[platform];
-    const exists = await fsExtra.pathExists(options.icon);
+    const resolvedIconPath = options.icon ? path.resolve(options.icon) : null;
+    const exists = resolvedIconPath && (await fsExtra.pathExists(resolvedIconPath));
     if (exists) {
         let updateIconPath = true;
-        let customIconExt = path.extname(options.icon).toLowerCase();
+        let customIconExt = path.extname(resolvedIconPath).toLowerCase();
         if (customIconExt !== iconInfo.fileExt) {
             updateIconPath = false;
             logger.warn(`✼ ${iconInfo.message}, but you give ${customIconExt}`);
@@ -705,10 +996,14 @@ StartupNotify=true
         else {
             const iconPath = path.join(npmDirectory, 'src-tauri/', iconInfo.path);
             tauriConf.bundle.resources = [iconInfo.path];
-            await fsExtra.copy(options.icon, iconPath);
+            // Avoid copying if source and destination are the same
+            const absoluteDestPath = path.resolve(iconPath);
+            if (resolvedIconPath !== absoluteDestPath) {
+                await fsExtra.copy(resolvedIconPath, iconPath);
+            }
         }
         if (updateIconPath) {
-            tauriConf.bundle.icon = [options.icon];
+            tauriConf.bundle.icon = [iconInfo.path];
         }
         else {
             logger.warn(`✼ Icon will remain as default.`);
@@ -726,8 +1021,8 @@ StartupNotify=true
             // 需要判断图标格式，默认只支持ico和png两种
             let iconExt = path.extname(systemTrayIcon).toLowerCase();
             if (iconExt == '.png' || iconExt == '.ico') {
-                const trayIcoPath = path.join(npmDirectory, `src-tauri/png/${name.toLowerCase()}${iconExt}`);
-                trayIconPath = `png/${name.toLowerCase()}${iconExt}`;
+                const trayIcoPath = path.join(npmDirectory, `src-tauri/png/${safeAppName}${iconExt}`);
+                trayIconPath = `png/${safeAppName}${iconExt}`;
                 await fsExtra.copy(systemTrayIcon, trayIcoPath);
             }
             else {
@@ -746,11 +1041,13 @@ StartupNotify=true
     const injectFilePath = path.join(npmDirectory, `src-tauri/src/inject/custom.js`);
     // inject js or css files
     if (inject?.length > 0) {
-        if (!inject.every((item) => item.endsWith('.css') || item.endsWith('.js'))) {
+        // Ensure inject is an array before calling .every()
+        const injectArray = Array.isArray(inject) ? inject : [inject];
+        if (!injectArray.every((item) => item.endsWith('.css') || item.endsWith('.js'))) {
             logger.error('The injected file must be in either CSS or JS format.');
             return;
         }
-        const files = inject.map((filepath) => path.isAbsolute(filepath) ? filepath : path.join(process.cwd(), filepath));
+        const files = injectArray.map((filepath) => path.isAbsolute(filepath) ? filepath : path.join(process.cwd(), filepath));
         tauriConf.pake.inject = files;
         await combineFiles(files, injectFilePath);
     }
@@ -759,6 +1056,16 @@ StartupNotify=true
         await fsExtra.writeFile(injectFilePath, '');
     }
     tauriConf.pake.proxy_url = proxyUrl || '';
+    tauriConf.pake.multi_instance = multiInstance;
+    // Configure WASM support with required HTTP headers
+    if (wasm) {
+        tauriConf.app.security = {
+            headers: {
+                'Cross-Origin-Opener-Policy': 'same-origin',
+                'Cross-Origin-Embedder-Policy': 'require-corp',
+            },
+        };
+    }
     // Save config file.
     const platformConfigPaths = {
         win32: 'tauri.windows.conf.json',
@@ -794,10 +1101,34 @@ class BaseBuilder {
             : undefined;
     }
     getInstallTimeout() {
-        return process.platform === 'win32' ? 600000 : 300000;
+        // Windows needs more time due to native compilation and antivirus scanning
+        return process.platform === 'win32' ? 900000 : 600000;
     }
     getBuildTimeout() {
-        return 900000; // 15 minutes for all builds
+        return 900000;
+    }
+    async detectPackageManager() {
+        if (BaseBuilder.packageManagerCache) {
+            return BaseBuilder.packageManagerCache;
+        }
+        const { execa } = await import('execa');
+        try {
+            await execa('pnpm', ['--version'], { stdio: 'ignore' });
+            logger.info('✺ Using pnpm for package management.');
+            BaseBuilder.packageManagerCache = 'pnpm';
+            return 'pnpm';
+        }
+        catch {
+            try {
+                await execa('npm', ['--version'], { stdio: 'ignore' });
+                logger.info('✺ pnpm not available, using npm for package management.');
+                BaseBuilder.packageManagerCache = 'npm';
+                return 'npm';
+            }
+            catch {
+                throw new Error('Neither pnpm nor npm is available. Please install a package manager.');
+            }
+        }
     }
     async prepare() {
         const tauriSrcPath = path.join(npmDirectory, 'src-tauri');
@@ -807,6 +1138,7 @@ class BaseBuilder {
             logger.warn('✼ The first use requires installing system dependencies.');
             logger.warn('✼ See more in https://tauri.app/start/prerequisites/.');
         }
+        ensureRustEnv();
         if (!checkRustInstalled()) {
             const res = await prompts({
                 type: 'confirm',
@@ -826,24 +1158,56 @@ class BaseBuilder {
         const rustProjectDir = path.join(tauriSrcPath, '.cargo');
         const projectConf = path.join(rustProjectDir, 'config.toml');
         await fsExtra.ensureDir(rustProjectDir);
-        // 统一使用npm，简单可靠
-        const packageManager = 'npm';
-        const registryOption = isChina
-            ? ' --registry=https://registry.npmmirror.com'
-            : '';
-        const legacyPeerDeps = ' --legacy-peer-deps'; // 解决dependency conflicts
+        // Detect available package manager
+        const packageManager = await this.detectPackageManager();
+        const registryOption = ' --registry=https://registry.npmmirror.com';
+        const peerDepsOption = packageManager === 'npm' ? ' --legacy-peer-deps' : '';
         const timeout = this.getInstallTimeout();
         const buildEnv = this.getBuildEnvironment();
-        if (isChina) {
-            logger.info('✺ Located in China, using npm/rsProxy CN mirror.');
-            const projectCnConf = path.join(tauriSrcPath, 'rust_proxy.toml');
-            await fsExtra.copy(projectCnConf, projectConf);
-            await shellExec(`cd "${npmDirectory}" && ${packageManager} install${registryOption}${legacyPeerDeps} --silent`, timeout, buildEnv);
+        // Show helpful message for first-time users
+        if (!tauriTargetPathExists) {
+            logger.info(process.platform === 'win32'
+                ? '✺ First-time setup may take 10-15 minutes on Windows (compiling dependencies)...'
+                : '✺ First-time setup may take 5-10 minutes (installing dependencies)...');
         }
-        else {
-            await shellExec(`cd "${npmDirectory}" && ${packageManager} install${legacyPeerDeps} --silent`, timeout, buildEnv);
+        let usedMirror = isChina;
+        try {
+            if (isChina) {
+                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);
+            }
+            else {
+                await shellExec(`cd "${npmDirectory}" && ${packageManager} install${peerDepsOption}`, timeout, buildEnv);
+            }
+            spinner.succeed(chalk.green('Package installed!'));
+        }
+        catch (error) {
+            // If installation times out and we haven't tried the mirror yet, retry with mirror
+            if (error instanceof Error &&
+                error.message.includes('timed out') &&
+                !usedMirror) {
+                spinner.fail(chalk.yellow('Installation timed out, retrying with CN mirror...'));
+                logger.info('✺ Retrying installation with CN mirror for better speed...');
+                const retrySpinner = getSpinner('Retrying installation...');
+                usedMirror = true;
+                try {
+                    const projectCnConf = path.join(tauriSrcPath, 'rust_proxy.toml');
+                    await fsExtra.copy(projectCnConf, projectConf);
+                    await shellExec(`cd "${npmDirectory}" && ${packageManager} install${registryOption}${peerDepsOption}`, timeout, buildEnv);
+                    retrySpinner.succeed(chalk.green('Package installed with CN mirror!'));
+                }
+                catch (retryError) {
+                    retrySpinner.fail(chalk.red('Installation failed'));
+                    throw retryError;
+                }
+            }
+            else {
+                spinner.fail(chalk.red('Installation failed'));
+                throw error;
+            }
         }
-        spinner.succeed(chalk.green('Package installed!'));
         if (!tauriTargetPathExists) {
             logger.warn('✼ The first packaging may be slow, please be patient and wait, it will be faster afterwards.');
         }
@@ -852,45 +1216,146 @@ class BaseBuilder {
         await this.buildAndCopy(url, this.options.targets);
     }
     async start(url) {
+        logger.info('Pake dev server starting...');
         await mergeConfig(url, this.options, tauriConfig);
+        const packageManager = await this.detectPackageManager();
+        const configPath = path.join(npmDirectory, 'src-tauri', '.pake', 'tauri.conf.json');
+        const features = this.getBuildFeatures();
+        const featureArgs = features.length > 0 ? `--features ${features.join(',')}` : '';
+        const argSeparator = packageManager === 'npm' ? ' --' : '';
+        const command = `cd "${npmDirectory}" && ${packageManager} run tauri${argSeparator} dev --config "${configPath}" ${featureArgs}`;
+        await shellExec(command);
     }
     async buildAndCopy(url, target) {
-        const { name } = this.options;
+        const { name = 'pake-app' } = this.options;
         await mergeConfig(url, this.options, tauriConfig);
+        // Detect available package manager
+        const packageManager = await this.detectPackageManager();
         // Build app
         const buildSpinner = getSpinner('Building app...');
-        // Let spinner run for a moment so user can see it, then stop before npm command
+        // Let spinner run for a moment so user can see it, then stop before package manager command
         await new Promise((resolve) => setTimeout(resolve, 500));
         buildSpinner.stop();
         // Show static message to keep the status visible
         logger.warn('✸ Building app...');
-        const buildEnv = this.getBuildEnvironment();
-        await shellExec(`cd "${npmDirectory}" && ${this.getBuildCommand()}`, this.getBuildTimeout(), buildEnv);
+        const baseEnv = this.getBuildEnvironment();
+        let buildEnv = {
+            ...(baseEnv ?? {}),
+            ...(process.env.NO_STRIP ? { NO_STRIP: process.env.NO_STRIP } : {}),
+        };
+        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);
         const appPath = this.getBuildAppPath(npmDirectory, fileName, fileType);
         const distPath = path.resolve(`${name}.${fileType}`);
         await fsExtra.copy(appPath, distPath);
+        // Copy raw binary if requested
+        if (this.options.keepBinary) {
+            await this.copyRawBinary(npmDirectory, name);
+        }
         await fsExtra.remove(appPath);
         logger.success('✔ Build success!');
         logger.success('✔ App installer located in', distPath);
+        // Log binary location if preserved
+        if (this.options.keepBinary) {
+            const binaryPath = this.getRawBinaryPath(name);
+            logger.success('✔ Raw binary located in', path.resolve(binaryPath));
+        }
     }
     getFileType(target) {
         return target;
     }
-    getBuildCommand() {
+    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'));
+    }
+    /**
+     * 解析目标架构
+     */
+    resolveTargetArch(requestedArch) {
+        if (requestedArch === 'auto' || !requestedArch) {
+            return process.arch;
+        }
+        return requestedArch;
+    }
+    /**
+     * 获取Tauri构建目标
+     */
+    getTauriTarget(arch, platform = process.platform) {
+        const platformMappings = BaseBuilder.ARCH_MAPPINGS[platform];
+        if (!platformMappings)
+            return null;
+        return platformMappings[arch] || null;
+    }
+    /**
+     * 获取架构显示名称（用于文件名）
+     */
+    getArchDisplayName(arch) {
+        return BaseBuilder.ARCH_DISPLAY_NAMES[arch] || arch;
+    }
+    /**
+     * 构建基础构建命令
+     */
+    buildBaseCommand(packageManager, configPath, target) {
         const baseCommand = this.options.debug
-            ? 'npm run build:debug'
-            : 'npm run build';
-        // Use temporary config directory to avoid modifying source files
-        const configPath = path.join(npmDirectory, 'src-tauri', '.pake', 'tauri.conf.json');
-        let fullCommand = `${baseCommand} -- -c "${configPath}"`;
-        // For macOS, use app bundles by default unless DMG is explicitly requested
-        if (IS_MAC && this.options.targets === 'app') {
-            fullCommand += ' --bundles app';
+            ? `${packageManager} run build:debug`
+            : `${packageManager} run build`;
+        const argSeparator = packageManager === 'npm' ? ' --' : '';
+        let fullCommand = `${baseCommand}${argSeparator} -c "${configPath}"`;
+        if (target) {
+            fullCommand += ` --target ${target}`;
         }
-        // Add features
+        // 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;
+    }
+    /**
+     * 获取构建特性列表
+     */
+    getBuildFeatures() {
         const features = ['cli-build'];
         // Add macos-proxy feature for modern macOS (Darwin 23+ = macOS 14+)
         if (IS_MAC) {
@@ -899,6 +1364,18 @@ class BaseBuilder {
                 features.push('macos-proxy');
             }
         }
+        return features;
+    }
+    getBuildCommand(packageManager = 'pnpm') {
+        // Use temporary config directory to avoid modifying source files
+        const configPath = path.join(npmDirectory, 'src-tauri', '.pake', 'tauri.conf.json');
+        let fullCommand = this.buildBaseCommand(packageManager, configPath);
+        // For macOS, use app bundles by default unless DMG is explicitly requested
+        if (IS_MAC && this.options.targets === 'app') {
+            fullCommand += ' --bundles app';
+        }
+        // Add features
+        const features = this.getBuildFeatures();
         if (features.length > 0) {
             fullCommand += ` --features ${features.join(',')}`;
         }
@@ -924,96 +1401,250 @@ class BaseBuilder {
         const bundleDir = fileType.toLowerCase() === 'app' ? 'macos' : fileType.toLowerCase();
         return path.join(npmDirectory, this.getBasePath(), bundleDir, `${fileName}.${fileType}`);
     }
+    /**
+     * Copy raw binary file to output directory
+     */
+    async copyRawBinary(npmDirectory, appName) {
+        const binaryPath = this.getRawBinarySourcePath(npmDirectory, appName);
+        const outputPath = this.getRawBinaryPath(appName);
+        if (await fsExtra.pathExists(binaryPath)) {
+            await fsExtra.copy(binaryPath, outputPath);
+            // Make binary executable on Unix-like systems
+            if (process.platform !== 'win32') {
+                await fsExtra.chmod(outputPath, 0o755);
+            }
+        }
+        else {
+            logger.warn(`✼ Raw binary not found at ${binaryPath}, skipping...`);
+        }
+    }
+    /**
+     * Get the source path of the raw binary file in the build directory
+     */
+    getRawBinarySourcePath(npmDirectory, appName) {
+        const basePath = this.options.debug ? 'debug' : 'release';
+        const binaryName = this.getBinaryName(appName);
+        // Handle cross-platform builds
+        if (this.options.multiArch || this.hasArchSpecificTarget()) {
+            return path.join(npmDirectory, this.getArchSpecificPath(), basePath, binaryName);
+        }
+        return path.join(npmDirectory, 'src-tauri/target', basePath, binaryName);
+    }
+    /**
+     * Get the output path for the raw binary file
+     */
+    getRawBinaryPath(appName) {
+        const extension = process.platform === 'win32' ? '.exe' : '';
+        const suffix = process.platform === 'win32' ? '' : '-binary';
+        return `${appName}${suffix}${extension}`;
+    }
+    /**
+     * Get the binary name based on app name and platform
+     */
+    getBinaryName(appName) {
+        const extension = process.platform === 'win32' ? '.exe' : '';
+        // Linux uses the unique binary name we set in merge.ts
+        if (process.platform === 'linux') {
+            return `pake-${generateIdentifierSafeName(appName)}${extension}`;
+        }
+        // Windows and macOS use 'pake' as binary name
+        return `pake${extension}`;
+    }
+    /**
+     * Check if this build has architecture-specific target
+     */
+    hasArchSpecificTarget() {
+        return false; // Override in subclasses if needed
+    }
+    /**
+     * Get architecture-specific path for binary
+     */
+    getArchSpecificPath() {
+        return 'src-tauri/target'; // Override in subclasses if needed
+    }
 }
+BaseBuilder.packageManagerCache = null;
+// 架构映射配置
+BaseBuilder.ARCH_MAPPINGS = {
+    darwin: {
+        arm64: 'aarch64-apple-darwin',
+        x64: 'x86_64-apple-darwin',
+        universal: 'universal-apple-darwin',
+    },
+    win32: {
+        arm64: 'aarch64-pc-windows-msvc',
+        x64: 'x86_64-pc-windows-msvc',
+    },
+    linux: {
+        arm64: 'aarch64-unknown-linux-gnu',
+        x64: 'x86_64-unknown-linux-gnu',
+    },
+};
+// 架构名称映射（用于文件名生成）
+BaseBuilder.ARCH_DISPLAY_NAMES = {
+    arm64: 'aarch64',
+    x64: 'x64',
+    universal: 'universal',
+};
 
 class MacBuilder extends BaseBuilder {
     constructor(options) {
         super(options);
-        // Use DMG by default for distribution
-        // Only create app bundles for testing to avoid user interaction
-        if (process.env.PAKE_CREATE_APP === '1') {
-            this.options.targets = 'app';
+        const validArchs = ['intel', 'apple', 'universal', 'auto', 'x64', 'arm64'];
+        this.buildArch = validArchs.includes(options.targets || '')
+            ? options.targets
+            : 'auto';
+        if (options.iterativeBuild || process.env.PAKE_CREATE_APP === '1') {
+            this.buildFormat = 'app';
         }
         else {
-            this.options.targets = 'dmg';
+            this.buildFormat = 'dmg';
         }
+        this.options.targets = this.buildFormat;
     }
     getFileName() {
-        const { name } = this.options;
-        // For app bundles, use simple name without version/arch
-        if (this.options.targets === 'app') {
+        const { name = 'pake-app' } = this.options;
+        if (this.buildFormat === 'app') {
             return name;
         }
-        // For DMG files, use versioned filename
         let arch;
-        if (this.options.multiArch) {
+        if (this.buildArch === 'universal' || this.options.multiArch) {
             arch = 'universal';
         }
+        else if (this.buildArch === 'apple') {
+            arch = 'aarch64';
+        }
+        else if (this.buildArch === 'intel') {
+            arch = 'x64';
+        }
         else {
-            arch = process.arch === 'arm64' ? 'aarch64' : process.arch;
+            arch = this.getArchDisplayName(this.resolveTargetArch(this.buildArch));
         }
         return `${name}_${tauriConfig.version}_${arch}`;
     }
-    getBuildCommand() {
-        if (this.options.multiArch) {
-            const baseCommand = this.options.debug
-                ? 'npm run tauri build -- --debug'
-                : 'npm run tauri build --';
-            // Use temporary config directory to avoid modifying source files
-            const configPath = path.join('src-tauri', '.pake', 'tauri.conf.json');
-            let fullCommand = `${baseCommand} --target universal-apple-darwin -c "${configPath}"`;
-            // Add features
-            const features = ['cli-build'];
-            // Add macos-proxy feature for modern macOS (Darwin 23+ = macOS 14+)
-            const macOSVersion = this.getMacOSMajorVersion();
-            if (macOSVersion >= 23) {
-                features.push('macos-proxy');
-            }
-            if (features.length > 0) {
-                fullCommand += ` --features ${features.join(',')}`;
-            }
-            return fullCommand;
+    getActualArch() {
+        if (this.buildArch === 'universal' || this.options.multiArch) {
+            return 'universal';
         }
-        return super.getBuildCommand();
+        else if (this.buildArch === 'apple') {
+            return 'arm64';
+        }
+        else if (this.buildArch === 'intel') {
+            return 'x64';
+        }
+        return this.resolveTargetArch(this.buildArch);
+    }
+    getBuildCommand(packageManager = 'pnpm') {
+        const configPath = path.join('src-tauri', '.pake', 'tauri.conf.json');
+        const actualArch = this.getActualArch();
+        const buildTarget = this.getTauriTarget(actualArch, 'darwin');
+        if (!buildTarget) {
+            throw new Error(`Unsupported architecture: ${actualArch} for macOS`);
+        }
+        let fullCommand = this.buildBaseCommand(packageManager, configPath, buildTarget);
+        const features = this.getBuildFeatures();
+        if (features.length > 0) {
+            fullCommand += ` --features ${features.join(',')}`;
+        }
+        return fullCommand;
     }
     getBasePath() {
-        return this.options.multiArch
-            ? 'src-tauri/target/universal-apple-darwin/release/bundle'
-            : super.getBasePath();
+        const basePath = this.options.debug ? 'debug' : 'release';
+        const actualArch = this.getActualArch();
+        const target = this.getTauriTarget(actualArch, 'darwin');
+        return `src-tauri/target/${target}/${basePath}/bundle`;
+    }
+    hasArchSpecificTarget() {
+        return true;
+    }
+    getArchSpecificPath() {
+        const actualArch = this.getActualArch();
+        const target = this.getTauriTarget(actualArch, 'darwin');
+        return `src-tauri/target/${target}`;
     }
 }
 
 class WinBuilder extends BaseBuilder {
     constructor(options) {
         super(options);
-        this.options.targets = 'msi';
+        this.buildFormat = 'msi';
+        const validArchs = ['x64', 'arm64', 'auto'];
+        this.buildArch = validArchs.includes(options.targets || '')
+            ? this.resolveTargetArch(options.targets)
+            : this.resolveTargetArch('auto');
+        this.options.targets = this.buildFormat;
     }
     getFileName() {
         const { name } = this.options;
-        const { arch } = process;
         const language = tauriConfig.bundle.windows.wix.language[0];
-        return `${name}_${tauriConfig.version}_${arch}_${language}`;
+        const targetArch = this.getArchDisplayName(this.buildArch);
+        return `${name}_${tauriConfig.version}_${targetArch}_${language}`;
+    }
+    getBuildCommand(packageManager = 'pnpm') {
+        const configPath = path.join('src-tauri', '.pake', 'tauri.conf.json');
+        const buildTarget = this.getTauriTarget(this.buildArch, 'win32');
+        if (!buildTarget) {
+            throw new Error(`Unsupported architecture: ${this.buildArch} for Windows`);
+        }
+        let fullCommand = this.buildBaseCommand(packageManager, configPath, buildTarget);
+        const features = this.getBuildFeatures();
+        if (features.length > 0) {
+            fullCommand += ` --features ${features.join(',')}`;
+        }
+        return fullCommand;
+    }
+    getBasePath() {
+        const basePath = this.options.debug ? 'debug' : 'release';
+        const target = this.getTauriTarget(this.buildArch, 'win32');
+        return `src-tauri/target/${target}/${basePath}/bundle/`;
+    }
+    hasArchSpecificTarget() {
+        return true;
+    }
+    getArchSpecificPath() {
+        const target = this.getTauriTarget(this.buildArch, 'win32');
+        return `src-tauri/target/${target}`;
     }
 }
 
 class LinuxBuilder extends BaseBuilder {
     constructor(options) {
         super(options);
+        const target = options.targets || 'deb';
+        if (target.includes('-arm64')) {
+            this.buildFormat = target.replace('-arm64', '');
+            this.buildArch = 'arm64';
+        }
+        else {
+            this.buildFormat = target;
+            this.buildArch = this.resolveTargetArch('auto');
+        }
+        this.options.targets = this.buildFormat;
     }
     getFileName() {
-        const { name, targets } = this.options;
+        const { name = 'pake-app', targets } = this.options;
         const version = tauriConfig.version;
-        let arch = process.arch === 'x64' ? 'amd64' : process.arch;
-        if (arch === 'arm64' && (targets === 'rpm' || targets === 'appimage')) {
-            arch = 'aarch64';
+        let arch;
+        if (this.buildArch === 'arm64') {
+            arch = targets === 'rpm' || targets === 'appimage' ? 'aarch64' : 'arm64';
+        }
+        else {
+            if (this.buildArch === 'x64') {
+                arch = targets === 'rpm' ? 'x86_64' : 'amd64';
+            }
+            else {
+                arch = this.buildArch;
+                if (this.buildArch === 'arm64' &&
+                    (targets === 'rpm' || targets === 'appimage')) {
+                    arch = 'aarch64';
+                }
+            }
         }
-        // The RPM format uses different separators and version number formats
         if (targets === 'rpm') {
             return `${name}-${version}-1.${arch}`;
         }
         return `${name}_${version}_${arch}`;
     }
-    // Customize it, considering that there are all targets.
     async build(url) {
         const targetTypes = ['deb', 'appimage', 'rpm'];
         for (const target of targetTypes) {
@@ -1022,12 +1653,49 @@ class LinuxBuilder extends BaseBuilder {
             }
         }
     }
+    getBuildCommand(packageManager = 'pnpm') {
+        const configPath = path.join('src-tauri', '.pake', 'tauri.conf.json');
+        const buildTarget = this.buildArch === 'arm64'
+            ? (this.getTauriTarget(this.buildArch, 'linux') ?? undefined)
+            : undefined;
+        let fullCommand = this.buildBaseCommand(packageManager, configPath, buildTarget);
+        const features = this.getBuildFeatures();
+        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() {
+        const basePath = this.options.debug ? 'debug' : 'release';
+        if (this.buildArch === 'arm64') {
+            const target = this.getTauriTarget(this.buildArch, 'linux');
+            return `src-tauri/target/${target}/${basePath}/bundle/`;
+        }
+        return super.getBasePath();
+    }
     getFileType(target) {
         if (target === 'appimage') {
             return 'AppImage';
         }
         return super.getFileType(target);
     }
+    hasArchSpecificTarget() {
+        return this.buildArch === 'arm64';
+    }
+    getArchSpecificPath() {
+        if (this.buildArch === 'arm64') {
+            const target = this.getTauriTarget(this.buildArch, 'linux');
+            return `src-tauri/target/${target}`;
+        }
+        return super.getArchSpecificPath();
+    }
 }
 
 const { platform } = process;
@@ -1046,13 +1714,230 @@ class BuilderProvider {
     }
 }
 
-async function startBuild() {
+var version = "3.6.1";
+var packageJson = {
+	version: version};
+
+const DEFAULT_PAKE_OPTIONS = {
+    icon: '',
+    height: 780,
+    width: 1200,
+    fullscreen: false,
+    maximize: false,
+    hideTitleBar: false,
+    alwaysOnTop: false,
+    appVersion: '1.0.0',
+    darkMode: false,
+    disabledWebShortcuts: false,
+    activationShortcut: '',
+    userAgent: '',
+    showSystemTray: false,
+    multiArch: false,
+    targets: (() => {
+        switch (process.platform) {
+            case 'linux':
+                return 'deb';
+            case 'darwin':
+                return 'dmg';
+            case 'win32':
+                return 'msi';
+            default:
+                return 'deb';
+        }
+    })(),
+    useLocalFile: false,
+    systemTrayIcon: '',
+    proxyUrl: '',
+    debug: false,
+    inject: [],
+    installerLanguage: 'en-US',
+    hideOnClose: undefined, // Platform-specific: true for macOS, false for others
+    incognito: false,
+    wasm: false,
+    enableDragDrop: false,
+    keepBinary: false,
+    multiInstance: false,
+    startToTray: false,
+    forceInternalNavigation: false,
+    iterativeBuild: false,
+    zoom: 100,
+    minWidth: 0,
+    minHeight: 0,
+    ignoreCertificateErrors: false,
+};
+
+function validateNumberInput(value) {
+    const parsedValue = Number(value);
+    if (isNaN(parsedValue)) {
+        throw new InvalidArgumentError('Not a number.');
+    }
+    return parsedValue;
+}
+function validateUrlInput(url) {
+    const isFile = fs.existsSync(url);
+    if (!isFile) {
+        try {
+            return normalizeUrl(url);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new InvalidArgumentError(error.message);
+            }
+            throw error;
+        }
+    }
+    return url;
+}
+
+function getCliProgram() {
+    const { green, yellow } = chalk;
+    const logo = `${chalk.green(' ____       _')}
+${green('|  _ \\ __ _| | _____')}
+${green('| |_) / _` | |/ / _ \\')}
+${green('|  __/ (_| |   <  __/')}  ${yellow('https://github.com/tw93/pake')}
+${green('|_|   \\__,_|_|\\_\\___|  can turn any webpage into a desktop app with Rust.')}
+`;
+    return program$1
+        .addHelpText('beforeAll', logo)
+        .usage(`[url] [options]`)
+        .showHelpAfterError()
+        .argument('[url]', 'The web URL you want to package', validateUrlInput)
+        .option('--name <string>', 'Application name')
+        .option('--icon <string>', 'Application icon', DEFAULT_PAKE_OPTIONS.icon)
+        .option('--width <number>', 'Window width', validateNumberInput, DEFAULT_PAKE_OPTIONS.width)
+        .option('--height <number>', 'Window height', validateNumberInput, DEFAULT_PAKE_OPTIONS.height)
+        .option('--use-local-file', 'Use local file packaging', DEFAULT_PAKE_OPTIONS.useLocalFile)
+        .option('--fullscreen', 'Start in full screen', DEFAULT_PAKE_OPTIONS.fullscreen)
+        .option('--hide-title-bar', 'For Mac, hide title bar', DEFAULT_PAKE_OPTIONS.hideTitleBar)
+        .option('--multi-arch', 'For Mac, both Intel and M1', DEFAULT_PAKE_OPTIONS.multiArch)
+        .option('--inject <files>', 'Inject local CSS/JS files into the page', (val, previous) => {
+        if (!val)
+            return DEFAULT_PAKE_OPTIONS.inject;
+        // Split by comma and trim whitespace, filter out empty strings
+        const files = val
+            .split(',')
+            .map((item) => item.trim())
+            .filter((item) => item.length > 0);
+        // If previous values exist (from multiple --inject options), merge them
+        return previous ? [...previous, ...files] : files;
+    }, DEFAULT_PAKE_OPTIONS.inject)
+        .option('--debug', 'Debug build and more output', DEFAULT_PAKE_OPTIONS.debug)
+        .addOption(new Option('--proxy-url <url>', 'Proxy URL for all network requests (http://, https://, socks5://)')
+        .default(DEFAULT_PAKE_OPTIONS.proxyUrl)
+        .hideHelp())
+        .addOption(new Option('--user-agent <string>', 'Custom user agent')
+        .default(DEFAULT_PAKE_OPTIONS.userAgent)
+        .hideHelp())
+        .addOption(new Option('--targets <string>', 'Build target format for your system').default(DEFAULT_PAKE_OPTIONS.targets))
+        .addOption(new Option('--app-version <string>', 'App version, the same as package.json version')
+        .default(DEFAULT_PAKE_OPTIONS.appVersion)
+        .hideHelp())
+        .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())
+        .addOption(new Option('--disabled-web-shortcuts', 'Disabled webPage shortcuts')
+        .default(DEFAULT_PAKE_OPTIONS.disabledWebShortcuts)
+        .hideHelp())
+        .addOption(new Option('--activation-shortcut <string>', 'Shortcut key to active App')
+        .default(DEFAULT_PAKE_OPTIONS.activationShortcut)
+        .hideHelp())
+        .addOption(new Option('--show-system-tray', 'Show system tray in app')
+        .default(DEFAULT_PAKE_OPTIONS.showSystemTray)
+        .hideHelp())
+        .addOption(new Option('--system-tray-icon <string>', 'Custom system tray icon')
+        .default(DEFAULT_PAKE_OPTIONS.systemTrayIcon)
+        .hideHelp())
+        .addOption(new Option('--hide-on-close [boolean]', 'Hide window on close instead of exiting (default: true for macOS, false for others)')
+        .default(DEFAULT_PAKE_OPTIONS.hideOnClose)
+        .argParser((value) => {
+        if (value === undefined)
+            return true; // --hide-on-close without value
+        if (value === 'true')
+            return true;
+        if (value === 'false')
+            return false;
+        throw new Error('--hide-on-close must be true or false');
+    })
+        .hideHelp())
+        .addOption(new Option('--title <string>', 'Window title').hideHelp())
+        .addOption(new Option('--incognito', 'Launch app in incognito/private mode')
+        .default(DEFAULT_PAKE_OPTIONS.incognito)
+        .hideHelp())
+        .addOption(new Option('--wasm', 'Enable WebAssembly support (Flutter Web, etc.)')
+        .default(DEFAULT_PAKE_OPTIONS.wasm)
+        .hideHelp())
+        .addOption(new Option('--enable-drag-drop', 'Enable drag and drop functionality')
+        .default(DEFAULT_PAKE_OPTIONS.enableDragDrop)
+        .hideHelp())
+        .addOption(new Option('--keep-binary', 'Keep raw binary file alongside installer')
+        .default(DEFAULT_PAKE_OPTIONS.keepBinary)
+        .hideHelp())
+        .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('--force-internal-navigation', 'Keep every link inside the Pake window instead of opening external handlers')
+        .default(DEFAULT_PAKE_OPTIONS.forceInternalNavigation)
+        .hideHelp())
+        .addOption(new Option('--installer-language <string>', 'Installer language')
+        .default(DEFAULT_PAKE_OPTIONS.installerLanguage)
+        .hideHelp())
+        .addOption(new Option('--zoom <number>', 'Initial page zoom level (50-200)')
+        .default(DEFAULT_PAKE_OPTIONS.zoom)
+        .argParser((value) => {
+        const zoom = parseInt(value);
+        if (isNaN(zoom) || zoom < 50 || zoom > 200) {
+            throw new Error('--zoom must be a number between 50 and 200');
+        }
+        return zoom;
+    })
+        .hideHelp())
+        .addOption(new Option('--min-width <number>', 'Minimum window width')
+        .default(DEFAULT_PAKE_OPTIONS.minWidth)
+        .argParser(validateNumberInput)
+        .hideHelp())
+        .addOption(new Option('--min-height <number>', 'Minimum window height')
+        .default(DEFAULT_PAKE_OPTIONS.minHeight)
+        .argParser(validateNumberInput)
+        .hideHelp())
+        .addOption(new Option('--ignore-certificate-errors', 'Ignore certificate errors (for self-signed certificates)')
+        .default(DEFAULT_PAKE_OPTIONS.ignoreCertificateErrors)
+        .hideHelp())
+        .addOption(new Option('--iterative-build', 'Turn on rapid build mode (app only, no dmg/deb/msi), good for debugging')
+        .default(DEFAULT_PAKE_OPTIONS.iterativeBuild)
+        .hideHelp())
+        .version(packageJson.version, '-v, --version')
+        .configureHelp({
+        sortSubcommands: true,
+        optionTerm: (option) => {
+            if (option.flags === '-v, --version' || option.flags === '-h, --help')
+                return '';
+            return option.flags;
+        },
+        optionDescription: (option) => {
+            if (option.flags === '-v, --version' || option.flags === '-h, --help')
+                return '';
+            return option.description;
+        },
+    });
+}
+
+const program = getCliProgram();
+program.action(async (url, options) => {
     log.setDefaultLevel('debug');
-    const appOptions = await handleOptions(DEFAULT_DEV_PAKE_OPTIONS, DEFAULT_DEV_PAKE_OPTIONS.url);
+    const appOptions = await handleOptions(options, url);
     log.debug('PakeAppOptions', appOptions);
     const builder = BuilderProvider.create(appOptions);
     await builder.prepare();
-    await builder.start(DEFAULT_DEV_PAKE_OPTIONS.url);
-}
-startBuild();
+    await builder.start(url);
+});
+program.parse();
 //# sourceMappingURL=dev.js.map