pake-cli 3.2.0-beta1 → 3.2.0-beta15

package/dist/cli.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import chalk from 'chalk';
 import { InvalidArgumentError, program, Option } from 'commander';
 import log from 'loglevel';
@@ -16,16 +17,18 @@ import updateNotifier from 'update-notifier';
 import axios from 'axios';
 import { dir } from 'tmp-promise';
 import { fileTypeFromBuffer } from 'file-type';
+import icongen from 'icon-gen';
+import sharp from 'sharp';
 import * as psl from 'psl';
 
 var name = "pake-cli";
-var version$1 = "3.2.0-beta1";
+var version$1 = "3.2.0-beta15";
 var description = "🤱🏻 Turn any webpage into a desktop app with Rust. 🤱🏻 利用 Rust 轻松构建轻量级多端桌面应用。";
 var engines = {
 	node: ">=16.0.0"
 };
 var bin = {
-	pake: "./cli.js"
+	pake: "./dist/cli.js"
 };
 var repository = {
 	type: "git",
@@ -45,13 +48,12 @@ var keywords = [
 ];
 var files = [
 	"dist",
-	"src-tauri",
-	"cli.js"
+	"src-tauri"
 ];
 var scripts = {
 	start: "npm run dev",
 	dev: "npm run tauri dev",
-	build: "npm run tauri build --release",
+	build: "npm run tauri build --",
 	"build:debug": "npm run tauri build -- --debug",
 	"build:mac": "npm run tauri build -- --target universal-apple-darwin",
 	"build:config": "chmod +x script/app_config.mjs && node script/app_config.mjs",
@@ -60,25 +62,29 @@ var scripts = {
 	cli: "rollup -c rollup.config.js --watch",
 	"cli:dev": "cross-env NODE_ENV=development rollup -c rollup.config.js -w",
 	"cli:build": "cross-env NODE_ENV=production rollup -c rollup.config.js",
-	format: "npx prettier --write . --ignore-unknown && cd src-tauri && cargo fmt --verbose",
+	test: "npm run cli:build && PAKE_CREATE_APP=1 node tests/index.js",
+	format: "prettier --write . --ignore-unknown && cd src-tauri && cargo fmt --verbose",
+	"hooks:setup": "bash .githooks/setup.sh",
 	prepublishOnly: "npm run cli:build"
 };
 var type = "module";
-var exports = "./dist/pake.js";
+var exports = "./dist/cli.js";
 var license = "MIT";
 var dependencies = {
-	"@tauri-apps/api": "^2.7.0",
-	"@tauri-apps/cli": "^2.7.1",
+	"@tauri-apps/api": "^2.8.0",
+	"@tauri-apps/cli": "^2.8.1",
 	axios: "^1.11.0",
-	chalk: "^5.5.0",
+	chalk: "^5.6.0",
 	commander: "^11.1.0",
 	execa: "^9.6.0",
 	"file-type": "^18.7.0",
 	"fs-extra": "^11.3.1",
+	"icon-gen": "^5.0.0",
 	loglevel: "^1.9.2",
 	ora: "^8.2.0",
 	prompts: "^2.4.2",
 	psl: "^1.15.0",
+	sharp: "^0.33.5",
 	"tmp-promise": "^3.0.3",
 	"update-notifier": "^7.3.1"
 };
@@ -89,15 +95,15 @@ var devDependencies = {
 	"@rollup/plugin-replace": "^6.0.2",
 	"@rollup/plugin-terser": "^0.4.4",
 	"@types/fs-extra": "^11.0.4",
-	"@types/node": "^20.19.10",
+	"@types/node": "^20.19.11",
 	"@types/page-icon": "^0.3.6",
 	"@types/prompts": "^2.4.9",
-	"@types/psl": "^1.11.0",
 	"@types/tmp": "^0.2.6",
 	"@types/update-notifier": "^6.0.8",
 	"app-root-path": "^3.1.0",
 	"cross-env": "^7.0.3",
-	rollup: "^4.46.2",
+	prettier: "^3.6.2",
+	rollup: "^4.46.3",
 	"rollup-plugin-typescript2": "^0.36.0",
 	tslib: "^2.8.1",
 	typescript: "^5.9.2"
@@ -133,7 +139,8 @@ var windows = [
 		dark_mode: false,
 		activation_shortcut: "",
 		disabled_web_shortcuts: false,
-		hide_on_close: true
+		hide_on_close: true,
+		incognito: false
 	}
 ];
 var user_agent = {
@@ -222,10 +229,10 @@ var MacConf = {
 	bundle: bundle$1
 };
 
-var productName = "we-read";
+var productName = "weekly";
 var bundle = {
 	icon: [
-		"png/weekly.png"
+		"png/weekly_512.png"
 	],
 	active: true,
 	linux: {
@@ -312,20 +319,25 @@ const IS_LINUX = platform$1 === 'linux';
 const currentModulePath = fileURLToPath(import.meta.url);
 // Resolve the parent directory of the current module
 const npmDirectory = path.join(path.dirname(currentModulePath), '..');
-const tauriConfigDirectory = path.join(npmDirectory, 'src-tauri');
+const tauriConfigDirectory = path.join(npmDirectory, 'src-tauri', '.pake');
 
-async function shellExec(command) {
+async function shellExec(command, timeout = 300000, env) {
     try {
         const { exitCode } = await execa(command, {
             cwd: npmDirectory,
-            stdio: 'inherit',
+            stdio: ['inherit', 'pipe', 'inherit'], // Hide stdout verbose, keep stderr
             shell: true,
+            timeout,
+            env: env ? { ...process.env, ...env } : process.env,
         });
         return exitCode;
     }
     catch (error) {
         const exitCode = error.exitCode ?? 'unknown';
         const errorMessage = error.message || 'Unknown error occurred';
+        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}`);
     }
 }
@@ -403,11 +415,11 @@ async function installRust() {
     const spinner = getSpinner('Downloading Rust...');
     try {
         await shellExec(IS_WIN ? rustInstallScriptForWindows : rustInstallScriptForMac);
-        spinner.succeed(chalk.green('Rust installed successfully!'));
+        spinner.succeed(chalk.green('✔ Rust installed successfully!'));
     }
     catch (error) {
-        console.error('Error installing Rust:', error.message);
-        spinner.fail(chalk.red('Rust installation failed!'));
+        spinner.fail(chalk.red('✕ Rust installation failed!'));
+        console.error(error.message);
         process.exit(1);
     }
 }
@@ -438,7 +450,26 @@ async function combineFiles(files, output) {
 }
 
 async function mergeConfig(url, options, tauriConf) {
-    const { width, height, fullscreen, hideTitleBar, alwaysOnTop, appVersion, darkMode, disabledWebShortcuts, activationShortcut, userAgent, showSystemTray, systemTrayIcon, useLocalFile, identifier, name, resizable = true, inject, proxyUrl, installerLanguage, hideOnClose, } = options;
+    // Ensure .pake directory exists and copy source templates if needed
+    const srcTauriDir = path.join(npmDirectory, 'src-tauri');
+    await fsExtra.ensureDir(tauriConfigDirectory);
+    // Copy source config files to .pake directory (as templates)
+    const sourceFiles = [
+        'tauri.conf.json',
+        'tauri.macos.conf.json',
+        'tauri.windows.conf.json',
+        'tauri.linux.conf.json',
+        'pake.json',
+    ];
+    await Promise.all(sourceFiles.map(async (file) => {
+        const sourcePath = path.join(srcTauriDir, file);
+        const destPath = path.join(tauriConfigDirectory, file);
+        if ((await fsExtra.pathExists(sourcePath)) &&
+            !(await fsExtra.pathExists(destPath))) {
+            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 { platform } = process;
     // Set Windows parameters.
     const tauriConfWindowOptions = {
@@ -452,6 +483,8 @@ async function mergeConfig(url, options, tauriConf) {
         dark_mode: darkMode,
         disabled_web_shortcuts: disabledWebShortcuts,
         hide_on_close: hideOnClose,
+        incognito: incognito,
+        title: title || null,
     };
     Object.assign(tauriConf.pake.windows[0], { url, ...tauriConfWindowOptions });
     tauriConf.productName = name;
@@ -604,7 +637,6 @@ async function mergeConfig(url, options, tauriConf) {
     };
     const configPath = path.join(tauriConfigDirectory, platformConfigPaths[platform]);
     const bundleConf = { bundle: tauriConf.bundle };
-    console.log('pakeConfig', tauriConf.pake);
     await fsExtra.outputJSON(configPath, bundleConf, { spaces: 4 });
     const pakeConfigPath = path.join(tauriConfigDirectory, 'pake.json');
     await fsExtra.outputJSON(pakeConfigPath, tauriConf.pake, { spaces: 4 });
@@ -618,6 +650,19 @@ class BaseBuilder {
     constructor(options) {
         this.options = options;
     }
+    getBuildEnvironment() {
+        return IS_MAC ? {
+            'CFLAGS': '-fno-modules',
+            'CXXFLAGS': '-fno-modules',
+            'MACOSX_DEPLOYMENT_TARGET': '14.0'
+        } : undefined;
+    }
+    getInstallTimeout() {
+        return process.platform === 'win32' ? 600000 : 300000;
+    }
+    getBuildTimeout() {
+        return 300000; // 5 minutes for build process
+    }
     async prepare() {
         const tauriSrcPath = path.join(npmDirectory, 'src-tauri');
         const tauriTargetPath = path.join(tauriSrcPath, 'target');
@@ -645,14 +690,20 @@ 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
+        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}" && npm install --registry=https://registry.npmmirror.com`);
+            await shellExec(`cd "${npmDirectory}" && ${packageManager} install${registryOption}${legacyPeerDeps} --silent`, timeout, buildEnv);
         }
         else {
-            await shellExec(`cd "${npmDirectory}" && npm install`);
+            await shellExec(`cd "${npmDirectory}" && ${packageManager} install${legacyPeerDeps} --silent`, timeout, buildEnv);
         }
         spinner.succeed(chalk.green('Package installed!'));
         if (!tauriTargetPathExists) {
@@ -669,9 +720,14 @@ class BaseBuilder {
         const { name } = this.options;
         await mergeConfig(url, this.options, tauriConfig);
         // Build app
-        const spinner = getSpinner('Building app...');
-        setTimeout(() => spinner.stop(), 3000);
-        await shellExec(`cd "${npmDirectory}" && ${this.getBuildCommand()}`);
+        const buildSpinner = getSpinner('Building app...');
+        // Let spinner run for a moment so user can see it, then stop before npm 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);
         // Copy app
         const fileName = this.getFileName();
         const fileType = this.getFileType(target);
@@ -686,25 +742,66 @@ class BaseBuilder {
         return target;
     }
     getBuildCommand() {
-        // the debug option should support `--debug` and `--release`
-        return this.options.debug ? 'npm run build:debug' : 'npm run build';
+        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';
+        }
+        // Add macos-proxy feature for modern macOS (Darwin 23+ = macOS 14+)
+        if (IS_MAC) {
+            const macOSVersion = this.getMacOSMajorVersion();
+            if (macOSVersion >= 23) {
+                fullCommand += ' --features macos-proxy';
+            }
+        }
+        return fullCommand;
+    }
+    getMacOSMajorVersion() {
+        try {
+            const os = require('os');
+            const release = os.release();
+            const majorVersion = parseInt(release.split('.')[0], 10);
+            return majorVersion;
+        }
+        catch (error) {
+            return 0; // Disable proxy feature if version detection fails
+        }
     }
     getBasePath() {
         const basePath = this.options.debug ? 'debug' : 'release';
         return `src-tauri/target/${basePath}/bundle/`;
     }
     getBuildAppPath(npmDirectory, fileName, fileType) {
-        return path.join(npmDirectory, this.getBasePath(), fileType.toLowerCase(), `${fileName}.${fileType}`);
+        // For app bundles on macOS, the directory is 'macos', not 'app'
+        const bundleDir = fileType.toLowerCase() === 'app' ? 'macos' : fileType.toLowerCase();
+        return path.join(npmDirectory, this.getBasePath(), bundleDir, `${fileName}.${fileType}`);
     }
 }
 
 class MacBuilder extends BaseBuilder {
     constructor(options) {
         super(options);
-        this.options.targets = 'dmg';
+        // 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';
+        }
+        else {
+            this.options.targets = 'dmg';
+        }
     }
     getFileName() {
         const { name } = this.options;
+        // For app bundles, use simple name without version/arch
+        if (this.options.targets === 'app') {
+            return name;
+        }
+        // For DMG files, use versioned filename
         let arch;
         if (this.options.multiArch) {
             arch = 'universal';
@@ -811,6 +908,7 @@ const DEFAULT_PAKE_OPTIONS = {
     inject: [],
     installerLanguage: 'en-US',
     hideOnClose: true,
+    incognito: false,
 };
 
 async function checkUpdateTips() {
@@ -819,61 +917,203 @@ async function checkUpdateTips() {
     });
 }
 
-async function handleIcon(options) {
+// Constants
+const ICON_CONFIG = {
+    minFileSize: 100,
+    downloadTimeout: 10000,
+    supportedFormats: ['png', 'ico', 'jpeg', 'jpg', 'webp'],
+    whiteBackground: { r: 255, g: 255, b: 255 },
+};
+// API Configuration
+const API_TOKENS = {
+    // cspell:disable-next-line
+    logoDev: ['pk_JLLMUKGZRpaG5YclhXaTkg', 'pk_Ph745P8mQSeYFfW2Wk039A'],
+    // cspell:disable-next-line
+    brandfetch: ['1idqvJC0CeFSeyp3Yf7', '1idej-yhU_ThggIHFyG'],
+};
+/**
+ * Adds white background to transparent icons only
+ */
+async function preprocessIcon(inputPath) {
+    try {
+        const metadata = await sharp(inputPath).metadata();
+        if (metadata.channels !== 4)
+            return inputPath; // No transparency
+        const { path: tempDir } = await dir();
+        const outputPath = path.join(tempDir, 'icon-with-background.png');
+        await sharp({
+            create: {
+                width: metadata.width || 512,
+                height: metadata.height || 512,
+                channels: 3,
+                background: ICON_CONFIG.whiteBackground,
+            },
+        })
+            .composite([{ input: inputPath }])
+            .png()
+            .toFile(outputPath);
+        return outputPath;
+    }
+    catch (error) {
+        logger.warn(`Failed to add background to icon: ${error.message}`);
+        return inputPath;
+    }
+}
+/**
+ * Converts icon to platform-specific format
+ */
+async function convertIconFormat(inputPath, appName) {
+    try {
+        if (!(await fsExtra.pathExists(inputPath)))
+            return null;
+        const { path: outputDir } = await dir();
+        const platformOutputDir = path.join(outputDir, 'converted-icons');
+        await fsExtra.ensureDir(platformOutputDir);
+        const processedInputPath = await preprocessIcon(inputPath);
+        const iconName = appName.toLowerCase();
+        // Generate platform-specific format
+        if (IS_WIN) {
+            await icongen(processedInputPath, platformOutputDir, {
+                report: false,
+                ico: { name: `${iconName}_256`, sizes: [256] },
+            });
+            return path.join(platformOutputDir, `${iconName}_256.ico`);
+        }
+        if (IS_LINUX) {
+            const outputPath = path.join(platformOutputDir, `${iconName}_512.png`);
+            await fsExtra.copy(processedInputPath, outputPath);
+            return outputPath;
+        }
+        // macOS
+        await icongen(processedInputPath, platformOutputDir, {
+            report: false,
+            icns: { name: iconName, sizes: [16, 32, 64, 128, 256, 512, 1024] },
+        });
+        const outputPath = path.join(platformOutputDir, `${iconName}.icns`);
+        return (await fsExtra.pathExists(outputPath)) ? outputPath : null;
+    }
+    catch (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);
         }
-        else {
-            return path.resolve(options.icon);
+        return path.resolve(options.icon);
+    }
+    // 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;
+    }
+    logger.info('✼ No icon provided, using default icon.');
+    const iconPath = IS_WIN
+        ? 'src-tauri/png/icon_256.ico'
+        : IS_LINUX
+            ? 'src-tauri/png/icon_512.png'
+            : 'src-tauri/icons/icon.icns';
+    return path.join(npmDirectory, iconPath);
+}
+/**
+ * Generates icon service URLs for a domain
+ */
+function generateIconServiceUrls(domain) {
+    const logoDevUrls = API_TOKENS.logoDev
+        .sort(() => Math.random() - 0.5)
+        .map(token => `https://img.logo.dev/${domain}?token=${token}&format=png&size=256`);
+    const brandfetchUrls = API_TOKENS.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`,
+    ];
+}
+/**
+ * Attempts to fetch favicon from website
+ */
+async function tryGetFavicon(url, appName) {
+    try {
+        const domain = new URL(url).hostname;
+        const spinner = getSpinner(`Fetching icon from ${domain}...`);
+        const serviceUrls = generateIconServiceUrls(domain);
+        for (const serviceUrl of serviceUrls) {
+            try {
+                const faviconPath = await downloadIcon(serviceUrl, false);
+                if (!faviconPath)
+                    continue;
+                const convertedPath = await convertIconFormat(faviconPath, appName);
+                if (convertedPath) {
+                    spinner.succeed(chalk.green('Icon fetched and converted successfully!'));
+                    return convertedPath;
+                }
+            }
+            catch {
+                continue;
+            }
         }
+        spinner.warn(`✼ No favicon found for ${domain}. Using default.`);
+        return null;
     }
-    else {
-        logger.warn('✼ No icon given, default in use. For a custom icon, use --icon option.');
-        const iconPath = IS_WIN
-            ? 'src-tauri/png/icon_256.ico'
-            : IS_LINUX
-                ? 'src-tauri/png/icon_512.png'
-                : 'src-tauri/icons/icon.icns';
-        return path.join(npmDirectory, iconPath);
+    catch (error) {
+        logger.warn(`Failed to fetch favicon: ${error.message}`);
+        return null;
     }
 }
-async function downloadIcon(iconUrl) {
-    const spinner = getSpinner('Downloading icon...');
+/**
+ * Downloads icon from URL
+ */
+async function downloadIcon(iconUrl, showSpinner = true) {
     try {
-        const iconResponse = await axios.get(iconUrl, {
+        const response = await axios.get(iconUrl, {
             responseType: 'arraybuffer',
+            timeout: ICON_CONFIG.downloadTimeout,
         });
-        const iconData = await iconResponse.data;
-        if (!iconData) {
+        const iconData = response.data;
+        if (!iconData || iconData.byteLength < ICON_CONFIG.minFileSize)
             return null;
-        }
         const fileDetails = await fileTypeFromBuffer(iconData);
-        if (!fileDetails) {
+        if (!fileDetails || !ICON_CONFIG.supportedFormats.includes(fileDetails.ext)) {
             return null;
         }
-        const { path: tempPath } = await dir();
-        let iconPath = `${tempPath}/icon.${fileDetails.ext}`;
-        // Fix this for linux
-        if (IS_LINUX) {
-            iconPath = 'png/linux_temp.png';
-            await fsExtra.outputFile(`${npmDirectory}/src-tauri/${iconPath}`, iconData);
-        }
-        else {
-            await fsExtra.outputFile(iconPath, iconData);
-        }
-        await fsExtra.outputFile(iconPath, iconData);
-        spinner.succeed(chalk.green('Icon downloaded successfully!'));
-        return iconPath;
+        return await saveIconFile(iconData, fileDetails.ext);
     }
     catch (error) {
-        spinner.fail(chalk.red('Icon download failed!'));
-        if (error.response && error.response.status === 404) {
-            return null;
+        if (showSpinner && !(error.response?.status === 404)) {
+            throw error;
         }
-        throw error;
+        return null;
     }
 }
+/**
+ * Saves icon file to temporary location
+ */
+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;
+}
 
 // Extracts the domain from a given URL.
 function getDomain(inputUrl) {
@@ -961,7 +1201,7 @@ async function handleOptions(options, url) {
         name,
         identifier: getIdentifier(url),
     };
-    appOptions.icon = await handleIcon(appOptions);
+    appOptions.icon = await handleIcon(appOptions, url);
     return appOptions;
 }
 
@@ -1054,6 +1294,10 @@ program
     .addOption(new Option('--hide-on-close', 'Hide window on close instead of exiting')
     .default(DEFAULT_PAKE_OPTIONS.hideOnClose)
     .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('--installer-language <string>', 'Installer language')
     .default(DEFAULT_PAKE_OPTIONS.installerLanguage)
     .hideHelp())
@@ -1074,7 +1318,6 @@ program
         log.setLevel('debug');
     }
     const appOptions = await handleOptions(options, url);
-    log.debug('PakeAppOptions', appOptions);
     const builder = BuilderProvider.create(appOptions);
     await builder.prepare();
     await builder.build(url);