whistle.easy-proxy 1.0.0 → 1.2.0

package/README.md

@@ -61,6 +61,7 @@ open http://local.whistlejs.com/plugin.easy-proxy/
 | `easy-proxy accel dns` | 刷新 DNS 缓存 |
 | `easy-proxy host add <域名> <IP>` | 添加手动 IP 覆盖 |
 | `easy-proxy health` | 综合健康检查 |
+| `easy-proxy mirror` | 开发镜像源加速（npm/pip/go，302 重定向到国内镜像） |
 | `easy-proxy status` | 查看整体状态 |
 
 **完整命令参考** → [docs/cli.md](docs/cli.md)
@@ -136,7 +137,7 @@ TCP 隧道 → IP 直连 + TLS 握手
 |------|---------|
 | GitHub 无法访问 | `easy-proxy start --init && easy-proxy accel on && easy-proxy proxy on` |
 | 访问速度慢 | `easy-proxy accel dns` 刷新缓存，或在 Web 面板测速选 IP |
-| 证书不受信任 | `easy-proxy cert install` 重新安装根证书 |
+| 证书不受信任 | `easy-proxy start` 重新安装根证书 |
 
 **完整故障排查** → [docs/troubleshooting.md](docs/troubleshooting.md)
 

package/lib/cert-check.js

@@ -5,7 +5,7 @@
  * whistle 证书路径: ~/.WhistleAppData/.whistle/certs/root.crt
  * macOS 信任检查: security find-certificate
  * Windows 信任检查: certutil
- * 有效期解析: 优先用 openssl（macOS 内置），回退到 node-forge
+ * 有效期解析: openssl（macOS/Linux 内置），Windows 用 certifi 的 CA 包
  */
 
 const fs = require('node:fs');
@@ -63,50 +63,102 @@ function parseCertWithOpenssl(certPath) {
 }
 
 /**
- * 用 node-forge 解析证书有效期（回退方案）
+ * 用 openssl 解析证书扩展，检查 whistle 根证书是否符合 Python 3.13+/OpenSSL 3
+ * 的严格校验要求。老版 whistle 生成的根证书有三个已知缺陷，浏览器不报错但
+ * Python 会拒收：1. Basic Constraints 未标 critical  2. 缺 Subject Key Identifier
+ * 3. 缺 Authority Key Identifier
  * @param {string} certPath
- * @returns {{notBefore: Date, notAfter: Date, subject: string}|null}
+ * @returns {string[]|null} 缺陷列表，null 表示无法解析
  */
