pake-cli 3.2.0-beta15 → 3.2.12

package/dist/dev.js

@@ -4,13 +4,14 @@ import chalk from 'chalk';
 import path from 'path';
 import axios from 'axios';
 import { dir } from 'tmp-promise';
-import { fileURLToPath } from 'url';
+import { fileTypeFromBuffer } from 'file-type';
+import icongen from 'icon-gen';
+import sharp from 'sharp';
 import crypto from 'crypto';
 import prompts from 'prompts';
 import ora from 'ora';
-import { fileTypeFromBuffer } from 'file-type';
+import { fileURLToPath } from 'url';
 import * as psl from 'psl';
-import icongen from 'icon-gen';
 import { execa, execaSync } from 'execa';
 import dns from 'dns';
 import http from 'http';
@@ -68,17 +69,6 @@ const logger = {
     },
 };
 
-// Convert the current module URL to a file path
-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', '.pake');
-
-const { platform: platform$2 } = process;
-const IS_MAC = platform$2 === 'darwin';
-const IS_WIN = platform$2 === 'win32';
-const IS_LINUX = platform$2 === 'linux';
-
 // Generates an identifier based on the given URL.
 function getIdentifier(url) {
     const postFixHash = crypto
@@ -112,66 +102,94 @@ function getSpinner(text) {
     }).start();
 }
 
-// Extracts the domain from a given URL.
-function getDomain(inputUrl) {
+// Convert the current module URL to a file path
+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', '.pake');
+
+const { platform: platform$2 } = process;
+const IS_MAC = platform$2 === 'darwin';
+const IS_WIN = platform$2 === 'win32';
+const IS_LINUX = platform$2 === 'linux';
+
+// 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 url = new URL(inputUrl);
-        // Use PSL to parse domain names.
-        const parsed = psl.parse(url.hostname);
-        // If domain is available, split it and return the SLD.
-        if ('domain' in parsed && parsed.domain) {
-            return parsed.domain.split('.')[0];
-        }
-        else {
-            return null;
-        }
+        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) {
-        return null;
+        logger.warn(`Failed to add background to icon: ${error.message}`);
+        return inputPath;
     }
 }
