@starpak/cli 0.0.0-stage → 1.0.5

package/lib/commands/cpc.js

@@ -0,0 +1,801 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.circuitBreakers = void 0;
+exports.runModuleWhitelistCheck = runModuleWhitelistCheck;
+exports.runSandboxWorker = runSandboxWorker;
+exports.isolatePlugin = isolatePlugin;
+exports.terminateSandbox = terminateSandbox;
+exports.isAvailable = isAvailable;
+exports.ensureAvailable = ensureAvailable;
+exports.initCPC = initCPC;
+exports.triggerCircuitBreaker = triggerCircuitBreaker;
+exports.restoreCircuitBreaker = restoreCircuitBreaker;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_1 = require("@starpak/config");
+const kleur_1 = __importDefault(require("kleur"));
+const firewall_1 = require("../cli/firewall");
+// ====== Plugin Check ======
+const BUILTIN_PACKAGES_DIR = (0, path_1.resolve)(process.cwd(), 'packages');
+const PLUGINS_DIR = (0, path_1.resolve)(process.cwd(), 'plugins');
+// ============================================================
+// 🛡️ MODULE WHITELIST — Authorized modules ONLY
+// Any package/plugin discovered at runtime MUST be present in
+// this list; otherwise CPC triggers a hard process exit so the
+// main framework refuses to start with untrusted code.
+// ============================================================
+const MODULE_WHITELIST = new Set([
+    // --- Core @starpak packages (monorepo internal) ---
+    '@starpak/util',
+    '@starpak/log',
+    '@starpak/config',
+    '@starpak/core',
+    '@starpak/loader',
+    '@starpak/cli',
+    '@starpak/node-b',
+    '@starpak/lang',
+    '@starpak/mods',
+    // --- Spak Package Manager ---
+    '@starpak/spm',
+    'spm',
+    'util',
+    'log',
+    'config',
+    'core',
+    'loader',
+    'cli',
+    'node-b',
+    'lang',
+    'mods',
+]);
+/**
+ * Run the whitelist validation step.
+ *
+ * Discovers every builtin package under /packages and every plugin
+ * under /plugins, then verifies each name appears in the hard-coded
+ * MODULE_WHITELIST above.
+ *
+ * If ANY unauthorized module is found:
+ *   1. log each offending name (未授权模块提示)
+ *   2. log a final violation summary
+ *   3. call process.exit(1) immediately so the framework cannot boot
+ *
+ * Returns silently when everything is authorized.
+ */
+function runModuleWhitelistCheck(failHard = true) {
+    console.log(kleur_1.default.cyan('\n  正在执行模块白名单检查...\n'));
+    const discovered = [];
+    // Collect builtin packages (scanned by /packages directory).
+    if ((0, fs_1.existsSync)(BUILTIN_PACKAGES_DIR)) {
+        const pkgs = (0, fs_1.readdirSync)(BUILTIN_PACKAGES_DIR).filter(d => (0, fs_1.statSync)((0, path_1.resolve)(BUILTIN_PACKAGES_DIR, d)).isDirectory());
+        for (const p of pkgs) {
+            discovered.push(p);
+            // Also add the @starpak/ scoped form so we accept directory name AND
+            // the full published package name convention in the whitelist.
+            discovered.push(`@starpak/${p}`);
+        }
+    }
+    // Collect plugins (scanned by /plugins directory).
+    if ((0, fs_1.existsSync)(PLUGINS_DIR)) {
+        const plugs = (0, fs_1.readdirSync)(PLUGINS_DIR).filter(d => (0, fs_1.statSync)((0, path_1.resolve)(PLUGINS_DIR, d)).isDirectory());
+        for (const p of plugs) {
+            discovered.push(p);
+            discovered.push(`@starpak/${p}`);
+        }
+    }
+    // Also honour any user-added extra modules declared in config via
+    // cpc.whitelist array, so users can self-approve without editing
+    // this source file. Fail silently if config loading errors.
+    let extraWhitelist = [];
+    try {
+        const cfg = (0, config_1.loadConfig)();
+        if (Array.isArray(cfg?.cpc?.whitelist))
+            extraWhitelist = cfg.cpc.whitelist;
+    }
+    catch { /* ignore */ }
+    const effectiveWhitelist = new Set([...MODULE_WHITELIST, ...extraWhitelist]);
+    const uniqueModules = [...new Set(discovered)];
+    const unauthorized = uniqueModules.filter(name => !effectiveWhitelist.has(name));
+    if (unauthorized.length > 0) {
+        for (const name of unauthorized) {
+            console.log(`  ${kleur_1.default.red('✗')} 未知模块不在白名单中: ${name}`);
+        }
+        console.log(kleur_1.default.red(`\n  CPC 白名单校验失败: 发现 ${unauthorized.length} 个未经授权的模块，为安全起见进程将立即退出。\n`));
+        if (failHard) {
+            // Deliberately crash the main framework process. Using exit(1)
+            // guarantees any caller (CLI serve, programmatic createApp, tests)
+            // observes a non-zero status and cannot continue.
+            process.exit(1);
+        }
+    }
+    else {
+        console.log(`  ${kleur_1.default.green('✓')} 模块白名单校验通过：${uniqueModules.length}/${uniqueModules.length} 个模块均为授权模块\n`);
+    }
+    return { unauthorized, total: uniqueModules.length };
+}
+function checkBuiltinPackage(name) {
+    const pkgDir = (0, path_1.resolve)(BUILTIN_PACKAGES_DIR, name);
+    const requiredDirs = ['src'];
+    const requiredFiles = ['package.json'];
+    if (!(0, fs_1.existsSync)(pkgDir)) {
+        return { name, valid: false, reason: '包目录未找到' };
+    }
+    for (const dir of requiredDirs) {
+        if (!(0, fs_1.existsSync)((0, path_1.resolve)(pkgDir, dir))) {
+            return { name, valid: false, reason: `缺失目录: ${dir}` };
+        }
+    }
+    for (const file of requiredFiles) {
+        if (!(0, fs_1.existsSync)((0, path_1.resolve)(pkgDir, file))) {
+            return { name, valid: false, reason: `缺失文件: ${file}` };
+        }
+    }
+    return { name, valid: true };
+}
+function checkPlugin(name) {
+    const pluginDir = (0, path_1.resolve)(PLUGINS_DIR, name);
+    if (!(0, fs_1.existsSync)(pluginDir)) {
+        return { name, valid: false, reason: '插件目录未找到' };
+    }
+    const pkgPath = (0, path_1.resolve)(pluginDir, 'package.json');
+    if (!(0, fs_1.existsSync)(pkgPath)) {
+        return { name, valid: false, reason: '未找到 package.json' };
+    }
+    let pkg;
+    try {
+        pkg = JSON.parse((0, fs_1.readFileSync)(pkgPath, 'utf-8'));
+    }
+    catch {
+        return { name, valid: false, reason: '无效的 package.json' };
+    }
+    // Check main entry
+    if (pkg.main && !(0, fs_1.existsSync)((0, path_1.resolve)(pluginDir, pkg.main))) {
+        return { name, valid: false, reason: `主入口未找到: ${pkg.main}` };
+    }
+    // Check dependencies (warn if missing)
+    if (pkg.dependencies) {
+        const missingDeps = [];
+        for (const dep of Object.keys(pkg.dependencies)) {
+            const depPath = (0, path_1.resolve)(process.cwd(), 'node_modules', dep);
+            if (!(0, fs_1.existsSync)(depPath) && !dep.startsWith('@starpak/')) {
+                missingDeps.push(dep);
+            }
+        }
+        if (missingDeps.length > 0) {
+            return { name, valid: false, reason: `缺失依赖: ${missingDeps.join(', ')}` };
+        }
+    }
+    return { name, valid: true };
+}
+function runPluginCheck() {
+    // Step 0 — Module whitelist validation. If this fails, process.exit(1)
+    // is triggered inside runModuleWhitelistCheck itself; we never reach the
+    // rest of runPluginCheck.
+    runModuleWhitelistCheck(true);
+    console.log(kleur_1.default.cyan('\n  正在检查插件和包...\n'));
+    // Check built-in packages
+    const builtinPackages = (0, fs_1.readdirSync)(BUILTIN_PACKAGES_DIR).filter(d => {
+        return (0, fs_1.statSync)((0, path_1.resolve)(BUILTIN_PACKAGES_DIR, d)).isDirectory();
+    });
+    let validCount = 0;
+    let totalCount = 0;
+    for (const pkg of builtinPackages) {
+        totalCount++;
+        const result = checkBuiltinPackage(pkg);
+        if (result.valid) {
+            validCount++;
+            console.log(`  ${kleur_1.default.green('✓')} ${kleur_1.default.bold(pkg)}: ${result.reason || '正常'}`);
+        }
+        else {
+            console.log(`  ${kleur_1.default.red('✗')} ${kleur_1.default.bold(pkg)}: ${result.reason}`);
+        }
+    }
+    // Check external plugins
+    if ((0, fs_1.existsSync)(PLUGINS_DIR)) {
+        const plugins = (0, fs_1.readdirSync)(PLUGINS_DIR).filter(d => {
+            return (0, fs_1.statSync)((0, path_1.resolve)(PLUGINS_DIR, d)).isDirectory();
+        });
+        for (const plugin of plugins) {
+            totalCount++;
+            const result = checkPlugin(plugin);
+            if (result.valid) {
+                validCount++;
+                console.log(`  ${kleur_1.default.green('✓')} ${kleur_1.default.bold(plugin)}: 正常`);
+            }
+            else {
+                console.log(`  ${kleur_1.default.red('✗')} ${kleur_1.default.bold(plugin)}: ${result.reason}`);
+            }
+        }
+    }
+    console.log(`\n  ${validCount}/${totalCount} 项检查通过\n`);
+}
+// ====== Sandbox ======
+const sandboxProcesses = new Map();
+/**
+ * Sandbox worker 主进程内运行入口（SEA 二进制标记分支）。
+ *
+ * 封闭二进制里 spawn 子进程用「自 re-exec」：
+ *   spawn(process.execPath, ['--spak-sandbox', name])
+ * 主 bundle 启动时检测到该标记，直接执行本函数（内嵌代码）；
+ * 防火墙来自同包模块引用，无需 cwd 的 node_modules ——
+ * 与非 SEA 场景的 `node -e` 字符串脚本行为等价。
+ */
+function runSandboxWorker(name) {
+    const pluginName = name || '';
+    const path = require('path');
+    const fs = require('fs');
+    const { createRequire } = require('module');
+    // 1) 安装防火墙规则（env 继承则直接应用；否则默认 fail-closed）
+    try {
+        if (typeof firewall_1.applyFirewallFromEnv === 'function')
+            (0, firewall_1.applyFirewallFromEnv)();
+        if (typeof firewall_1.installFirewall === 'function' && !process.env.SPAK_FIREWALL_RULES)
+            (0, firewall_1.installFirewall)();
+    }
+    catch (e) {
+        if (process.env.SPAK_DEBUG)
+            console.debug('[sandbox] firewall:', String(e?.message || e));
+    }
+    // 2) 真实入口 loading（smoke）：plugins/<name> 存在则装载
+    try {
+        const req = createRequire(path.resolve(process.cwd(), 'package.json'));
+        let entry = null;
+        const pkgPath = path.resolve(process.cwd(), 'plugins', pluginName, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+                entry = pkg.main ? path.resolve(process.cwd(), 'plugins', pluginName, pkg.main) : null;
+            }
+            catch { }
+        }
+        if (!entry) {
+            const mPath = path.resolve(process.cwd(), 'plugins', pluginName, 'spak.manifest.json');
+            if (fs.existsSync(mPath)) {
+                try {
+                    const m = JSON.parse(fs.readFileSync(mPath, 'utf8'));
+                    entry = m.master ? path.resolve(process.cwd(), 'plugins', pluginName, m.master) : null;
+                }
+                catch { }
+            }
+        }
+        if (entry && fs.existsSync(entry)) {
+            req(entry);
+            console.log('[sandbox] entry-loaded: ' + entry);
+        }
+        else {
+            try {
+                req.resolve(pluginName);
+                console.log('[sandbox] plugin-resolved: ' + pluginName);
+            }
+            catch { }
+        }
+    }
+    catch (err) {
+        if (process.env.SPAK_DEBUG)
+            console.debug('[sandbox] entry load guard:', err?.message ?? String(err));
+    }
+    // 3) RSS 自守卫：超预算上报父进程触发熔断
+    const limitMB = Number(process.env.SPAK_SANDBOX_MEM_MB) || 512;
+    const guard = setInterval(() => {
+        const rssMB = process.memoryUsage().rss / 1024 / 1024;
+        if (rssMB > limitMB && process.send) {
+            process.send({ type: 'overbudget', plugin: pluginName, rss: Math.round(rssMB) });
+        }
+    }, 5000);
+    if (guard.unref)
+        guard.unref();
+    console.log('[sandbox] plugin "' + pluginName + '" started');
+    if (process.send) {
+        process.send({ type: 'ready', plugin: pluginName, pid: process.pid });
+        process.on('message', (msg) => {
+            if (msg && msg.type === 'shutdown')
+                process.exit(0);
+        });
+    }
+    process.stdin.resume();
+}
+function isolatePlugin(name) {
+    if (process.env.SPAK_NO_SANDBOX === '1') {
+        console.log(kleur_1.default.yellow('  ⚠ 沙箱已禁用 — 插件将在无隔离环境下运行 (不安全!)'));
+        return;
+    }
+    console.log(kleur_1.default.cyan(`  正在隔离插件: ${name}...`));
+    // Respect circuit breakers: if the plugin is in the open state, refuse to
+    // isolate it — same behaviour as the runtime loader should use.
+    if (circuitBreakers.get(name)) {
+        console.log(kleur_1.default.red(`${name} 熔断器已断开 — 隔离已中止`));
+        return;
+    }
+    // Sandbox memory cap: worker gets its own V8 heap limit so RSS can't
+    // grow unbounded — and reports back to trip the circuit breaker.
+    const memLimitMB = resolveMemoryLimitMB();
+    // Pass the plugin name via argv[3] so we never concatenate a user-controlled
+    // string into JS source code (prevents command injection via crafted names
+    // that escape the JSON string context).
+    const workerScript = `
+    // argv mapping for: node -e SCRIPT -- <name>  →  argv[1]=<name> ('--' consumed)
+    const pluginName = process.argv[1] || '';
+    const { createRequire } = require('module');
+    const path = require('path');
+    const fs = require('fs');
+
+    // 1) Install the same firewall rules as the parent (net-layer blocking).
+    //    If no rules are inherited, the sandbox still defaults to fail-closed.
+    try {
+      const req0 = createRequire(path.resolve(process.cwd(), 'package.json'));
+      const fw = req0('@starpak/cli/cli/firewall');
+      if (fw.applyFirewallFromEnv) fw.applyFirewallFromEnv();
+      if (fw.installFirewall && !process.env.SPAK_FIREWALL_RULES) fw.installFirewall();
+    } catch (e) { if (process.env.SPAK_DEBUG) console.debug('[sandbox] firewall:', String((e)?.message || e)); }
+
+    // 2) Real plugin entry loading (smoke): resolve main from package.json,
+    //    fall back to spak.manifest.json master, then require it.
+    try {
+      const req = createRequire(path.resolve(process.cwd(), 'package.json'));
+      let entry = null;
+      const pkgPath = path.resolve(process.cwd(), 'plugins', pluginName, 'package.json');
+      if (fs.existsSync(pkgPath)) {
+        try { const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8')); entry = pkg.main ? path.resolve(process.cwd(), 'plugins', pluginName, pkg.main) : null; } catch {}
+      }
+      if (!entry) {
+        const mPath = path.resolve(process.cwd(), 'plugins', pluginName, 'spak.manifest.json');
+        if (fs.existsSync(mPath)) {
+          try { const m = JSON.parse(fs.readFileSync(mPath, 'utf8')); entry = m.master ? path.resolve(process.cwd(), 'plugins', pluginName, m.master) : null; } catch {}
+        }
+      }
+      if (entry && fs.existsSync(entry)) { req(entry); console.log('[sandbox] entry-loaded: ' + entry); }
+      else { try { req.resolve(pluginName); console.log('[sandbox] plugin-resolved: ' + pluginName); } catch {} }
+    } catch (err) {
+      if (process.env.SPAK_DEBUG) console.debug('[sandbox] entry load guard:', (err as any)?.message ?? String(err))
+    }
+
+    // 3) Self RSS guard: report over-budget to parent so the circuit breaker
+    //    opens and the parent can terminate us.
+    const limitMB = Number(process.env.SPAK_SANDBOX_MEM_MB) || ${memLimitMB};
+    const guard = setInterval(() => {
+      const rssMB = process.memoryUsage().rss / 1024 / 1024;
+      if (rssMB > limitMB && process.send) {
+        process.send({ type: 'overbudget', plugin: pluginName, rss: Math.round(rssMB) });
+      }
+    }, 5000);
+    if (guard.unref) guard.unref();
+
+    console.log('[sandbox] plugin "' + pluginName + '" started');
+    if (process.send) {
+      process.send({ type: 'ready', plugin: pluginName, pid: process.pid });
+      process.on('message', (msg) => {
+        if (msg && (msg as any).type === 'shutdown') process.exit(0);
+      });
+    }
+    process.stdin.resume();
+  `;
+    const isSea = (() => {
+        try {
+            const sea = require('node:sea');
+            return typeof sea.isSea === 'function' && sea.isSea();
+        }
+        catch {
+            return false;
+        }
+    })();
+    // SEA 二进制：自 re-exec 走内嵌 runSandboxWorker 分支；
+    // 普通 node 环境：保持原 `node -e` 字符串脚本行为。
+    const child = isSea
+        ? (0, child_process_1.spawn)(process.execPath, ['--spak-sandbox', name], {
+            stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
+            detached: true,
+            env: {
+                ...process.env,
+                NODE_OPTIONS: `${process.env.NODE_OPTIONS || ''} --max-old-space-size=${memLimitMB}`.trim(),
+                SPAK_FIREWALL_RULES: JSON.stringify((0, firewall_1.getFirewallRules)()),
+                SPAK_SANDBOX_MEM_MB: String(memLimitMB),
+            },
+        })
+        : (0, child_process_1.spawn)(process.execPath, ['-e', workerScript, '--', name], {
+            stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
+            detached: true,
+            env: {
+                ...process.env,
+                // V8 heap cap via NODE_OPTIONS (spawn has no execArgv; NODE_OPTIONS is
+                // honoured by node children and limits sandbox RSS growth).
+                NODE_OPTIONS: `${process.env.NODE_OPTIONS || ''} --max-old-space-size=${memLimitMB}`.trim(),
+                SPAK_FIREWALL_RULES: JSON.stringify((0, firewall_1.getFirewallRules)()),
+                SPAK_SANDBOX_MEM_MB: String(memLimitMB),
+            },
+        });
+    // Prevent accidental memory leaks from pending IPC buffers — we don't
+    // forward raw stdio to the user's terminal (they are ignored above) but
+    // we still want lifecycle notifications.
+    child.on('error', (err) => {
+        console.warn(kleur_1.default.yellow(`[沙箱] ${name} 错误: ${String(err.message)}`));
+    });
+    // Wire the sandbox into the circuit breaker: over-budget workers trip
+    // their breaker and get terminated.
+    child.on('message', (msg) => {
+        const m = msg;
+        if (m && m.type === 'overbudget') {
+            console.warn(kleur_1.default.red(`[沙箱] ${name} 内存超限 (${String(m.rss)}MB)，触发熔断并终止!`));
+            if (!circuitBreakers.get(name))
+                triggerCircuitBreaker(name);
+            terminateSandbox(name);
+        }
+    });
+    child.on('exit', (code) => {
+        sandboxProcesses.delete(name);
+    });
+    sandboxProcesses.set(name, child);
+    console.log(kleur_1.default.green(`  插件 ${name} 已隔离 (pid=${child.pid ?? -1})\n`)
+        + kleur_1.default.dim(`    沙箱内存上限: ${memLimitMB}MB`));
+}
+function terminateSandbox(name) {
+    const proc = sandboxProcesses.get(name);
+    if (proc && proc.connected) {
+        try {
+            proc.send({ type: 'shutdown' });
+        }
+        catch { /* IPC already closed */ }
+        // Fallback kill if graceful shutdown didn't happen within 500ms
+        const killTimer = setTimeout(() => {
+            if (proc.pid)
+                try {
+                    process.kill(proc.pid, 'SIGKILL');
+                }
+                catch { }
+        }, 500);
+        if (killTimer.unref)
+            killTimer.unref();
+    }
+    else if (proc && proc.pid) {
+        try {
+            process.kill(proc.pid);
+        }
+        catch { }
+    }
+    if (proc) {
+        const pid = proc.pid;
+        sandboxProcesses.delete(name);
+        console.log(kleur_1.default.yellow(`  沙箱已终止 (pid=${pid ?? -1})`));
+    }
+}
+// ====== SSetPS - Safety Set Protection System ======
+let ssetpsInterval = null;
+const DEFAULT_MEMORY_LIMIT_MB = 512;
+let currentMemoryLimitMB = DEFAULT_MEMORY_LIMIT_MB;
+const circuitBreakers = new Map();
+exports.circuitBreakers = circuitBreakers;
+let gcHintShown = false;
+/**
+ * Resolve the effective SSetPS memory limit (MB). Precedence:
+ *   1. SPAK_SSETPS_MEMORY_LIMIT_MB env var (highest, deploy-time override)
+ *   2. config.cpc.ssetps.memoryLimitMB (from user config)
+ *   3. DEFAULT_MEMORY_LIMIT_MB = 512 (fallback, historic hard-coded value)
+ */
+function resolveMemoryLimitMB(userLimit) {
+    const envVal = Number(process.env.SPAK_SSETPS_MEMORY_LIMIT_MB);
+    if (Number.isFinite(envVal) && envVal > 0)
+        return Math.floor(envVal);
+    if (Number.isFinite(userLimit) && userLimit > 0)
+        return Math.floor(userLimit);
+    return DEFAULT_MEMORY_LIMIT_MB;
+}
+function startSSetPS(overrideLimitMB) {
+    if (ssetpsInterval)
+        return;
+    currentMemoryLimitMB = resolveMemoryLimitMB(overrideLimitMB);
+    console.log(kleur_1.default.cyan(`  SSetPS 监控已启动 ${kleur_1.default.dim(`(limit=${currentMemoryLimitMB}MB)`)}`));
+    // Check if global.gc is available (--expose-gc flag required)
+    if (typeof global.gc !== 'function' && !gcHintShown) {
+        gcHintShown = true;
+        console.log(kleur_1.default.yellow('  提示: 使用 NODE_OPTIONS="--expose-gc" 启动可让 SSetPS 在内存过高时强制 GC'));
+    }
+    ssetpsInterval = setInterval(() => {
+        const memUsage = process.memoryUsage();
+        const rssMB = memUsage.rss / 1024 / 1024;
+        const limitMB = currentMemoryLimitMB;
+        const usagePercent = (rssMB / limitMB) * 100;
+        if (usagePercent > 80) {
+            console.log(kleur_1.default.yellow(`  内存使用率 ${usagePercent.toFixed(1)}% ${kleur_1.default.dim(`[rss=${rssMB.toFixed(0)}/${limitMB}MB]`)}`));
+            // Check if global.gc is available (--expose-gc flag required)
+            if (typeof global.gc === 'function') {
+                const before = process.memoryUsage().rss;
+                global.gc();
+                const after = process.memoryUsage().rss;
+                const freed = (before - after) / 1024 / 1024;
+                if (freed > 0) {
+                    console.log(kleur_1.default.green(`  GC 释放了 ${freed.toFixed(1)}MB`));
+                }
+            }
+            // Tripping the 80% threshold for a sandboxed plugin auto-trips its
+            // circuit breaker. This finally wires `circuitBreakers` into the
+            // rest of the CPC system (isolation, status and restore commands
+            // already reference the same Map).
+            for (const name of sandboxProcesses.keys()) {
+                if (!circuitBreakers.get(name))
+                    triggerCircuitBreaker(name);
+            }
+        }
+    }, 10000);
+}
+function stopSSetPS() {
+    if (ssetpsInterval) {
+        clearInterval(ssetpsInterval);
+        ssetpsInterval = null;
+    }
+}
+function triggerCircuitBreaker(pluginName) {
+    circuitBreakers.set(pluginName, true);
+    console.log(kleur_1.default.red(`  已为 ${pluginName} 触发熔断器`));
+    console.log(kleur_1.default.red(`  ${pluginName} 熔断器已断开`));
+}
+function restoreCircuitBreaker(pluginName) {
+    circuitBreakers.delete(pluginName);
+    console.log(kleur_1.default.green(`  ${pluginName} 熔断器已恢复`));
+}
+/**
+ * Apply a firewall rule to control network access.
+ * Rules are in the format: 'action: target' where action is 'allow' or 'deny'
+ * and target can be 'localhost', 'external', or a specific host/IP[:port].
+ *
+ * Real implementation: the rule is registered into the net-layer firewall
+ * engine (cli/firewall.ts) which patches Socket.connect — so http/https/net
+ * outbound calls are actually blocked, not just logged.
+ */
+function applyFirewallRule(rule, notify = true) {
+    const result = (0, firewall_1.addFirewallRule)(rule);
+    if (!result.ok) {
+        console.log(kleur_1.default.yellow(`  ⚠ 无效的防火墙规则: ${rule}`));
+        return;
+    }
+    if (notify) {
+        console.log(kleur_1.default.cyan(`  防火墙规则: ${rule}  ${kleur_1.default.green('✓')}`));
+    }
+}
+// ====== Test Suite ======
+function runTestServe(url) {
+    console.log(kleur_1.default.cyan('\n  正在启动测试服务器...'));
+    console.log(kleur_1.default.green(`  测试服务器运行在 ${url}`));
+    process.env.DEBUG = '*';
+    process.env.SPAK_LOG_LEVEL = '3';
+    console.log(`  ${kleur_1.default.cyan('[DEBUG]')} 调试模式已启用`);
+    console.log(`  ${kleur_1.default.cyan('[DEBUG]')} 日志级别: verbose`);
+    console.log(`  ${kleur_1.default.cyan('[DEBUG]')} 环境: test`);
+}
+// ====== Export ======
+function isAvailable() {
+    try {
+        const config = (0, config_1.loadConfig)();
+        return config.cpc?.enabled === true;
+    }
+    catch {
+        return false;
+    }
+}
+function ensureAvailable() {
+    if (!isAvailable()) {
+        console.log(kleur_1.default.red(`\n  CPC 未启用。请在配置中设置 'cpc.enabled: true'\n`));
+        process.exit(1);
+    }
+}
+// Main CPC initialization
+function initCPC(config) {
+    if (!config?.enabled)
+        return;
+    console.log(kleur_1.default.cyan('\n  插件安全检查 (CPC)\n'));
+    if (process.env.SPAK_NO_SANDBOX === '1') {
+        console.log(kleur_1.default.yellow('  ⚠ 沙箱已禁用 — 插件将在无隔离环境下运行 (不安全!)'));
+    }
+    else if (config.sandbox?.enabled) {
+        console.log(`  ${kleur_1.default.green('✓')} 沙箱已启用`);
+    }
+    if (config.processIsolation?.enabled) {
+        console.log(`  ${kleur_1.default.green('✓')} 进程隔离已启用`);
+    }
+    if (config.ssetps?.enabled !== false) {
+        // Wire the user's configured memory limit through (env overrides still
+        // win inside startSSetPS via resolveMemoryLimitMB).
+        startSSetPS(config.ssetps?.memoryLimitMB);
+        // Install the actual net-layer firewall (was a logging stub). Default
+        // policy: allow loopback, deny everything external (fail-closed).
+        (0, firewall_1.installFirewall)();
+        for (const r of (0, firewall_1.getFirewallRules)()) {
+            console.log(kleur_1.default.cyan(`  防火墙已生效: ${r.action}: ${r.target}`));
+        }
+    }
+    runPluginCheck();
+}
+function testAction(args, options) {
+    // Extract subcommand from argv (e.g. "test serve" → "serve")
+    const testIdx = process.argv.indexOf('test');
+    const sub = testIdx >= 0 ? process.argv.slice(testIdx + 1).filter(a => !a.startsWith('-'))[0] || '' : '';
+    if (sub === 'serve') {
+        const host = options.host || '0.0.0.0';
+        const port = options.port || '4321';
+        runTestServe(`http://${host}:${port}`);
+        return;
+    }
+    console.log(kleur_1.default.cyan('\n  正在运行 CPC 测试...\n'));
+    runPluginCheck();
+    console.log(`  ${kleur_1.default.green('✓')} 0/0 项测试通过\n`);
+}
+function cpcAction(args, options) {
+    ensureAvailable();
+    const sub = args.command || '';
+    const arg1 = args.name || '';
+    const action = args.action || '';
+    if (!sub || sub === 'help') {
+        console.log(`CPC 命令:
+  spak cpc check          检查所有插件和包
+  spak cpc sandbox <名称> 在沙箱中隔离插件
+  spak cpc sandbox stop <名称> 停止沙箱中的插件
+  spak cpc ssetps         启动 SSetPS 监控
+  spak cpc circuit <名称> 触发熔断器
+  spak cpc circuit restore <名称> 恢复熔断器
+  spak cpc status         显示 CPC 状态`);
+        return;
+    }
+    switch (sub) {
+        case 'check':
+            runPluginCheck();
+            break;
+        case 'sandbox':
+            if (arg1 === 'stop') {
+                if (!action) {
+                    console.log(kleur_1.default.red('用法: spak cpc sandbox stop <名称>'));
+                    return;
+                }
+                terminateSandbox(action);
+            }
+            else {
+                if (!arg1) {
+                    console.log(kleur_1.default.red('用法: spak cpc sandbox <名称>'));
+                    return;
+                }
+                isolatePlugin(arg1);
+            }
+            break;
+        case 'ssetps': {
+            // CLI one-shot snapshot mode: print the current memory state and exit.
+            // Long-running monitoring is owned by `serve` (via initCPC → startSSetPS),
+            // so a standalone `cpc ssetps` must NOT leave a setInterval keeping the
+            // process alive — otherwise the CLI hangs forever after printing.
+            const ssetpsCfg = (() => { try {
+                return (0, config_1.loadConfig)();
+            }
+            catch {
+                return undefined;
+            } })();
+            const limit = resolveMemoryLimitMB(ssetpsCfg?.cpc?.ssetps?.memoryLimitMB);
+            const usedNum = process.memoryUsage().rss / 1024 / 1024;
+            const used = usedNum.toFixed(1);
+            const usagePercent = (usedNum / limit) * 100;
+            console.log(kleur_1.default.cyan(`  SSetPS 监控已启动 ${kleur_1.default.dim(`(limit=${limit}MB)`)}`));
+            console.log(`  ${used} / ${limit}MB (阈值 80%)`);
+            if (usagePercent > 80) {
+                console.log(kleur_1.default.yellow(`  内存使用率 ${usagePercent.toFixed(1)}%`));
+            }
+            else {
+                console.log(kleur_1.default.green(`  内存健康 (${usagePercent.toFixed(1)}%)`));
+            }
+            break;
+        }
+        case 'circuit':
+            if (arg1 === 'restore') {
+                if (!action) {
+                    console.log(kleur_1.default.red('用法: spak cpc circuit restore <名称>'));
+                    return;
+                }
+                restoreCircuitBreaker(action);
+            }
+            else {
+                if (!arg1) {
+                    console.log(kleur_1.default.red('用法: spak cpc circuit <名称>'));
+                    return;
+                }
+                triggerCircuitBreaker(arg1);
+            }
+            break;
+        case 'status': {
+            // Reflect the effective memory limit (env > config > default) even when
+            // SSetPS hasn't been started, so `cpc status` never shows a stale 512MB.
+            const statusCfg = (() => { try {
+                return (0, config_1.loadConfig)();
+            }
+            catch {
+                return undefined;
+            } })();
+            const effectiveLimit = resolveMemoryLimitMB(statusCfg?.cpc?.ssetps?.memoryLimitMB);
+            console.log(kleur_1.default.cyan('\n  插件安全检查 (CPC)'));
+            console.log(`  ${kleur_1.default.bold('沙箱:')} ${sandboxProcesses.size}`);
+            console.log(`  ${kleur_1.default.bold('熔断器:')} ${circuitBreakers.size}`);
+            console.log(`  ${kleur_1.default.bold('SSetPS:')} ${ssetpsInterval ? '活跃' : '未活跃'}`);
+            console.log(`  ${kleur_1.default.bold('内存:')} ${(process.memoryUsage().rss / 1024 / 1024).toFixed(1)} / ${effectiveLimit}MB (阈值 80%)\n`);
+            break;
+        }
+        default:
+            console.log(kleur_1.default.red(`未知命令: ${sub}`));
+    }
+}
+const cpcDeclarations = [
+    {
+        command: 'test',
+        description: '运行 CPC 测试套件',
+        action: testAction,
+    },
+    {
+        command: 'cpc',
+        description: '插件安全检查 (CPC) 命令',
+        args: [
+            { name: 'command', description: '子命令: check, sandbox, ssetps, circuit, status', required: false },
+            { name: 'name', description: '插件名参数', required: false },
+            { name: 'action', description: '子操作参数', required: false },
+        ],
+        action: cpcAction,
+    },
+    {
+        command: 'cpc check',
+        description: '检查所有插件和内置包',
+        action: () => { ensureAvailable(); runPluginCheck(); },
+    },
+    {
+        command: 'cpc sandbox',
+        description: '在沙箱中隔离插件',
+        args: [{ name: 'name', description: '插件名', required: true }],
+        action: (args) => {
+            ensureAvailable();
+            if (!args.name) {
+                console.log(kleur_1.default.red('用法: spak cpc sandbox <名称>'));
+                return;
+            }
+            // Handle "sandbox stop <name>" form
+            if (args.name === 'stop') {
+                const stopName = process.argv[process.argv.indexOf('stop') + 1] || '';
+                if (!stopName) {
+                    console.log(kleur_1.default.red('用法: spak cpc sandbox stop <名称>'));
+                    return;
+                }
+                terminateSandbox(stopName);
+                return;
+            }
+            isolatePlugin(args.name);
+        },
+    },
+    {
+        command: 'cpc ssetps',
+        description: '启动 SSetPS 监控 (memoryLimitMB 来自配置或 SPAK_SSETPS_MEMORY_LIMIT_MB 环境变量)',
+        action: () => { ensureAvailable(); cpcAction({ command: 'ssetps', name: '', action: '' }, {}); },
+    },
+    {
+        command: 'cpc circuit',
+        description: '为插件触发熔断器',
+        args: [{ name: 'name', description: '插件名', required: true }],
+        action: (args) => {
+            ensureAvailable();
+            if (!args.name) {
+                console.log(kleur_1.default.red('用法: spak cpc circuit <名称>'));
+                return;
+            }
+            // Handle "circuit restore <name>" form
+            if (args.name === 'restore') {
+                const restoreName = process.argv[process.argv.indexOf('restore') + 1] || '';
+                if (!restoreName) {
+                    console.log(kleur_1.default.red('用法: spak cpc circuit restore <名称>'));
+                    return;
+                }
+                restoreCircuitBreaker(restoreName);
+                return;
+            }
+            triggerCircuitBreaker(args.name);
+        },
+    },
+    {
+        command: 'cpc status',
+        description: '显示 CPC 状态',
+        action: () => { ensureAvailable(); cpcAction({ command: 'status', name: '', action: '' }, {}); },
+    },
+];
+exports.default = cpcDeclarations;
+//# sourceMappingURL=cpc.js.map