-function parseCertWithForge(certPath) {
+function checkCertCompliance(certPath) {
   try {
-    var forge = require('node-forge');
-    var pem = fs.readFileSync(certPath, 'utf-8');
-    var cert = forge.pki.certificateFromPem(pem);
-    var cn = cert.subject.attributes.find((a) => a.name === 'commonName');
-    return {
-      subject: cn ? cn.value : '',
-      notBefore: cert.validity.notBefore,
-      notAfter: cert.validity.notAfter,
-    };
+    var text = execSync(`openssl x509 -in "${certPath}" -noout -text`, {
+      encoding: 'utf-8',
+    });
+    var issues = [];
+    if (!/Basic Constraints:\s*critical/.test(text)) {
+      issues.push(
+        /Basic Constraints/.test(text) ? 'Basic Constraints 未标 critical' : '缺 Basic Constraints'
+      );
+    }
+    if (!/Subject Key Identifier/.test(text)) issues.push('缺 Subject Key Identifier');
+    if (!/Authority Key Identifier/.test(text)) issues.push('缺 Authority Key Identifier');
+    return issues;
   } catch (_e) {
     return null;
   }
 }
 
+/**
+ * 用原私钥重签根证书，补齐严格校验所需的扩展（key 不变，叶子证书链依然有效）。
+ * whistle（含 2.10.10）生成的根证书有三个已知缺陷：Basic Constraints 未标
+ * critical、缺 SKI、缺 AKI，Python 3.13+ 等严格校验的应用会拒收。
+ * @param {string} certPath - whistle 根证书路径（须有同名 root.key）
+ * @returns {boolean}
+ */
+function fixCertCompliance(certPath) {
+  try {
+    var forge = require('node-forge');
+    var cert = forge.pki.certificateFromPem(fs.readFileSync(certPath, 'utf-8'));
+    var keyPath = path.join(path.dirname(certPath), 'root.key');
+    var key = forge.pki.privateKeyFromPem(fs.readFileSync(keyPath, 'utf-8'));
+    // pem 解析出的私钥可能不带 publicKey 属性，从 n/e 重建
+    var pk = key.publicKey || forge.pki.rsa.setPublicKey(key.n, key.e);
+    var ski = forge.pki.getPublicKeyFingerprint(pk, {
+      type: 'SubjectPublicKeyInfo',
+      md: forge.md.sha256.create(),
+      encoding: 'binary',
+    });
+    cert.setExtensions([
+      { name: 'basicConstraints', cA: true, critical: true },
+      {
+        name: 'keyUsage',
+        keyCertSign: true,
+        digitalSignature: true,
+        nonRepudiation: true,
+        keyEncipherment: true,
+        dataEncipherment: true,
+        critical: true,
+      },
+      { name: 'subjectKeyIdentifier', subjectKeyIdentifier: ski },
+      // 自签名 CA：authorityKeyIdentifier 与 subjectKeyIdentifier 相同
+      { name: 'authorityKeyIdentifier', authorityKeyIdentifier: ski },
+    ]);
+    cert.sign(key, forge.md.sha256.create());
+    fs.writeFileSync(certPath, forge.pki.certificateToPem(cert));
+    // 不删合并 CA 包：重签后 root.crt 的 mtime 更新，ensureMergedCaBundle 的
+    // staleness 检查会自动重建（直接 unlink 会让环境变量悬空指向不存在的文件）
+    return true;
+  } catch (_e) {
+    return false;
+  }
+}
+
 /**
  * 检查证书是否已安装到系统信任库
- * @param {string} subject - 证书 CN（用于搜索）
+ * @param {string} subject - openssl 输出的 subject 行（如 "subject= /CN=whistle.xxx/..."）
+ * @param {string} certPath - 证书文件路径（macOS 用于精确信任校验）
  * @returns {boolean}
  */
-function checkTrusted(subject) {
+function checkTrusted(subject, certPath) {
   if (IS_MACOS) {
-    // 检查 login keychain 和 system keychain
-    try {
-      var keyword = subject ? subject.split('.')[0] : 'whistle';
-      execSync(`security find-certificate -c "${keyword}" 2>/dev/null`, { encoding: 'utf-8' });
-      return true;
-    } catch (_e) {
-      // 在 login keychain 中未找到，检查 system keychain
+    // 精确校验：verify-cert 走真实信任链评估（存在但未被信任也会返回 false）
+    if (certPath) {
       try {
-        execSync(
-          'security find-certificate -c "whistle" /Library/Keychains/System.keychain 2>/dev/null',
-          { encoding: 'utf-8' }
-        );
+        execSync(`security verify-cert -c "${certPath}" 2>&1`, { encoding: 'utf-8' });
         return true;
-      } catch (_e2) {
+      } catch (_e) {
         return false;
       }
     }
+    // 回退：按 CN 搜索 keychain
+    try {
+      var cn = (subject.match(/CN=([^/]+)/) || [])[1] || 'whistle';
+      execSync(`security find-certificate -c "${cn}" 2>/dev/null`, { encoding: 'utf-8' });
+      return true;
+    } catch (_e) {
+      return false;
+    }
   }
   if (IS_WINDOWS) {
     try {
@@ -119,6 +171,131 @@ function checkTrusted(subject) {
   return false;
 }
 
+// 项目配置目录：~/.easy-proxy/（合并 CA 文件等）
+const EASY_PROXY_DIR = path.join(HOME, '.easy-proxy');
+const MERGED_CA_PATH = path.join(EASY_PROXY_DIR, 'cert', 'ca-bundle.pem');
+
+/**
+ * 生成合并 CA 文件（系统 CA + whistle 根证书），供 Python/Node 等不走系统
+ * 信任库的应用使用。源文件比合并文件新（系统 CA 更新 / whistle 证书重签）
+ * 则重建。已导出的环境变量指向固定路径，文件重建后依然有效。
+ * @param {string} certPath - whistle 根证书路径
+ * @returns {string|null} 合并文件路径，失败返回 null
+ */
+function ensureMergedCaBundle(certPath) {
+  var merged = MERGED_CA_PATH;
+  try {
+    var sources = [certPath];
+    if (IS_MACOS) {
+      // /etc/ssl/cert.pem 是系统自带的 CA 包，直接复用
+      sources.push('/etc/ssl/cert.pem');
+    } else if (IS_WINDOWS) {
+      // certifi 的 CA 包（requests/httpx 都带 certifi）
+      sources.push(
+        execSync('python -c "import certifi; print(certifi.where())"', {
+          encoding: 'utf-8',
+          windowsHide: true,
+        }).trim()
+      );
+    } else {
+      sources.push('/etc/ssl/certs/ca-certificates.crt');
+    }
+    // 任一源文件比合并文件新（系统 CA 更新 / whistle 证书重签）则重建
+    if (fs.existsSync(merged)) {
+      var mergedMtime = fs.statSync(merged).mtimeMs;
+      var stale = sources.some(function (src) {
+        try {
+          return fs.statSync(src).mtimeMs > mergedMtime;
+        } catch (_e) {
+          return true; // 源文件读不到，视为过期
+        }
+      });
+      if (!stale) return merged;
+    }
+    var base = fs.readFileSync(sources[1], 'utf-8');
+    // whistle 生成的 root.crt 是 CRLF 行尾，Node/NODE_EXTRA_CA_CERTS 加载器会拒收混入的 CRLF 证书
+    var whistlePem = fs.readFileSync(certPath, 'utf-8').replace(/\r/g, '');
+    fs.mkdirSync(path.dirname(merged), { recursive: true });
+    // 原子写：先写临时文件再 rename，避免写一半崩溃留下坏文件
+    var tmp = merged + '.tmp-' + process.pid;
+    fs.writeFileSync(tmp, base + '\n' + whistlePem);
+    fs.renameSync(tmp, merged);
+    return merged;
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * 提示 Python/Node 等不走系统信任库的应用所需的 CA 环境变量。
+ * whistle 根证书装进系统钥匙串后浏览器正常，但 Python（certifi）、Node（内置 CA）
+ * 不读系统信任库，仍会报证书异常，需设置环境变量指向合并 CA 文件。
+ */
+var APP_CA_VARS = [
+  ['REQUESTS_CA_BUNDLE', 'Python requests/httpx'],
+  ['SSL_CERT_FILE', 'Python 原生 ssl/urllib'],
+  ['NODE_EXTRA_CA_CERTS', 'Node.js'],
+];
+
+function printAppCaHints(certPath) {
+  var needs = APP_CA_VARS.filter(function (n) {
+    return !process.env[n[0]];
+  });
+  if (!needs.length) return;
+
+  var merged = ensureMergedCaBundle(certPath);
+  if (!merged) return;
+  console.log(
+    `${c.yellow}⚠ Python/Node 等不读系统信任库，需设置以下环境变量（建议写入 ~/.zshrc）：${c.reset}`
+  );
+  needs.forEach(function (n) {
+    console.log(`    export ${n[0]}=${merged}${c.gray}  # ${n[1]}${c.reset}`);
+  });
+}
+
+/**
+ * 将 Python/Node 所需的 CA 环境变量写入 ~/.zshrc（幂等）。
+ * 变量已存在且指向合并文件则跳过；指向其他路径则视为用户自行配置，仅提示不覆盖。
+ * @param {string} merged - 合并 CA 文件路径
+ * @returns {{added: string[], conflicts: string[]}|null} 新增与冲突的变量名，失败返回 null
+ */
+function writeShellExports(merged) {
+  if (IS_WINDOWS) return null;
+  var zshrc = path.join(HOME, '.zshrc');
+  try {
+    var content = fs.existsSync(zshrc) ? fs.readFileSync(zshrc, 'utf-8') : '';
+    var added = [];
+    var conflicts = [];
+    // 需要写入的变量 = zshrc 里还没定义的
+    APP_CA_VARS.forEach(function (n) {
+      var lineRe = new RegExp('^\\s*(export\\s+)?' + n[0] + '=', 'm');
+      if (!lineRe.test(content)) added.push(n);
+      else if (content.indexOf(n[0] + '=' + merged) === -1) conflicts.push(n[0]);
+    });
+    if (added.length) {
+      // 包一层 -f 检查：证书/合并文件被清理后，环境变量自动失效，不会指向不存在的文件
+      var block =
+        '\n# easy-proxy: whistle MITM CA（由 easy-proxy start 维护，证书缺失时自动跳过）\n' +
+        'if [ -f "' +
+        merged +
+        '" ]; then\n';
+      added.forEach(function (n) {
+        block += '  export ' + n[0] + '=' + merged + '  # ' + n[1] + '\n';
+      });
+      block += 'fi\n';
+      fs.appendFileSync(zshrc, block);
+    }
+    return {
+      added: added.map(function (n) {
+        return n[0];
+      }),
+      conflicts: conflicts,
+    };
+  } catch (_e) {
+    return null;
+  }
+}
+
 // ANSI 颜色（与 bin CLI 一致）
 var c = {
   reset: '\x1b[0m',
@@ -133,21 +310,42 @@ var c = {
 /**
  * 检查证书状态并输出
  * @param {boolean} [compact] - 紧凑模式（用于 health 命令，不输出标题）
+ * @param {boolean} [autoInstall] - 自动管理模式（start 用）：未信任时自动安装
  * @returns {Promise<void>}
  */
-async function checkCertStatus(compact) {
+async function checkCertStatus(compact, autoInstall) {
   var certPath = findCertFile();
   if (!certPath) {
     console.log(`${(compact ? '  ' : '') + c.red}✖${c.reset} 证书: 未找到（whistle 可能未启动过）`);
     if (!compact) {
       console.log(`${c.gray}    运行 easy-proxy start 启动 whistle（会自动生成证书）${c.reset}`);
-      console.log(`${c.gray}    然后运行 easy-proxy cert install 安装证书到系统信任库${c.reset}`);
+      console.log(`${c.gray}    然后运行 easy-proxy start 安装证书到系统信任库${c.reset}`);
     }
     return;
   }
 
+  // 合并 CA 文件可能被删除（证书更新/清理时），静默重建，
+  // 避免已导出的 REQUESTS_CA_BUNDLE 等环境变量指向不存在的文件
+  ensureMergedCaBundle(certPath);
+
+  // 合规校验（Python 3.13+/OpenSSL 3 会拒收不合规的 CA 证书），自动修复后重新解析
+  // 先修复合规性（重签会作废合并文件），合并文件在重签后下方重建
+  var issues = checkCertCompliance(certPath);
+  if (issues && issues.length) {
+    if (fixCertCompliance(certPath)) {
+      ensureMergedCaBundle(certPath);
+      if (!compact) {
+        console.log(`${c.yellow}🔧${c.reset} 证书: 已重签修复（${issues.join('、')}）`);
+      }
+    } else {
+      console.log(
+        `${(compact ? '  ' : '') + c.yellow}⚠${c.reset} 证书: 不合规（${issues.join('、')}），自动修复失败`
+      );
+    }
+  }
+
   // 解析有效期
-  var info = parseCertWithOpenssl(certPath) || parseCertWithForge(certPath);
+  var info = parseCertWithOpenssl(certPath);
   if (!info) {
     console.log(`${(compact ? '  ' : '') + c.yellow}⚠${c.reset} 证书: 已存在（无法解析有效期）`);
     console.log(`${c.gray}    路径: ${certPath}${c.reset}`);
@@ -156,9 +354,26 @@ async function checkCertStatus(compact) {
 
   var now = new Date();
   var daysLeft = Math.floor((info.notAfter.getTime() - now.getTime()) / (24 * 60 * 60 * 1000));
-  var trusted = checkTrusted(info.subject);
+  var trusted = checkTrusted(info.subject, certPath);
   var dateStr = info.notAfter.toISOString().slice(0, 10);
 
+  // 自动管理模式（start）：未信任则用 whistle 内置安装器装进系统信任库 + 写 zshrc 环境变量
+  if (autoInstall && !trusted) {
+    try {
+      var installRootCA = require('whistle/bin/ca');
+      installRootCA(certPath);
+      var merged = ensureMergedCaBundle(certPath);
+      if (merged && writeShellExports(merged)) {
+        console.log(`${c.green}✔${c.reset} 根证书已安装，CA 环境变量已写入 ~/.zshrc（新终端生效）`);
+      }
+      trusted = checkTrusted(info.subject, certPath);
+    } catch (e) {
+      console.log(
+        `${c.yellow}⚠${c.reset} 根证书未信任，自动安装失败: ${e.message}（可运行 easy-proxy w2 ca 手动安装）`
+      );
+    }
+  }
+
   // 状态判断
   var status, color;
   if (daysLeft <= 0) {
@@ -200,12 +415,22 @@ async function checkCertStatus(compact) {
       console.log(`${c.blue}ℹ${c.reset} 颁发对象:  ${c.gray}${info.subject}${c.reset}`);
     }
     console.log(c.gray + '─'.repeat(40) + c.reset);
+    printAppCaHints(certPath);
     if (daysLeft <= 0) {
-      console.log(`${c.gray}    运行 easy-proxy cert install 重新安装证书${c.reset}`);
+      console.log(`${c.gray}    运行 easy-proxy start 重新安装证书${c.reset}`);
     } else if (!trusted) {
-      console.log(`${c.gray}    运行 easy-proxy cert install 安装证书到系统信任库${c.reset}`);
+      console.log(`${c.gray}    运行 easy-proxy start 安装证书到系统信任库${c.reset}`);
     }
   }
 }
 
-module.exports = { checkCertStatus, findCertFile, parseCertWithOpenssl };
+module.exports = {
+  checkCertStatus,
+  findCertFile,
+  parseCertWithOpenssl,
+  checkCertCompliance,
+  fixCertCompliance,
+  ensureMergedCaBundle,
+  writeShellExports,
+  checkTrusted,
+};

package/lib/cli/commands/accel.js

@@ -72,9 +72,7 @@ function registerAccel(program) {
       title('加速状态');
       sep();
       info(
-        '加速功能:         ' +
-          (cfg.enabled ? `${c.green}✓ 已启用` : `${c.red}✗ 已关闭`) +
-          c.reset
+        '加速功能:         ' + (cfg.enabled ? `${c.green}✓ 已启用` : `${c.red}✗ 已关闭`) + c.reset
       );
       info(
         'SNI 改写:         ' +

package/lib/cli/commands/index.js

@@ -3,12 +3,12 @@ const { registerAccel } = require('./accel');
 const { registerHost } = require('./host');
 const { registerRule } = require('./rule');
 const { registerProxy } = require('./proxy');
-const { registerCert } = require('./cert');
 const { registerHealth } = require('./health');
 const { registerStatus } = require('./status');
 const { registerConfig } = require('./config-cmd');
 const { registerIntercept } = require('./intercept');
 const { registerNetwork } = require('./network');
+const { registerMirror } = require('./mirror');
 
 function registerAllCommands(program) {
   registerStart(program);
@@ -18,12 +18,12 @@ function registerAllCommands(program) {
   registerHost(program);
   registerRule(program);
   registerProxy(program);
-  registerCert(program);
   registerHealth(program);
   registerStatus(program);
   registerConfig(program);
   registerIntercept(program);
   registerNetwork(program);
+  registerMirror(program);
 }
 
 module.exports = {

package/lib/cli/commands/mirror.js

@@ -0,0 +1,101 @@
+const { readConfig, writeConfig, c, info, ok, err, title, sep } = require('../helpers');
+
+// 镜像开关状态存在主配置 config.json 的 mirrors 字段: { npm: true, pip: false, ... }
+function loadMirrorState() {
+  const cfg = readConfig();
+  return cfg.mirrors || {};
+}
+
+function saveMirrorState(state) {
+  const cfg = readConfig();
+  cfg.mirrors = state;
+  writeConfig(cfg);
+}
+
+function registerMirror(program) {
+  const mirrorCmd = program.command('mirror').description('开发镜像源加速（npm/pip/go 等，302 重定向到国内镜像）');
+
+  mirrorCmd
+    .command('status')
+    .description('查看镜像源状态')
+    .action(() => {
+      const { MIRROR_RULESETS } = require('../mirror-rulesets');
+      const state = loadMirrorState();
+      title('镜像源加速');
+      sep();
+      for (const name of Object.keys(MIRROR_RULESETS)) {
+        const on = state[name] === true;
+        info(`${on ? `${c.green}✓ 开启` : `${c.red}✗ 关闭`}${c.reset}  ${name}`);
+      }
+      sep();
+      info('开关立即同步到 whistle（需 whistle 运行中）');
+    });
+
+  mirrorCmd
+    .command('list')
+    .description('查看镜像规则内容')
+    .action(() => {
+      const { MIRROR_RULESETS } = require('../mirror-rulesets');
+      title('内置镜像规则');
+      sep();
+      for (const [name, rule] of Object.entries(MIRROR_RULESETS)) {
+        info(`${c.bold}${name}${c.reset}`);
+        rule
+          .split('\n')
+          .filter((l) => !l.startsWith('#'))
+          .forEach((l) => info(`  ${l}`));
+      }
+      sep();
+    });
+
+  mirrorCmd
+    .command('on [name]')
+    .description('启用镜像（无参数=全部启用）')
+    .action(async (name) => {
+      const { MIRROR_RULESETS } = require('../mirror-rulesets');
+      if (name && !MIRROR_RULESETS[name]) {
+        err(`未知镜像: ${name}（可用: ${Object.keys(MIRROR_RULESETS).join(', ')}）`);
+        return;
+      }
+      const state = loadMirrorState();
+      if (name) state[name] = true;
+      else for (const k of Object.keys(MIRROR_RULESETS)) state[k] = true;
+      saveMirrorState(state);
+
+      const { syncMirrors } = require('../mirror-sync');
+      try {
+        await syncMirrors();
+        ok(name ? `镜像 ${name} 已开启` : '所有镜像已开启');
+      } catch (e) {
+        info('whistle 未运行，配置已保存，下次 start 自动生效');
+      }
+    });
+
+  mirrorCmd
+    .command('off [name]')
+    .description('关闭镜像（无参数=全部关闭）')
+    .action(async (name) => {
+      const { MIRROR_RULESETS } = require('../mirror-rulesets');
+      if (name && !MIRROR_RULESETS[name]) {
+        err(`未知镜像: ${name}（可用: ${Object.keys(MIRROR_RULESETS).join(', ')}）`);
+        return;
+      }
+      const state = loadMirrorState();
+      if (name) delete state[name];
+      else for (const k of Object.keys(MIRROR_RULESETS)) delete state[k];
+      saveMirrorState(state);
+
+      const { syncMirrors } = require('../mirror-sync');
+      try {
+        await syncMirrors();
+        ok(name ? `镜像 ${name} 已关闭` : '所有镜像已关闭');
+      } catch (_e) {
+        info('whistle 未运行，配置已保存，下次 start 自动生效');
+      }
+    });
+}
+
+module.exports = {
+  registerMirror,
+  loadMirrorState,
+};

package/lib/cli/commands/proxy.js

@@ -1,4 +1,15 @@
-const { localW2Path, getWhistleStatus, info, ok, warn, err, title, sep, c, editInEditor } = require('../helpers');
+const {
+  localW2Path,
+  getWhistleStatus,
+  info,
+  ok,
+  warn,
+  err,
+  title,
+  sep,
+  c,
+  editInEditor,
+} = require('../helpers');
 
 function enableSystemProxy() {
   const { execSync } = require('node:child_process');
@@ -142,7 +153,14 @@ function registerProxy(program) {
         info('未配置代理');
       } else {
         proxies.forEach((p) => {
-          info(`${p.name}: ${p.url}`);
+          const state = p.disabled ? `${c.yellow}（已停用）${c.reset}` : '';
+          const addr = p.disabled ? `# ${p.url}` : p.url;
+          info(`${p.name}: ${addr} ${state}`);
+          if (p.disabledUrls && p.disabledUrls.length > 0) {
+            p.disabledUrls.forEach((u) => {
+              info(`  # ${u}`);
+            });
+          }
           if (p.domains.length > 0) {
             p.domains.forEach((d) => {
               info(`  ${d}`);
@@ -176,98 +194,65 @@ function registerProxy(program) {
     });
 
   // ---- proxy bypass ----
-  const bypassCmd = proxyCmd.command('bypass').description('管理跳过代理的域名');
-
-  bypassCmd
-    .command('show')
-    .description('查看当前跳过列表')
+  // 一行一个域名，# 注释；全删 = 恢复默认列表
+  const bypassCmd = proxyCmd
+    .command('bypass')
+    .description('编辑跳过代理的域名列表（打开 $EDITOR，一行一个域名）')
     .action(() => {
       const proxyConfig = require('../proxy-config');
-      const config = proxyConfig.loadConfig();
-      const domains = config.bypassDomains || proxyConfig.getDefaultBypass();
-      title('跳过代理的域名');
-      sep();
-      if (domains.length === 0) {
-        info('(空)');
-      } else {
-        domains.forEach((d) => {
-          info(`  ${d}`);
-        });
-      }
-      if (!config.bypassDomains) {
-        info(`${c.gray}(使用默认列表)${c.reset}`);
-      }
-      sep();
-    });
+      const oldList = proxyConfig.getEffectiveBypass();
 
-  bypassCmd
-    .command('set <domains>')
-    .description('设置跳过列表（逗号分隔，如: 127.0.0.1,localhost,*.local）')
-    .action((domains) => {
-      const proxyConfig = require('../proxy-config');
-      const list = domains
-        .split(',')
-        .map((d) => d.trim())
-        .filter(Boolean);
-      if (list.length === 0) {
-        err('请提供至少一个域名');
-        return;
-      }
-      proxyConfig.saveConfig({ bypassDomains: list });
-      ok(`已设置跳过列表: ${list.join(', ')}`);
-      info('重新开启系统代理后生效: easy-proxy proxy on');
-    });
+      const buildContent = (domains) =>
+        [
+          '# 跳过代理的域名（一行一个，# 开头为注释）',
+          '# 清空所有域名 = 恢复默认列表；保存后需重新 proxy on 生效',
+          '',
+          ...domains,
+        ].join('\n');
 
-  bypassCmd
-    .command('add <domain>')
-    .description('添加一个跳过域名')
-    .action((domain) => {
-      const proxyConfig = require('../proxy-config');
-      const config = proxyConfig.loadConfig();
-      const list = config.bypassDomains
-        ? config.bypassDomains.slice()
-        : proxyConfig.getDefaultBypass().slice();
-      if (list.indexOf(domain) >= 0) {
-        warn(`已存在: ${domain}`);
-        return;
+      let content = buildContent(oldList);
+      let newList;
+      while (true) {
+        let editedText;
+        try {
+          editedText = editInEditor(content, 'bypass');
+        } catch (_e) {
+          // 编辑器非零退出码（如 vi :q!）视为用户取消
+          info('已取消');
+          return;
+        }
+        const list = [];
+        const seen = new Set();
+        for (const raw of editedText.replace(/\r/g, '').split('\n')) {
+          const line = raw.trim();
+          if (!line || line.startsWith('#')) continue;
+          const key = line.toLowerCase();
+          if (seen.has(key)) continue;
+          seen.add(key);
+          list.push(line);
+        }
+        // 清空 = 恢复默认列表
+        if (list.length === 0) {
+          proxyConfig.saveConfig({ bypassDomains: null });
+          ok(`已清空，恢复默认列表（${proxyConfig.getEffectiveBypass().length} 个域名）`);
+          return;
+        }
+        if (list.some((d) => /^https?:\/\//i.test(d))) {
+          err('域名不应包含 http:// 或 https:// 前缀，请修正后重新保存...');
+          content = editedText;
+          continue;
+        }
+        newList = list;
+        break;
       }
-      list.push(domain);
-      proxyConfig.saveConfig({ bypassDomains: list });
-      ok(`已添加: ${domain}`);
-      info('重新开启系统代理后生效: easy-proxy proxy on');
-    });
 
-  bypassCmd
-    .command('remove <domain>')
-    .description('移除一个跳过域名')
-    .action((domain) => {
-      const proxyConfig = require('../proxy-config');
-      const config = proxyConfig.loadConfig();
-      if (!config.bypassDomains) {
-        warn('未自定义跳过列表，当前使用默认列表');
-        return;
-      }
-      const index = config.bypassDomains.indexOf(domain);
-      if (index < 0) {
-        warn(`未找到: ${domain}`);
+      if (JSON.stringify(oldList) === JSON.stringify(newList)) {
+        info('无改动');
         return;
       }
-      config.bypassDomains.splice(index, 1);
-      proxyConfig.saveConfig({ bypassDomains: config.bypassDomains });
-      ok(`已移除: ${domain}`);
-      info('重新开启系统代理后生效: easy-proxy proxy on');
-    });
 
-  bypassCmd
-    .command('reset')
-    .description('重置为默认跳过列表')
-    .action(() => {
-      const proxyConfig = require('../proxy-config');
-      proxyConfig.saveConfig({ bypassDomains: null });
-      ok('已重置为默认列表');
-      proxyConfig.getDefaultBypass().forEach((d) => {
-        info(`  ${d}`);
-      });
+      proxyConfig.saveConfig({ bypassDomains: newList });
+      ok(`已保存跳过列表（${newList.length} 个域名）`);
       info('重新开启系统代理后生效: easy-proxy proxy on');
     });
 }

package/lib/cli/commands/start.js

@@ -4,13 +4,19 @@ const { enableSystemProxy, disableSystemProxy } = require('./proxy');
 function registerStart(program) {
   program
     .command('start')
-    .description('启动 whistle（自动设置代理和安装证书）')
+    .description('启动 whistle（自动设置代理和管理证书）')
     .option('--init', '初始化（安装证书 + 设置代理）')
     .action(async (opts) => {
       const { execSync } = require('node:child_process');
       try {
+        // NODE_EXTRA_CA_CERTS 可能指向被删的合并文件，先自愈再调 w2（Node 进程启动时加载）
+        const { findCertFile, ensureMergedCaBundle, checkCertStatus } = require('../../cert-check');
+        const certPath = findCertFile();
+        if (certPath) ensureMergedCaBundle(certPath);
+
         const args = opts.init ? 'start --init' : 'start';
-        execSync(`"${localW2Path}" ${args}`, { stdio: 'inherit' });
+        // --dnsServer 绕过系统 DNS（ISP DNS 可能被污染，如 nodejs.org 解析到假 IP 导致 502 socket hang up）
+        execSync(`"${localW2Path}" ${args} --dnsServer 223.5.5.5`, { stdio: 'inherit' });
         ok('whistle 已启动');
 
         try {
@@ -19,6 +25,20 @@ function registerStart(program) {
           err(`开启系统代理失败: ${e.message}`);
         }
 
+        // 证书自动管理：whistle 异步生成证书（RSA 密钥生成需数秒），轮询等待后自愈
+        let newCertPath = findCertFile();
+        if (!newCertPath) {
+          for (let i = 0; i < 10 && !newCertPath; i++) {
+            await new Promise((r) => setTimeout(r, 1000));
+            newCertPath = findCertFile();
+          }
+        }
+        if (newCertPath) {
+          await checkCertStatus(true, true);
+        } else {
+          info('证书: 未找到（whistle 生成超时，下次启动自动重试）');
+        }
+
         const upstream = require('../upstream-proxy');
         const proxies = upstream.loadProxies();
         if (proxies.length > 0) {
@@ -47,6 +67,15 @@ function registerStart(program) {
           }
           if (count > 0) ok(`已同步 ${count} 个自定义规则`);
         }
+
+        // 内置镜像规则集（按开关状态同步，默认 npm/pip/go 开启）
+        try {
+          const { syncMirrors } = require('../mirror-sync');
+          const { added } = await syncMirrors();
+          if (added.length > 0) ok(`已同步 ${added.length} 个镜像规则集`);
+        } catch (e) {
+          debug('Mirror sync failed:', e.message);
+        }
       } catch (e) {
         err(`启动 whistle 失败: ${e.message}`);
         process.exit(1);

package/lib/cli/commands/status.js

@@ -17,9 +17,7 @@ function registerStatus(program) {
           (ws.running ? `${c.green}✓ 运行中${c.reset}` : `${c.red}✗ 未运行${c.reset}`) +
           (ws.port ? `（端口: ${ws.port}）` : '')
       );
-      info(
-        `加速功能:        ${cfg.enabled ? `${c.green}✓ 已启用` : `${c.red}✗ 已关闭`}${c.reset}`
-      );
+      info(`加速功能:        ${cfg.enabled ? `${c.green}✓ 已启用` : `${c.red}✗ 已关闭`}${c.reset}`);
       info(
         '拦截规则:        ' +
           (interceptOn ? `${c.green}✓ 已启用` : `${c.red}✗ 已关闭`) +
@@ -41,7 +39,7 @@ function registerStatus(program) {
       info('常用命令:        easy-proxy start --init  （启动 whistle + 代理 + 证书）');
       info('                 easy-proxy intercept list  （查看拦截规则）');
       info('                 easy-proxy proxy on / easy-proxy proxy off  （切换系统代理）');
-      info('                 easy-proxy cert install  （安装证书）');
+      info('                 easy-proxy start  （安装证书）');
     });
 }
 

package/lib/cli/mirror-rulesets.js

@@ -0,0 +1,58 @@
+/**
+ * 内置镜像源规则集
+ * 每个 Key 是一个规则集名（easy-proxy mirror on/off <name>），value 是 whistle 规则文本。
+ *
+ * 原理：whistle 302 重定向。工具仍请求官方源，whistle 把请求重定向到国内镜像，
+ * 包管理器自动跟随重定向，无需改 .npmrc / pip.conf / GOPROXY 等工具配置。
+ *
+ * 已实测验证的链路：npm（302→npmmirror→tarball 下载成功）、pip（simple 页 + files.pythonhosted
+ * 文件下载成功）、go（proxy.golang.org → goproxy.cn）。Homebrew 的 formulae.brew.sh
+ * 重定向到清华镜像目录结构对不上，且 brew 本身走 GitHub（由 GitHub 加速覆盖），不内置。
+ */
+
+const MIRROR_RULESETS = {
+  npm: [
+    '# npm registry → npmmirror（npmpack/tarball 均跟随 302）',
+    '# 仅重定向 GET：npm publish（PUT/POST）直达官方源，不发镜像',
+    '^registry.npmjs.org/*** redirect://https://registry.npmmirror.com/$1 includeFilter://m:get',
+    '^registry.yarnpkg.com/*** redirect://https://registry.npmmirror.com/$1 includeFilter://m:get',
+  ].join('\n'),
+
+  pip: [
+    '# pip → 清华 TUNA 镜像',
+    '# index 页（/simple/）和包文件（files.pythonhosted.org/packages/...）都要重定向，',
+    '# 否则 index 能拿到但下载 whl 还是走官方源',
+    '^pypi.org/simple/*** redirect://https://pypi.tuna.tsinghua.edu.cn/simple/$1',
+    '^files.pythonhosted.org/*** redirect://https://pypi.tuna.tsinghua.edu.cn/packages/$1',
+  ].join('\n'),
+
+  go: [
+    '# Go module proxy → goproxy.cn',
+    '^proxy.golang.org/*** redirect://https://goproxy.cn/$1',
+  ].join('\n'),
+
+  node: [
+    '# Node.js 二进制分发 → 清华镜像（fnm/nvm/n/volta 通用，工具自动跟随 302，无需设 FNM_NODE_DIST_MIRROR）',
+    '^nodejs.org/dist/*** redirect://https://mirrors.tuna.tsinghua.edu.cn/nodejs-release/$1',
+  ].join('\n'),
+
+  conda: [
+    '# conda → 清华 anaconda 镜像',
+    '# 需配合工具配置 conda config --add channels 后再用，纯重定向只覆盖 repo.anaconda.com 主源',
+    '^repo.anaconda.com/pkgs/main/*** redirect://https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/$1',
+    '^conda.anaconda.org/*** redirect://https://mirrors.tuna.tsinghua.edu.cn/anaconda-cloud/$1',
+  ].join('\n'),
+
+  huggingface: [
+    '# HuggingFace → hf-mirror.com（模型/数据集下载）',
+    '^huggingface.co/*** redirect://https://hf-mirror.com/$1',
+  ].join('\n'),
+};
+
+// 默认启用的镜像规则集（easy-proxy start 同步时自动 select）
+const DEFAULT_ENABLED = ['npm', 'pip', 'go'];
+
+module.exports = {
+  MIRROR_RULESETS,
+  DEFAULT_ENABLED,
+};

package/lib/cli/mirror-sync.js

@@ -0,0 +1,48 @@
+/**
+ * 镜像规则集 → whistle 同步
+ * 规则集名统一加 "mirror-" 前缀放独立分组，关闭 = 从 whistle 删除规则集，
+ * 不污染用户的自定义规则空间。
+ */
+
+const MIRROR_GROUP = '\rEasyProxy 镜像加速';
+const RULESET_PREFIX = 'mirror-';
+
+/**
+ * 把当前开关状态同步到 whistle（规则集存在性 = 开关状态）
+ * @returns {Promise<{added: string[], removed: string[]}>}
+ */
+async function syncMirrors() {
+  const api = require('./rule-api');
+  const { MIRROR_RULESETS } = require('./mirror-rulesets');
+  const { loadMirrorState } = require('./commands/mirror');
+  const state = loadMirrorState();
+
+  await api.createGroup(MIRROR_GROUP);
+  const added = [];
+  const removed = [];
+
+  for (const [name, rule] of Object.entries(MIRROR_RULESETS)) {
+    const rulesetName = RULESET_PREFIX + name;
+    if (state[name] === true) {
+      await api.addRuleset(rulesetName, rule, MIRROR_GROUP);
+      await api.selectRuleset(rulesetName, rule);
+      added.push(rulesetName);
+    } else {
+      // 关闭 = 删除规则集（不存在时 remove 返回错误，忽略）
+      try {
+        await api.removeRuleset(rulesetName);
+        removed.push(rulesetName);
+      } catch (_e) {
+        // 本来就没开，跳过
+      }
+    }
+  }
+
+  return { added, removed };
+}
+
+module.exports = {
+  syncMirrors,
+  MIRROR_GROUP,
+  RULESET_PREFIX,
+};

package/lib/cli/proxy-config.js

@@ -28,14 +28,9 @@ function getEffectiveBypass() {
   return bypassDomains?.length > 0 ? bypassDomains : DEFAULT_BYPASS_DOMAINS;
 }
 
-function getDefaultBypass() {
-  return DEFAULT_BYPASS_DOMAINS;
-}
-
 module.exports = {
   DEFAULT_BYPASS_DOMAINS,
   loadConfig: loadProxyConfig,
   saveConfig: saveProxyConfig,
   getEffectiveBypass,
-  getDefaultBypass,
 };

package/lib/cli/upstream-editor.js

@@ -6,6 +6,7 @@
  *   - 每个代理占一块，第1行=名称，第2行=URL，第3行起=域名列表
  *   - 多个代理之间用空行分隔
  *   - 以 # 开头的行是注释（整行），会被忽略
+ *   - URL 行前加 # 注释（如 `# http://...`）可停用该代理，块结构保留，重新编辑时仍显示
  *   - 支持 \r\n 和 \n 换行
  */
 
@@ -30,19 +31,18 @@ function dedupeDomains(domains) {
 }
 
 /**
- * 将文本分割为「原始行号 + 内容」的数组，同时处理 \r\n 和注释过滤
+ * 将文本分割为「原始行号 + 内容 + 是否注释」的数组，同时处理 \r\n
+ * 保留注释行（标记 isComment），用于识别「注释掉的代理地址」来停用代理
  * 保留原始行号用于错误提示
  * @param {string} text
- * @returns {Array<{lineNo: number, content: string}>}
+ * @returns {Array<{lineNo: number, content: string, isComment: boolean}>}
  */
 function splitLinesWithNumbers(text) {
   const rawLines = text.replace(/\r/g, '').split('\n');
   const result = [];
   for (let i = 0; i < rawLines.length; i++) {
-    const line = rawLines[i].trim();
-    // 过滤整行注释
-    if (line.startsWith('#')) continue;
-    result.push({ lineNo: i + 1, content: line });
+    const content = rawLines[i].trim();
+    result.push({ lineNo: i + 1, content, isComment: content.startsWith('#') });
   }
   return result;
 }
@@ -52,7 +52,7 @@ function splitLinesWithNumbers(text) {
 /**
  * 解析文本格式的上游代理配置
  * @param {string} text - 编辑器中的文本内容
- * @returns {Array<{name: string, url: string, domains: string[]}>}
+ * @returns {Array<{name: string, url: string, domains: string[], disabled?: boolean}>}
  * @throws {Error} 格式错误时抛出，错误信息包含具体位置和原因
  */
 function parse(text) {
@@ -63,43 +63,59 @@ function parse(text) {
   let i = 0;
 
   while (i < lines.length) {
-    // 跳过连续空行
-    if (lines[i].content === '') {
+    // 跳过连续空行和注释行（块开始前的注释）
+    while (i < lines.length && (lines[i].content === '' || lines[i].isComment)) {
       i++;
-      continue;
     }
+    if (i >= lines.length) break;
 
     // 第 1 行：代理名称
     const nameLine = lines[i];
     const name = nameLine.content;
-    if (!name) {
-      throw new Error(`第 ${nameLine.lineNo} 行: 代理名称不能为空`);
-    }
     i++;
 
-    // 第 2 行：代理 URL
-    if (i >= lines.length || lines[i].content === '') {
-      throw new Error(`第 ${nameLine.lineNo} 行: 代理 "${name}" 缺少 URL`);
-    }
-    const urlLine = lines[i];
-    const url = urlLine.content;
-    if (!/^https?:\/\//i.test(url)) {
-      throw new Error(`第 ${urlLine.lineNo} 行: 代理 URL 必须以 http:// 或 https:// 开头`);
-    }
-    i++;
-
-    // 第 3 行起：域名列表（直到空行或结尾）
+    // 第 2 行起：地址行 + 域名行（直到空行或结尾）
+    // 地址行：以 http(s):// 开头的行；被 # 注释的为备用地址，未注释的为生效地址
+    // 域名行：其他非空、非注释的行
+    const addresses = [];
     const domains = [];
     while (i < lines.length && lines[i].content !== '') {
-      const domain = lines[i].content;
-      domains.push(domain);
+      const line = lines[i];
+      if (line.isComment) {
+        const candidate = line.content.replace(/^#+\s*/, '');
+        if (/^https?:\/\//i.test(candidate)) {
+          addresses.push({ value: candidate, disabled: true });
+        }
+        // 普通注释行忽略
+      } else if (/^https?:\/\//i.test(line.content)) {
+        addresses.push({ value: line.content, disabled: false });
+      } else {
+        domains.push(line.content);
+      }
       i++;
     }
 
+    const activeUrls = addresses.filter((a) => !a.disabled);
+    const disabledUrls = addresses.filter((a) => a.disabled).map((a) => a.value);
+    if (activeUrls.length === 0 && disabledUrls.length === 0) {
+      throw new Error(`第 ${nameLine.lineNo} 行: 代理 "${name}" 缺少 URL`);
+    }
+    if (activeUrls.length > 1) {
+      throw new Error(
+        `第 ${nameLine.lineNo} 行: 代理 "${name}" 有多个生效地址，只能有一个（其余用 # 注释）`
+      );
+    }
+
+    // 未注释地址为生效地址；全被注释则整个代理停用
+    const disabled = activeUrls.length === 0;
+    const url = activeUrls.length > 0 ? activeUrls[0].value : disabledUrls[0];
+
     proxies.push({
       name,
       url,
       domains: dedupeDomains(domains),
+      ...(disabledUrls.length > 0 ? { disabledUrls } : {}),
+      ...(disabled ? { disabled: true } : {}),
     });
   }
 
@@ -118,14 +134,23 @@ function parse(text) {
 
 /**
  * 将代理数组格式化为文本（不含注释头部）
- * @param {Array<{name: string, url: string, domains: string[]}>} proxies
+ * 地址输出顺序：备用地址（disabledUrls，以 `# ` 前缀）→ 生效地址（url，仅非停用）
+ * 停用的代理（disabled）其地址全部以 `# ` 前缀输出，重新解析后可恢复
+ * @param {Array<{name: string, url: string, domains: string[], disabled?: boolean, disabledUrls?: string[]}>} proxies
  * @returns {string}
  */
 function format(proxies) {
   if (!proxies || proxies.length === 0) return '';
 
   const blocks = proxies.map((p) => {
-    const lines = [p.name, p.url];
+    const addrLines = (p.disabledUrls || []).map((u) => `# ${u}`);
+    if (p.disabled) {
+      // 兼容旧数据：无 disabledUrls 时，用 url 作为注释地址输出
+      if (addrLines.length === 0 && p.url) addrLines.push(`# ${p.url}`);
+    } else if (p.url) {
+      addrLines.push(p.url);
+    }
+    const lines = [p.name, ...addrLines];
     if (p.domains && p.domains.length > 0) {
       lines.push(...p.domains);
     }
@@ -175,10 +200,21 @@ function validate(proxies) {
 
     // 域名 trim + 去重
     const domains = dedupeDomains(
-      (proxy.domains || []).map((d) => (d || '').trim()).filter(Boolean),
+      (proxy.domains || []).map((d) => (d || '').trim()).filter(Boolean)
+    );
+
+    // 备用地址 trim + 去重
+    const disabledUrls = dedupeDomains(
+      (proxy.disabledUrls || []).map((d) => (d || '').trim()).filter(Boolean)
     );
 
-    return { name, url, domains };
+    return {
+      name,
+      url,
+      domains,
+      ...(disabledUrls.length > 0 ? { disabledUrls } : {}),
+      ...(proxy.disabled ? { disabled: true } : {}),
+    };
   });
 }
 
@@ -191,9 +227,11 @@ function buildEditContent(proxies) {
   const header = [
     '# EasyProxy 上游代理配置',
     '# 格式说明：',
-    '#   - 每个代理占一块，第一行是代理名称，第二行是代理地址，第三行起是域名列表',
+    '#   - 每个代理占一块，第一行是代理名称，其后是代理地址行（可多行），最后是域名列表',
+    '#   - 地址行以 http:// 或 https:// 开头；# 注释掉的为备用地址，未注释的为生效地址',
     '#   - 多个代理之间用空行分隔',
     '#   - 以 # 开头的行是注释，会被忽略',
+    '#   - 所有地址都被注释 = 停用该代理（块会保留，可随时恢复）',
     '# 示例：',
     '#   corp-proxy',
     '#   http://10.0.0.1:8080',
@@ -201,6 +239,15 @@ function buildEditContent(proxies) {
     '#   google.com',
     '#',
     '#   home-proxy',
+    '#   # http://192.168.1.100:3128',
+    '#   http://192.168.1.101:3128',
+    '#   internal.company.com',
+    '#   corp-proxy',
+    '#   http://10.0.0.1:8080',
+    '#   github.com',
+    '#   google.com',
+    '#',
+    '#   home-proxy',
     '#   http://192.168.1.100:3128',
     '#   internal.company.com',
   ].join('\n');

package/lib/cli/upstream-proxy.js

@@ -40,6 +40,8 @@ function generateRules(proxies) {
   const lines = ['# EasyProxy 上游代理规则（自动生成，请勿手动编辑）'];
   let hasRules = false;
   proxies.forEach((proxy) => {
+    // 停用的代理不生成规则（用户通过注释地址行停用）
+    if (proxy.disabled) return;
     const proxyUrl = toProxyProtocol(proxy.url);
     proxy.domains.forEach((domain) => {
       lines.push(`${domain} ${proxyUrl}`);

package/lib/config.js

@@ -21,6 +21,8 @@ const DEFAULT_CONFIG = {
   hosts: [],
   upstreamProxies: [],
   proxyBypassDomains: null,
+  // 内置镜像源开关（默认启用，见 lib/cli/mirror-rulesets.js）
+  mirrors: { npm: true, pip: true, go: true, node: true },
 };
 
 function ensureDir() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whistle.easy-proxy",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "EasyProxy whistle plugin — GitHub acceleration, SNI rewrite, hosts management",
   "main": "index.js",
   "homepage": "https://github.com/sqlwwx/easy-proxy",
@@ -13,6 +13,7 @@
   },
   "author": "sqlwwx",
   "license": "MIT",
+  "packageManager": "pnpm@11.18.0",
   "files": [
     "index.js",
     "bin/",
@@ -38,9 +39,10 @@
     "hosts"
   ],
   "dependencies": {
-    "chalk": "^4.1.2",
-    "commander": "^12.1.0",
-    "whistle": "^2.10.8"
+    "chalk": "^6.0.1",
+    "commander": "^15.0.0",
+    "node-forge": "^1.4.0",
+    "whistle": "^2.10.10"
   },
   "engines": {
     "node": ">=22.0.0"
@@ -50,15 +52,17 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "devDependencies": {
-    "@biomejs/biome": "^2.5.7"
-  },
   "scripts": {
+    "preinstall": "npx only-allow pnpm",
     "start": "easy-proxy start",
     "stop": "easy-proxy stop",
     "test": "node --test",
     "health": "easy-proxy health",
     "format": "biome format . --write",
-    "format:check": "biome format ."
+    "format:check": "biome format .",
+    "prepublishOnly": "npm test"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.14"
   }
-}
+}

package/lib/cli/commands/cert.js

@@ -1,35 +0,0 @@
-const { localW2Path, ok, err, info } = require('../helpers');
-
-function registerCert(program) {
-  const certCmd = program.command('cert').description('证书管理');
-
-  certCmd
-    .command('install')
-    .description('安装根证书（调用 w2 ca）')
-    .option('-f, --force', '强制重新生成证书')
-    .action((opts) => {
-      const { execSync } = require('node:child_process');
-      try {
-        if (opts.force) {
-          info('强制重新生成证书...');
-        }
-        execSync(`"${localW2Path}" ca`, { stdio: 'inherit' });
-        ok('证书安装完成');
-      } catch (e) {
-        err(`证书安装失败: ${e.message}`);
-        process.exit(1);
-      }
-    });
-
-  certCmd
-    .command('check')
-    .description('检查证书安装状态和有效期')
-    .action(async () => {
-      const { checkCertStatus } = require('../../cert-check');
-      await checkCertStatus();
-    });
-}
-
-module.exports = {
-  registerCert,
-};