@addfox/cli 0.1.1-beta.2

package/dist/cli.js

@@ -0,0 +1,1022 @@
+#!/usr/bin/env node
+import { dirname, resolve as external_path_resolve } from "path";
+import { createWriteStream, existsSync as external_fs_existsSync, mkdirSync, readFileSync as external_fs_readFileSync, readdirSync, statSync, watch } from "fs";
+import { mergeRsbuildConfig } from "@rsbuild/core";
+import { ADDFOX_ERROR_CODES, AddfoxError, HookManager, error, exitWithError, formatError, getWebExtStdoutOriginDepth, log as common_log, logDone, logDoneTimed, logDoneWithValue, setAddfoxLoggerRawWrites, warn as common_warn } from "@addfox/common";
+import { ADDFOX_OUTPUT_ROOT, CLI_COMMANDS, CONFIG_FILES, HMR_WS_PORT, clearConfigCache, getBrowserOutputDir, getManifestRecordForTarget, getResolvedConfigFilePath, getResolvedRstestConfigFilePath, resolveAddfoxConfig, toReloadManagerEntries } from "@addfox/core";
+import { Pipeline } from "@addfox/core/pipeline";
+import { hmrPlugin, launchBrowserOnly } from "@addfox/rsbuild-plugin-extension-hmr";
+import { detectFromLockfile as pkg_manager_detectFromLockfile, getAddCommand, getMissingPackages } from "@addfox/pkg-manager";
+import { entryPlugin } from "@addfox/rsbuild-plugin-extension-entry";
+import { extensionPlugin } from "@addfox/rsbuild-plugin-extension-manifest";
+import { monitorPlugin } from "@addfox/rsbuild-plugin-extension-monitor";
+import { getVueRsbuildPlugins } from "@addfox/rsbuild-plugin-vue";
+import { spawnSync as external_child_process_spawnSync } from "child_process";
+import archiver from "archiver";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+function expandUserPlugins(userPlugins, appRoot) {
+    const out = [];
+    const list = userPlugins ?? [];
+    const arr = Array.isArray(list) ? list : [
+        list
+    ];
+    for (const p of arr){
+        const name = p?.name;
+        if ("rsbuild-plugin-vue" === name) {
+            const vuePlugins = getVueRsbuildPlugins(appRoot);
+            if (Array.isArray(vuePlugins)) out.push(...vuePlugins);
+        }
+        out.push(p);
+    }
+    return out;
+}
+function buildFrameworkPluginList(ctx) {
+    const useEntry = false !== ctx.config.entry;
+    const expanded = expandUserPlugins(ctx.config.plugins, ctx.root);
+    const useMonitor = ctx.isDev && true === ctx.config.debug;
+    const list = [];
+    if (useEntry) list.push(entryPlugin(ctx.config, ctx.entries, ctx.distPath, {
+        browser: ctx.browser
+    }));
+    list.push(...expanded);
+    if (useMonitor) list.push(monitorPlugin(ctx.config, ctx.entries, ctx.browser));
+    list.push(extensionPlugin(ctx.config, ctx.entries, ctx.browser, ctx.distPath));
+    return list;
+}
+class Pipeline_Pipeline {
+    hookManager;
+    corePipeline;
+    options;
+    constructor(options){
+        this.options = options;
+        this.hookManager = new HookManager();
+        this.corePipeline = new Pipeline(this.hookManager);
+        this.registerDefaultHooks();
+    }
+    get hooks() {
+        return this.hookManager;
+    }
+    async run() {
+        return this.corePipeline.execute(this.options.root, []);
+    }
+    registerDefaultHooks() {
+        this.hookManager.register('load', 'after', async (ctx)=>{
+            if (this.options.config) {
+                ctx.config = this.options.config;
+                ctx.baseEntries = this.options.baseEntries ?? [];
+                ctx.entries = this.options.entries ?? [];
+            } else {
+                const result = resolveAddfoxConfig(ctx.root);
+                ctx.config = result.config;
+                ctx.baseEntries = result.baseEntries;
+                ctx.entries = result.entries;
+            }
+        });
+        this.hookManager.register('resolve', 'after', async (ctx)=>{
+            ctx.command = this.options.command;
+            ctx.browser = this.options.browser;
+            ctx.cache = this.options.cache;
+            ctx.report = this.options.report;
+            ctx.isDev = 'dev' === this.options.command;
+            const browserSubDir = getBrowserOutputDir(ctx.browser);
+            ctx.distPath = external_path_resolve(ctx.root, ctx.config.outputRoot, ctx.config.outDir, browserSubDir);
+            if (void 0 !== this.options.debug) ctx.config = {
+                ...ctx.config,
+                debug: this.options.debug
+            };
+            if ('chromium' === ctx.browser) {
+                const record = getManifestRecordForTarget(ctx.config.manifest, ctx.browser);
+                if (record?.manifest_version === 2) common_warn('Warning: MV2 has been deprecated for Chrome. Please use MV3.');
+            }
+        });
+        this.hookManager.register('build', 'after', async (ctx)=>{
+            ctx.rsbuild = await this.buildRsbuildConfig(ctx);
+        });
+    }
+    async buildRsbuildConfig(ctx) {
+        const base = this.buildBaseRsbuildConfig(ctx);
+        const userConfig = await this.resolveUserRsbuildConfig(base, ctx.config);
+        let merged = mergeRsbuildConfig(base, userConfig);
+        if (ctx.isDev) {
+            const hmrOverrides = this.buildHmrOverrides(ctx);
+            if (hmrOverrides) merged = mergeRsbuildConfig(merged, hmrOverrides);
+        }
+        if (ctx.report) merged = await this.mergeRsdoctorPlugin(merged, ctx.root, ctx.config.outputRoot, ctx.report);
+        return merged;
+    }
+    buildBaseRsbuildConfig(ctx) {
+        const runtimeEnvConfig = buildRuntimeEnvConfig(ctx.config, ctx.browser, ctx.root, ctx.isDev);
+        const plugins = buildFrameworkPluginList(ctx);
+        const scopedProcessEnvPlugin = createScopedProcessEnvPlugin(runtimeEnvConfig.processEnvBase, runtimeEnvConfig.backgroundPrivateEnv);
+        if (scopedProcessEnvPlugin) plugins.push(scopedProcessEnvPlugin);
+        return {
+            root: ctx.root,
+            plugins,
+            source: {
+                define: runtimeEnvConfig.define
+            },
+            output: {
+                legalComments: 'none',
+                sourceMap: ctx.isDev ? {
+                    js: 'inline-source-map'
+                } : false
+            }
+        };
+    }
+    async resolveUserRsbuildConfig(base, config) {
+        const user = config.rsbuild;
+        if ('function' == typeof user) return user(base, {
+            merge: mergeRsbuildConfig
+        });
+        return user && 'object' == typeof user ? user : {};
+    }
+    buildHmrOverrides(ctx) {
+        const hotReload = ctx.config.hotReload;
+        const hotReloadEnabled = false !== hotReload;
+        const hotReloadOpts = 'object' == typeof hotReload && null !== hotReload ? hotReload : void 0;
+        const isConfigRestart = '1' === process.env.ADDFOX_CONFIG_RESTART;
+        const reloadManagerEntries = toReloadManagerEntries(ctx.entries, ctx.root);
+        const browserPathConfig = ctx.config.browserPath ?? {};
+        const hmrOpts = {
+            distPath: ctx.distPath,
+            autoOpen: !isConfigRestart && false !== this.options.open,
+            browser: this.options.launch,
+            debug: ctx.config.debug,
+            root: ctx.root,
+            outputRoot: ctx.config.outputRoot,
+            chromePath: browserPathConfig.chrome,
+            chromiumPath: browserPathConfig.chromium,
+            edgePath: browserPathConfig.edge,
+            bravePath: browserPathConfig.brave,
+            vivaldiPath: browserPathConfig.vivaldi,
+            operaPath: browserPathConfig.opera,
+            santaPath: browserPathConfig.santa,
+            arcPath: browserPathConfig.arc,
+            yandexPath: browserPathConfig.yandex,
+            browserosPath: browserPathConfig.browseros,
+            customPath: browserPathConfig.custom,
+            firefoxPath: browserPathConfig.firefox,
+            cache: ctx.cache,
+            wsPort: hotReloadOpts?.port ?? HMR_WS_PORT,
+            enableReload: hotReloadEnabled,
+            autoRefreshContentPage: hotReloadEnabled ? hotReloadOpts?.autoRefreshContentPage ?? true : false,
+            reloadManagerEntries
+        };
+        const useRsbuildClientHmr = 'firefox' !== ctx.browser && hotReloadEnabled;
+        const devConfig = useRsbuildClientHmr ? {
+            hmr: true,
+            client: {
+                protocol: 'ws',
+                host: '127.0.0.1',
+                port: '<port>',
+                path: '/rsbuild-hmr'
+            },
+            liveReload: true,
+            writeToDisk: true
+        } : {
+            hmr: false,
+            liveReload: false,
+            writeToDisk: true
+        };
+        return {
+            dev: devConfig,
+            server: {
+                printUrls: false,
+                cors: {
+                    origin: '*'
+                }
+            },
+            plugins: [
+                hmrPlugin(hmrOpts)
+            ]
+        };
+    }
+    async mergeRsdoctorPlugin(config, root, outputRoot, reportOption) {
+        const missing = getMissingPackages(root, [
+            '@rsdoctor/rspack-plugin'
+        ]);
+        if (missing.length > 0) {
+            const pm = pkg_manager_detectFromLockfile(root);
+            const cmd = getAddCommand(pm, missing.join(' '), true);
+            throw new AddfoxError({
+                code: ADDFOX_ERROR_CODES.RSDOCTOR_NOT_INSTALLED,
+                message: "Rsdoctor plugin not installed",
+                details: "report (-r/--report or config.report) requires @rsdoctor/rspack-plugin",
+                hint: `Install with: ${cmd}`
+            });
+        }
+        const reportDir = external_path_resolve(root, outputRoot, 'report');
+        const { RsdoctorRspackPlugin } = await import("@rsdoctor/rspack-plugin");
+        const tools = config.tools;
+        const existing = tools?.rspack?.plugins ?? [];
+        const pluginOptions = true === reportOption ? {
+            output: {
+                reportDir
+            },
+            mode: 'brief'
+        } : {
+            ...reportOption,
+            output: {
+                ...reportOption.output,
+                reportDir
+            }
+        };
+        const rsdoctorPlugin = new RsdoctorRspackPlugin(pluginOptions);
+        return mergeRsbuildConfig(config, {
+            tools: {
+                rspack: {
+                    plugins: [
+                        ...existing,
+                        rsdoctorPlugin
+                    ]
+                }
+            }
+        });
+    }
+}
+function getManifestVersionValue(config, browser) {
+    const manifestRecord = getManifestRecordForTarget(config.manifest, browser);
+    const mv = manifestRecord?.manifest_version;
+    if ("number" == typeof mv || "string" == typeof mv) return String(mv);
+    return "";
+}
+function buildRuntimeEnvConfig(config, browser, root, isDev) {
+    const mode = isDev ? "development" : "production";
+    const fileEnv = loadDotEnvByMode(root, mode);
+    const mergedEnv = {
+        ...fileEnv,
+        ...process.env
+    };
+    const envPrefixes = getLoadEnvPrefixes(config);
+    const publicEnv = pickPublicEnvVars(mergedEnv, envPrefixes);
+    const backgroundPrivateEnv = pickBackgroundPrivateEnvVars(mergedEnv, envPrefixes);
+    const manifestVersion = getManifestVersionValue(config, browser);
+    const importMetaEnv = {
+        ...publicEnv,
+        MODE: mode,
+        DEV: isDev,
+        PROD: !isDev,
+        BROWSER: browser,
+        MANIFEST_VERSION: manifestVersion
+    };
+    const processEnvForBundle = {
+        NODE_ENV: mode,
+        BROWSER: browser,
+        MANIFEST_VERSION: manifestVersion,
+        ...publicEnv
+    };
+    return {
+        define: {
+            "process.env": "globalThis.__ADDFOX_PROCESS_ENV__",
+            "import.meta.env": JSON.stringify(importMetaEnv),
+            "import.meta.env.BROWSER": JSON.stringify(browser),
+            "import.meta.env.MANIFEST_VERSION": JSON.stringify(manifestVersion)
+        },
+        processEnvBase: processEnvForBundle,
+        backgroundPrivateEnv
+    };
+}
+function getLoadEnvPrefixes(config) {
+    return config.envPrefix ?? [
+        "ADDFOX_PUBLIC_"
+    ];
+}
+function pickPublicEnvVars(env, prefixes) {
+    const result = {};
+    for (const [key, value] of Object.entries(env))if ("string" == typeof value) {
+        if (prefixes.some((prefix)=>key.startsWith(prefix))) result[key] = value;
+    }
+    return result;
+}
+function pickBackgroundPrivateEnvVars(env, publicPrefixes) {
+    const result = {};
+    for (const [key, value] of Object.entries(env)){
+        if ("string" == typeof value) {
+            if (key.startsWith("ADDFOX_")) {
+                if (!publicPrefixes.some((prefix)=>key.startsWith(prefix))) result[key] = value;
+            }
+        }
+    }
+    return result;
+}
+function createScopedProcessEnvPlugin(processEnvBase, privateEnv) {
+    if (0 === Object.keys(processEnvBase).length) return;
+    return {
+        name: "addfox-scoped-process-env",
+        setup (api) {
+            api.modifyRsbuildConfig((config)=>{
+                const source = config.source ?? {};
+                const entry = source.entry;
+                if (!entry) return;
+                const nextEntry = {
+                    ...entry
+                };
+                const scopedEnvByEntry = buildScopedEnvByEntry(Object.keys(entry), processEnvBase, privateEnv);
+                for (const [entryName, entryValue] of Object.entries(entry)){
+                    const scopedEnv = scopedEnvByEntry[entryName] ?? processEnvBase;
+                    const snippet = buildScopedProcessEnvSnippet(scopedEnv);
+                    const prepend = `data:text/javascript,${encodeURIComponent(snippet)}`;
+                    nextEntry[entryName] = prependDataModule(entryValue, prepend);
+                }
+                config.source = {
+                    ...source,
+                    entry: nextEntry
+                };
+            });
+        }
+    };
+}
+function buildScopedEnvByEntry(entryNames, processEnvBase, privateEnv) {
+    const result = {};
+    for (const entryName of entryNames)result[entryName] = "background" === entryName ? {
+        ...processEnvBase,
+        ...privateEnv
+    } : {
+        ...processEnvBase
+    };
+    return result;
+}
+function buildScopedProcessEnvSnippet(processEnv) {
+    const envJson = JSON.stringify(processEnv);
+    return `
+const addfoxScopedEnv = ${envJson};
+if (!globalThis.__ADDFOX_PROCESS_ENV__) {
+  globalThis.__ADDFOX_PROCESS_ENV__ = {};
+}
+Object.assign(globalThis.__ADDFOX_PROCESS_ENV__, addfoxScopedEnv);
+`;
+}
+function prependDataModule(entryValue, prependModule) {
+    if ("string" == typeof entryValue) return {
+        import: [
+            prependModule,
+            entryValue
+        ]
+    };
+    if (Array.isArray(entryValue.import)) return {
+        ...entryValue,
+        import: [
+            prependModule,
+            ...entryValue.import
+        ]
+    };
+    return {
+        ...entryValue,
+        import: [
+            prependModule,
+            entryValue.import
+        ]
+    };
+}
+function loadDotEnvByMode(root, mode) {
+    const result = {};
+    const files = [
+        ".env",
+        ".env.local",
+        `.env.${mode}`,
+        `.env.${mode}.local`
+    ];
+    for (const file of files){
+        const path = external_path_resolve(root, file);
+        if (!external_fs_existsSync(path)) continue;
+        const parsed = parseDotEnv(external_fs_readFileSync(path, "utf-8"));
+        Object.assign(result, parsed);
+    }
+    return result;
+}
+function parseDotEnv(content) {
+    const result = {};
+    const lines = content.split(/\r?\n/);
+    for (const line of lines){
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eq = trimmed.indexOf("=");
+        if (eq <= 0) continue;
+        const key = trimmed.slice(0, eq).trim();
+        const rawValue = trimmed.slice(eq + 1).trim();
+        result[key] = stripQuotes(rawValue);
+    }
+    return result;
+}
+function stripQuotes(value) {
+    if (value.length < 2) return value;
+    const quote = value[0];
+    if ('"' !== quote && "'" !== quote || value[value.length - 1] !== quote) return value;
+    return value.slice(1, -1);
+}
+async function runPipeline(options) {
+    const pipeline = new Pipeline_Pipeline(options);
+    return pipeline.run();
+}
+const BROWSER_FLAGS = [
+    "-b",
+    "--browser"
+];
+const REPORT_FLAGS = [
+    "-r",
+    "--report"
+];
+const BROWSER_TO_TARGET = {
+    chromium: "chromium",
+    chrome: "chromium",
+    edge: "chromium",
+    brave: "chromium",
+    vivaldi: "chromium",
+    opera: "chromium",
+    santa: "chromium",
+    arc: "chromium",
+    yandex: "chromium",
+    browseros: "chromium",
+    custom: "chromium",
+    firefox: "firefox"
+};
+const VALID_LAUNCH_TARGETS = new Set([
+    "chrome",
+    "chromium",
+    "edge",
+    "brave",
+    "vivaldi",
+    "opera",
+    "santa",
+    "arc",
+    "yandex",
+    "browseros",
+    "custom",
+    "firefox"
+]);
+class CliParser {
+    parse(argv) {
+        const cmdRaw = argv[0] ?? "dev";
+        const command = CLI_COMMANDS.includes(cmdRaw) ? cmdRaw : null;
+        if (null === command) throw new AddfoxError({
+            code: ADDFOX_ERROR_CODES.UNKNOWN_COMMAND,
+            message: "Unknown command",
+            details: `Command: "${cmdRaw}"`,
+            hint: "Supported: addfox dev | addfox build | addfox test [-b chrome|...]; custom requires browser.custom in config"
+        });
+        const { browser, launch, unknown: unknownBrowser } = this.getBrowserFromArgv(argv);
+        const cache = this.getCacheFromArgv(argv);
+        const debug = this.getDebugFromArgv(argv);
+        const report = this.getReportFromArgv(argv);
+        const open = this.getOpenFromArgv(argv);
+        return {
+            command,
+            browser,
+            launch,
+            unknownBrowser,
+            cache,
+            debug,
+            report,
+            open
+        };
+    }
+    getBrowserFromArgv(argv) {
+        for(let i = 0; i < argv.length; i++){
+            const arg = argv[i];
+            if (BROWSER_FLAGS.includes(arg)) {
+                const value = argv[i + 1];
+                if (value && !value.startsWith("-")) {
+                    const normalized = value.trim().toLowerCase();
+                    const browser = BROWSER_TO_TARGET[normalized];
+                    if (browser) {
+                        const launch = VALID_LAUNCH_TARGETS.has(normalized) ? normalized : void 0;
+                        return {
+                            browser,
+                            launch
+                        };
+                    }
+                    return {
+                        unknown: value
+                    };
+                }
+            }
+            if (arg.startsWith("-b=") || arg.startsWith("--browser=")) {
+                const normalized = (arg.split("=")[1] ?? "").trim().toLowerCase();
+                const browser = BROWSER_TO_TARGET[normalized];
+                if (browser) {
+                    const launch = VALID_LAUNCH_TARGETS.has(normalized) ? normalized : void 0;
+                    return {
+                        browser,
+                        launch
+                    };
+                }
+                return {
+                    unknown: normalized
+                };
+            }
+        }
+        return {};
+    }
+    getCacheFromArgv(argv) {
+        let cache;
+        for (const arg of argv){
+            if ("-c" === arg || "--cache" === arg) cache = true;
+            if ("--no-cache" === arg) cache = false;
+        }
+        return cache;
+    }
+    getDebugFromArgv(argv) {
+        return argv.some((arg)=>"--debug" === arg) ? true : void 0;
+    }
+    getReportFromArgv(argv) {
+        return argv.some((arg)=>REPORT_FLAGS.includes(arg)) ? true : void 0;
+    }
+    getOpenFromArgv(argv) {
+        return !argv.some((arg)=>"--no-open" === arg);
+    }
+    assertSupportedBrowser(value) {
+        const b = BROWSER_TO_TARGET[value.trim().toLowerCase()];
+        if (b) return;
+        throw new AddfoxError({
+            code: ADDFOX_ERROR_CODES.INVALID_BROWSER,
+            message: "Unsupported browser argument",
+            details: `Current value: "${value}"`,
+            hint: "Use -b chrome/chromium/edge/brave/vivaldi/opera/santa/arc/yandex/browseros/custom/firefox or --browser=...; use custom only with browser.custom in config"
+        });
+    }
+}
+const defaultParser = new CliParser();
+function parseCliArgs(argv) {
+    return defaultParser.parse(argv);
+}
+function getDistSizeSync(dirPath) {
+    if (!external_fs_existsSync(dirPath)) return -1;
+    const stat = statSync(dirPath);
+    if (!stat.isDirectory()) return stat.size;
+    let total = 0;
+    for (const name of readdirSync(dirPath)){
+        const s = statSync(external_path_resolve(dirPath, name));
+        total += s.isDirectory() ? getDistSizeSync(external_path_resolve(dirPath, name)) : s.size;
+    }
+    return total;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024) return bytes + " B";
+    if (bytes < 1048576) return (bytes / 1024).toFixed(2) + " KB";
+    return (bytes / 1048576).toFixed(2) + " MB";
+}
+function isSourceMapEnabled(rsbuildConfig) {
+    const sm = rsbuildConfig?.output?.sourceMap;
+    if (true === sm) return true;
+    if (sm && "object" == typeof sm && "string" == typeof sm.js) return true;
+    return false;
+}
+function getBuildOutputSize(result) {
+    const stats = result?.stats;
+    if (!stats?.toJson) return null;
+    try {
+        const json = stats.toJson({
+            all: false,
+            assets: true
+        });
+        const assets = json?.assets;
+        if (!Array.isArray(assets)) return null;
+        let total = 0;
+        for (const a of assets)if (a && "number" == typeof a.size) total += a.size;
+        return total > 0 ? total : null;
+    } catch  {
+        return null;
+    }
+}
+const ADDFOX_PREFIX = "\x1b[38;5;208m[Addfox]\x1b[0m ";
+const RSBUILD_PREFIX = "\x1b[38;5;141m[Rsbuild]\x1b[0m ";
+const WEBEXT_PREFIX = "\x1b[38;5;45m[Web-ext]\x1b[0m ";
+let rawStdoutWrite = null;
+let rawStderrWrite = null;
+let outputPrefix = "addfox";
+function setOutputPrefixRsbuild() {
+    outputPrefix = "rsbuild";
+}
+function setOutputPrefixAddfox() {
+    outputPrefix = "addfox";
+}
+function getRawWrites() {
+    return {
+        stdout: rawStdoutWrite ?? process.stdout.write.bind(process.stdout),
+        stderr: rawStderrWrite ?? process.stderr.write.bind(process.stderr)
+    };
+}
+function isEncoding(x) {
+    return "string" == typeof x;
+}
+function createPrefixedWrite(stream, getPrefix) {
+    const originalWrite = stream.write.bind(stream);
+    let buffer = "";
+    function flushIncomplete() {
+        if (buffer.length > 0) {
+            originalWrite(getPrefix(buffer) + buffer);
+            buffer = "";
+        }
+    }
+    const write = function(chunk, encodingOrCallback, callback) {
+        const encoding = isEncoding(encodingOrCallback) ? encodingOrCallback : void 0;
+        const cb = "function" == typeof encodingOrCallback ? encodingOrCallback : callback;
+        const str = "string" == typeof chunk ? chunk : chunk.toString(encoding ?? "utf8");
+        buffer += str;
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines)originalWrite(getPrefix(line) + line + "\n", encoding);
+        if ("function" == typeof cb) cb();
+        return true;
+    };
+    write.flush = flushIncomplete;
+    return write;
+}
+function wrapAddfoxOutput() {
+    rawStdoutWrite = process.stdout.write.bind(process.stdout);
+    rawStderrWrite = process.stderr.write.bind(process.stderr);
+    const getPrefix = (_line)=>{
+        if ("rsbuild" === outputPrefix && getWebExtStdoutOriginDepth() > 0) return WEBEXT_PREFIX;
+        return "rsbuild" === outputPrefix ? RSBUILD_PREFIX : ADDFOX_PREFIX;
+    };
+    const stdoutWrite = createPrefixedWrite(process.stdout, getPrefix);
+    const stderrWrite = createPrefixedWrite(process.stderr, getPrefix);
+    process.stdout.write = stdoutWrite;
+    process.stderr.write = stderrWrite;
+    const flush = ()=>{
+        const fOut = stdoutWrite.flush;
+        const fErr = stderrWrite.flush;
+        if (fOut) fOut();
+        if (fErr) fErr();
+    };
+    process.once("exit", flush);
+}
+const ZIP_OUTPUT_CODE = "ADDFOX_ZIP_OUTPUT";
+const ZIP_ARCHIVE_CODE = "ADDFOX_ZIP_ARCHIVE";
+const ZIP_LEVEL = 9;
+function zipDist(distPath, root, outDir, browser, deps) {
+    const createStream = deps?.createWriteStream ?? createWriteStream;
+    const archiverFn = deps?.archiver ?? archiver;
+    const mkdir = deps?.mkdirSync ?? mkdirSync;
+    const exists = deps?.existsSync ?? external_fs_existsSync;
+    const outputRoot = ADDFOX_OUTPUT_ROOT;
+    const zipDir = external_path_resolve(root, outputRoot, outDir);
+    if (!exists(zipDir)) mkdir(zipDir, {
+        recursive: true
+    });
+    const browserSuffix = browser ? `-${browser}` : "";
+    const zipPath = external_path_resolve(zipDir, `${outDir}${browserSuffix}.zip`);
+    const output = createStream(zipPath);
+    const archive = archiverFn("zip", {
+        zlib: {
+            level: ZIP_LEVEL
+        }
+    });
+    return new Promise((resolvePromise, reject)=>{
+        output.on("error", (err)=>reject(new AddfoxError({
+                message: "Zip output stream failed",
+                code: ZIP_OUTPUT_CODE,
+                details: err instanceof Error ? err.message : String(err),
+                cause: err
+            })));
+        output.on("close", ()=>resolvePromise(zipPath));
+        archive.on("error", (err)=>reject(new AddfoxError({
+                message: "Zip archive failed",
+                code: ZIP_ARCHIVE_CODE,
+                details: err instanceof Error ? err.message : String(err),
+                cause: err
+            })));
+        archive.pipe(output);
+        archive.directory(distPath, false);
+        archive.finalize();
+    });
+}
+const version_require = createRequire(import.meta.url);
+function readPackageVersion(pkgPath) {
+    try {
+        const pkg = JSON.parse(external_fs_readFileSync(pkgPath, "utf-8"));
+        return pkg.version ?? "?";
+    } catch  {
+        return "?";
+    }
+}
+function getVersion() {
+    try {
+        const pkgPath = external_path_resolve(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+        return readPackageVersion(pkgPath) || "0.0.0";
+    } catch  {
+        return "0.0.0";
+    }
+}
+function getRsbuildVersion(projectRoot) {
+    const cliDir = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        ()=>{
+            const p = external_path_resolve(projectRoot, "node_modules", "@rsbuild", "core", "package.json");
+            return external_fs_existsSync(p) ? p : null;
+        },
+        ()=>{
+            try {
+                return version_require.resolve("@rsbuild/core/package.json", {
+                    paths: [
+                        projectRoot
+                    ]
+                });
+            } catch  {
+                return null;
+            }
+        },
+        ()=>{
+            try {
+                return version_require.resolve("@rsbuild/core/package.json", {
+                    paths: [
+                        external_path_resolve(cliDir, ".."),
+                        external_path_resolve(cliDir, "..", "..")
+                    ]
+                });
+            } catch  {
+                return null;
+            }
+        }
+    ];
+    for (const getPath of candidates){
+        const pkgPath = getPath();
+        if (pkgPath) return readPackageVersion(pkgPath);
+    }
+    return "?";
+}
+const test_require = createRequire(import.meta.url);
+function hasRstestConfigFile(projectRoot) {
+    return null !== getResolvedRstestConfigFilePath(projectRoot);
+}
+function isRstestBrowserEnabled(projectRoot) {
+    const configPath = getResolvedRstestConfigFilePath(projectRoot);
+    if (!configPath) return false;
+    try {
+        const content = external_fs_readFileSync(configPath, "utf-8");
+        return /browser\s*:\s*\{[^}]*enabled\s*:\s*true/.test(content) || /browser\.enabled\s*===?\s*true/.test(content);
+    } catch  {
+        return false;
+    }
+}
+function getRequiredTestPackages(projectRoot) {
+    const required = [
+        "@rstest/core"
+    ];
+    if (isRstestBrowserEnabled(projectRoot)) required.push("@rstest/browser", "playwright");
+    return required;
+}
+function getRstestBinPath(projectRoot) {
+    const binDir = external_path_resolve(projectRoot, "node_modules", ".bin");
+    const name = "win32" === process.platform ? "rstest.cmd" : "rstest";
+    const p = external_path_resolve(binDir, name);
+    if (external_fs_existsSync(p)) return p;
+    const fallback = external_path_resolve(binDir, "rstest");
+    if (external_fs_existsSync(fallback)) return fallback;
+    try {
+        const corePkgPath = test_require.resolve("@rstest/core/package.json", {
+            paths: [
+                projectRoot
+            ]
+        });
+        const coreDir = dirname(corePkgPath);
+        const binInCore = external_path_resolve(coreDir, "bin", "rstest.js");
+        if (external_fs_existsSync(binInCore)) return binInCore;
+    } catch  {}
+    exitWithError(new Error("rstest binary not found in node_modules/.bin after installing @rstest/core"));
+}
+function runRstest(projectRoot, restArgs) {
+    const rstestBin = getRstestBinPath(projectRoot);
+    const result = external_child_process_spawnSync(rstestBin, restArgs, {
+        cwd: projectRoot,
+        stdio: "inherit",
+        shell: "win32" === process.platform
+    });
+    return result.status ?? 0;
+}
+async function runTest(projectRoot, argv) {
+    if (!hasRstestConfigFile(projectRoot)) {
+        const files = "rstest.config.cts, rstest.config.mts, rstest.config.cjs, rstest.config.js, rstest.config.ts, rstest.config.mjs";
+        throw new AddfoxError({
+            code: ADDFOX_ERROR_CODES.RSTEST_CONFIG_NOT_FOUND,
+            message: "Rstest config file not found",
+            details: `No rstest.config.* found under ${projectRoot}`,
+            hint: `Create one of: ${files}`
+        });
+    }
+    const required = getRequiredTestPackages(projectRoot);
+    const missing = getMissingPackages(projectRoot, required);
+    if (missing.length > 0) {
+        const pm = pkg_manager_detectFromLockfile(projectRoot);
+        const installCmd = getAddCommand(pm, missing.join(" "), true);
+        exitWithError(new Error(`Missing test dependencies: ${missing.join(", ")}. Please run:\n  ${installCmd}`));
+    }
+    const restArgs = argv.slice(1);
+    const code = runRstest(projectRoot, restArgs);
+    process.exit(code);
+}
+const cli_root = process.cwd();
+const PURPLE = "\x1b[38;5;141m";
+const RESET = "\x1b[0m";
+function hasConfigFile() {
+    return CONFIG_FILES.some((file)=>external_fs_existsSync(external_path_resolve(cli_root, file)));
+}
+function printHelp() {
+    const version = getVersion();
+    console.log(`
+  addfox v${version}
+
+  Build tool for browser extensions
+
+  Usage:
+    addfox <command> [options]
+
+  Commands:
+    dev                        Start development server with HMR
+    build                      Build for production
+    test                       Run tests with rstest (unit + optional E2E); forwards args to rstest
+
+  Options:
+    -b, --browser <browser>    Target/launch browser (chromium | firefox | chrome | edge | brave | ...)
+    -c, --cache                Cache browser profile between launches
+    --no-cache                 Disable browser profile cache for current run
+    -r, --report               Enable Rsdoctor build report (opens analysis after build)
+    --no-open                  Do not auto-open browser (dev/build)
+    --debug                    Enable debug mode
+    --help                     Show this help message
+    --version                  Show version number
+`);
+}
+function resolveOptions(argv, config) {
+    const parsed = parseCliArgs(argv);
+    const browser = parsed.browser ?? "chromium";
+    const launch = parsed.launch ?? ("firefox" === browser ? "firefox" : "chrome");
+    const debug = parsed.debug ?? config.debug ?? false;
+    return {
+        browser,
+        launch,
+        cache: parsed.cache ?? config.cache ?? true,
+        report: parsed.report ?? false,
+        debug,
+        open: parsed.open ?? true
+    };
+}
+async function createRsbuildInstance(ctx) {
+    setOutputPrefixRsbuild();
+    const { createRsbuild } = await import("@rsbuild/core");
+    const rsbuild = await createRsbuild({
+        rsbuildConfig: ctx.rsbuild,
+        cwd: ctx.root,
+        loadEnv: {
+            cwd: ctx.root,
+            prefixes: getLoadEnvPrefixes(ctx.config)
+        }
+    });
+    return rsbuild;
+}
+function logExtensionSize(distDir, rsbuildConfig) {
+    const size = getDistSizeSync(distDir);
+    if (size < 0) return;
+    const sizeStr = formatBytes(size);
+    const suffix = isSourceMapEnabled(rsbuildConfig) ? " (with inline-source-map)" : "";
+    logDoneWithValue("Extension size:", sizeStr + suffix);
+}
+const ADDFOX_CONFIG_DEBOUNCE_MS = 300;
+function watchAddfoxConfig(configPath, onRestart) {
+    let timer = null;
+    const run = ()=>{
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(()=>{
+            timer = null;
+            Promise.resolve(onRestart()).catch((e)=>{
+                error(formatError(e));
+                exitWithError(e);
+            });
+        }, ADDFOX_CONFIG_DEBOUNCE_MS);
+    };
+    try {
+        const watcher = watch(configPath, {
+            persistent: true
+        }, (eventType, filename)=>{
+            if (filename && ("change" === eventType || "rename" === eventType)) run();
+        });
+        return {
+            close () {
+                try {
+                    watcher.close();
+                } catch  {}
+            }
+        };
+    } catch  {
+        return {
+            close () {}
+        };
+    }
+}
+async function runDev(root, argv) {
+    const { config, baseEntries, entries } = resolveAddfoxConfig(root);
+    const resolved = resolveOptions(argv, config);
+    const options = {
+        root,
+        command: 'dev',
+        ...resolved,
+        config,
+        baseEntries,
+        entries
+    };
+    const rsbuildReadyStart = performance.now();
+    const ctx = await runPipeline(options);
+    process.env.NODE_ENV = ctx.isDev ? "development" : "production";
+    const rsbuild = await createRsbuildInstance(ctx);
+    logDoneTimed("Rsbuild ready", Math.round(performance.now() - rsbuildReadyStart));
+    const configPath = getResolvedConfigFilePath(ctx.root);
+    let devServerRef = null;
+    let watcherRef = null;
+    const onAddfoxConfigChange = async ()=>{
+        if (watcherRef) {
+            watcherRef.close();
+            watcherRef = null;
+        }
+        if (devServerRef?.server?.close) await devServerRef.server.close();
+        if (configPath) clearConfigCache(configPath);
+        process.env.ADDFOX_CONFIG_RESTART = "1";
+        try {
+            await runDev(root, argv);
+        } finally{
+            delete process.env.ADDFOX_CONFIG_RESTART;
+        }
+    };
+    if (configPath) watcherRef = watchAddfoxConfig(configPath, onAddfoxConfigChange);
+    const devServerStart = performance.now();
+    devServerRef = await rsbuild.startDevServer({
+        getPortSilently: true
+    });
+    const urls = devServerRef?.urls ?? [];
+    const mainUrl = urls[0] ?? `http://localhost:${devServerRef?.port ?? "?"}`;
+    logDoneTimed("Dev server " + mainUrl, Math.round(performance.now() - devServerStart));
+    const devDistDir = rsbuild.context?.distPath ?? ctx.distPath;
+    setTimeout(()=>logExtensionSize(devDistDir, ctx.rsbuild), 2500);
+}
+async function runBuild(root, argv) {
+    const { config, baseEntries, entries } = resolveAddfoxConfig(root);
+    const resolved = resolveOptions(argv, config);
+    const options = {
+        root,
+        command: 'build',
+        ...resolved,
+        config,
+        baseEntries,
+        entries
+    };
+    const rsbuildReadyStart = performance.now();
+    const ctx = await runPipeline(options);
+    const rsbuild = await createRsbuildInstance(ctx);
+    logDoneTimed("Rsbuild ready", Math.round(performance.now() - rsbuildReadyStart));
+    const buildStart = performance.now();
+    const buildResult = await rsbuild.build();
+    logDoneTimed("Rsbuild build", Math.round(performance.now() - buildStart));
+    setOutputPrefixAddfox();
+    if (false !== ctx.config.zip) {
+        const zipPath = await zipDist(ctx.distPath, ctx.root, ctx.config.outDir, ctx.browser);
+        logDone("Zipped output to", zipPath);
+    }
+    const distDir = rsbuild.context?.distPath || ctx.distPath;
+    const distSize = getBuildOutputSize(buildResult) ?? getDistSizeSync(distDir);
+    if (distSize >= 0) logDoneWithValue("Extension size:", formatBytes(distSize));
+    if (resolved.open) {
+        const browserPathConfig = ctx.config.browserPath ?? {};
+        await launchBrowserOnly({
+            distPath: distDir,
+            browser: resolved.launch,
+            cache: resolved.cache,
+            chromePath: browserPathConfig.chrome,
+            chromiumPath: browserPathConfig.chromium,
+            edgePath: browserPathConfig.edge,
+            bravePath: browserPathConfig.brave,
+            vivaldiPath: browserPathConfig.vivaldi,
+            operaPath: browserPathConfig.opera,
+            santaPath: browserPathConfig.santa,
+            arcPath: browserPathConfig.arc,
+            yandexPath: browserPathConfig.yandex,
+            browserosPath: browserPathConfig.browseros,
+            customPath: browserPathConfig.custom,
+            firefoxPath: browserPathConfig.firefox
+        });
+    }
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv.includes("--help") || argv.includes("-h")) return void printHelp();
+    if (argv.includes("--version") || argv.includes("-v")) return void console.log(getVersion());
+    wrapAddfoxOutput();
+    setAddfoxLoggerRawWrites(getRawWrites());
+    common_log("Addfox " + getVersion() + " with " + PURPLE + "Rsbuild " + getRsbuildVersion(cli_root) + RESET);
+    const command = argv[0];
+    if ("test" === command) return void await runTest(cli_root, argv);
+    if (!hasConfigFile()) throw new AddfoxError({
+        code: ADDFOX_ERROR_CODES.CONFIG_NOT_FOUND,
+        message: "Addfox config file not found",
+        details: `No addfox.config.ts, addfox.config.js or addfox.config.mjs found under ${cli_root}`,
+        hint: "Run the command from project root or create addfox.config.ts / addfox.config.js"
+    });
+    process.env.NODE_ENV = "dev" === command ? "development" : "production";
+    if ("dev" === command) await runDev(cli_root, argv);
+    else await runBuild(cli_root, argv);
+}
+main().catch((e)=>{
+    error(formatError(e));
+    exitWithError(e);
+});
+
+//# sourceMappingURL=cli.js.map