-
-// Helper function to convert icon to required platform format
+/**
+ * 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);
-        // Get the required format based on current platform
-        const requiredFormat = IS_WIN ? 'ico' : IS_LINUX ? 'png' : 'icns';
-        const outputFileName = IS_WIN
-            ? `${appName.toLowerCase()}_256.ico`
-            : IS_LINUX
-                ? `${appName.toLowerCase()}_512.png`
-                : `${appName.toLowerCase()}.icns`;
-        const outputPath = path.join(platformOutputDir, outputFileName);
-        // Convert using icon-gen
-        if (requiredFormat === 'icns') {
-            await icongen(inputPath, platformOutputDir, {
-                report: false,
-                icns: {
-                    name: appName.toLowerCase(),
-                    sizes: [16, 32, 64, 128, 256, 512, 1024]
-                }
-            });
-        }
-        else if (requiredFormat === 'ico') {
-            await icongen(inputPath, 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: `${appName.toLowerCase()}_256`,
-                    sizes: [16, 24, 32, 48, 64, 128, 256]
-                }
+                ico: { name: `${iconName}_256`, sizes: [256] },
             });
+            return path.join(platformOutputDir, `${iconName}_256.ico`);
         }
-        else {
-            // For Linux, just copy the PNG file
-            await fsExtra.copy(inputPath, outputPath);
+        if (IS_LINUX) {
+            const outputPath = path.join(platformOutputDir, `${iconName}_512.png`);
+            await fsExtra.copy(processedInputPath, outputPath);
+            return 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}`);
+        logger.warn(`Icon format conversion failed: ${error.message}`);
         return null;
     }
 }
@@ -180,118 +198,169 @@ async function handleIcon(options, url) {
         if (options.icon.startsWith('http')) {
             return downloadIcon(options.icon);
         }
-        else {
-            return path.resolve(options.icon);
-        }
+        return path.resolve(options.icon);
     }
-    else {
-        // Try to get favicon from website if URL is provided and it's a web URL
-        if (url && url.startsWith('http') && options.name) {
-            const faviconPath = await tryGetFavicon(url, options.name);
-            if (faviconPath) {
-                return faviconPath;
+    // 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.');
+    // For Windows, ensure we have proper fallback handling
+    if (IS_WIN) {
+        const defaultIcoPath = path.join(npmDirectory, 'src-tauri/png/icon_256.ico');
+        const defaultPngPath = path.join(npmDirectory, 'src-tauri/png/icon_512.png');
+        // First try default ico
+        if (await fsExtra.pathExists(defaultIcoPath)) {
+            return defaultIcoPath;
+        }
+        // If ico doesn't exist, try to convert from png
+        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;
+                }
+            }
+            catch (error) {
+                logger.warn(`Failed to convert default png to ico: ${error.message}`);
             }
         }
-        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);
+        // Last resort: return png path if it exists (Windows can handle png in some cases)
+        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');
     }
+    const iconPath = IS_LINUX
+        ? 'src-tauri/png/icon_512.png'
+        : 'src-tauri/icons/icon.icns';
+    return path.join(npmDirectory, iconPath);
 }
-async function tryGetFavicon(url, appName) {
-    const domain = getDomain(url);
-    if (!domain) {
-        return null;
-    }
-    const spinner = getSpinner('Fetching website favicon...');
-    // List of logo/favicon services to try in order of preference
-    const logoServices = [
-        // Professional Logo APIs (free tier, higher quality)
+/**
+ * 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}`,
-        // Google's reliable service with larger size
         `https://www.google.com/s2/favicons?domain=${domain}&sz=256`,
-        // Other favicon services
         `https://favicon.is/${domain}`,
         `https://icons.duckduckgo.com/ip3/${domain}.ico`,
         `https://icon.horse/icon/${domain}`,
-        // Direct favicon checks
         `https://${domain}/favicon.ico`,
         `https://www.${domain}/favicon.ico`,
         `https://${domain}/apple-touch-icon.png`,
         `https://${domain}/apple-touch-icon-precomposed.png`,
     ];
-    for (const logoUrl of logoServices) {
-        try {
-            const faviconPath = await downloadIcon(logoUrl, false);
-            if (faviconPath) {
-                spinner.text = 'Converting favicon to platform format...';
-                // Convert to the correct format for the current platform
+}
+/**
+ * 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);
+        // Use shorter timeout for CI environments
+        const isCI = process.env.CI === 'true' || process.env.GITHUB_ACTIONS === 'true';
+        const downloadTimeout = isCI ? 5000 : ICON_CONFIG.downloadTimeout;
+        for (const serviceUrl of serviceUrls) {
+            try {
+                const faviconPath = await downloadIcon(serviceUrl, false, downloadTimeout);
+                if (!faviconPath)
+                    continue;
                 const convertedPath = await convertIconFormat(faviconPath, appName);
                 if (convertedPath) {
-                    spinner.succeed(chalk.green(`Favicon downloaded and converted for ${domain}!`));
+                    spinner.succeed(chalk.green('Icon fetched and converted successfully!'));
                     return convertedPath;
                 }
-                else {
-                    // If conversion fails, try the next service
-                    continue;
+            }
+            catch (error) {
+                // Log specific errors in CI for debugging
+                if (isCI) {
+                    logger.debug(`Icon service ${serviceUrl} failed: ${error.message}`);
                 }
+                continue;
             }
         }
-        catch (error) {
-            // Continue to next service
-            continue;
-        }
+        spinner.warn(`✼ No favicon found for ${domain}. Using default.`);
+        return null;
+    }
+    catch (error) {
+        logger.warn(`Failed to fetch favicon: ${error.message}`);
+        return null;
     }
-    spinner.fail(chalk.yellow(`No favicon found for ${domain}, using default icon.`));
-    return null;
 }
-async function downloadIcon(iconUrl, showSpinner = true) {
-    const spinner = showSpinner ? getSpinner('Downloading icon...') : null;
+/**
+ * Downloads icon from URL
+ */
+async function downloadIcon(iconUrl, showSpinner = true, customTimeout) {
     try {
-        const iconResponse = await axios.get(iconUrl, {
+        const response = await axios.get(iconUrl, {
             responseType: 'arraybuffer',
-            timeout: 10000, // 10 second timeout
+            timeout: customTimeout || ICON_CONFIG.downloadTimeout,
         });
-        const iconData = await iconResponse.data;
-        if (!iconData || iconData.byteLength < 100) {
-            // Skip very small responses (likely error pages)
+        const iconData = response.data;
+        if (!iconData || iconData.byteLength < ICON_CONFIG.minFileSize)
             return null;
-        }
         const fileDetails = await fileTypeFromBuffer(iconData);
-        if (!fileDetails || !['png', 'ico', 'jpeg', 'jpg', 'gif', 'webp'].includes(fileDetails.ext)) {
-            // Only accept common image formats
+        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);
-        if (spinner) {
-            spinner.succeed(chalk.green('Icon downloaded successfully!'));
+        return await saveIconFile(iconData, fileDetails.ext);
+    }
+    catch (error) {
+        if (showSpinner && !(error.response?.status === 404)) {
+            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;
     }
-    catch (error) {
-        if (spinner) {
-            spinner.fail(chalk.red('Icon download failed!'));
+    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) {
+    try {
+        const url = new URL(inputUrl);
+        // Use PSL to parse domain names.
+        const parsed = psl.parse(url.hostname);
+        // If domain is available, split it and return the SLD.
+        if ('domain' in parsed && parsed.domain) {
+            return parsed.domain.split('.')[0];
         }
-        if (error.response && error.response.status === 404) {
+        else {
             return null;
         }
-        if (showSpinner) {
-            throw error;
-        }
+    }
+    catch (error) {
         return null;
     }
 }
@@ -346,136 +415,13 @@ async function handleOptions(options, url) {
     return appOptions;
 }
 
-var windows = [
-	{
-		url: "https://weekly.tw93.fun/",
-		url_type: "web",
-		hide_title_bar: true,
-		fullscreen: false,
-		width: 1200,
-		height: 780,
-		resizable: true,
-		always_on_top: false,
-		dark_mode: false,
-		activation_shortcut: "",
-		disabled_web_shortcuts: false,
-		hide_on_close: true,
-		incognito: false
-	}
-];
-var user_agent = {
-	macos: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15",
-	linux: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36",
-	windows: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36"
-};
-var system_tray = {
-	macos: false,
-	linux: true,
-	windows: true
-};
-var system_tray_path = "icons/icon.png";
-var inject = [
-];
-var proxy_url = "";
-var pakeConf = {
-	windows: windows,
-	user_agent: user_agent,
-	system_tray: system_tray,
-	system_tray_path: system_tray_path,
-	inject: inject,
-	proxy_url: proxy_url
-};
-
-var productName$1 = "Weekly";
-var identifier = "com.pake.weekly";
-var version = "1.0.0";
-var app = {
-	withGlobalTauri: true,
-	trayIcon: {
-		iconPath: "png/weekly_512.png",
-		iconAsTemplate: false,
-		id: "pake-tray"
-	}
-};
-var build = {
-	frontendDist: "../dist"
-};
-var CommonConf = {
-	productName: productName$1,
-	identifier: identifier,
-	version: version,
-	app: app,
-	build: build
-};
-
-var bundle$2 = {
-	icon: [
-		"png/weekly_256.ico",
-		"png/weekly_32.ico"
-	],
-	active: true,
-	resources: [
-		"png/weekly_32.ico"
-	],
-	targets: [
-		"msi"
-	],
-	windows: {
-		digestAlgorithm: "sha256",
-		wix: {
-			language: [
-				"en-US"
-			],
-			template: "assets/main.wxs"
-		}
-	}
-};
-var WinConf = {
-	bundle: bundle$2
-};
-
-var bundle$1 = {
-	icon: [
-		"icons/weekly.icns"
-	],
-	active: true,
-	macOS: {
-	},
-	targets: [
-		"dmg"
-	]
-};
-var MacConf = {
-	bundle: bundle$1
-};
-
-var productName = "weekly";
-var bundle = {
-	icon: [
-		"png/weekly_512.png"
-	],
-	active: true,
-	linux: {
-		deb: {
-			depends: [
-				"curl",
-				"wget"
-			],
-			files: {
-				"/usr/share/applications/com-pake-weekly.desktop": "assets/com-pake-weekly.desktop"
-			}
-		}
-	},
-	targets: [
-		"deb",
-		"appimage"
-	]
-};
-var LinuxConf = {
-	productName: productName,
-	bundle: bundle
-};
-
+// Load configs from npm package directory, not from project source
+const tauriSrcDir = path.join(npmDirectory, 'src-tauri');
+const pakeConf = fsExtra.readJSONSync(path.join(tauriSrcDir, 'pake.json'));
+const CommonConf = fsExtra.readJSONSync(path.join(tauriSrcDir, 'tauri.conf.json'));
+const WinConf = fsExtra.readJSONSync(path.join(tauriSrcDir, 'tauri.windows.conf.json'));
+const MacConf = fsExtra.readJSONSync(path.join(tauriSrcDir, 'tauri.macos.conf.json'));
+const LinuxConf = fsExtra.readJSONSync(path.join(tauriSrcDir, 'tauri.linux.conf.json'));
 const platformConfigs = {
     win32: WinConf,
     darwin: MacConf,
@@ -497,13 +443,14 @@ let tauriConfig = {
     pake: pakeConf,
 };
 
-async function shellExec(command, timeout = 300000) {
+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;
     }
@@ -572,11 +519,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);
     }
 }
@@ -689,7 +636,33 @@ async function mergeConfig(url, options, tauriConf) {
     tauriConf.pake.system_tray[currentPlatform] = showSystemTray;
     // Processing targets are currently only open to Linux.
     if (platform === 'linux') {
+        // 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 desktopFileName = `${identifier}.desktop`;
+        // Create desktop file content
+        const desktopContent = `[Desktop Entry]
+Version=1.0
+Type=Application
+Name=${name}
+Comment=${name}
+Exec=${appNameLower}
+Icon=${appNameLower}
+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);
+        // Set up desktop file in bundle configuration
+        tauriConf.bundle.linux.deb.files = {
+            [`/usr/share/applications/${desktopFileName}`]: `assets/${desktopFileName}`,
+        };
         const validTargets = ['deb', 'appimage', 'rpm'];
         if (validTargets.includes(options.targets)) {
             tauriConf.bundle.targets = [options.targets];
@@ -794,7 +767,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 });
@@ -812,6 +784,21 @@ 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 900000; // 15 minutes for all builds
+    }
     async prepare() {
         const tauriSrcPath = path.join(npmDirectory, 'src-tauri');
         const tauriTargetPath = path.join(tauriSrcPath, 'target');
@@ -839,21 +826,22 @@ class BaseBuilder {
         const rustProjectDir = path.join(tauriSrcPath, '.cargo');
         const projectConf = path.join(rustProjectDir, 'config.toml');
         await fsExtra.ensureDir(rustProjectDir);
-        // For global CLI installation, always use npm
+        // 统一使用npm，简单可靠
         const packageManager = 'npm';
         const registryOption = isChina
             ? ' --registry=https://registry.npmmirror.com'
             : '';
-        // Windows环境下需要更长的超时时间
-        const timeout = process.platform === 'win32' ? 600000 : 300000;
+        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}" && ${packageManager} install${registryOption}`, timeout);
+            await shellExec(`cd "${npmDirectory}" && ${packageManager} install${registryOption}${legacyPeerDeps} --silent`, timeout, buildEnv);
         }
         else {
-            await shellExec(`cd "${npmDirectory}" && ${packageManager} install`, timeout);
+            await shellExec(`cd "${npmDirectory}" && ${packageManager} install${legacyPeerDeps} --silent`, timeout, buildEnv);
         }
         spinner.succeed(chalk.green('Package installed!'));
         if (!tauriTargetPathExists) {
@@ -870,9 +858,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);
@@ -897,13 +890,18 @@ class BaseBuilder {
         if (IS_MAC && this.options.targets === 'app') {
             fullCommand += ' --bundles app';
         }
+        // Add features
+        const features = ['cli-build'];
         // 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';
+                features.push('macos-proxy');
             }
         }
+        if (features.length > 0) {
+            fullCommand += ` --features ${features.join(',')}`;
+        }
         return fullCommand;
     }
     getMacOSMajorVersion() {
@@ -957,9 +955,26 @@ class MacBuilder extends BaseBuilder {
         return `${name}_${tauriConfig.version}_${arch}`;
     }
     getBuildCommand() {
-        return this.options.multiArch
-            ? 'npm run build:mac'
-            : super.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;
+        }
+        return super.getBuildCommand();
     }
     getBasePath() {
         return this.options.multiArch