mihomo-cli 2.4.1 → 2.5.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## [2.5.0] - 2026-05-03
+
+### 新功能
+
+- **test 命令** - `mihomo test` 快速测试当前运行实例的节点连通性
+- **clean 命令** - `mihomo clean` 清理失败节点并自动重启
+
+### 改进
+
+- `sub test` / `sub clean` 改用独立临时进程测试，不影响当前代理，支持测试任意订阅（不限于活跃订阅）
+- 启动时 auto-clean 使用当前运行实例直接测速，提升启动速度
+
+### 移除
+
+- 移除 `sub best` 命令
+
+---
+
+## [2.4.2] - 2026-05-02
+
+### 改进
+
+- 自动清理阈值统一为 50 个节点（不再区分订阅类型）
+- 订阅默认更新间隔从 12 小时缩短为 4 小时
+
+---
+
 ## [2.4.1] - 2026-05-02
 
 ### 修复

package/README.md

@@ -7,10 +7,9 @@
 - 🌐 **订阅管理** - 添加/更新订阅，支持流量统计和到期时间显示
 - 🔄 **自动更新** - 启动时自动检查并更新过期订阅
 - 🔍 **模糊匹配** - `sub use` / `sub web` 支持订阅名称模糊匹配
-- 🧹 **节点测速清理** - `sub test` 测试连通性，`sub clean` 自动清理失败节点，启动时自动清理
+- 🧹 **节点测速清理** - `test` 快速测试、`clean` 清理并重启；`sub test/clean` 独立进程测试任意订阅
 - 📊 **免费订阅基准测试** - `bench` 命令一键测试 20 个内置免费订阅源质量排名
 - 🆓 **快速添加免费订阅** - `sub free <id>` 一键添加内置免费订阅源
-- 🏆 **聚合订阅** - `sub best <id>` 一键添加自动更新的聚合订阅（每小时更新、去重、测活）
 - 📝 **覆写配置** - 在订阅基础上进行自定义覆写，支持强制覆盖、数组合并
 - 🔄 **智能重启** - `sub use` 切换订阅、`ow on/off` 切换覆写后自动重启
 - 🚀 **进程管理** - 启动/停止/切换模式，自动清理残留进程
@@ -101,13 +100,14 @@ mihomo ui yacd     # YACD
 | `mihomo sub use <name>`       | 切换当前订阅（支持模糊匹配，自动重启） |
 | `mihomo sub add <url> [name]` | 添加订阅并自动切换（支持逗号分隔多 URL 合并） |
 | `mihomo sub free <id>`        | 添加内置免费订阅（`0`=合并 #1+#2，`sub free` 列出可用源）|
-| `mihomo sub best <id>`        | 添加聚合订阅（`sub best` 列出可用源）|
 | `mihomo sub update`           | 更新所有订阅                           |
 | `mihomo sub update <name>`    | 更新指定订阅（支持模糊匹配）           |
 | `mihomo sub remove <name>`    | 删除订阅（支持模糊匹配）               |
 | `mihomo sub web [name]`       | 打开订阅页面（无参打开默认）           |
 | `mihomo sub test [name]`      | 测试节点连通性（`-t` 超时，`-j` 并发） |
 | `mihomo sub clean [name]`     | 测速并清理失败节点                     |
+| `mihomo test`                 | 快速测试当前节点连通性（`-t` 超时，`-j` 并发） |
+| `mihomo clean`                | 清理失败节点并自动重启（`-t` 超时，`-j` 并发） |
 
 ### 覆写配置
 
@@ -198,7 +198,7 @@ mihomo kernel --mirror-all hk.gh-proxy.org
 
 ## 订阅自动更新
 
-- 默认更新间隔：12 小时（或订阅服务端指定的 `profile-update-interval`）
+- 默认更新间隔：4 小时（或订阅服务端指定的 `profile-update-interval`）
 - 触发时机：`start` 命令、`sub list` 命令
 - 更新失败时继续使用本地缓存，不影响使用
 

package/dist/index.js

@@ -2687,14 +2687,6 @@ function getFreeSubscriptionSources() {
     { name: "NoMoreWalls", url: "https://gh-proxy.org/raw.githubusercontent.com/peasoft/NoMoreWalls/master/list.meta.yml" }
   ];
 }
-var GH_SUB = "https://gh-proxy.org/raw.githubusercontent.com/imaex/mihomo-free-sub/sub";
-function getBestSubscriptionSources() {
-  return [
-    { name: "curated", url: `${GH_SUB}/curated.yaml`, description: "\u7CBE\u9009 29 \u7EC4\uFF08\u4EC5\u6D4B\u901F\u6E90\uFF09" },
-    { name: "acl4ssr", url: `${GH_SUB}/acl4ssr.yaml`, description: "ACL4SSR 29 \u7EC4\uFF08\u5168\u90E8\u6E90\uFF09" },
-    { name: "freesub", url: `${GH_SUB}/freesub.yaml`, description: "freeSub 24 \u7EC4" }
-  ];
-}
 var BENCH_CONFIG = {
   "allow-lan": false,
   "external-controller": "127.0.0.1:19090",
@@ -2703,6 +2695,14 @@ var BENCH_CONFIG = {
   "log-level": "error",
   "geodata-mode": true
 };
+var TEST_CONFIG = {
+  "allow-lan": false,
+  "external-controller": "127.0.0.1:29090",
+  port: 27890,
+  "socks-port": 27891,
+  "log-level": "error",
+  "geodata-mode": true
+};
 var BASE_CONFIG = {
   "allow-lan": false,
   "external-controller": "127.0.0.1:9090",
@@ -3397,6 +3397,15 @@ function parseMirrorArg(args) {
   }
   return { mirror: null, isOverride: false, type: "download" };
 }
+function isProxyValid(proxy) {
+  if (!proxy.name || !proxy.server || !proxy.port) return false;
+  if (!proxy.type) return false;
+  if (proxy.type === "ss" && typeof proxy.cipher === "string" && proxy.cipher.startsWith("2022-blake3")) {
+    const pw = String(proxy.password || "");
+    if (!/^[A-Za-z0-9+/]+=*$/.test(pw) || pw.length < 20) return false;
+  }
+  return true;
+}
 
 // src/bench.ts
 var BENCH_DIR = path3.join(USER_DATA_DIR, "bench");
@@ -3541,15 +3550,6 @@ async function downloadAllSources(sources, onProgress) {
   });
   return await Promise.all(tasks);
 }
-function isProxyValid(proxy) {
-  if (!proxy.name || !proxy.server || !proxy.port) return false;
-  if (!proxy.type) return false;
-  if (proxy.type === "ss" && typeof proxy.cipher === "string" && proxy.cipher.startsWith("2022-blake3")) {
-    const pw = String(proxy.password || "");
-    if (!/^[A-Za-z0-9+/]+=*$/.test(pw) || pw.length < 20) return false;
-  }
-  return true;
-}
 function buildMergedBenchConfig(allProxies) {
   ensureBenchDirs();
   const validProxies = allProxies.filter(isProxyValid);
@@ -4211,7 +4211,7 @@ function viewLogWithTail(logPath, options) {
 }
 
 // src/subscription.ts
-var DEFAULT_UPDATE_INTERVAL_HOURS = 12;
+var DEFAULT_UPDATE_INTERVAL_HOURS = 4;
 var YAML_DUMP_OPTS = { indent: 2, lineWidth: -1, noCompatMode: true };
 var HTTP_CLIENT = createHttpClient({ timeout: 6e4 });
 function isMultiUrl(url) {
@@ -4484,9 +4484,9 @@ async function autoUpdateStaleSubscription() {
 }
 var API_BASE = `http://${BASE_CONFIG["external-controller"]}`;
 var DEFAULT_TEST_URL = "http://www.gstatic.com/generate_204";
-async function testProxyDelay(proxyName, timeout, testUrl, client) {
+async function testProxyDelay(proxyName, timeout, testUrl, client, apiBase = API_BASE) {
   const encodedName = encodeURIComponent(proxyName);
-  const url = `${API_BASE}/proxies/${encodedName}/delay?timeout=${timeout}&url=${encodeURIComponent(testUrl)}`;
+  const url = `${apiBase}/proxies/${encodedName}/delay?timeout=${timeout}&url=${encodeURIComponent(testUrl)}`;
   try {
     const response = await client.get(url);
     const data = JSON.parse(response.data);
@@ -4506,7 +4506,7 @@ async function testProxyDelay(proxyName, timeout, testUrl, client) {
   }
 }
 async function testSubscriptionProxies(subName, options = {}) {
-  const { timeout = 2e3, concurrency = 100, testUrl = DEFAULT_TEST_URL, onResult } = options;
+  const { timeout = 2e3, concurrency = 100, testUrl = DEFAULT_TEST_URL, apiBase = API_BASE, onResult } = options;
   const { proxies } = options.parsed || loadSubscriptionConfig(subName);
   if (proxies.length === 0) {
     return { total: 0, alive: 0, dead: 0, results: [] };
@@ -4516,7 +4516,7 @@ async function testSubscriptionProxies(subName, options = {}) {
   let completedCount = 0;
   for (let i = 0; i < proxies.length; i += concurrency) {
     const batch = proxies.slice(i, i + concurrency);
-    const batchResults = await Promise.all(batch.map((proxy) => testProxyDelay(proxy.name, timeout, testUrl, client)));
+    const batchResults = await Promise.all(batch.map((proxy) => testProxyDelay(proxy.name, timeout, testUrl, client, apiBase)));
     for (const result of batchResults) {
       results.push(result);
       onResult?.(result, completedCount, proxies.length);
@@ -4598,12 +4598,138 @@ async function autoCleanSubscription(subName, options = {}) {
       removedGroups = cleanResult.removedGroups;
     }
   }
-  if (!skipped) {
+  if (!skipped && removedProxies > 0) {
     saveSubscriptionConfig(subName, parsed);
   }
   return { summary, removedProxies, updatedGroups, removedGroups, skipped };
 }
 
+// src/test-instance.ts
+import { spawn as spawn3 } from "child_process";
+import fs7 from "fs";
+import path5 from "path";
+var TEST_DIR = path5.join(USER_DATA_DIR, "test");
+var TEST_DIRS = {
+  data: path5.join(TEST_DIR, "data"),
+  runtime: path5.join(TEST_DIR, "runtime")
+};
+var TEST_PATHS = {
+  configFile: path5.join(TEST_DIRS.runtime, "config.yaml"),
+  pidFile: path5.join(TEST_DIRS.runtime, "pid"),
+  logFile: path5.join(TEST_DIR, "test.log")
+};
+var TEST_API = `http://${TEST_CONFIG["external-controller"]}`;
+function ensureTestDirs() {
+  for (const dir of Object.values(TEST_DIRS)) {
+    fs7.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+}
+function cleanupTestDir() {
+  rmrf(TEST_DIR);
+}
+function buildTestConfig(subName) {
+  ensureTestDirs();
+  const rawContent = readSubscriptionRawConfig(subName);
+  if (!rawContent) {
+    throw new Error(`\u672A\u627E\u5230\u8BA2\u9605\u914D\u7F6E "${subName}"`);
+  }
+  const parsed = parseYamlOrJson(rawContent, "\u8BA2\u9605\u5185\u5BB9");
+  const proxies = (parsed.proxies || []).filter(isProxyValid);
+  if (proxies.length === 0) {
+    throw new Error(`\u8BA2\u9605 "${subName}" \u6CA1\u6709\u6709\u6548\u8282\u70B9`);
+  }
+  const nameCount = /* @__PURE__ */ new Map();
+  for (const proxy of proxies) {
+    const count = (nameCount.get(proxy.name) || 0) + 1;
+    nameCount.set(proxy.name, count);
+    if (count > 1) {
+      proxy.name = `${proxy.name} #${count}`;
+    }
+  }
+  const config = {
+    ...TEST_CONFIG,
+    proxies,
+    "proxy-groups": [
+      {
+        name: "PROXY",
+        type: "select",
+        proxies: proxies.map((p) => p.name)
+      }
+    ],
+    rules: ["MATCH,PROXY"]
+  };
+  const content = jsYaml.dump(config, { indent: 2, lineWidth: -1, noCompatMode: true });
+  fs7.writeFileSync(TEST_PATHS.configFile, content, { mode: 384 });
+}
+async function startTestInstance() {
+  const binary2 = PATHS.mihomoBinary;
+  if (!fs7.existsSync(binary2)) throw new Error("\u672A\u627E\u5230 mihomo \u5185\u6838");
+  stopTestInstance();
+  const logFd = fs7.openSync(TEST_PATHS.logFile, "a");
+  const child = spawn3(binary2, ["-d", TEST_DIRS.data, "-f", TEST_PATHS.configFile], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd]
+  });
+  fs7.closeSync(logFd);
+  child.unref();
+  const pid = child.pid;
+  fs7.writeFileSync(TEST_PATHS.pidFile, pid.toString(), { mode: 384 });
+  const client = createHttpClient({ timeout: 2e3 });
+  let ready = false;
+  for (let i = 0; i < 60; i++) {
+    if (!isProcessRunning(pid)) break;
+    try {
+      await client.get(`${TEST_API}/version`);
+      ready = true;
+      break;
+    } catch {
+      await sleep(500);
+    }
+  }
+  if (!isProcessRunning(pid)) {
+    let errorDetail = "";
+    try {
+      errorDetail = fs7.readFileSync(TEST_PATHS.logFile, "utf8").slice(-1e3);
+    } catch {
+    }
+    throw new Error(`\u6D4B\u8BD5\u5B9E\u4F8B\u542F\u52A8\u5931\u8D25${errorDetail ? `
+${errorDetail}` : ""}`);
+  }
+  if (!ready) {
+    throw new Error("\u6D4B\u8BD5\u5B9E\u4F8B\u542F\u52A8\u8D85\u65F6\uFF0CAPI \u672A\u54CD\u5E94");
+  }
+}
+function stopTestInstance() {
+  let pid;
+  try {
+    pid = parseInt(fs7.readFileSync(TEST_PATHS.pidFile, "utf8").trim(), 10);
+  } catch {
+    return;
+  }
+  if (pid > 0 && isProcessRunning(pid)) {
+    process.kill(pid, "SIGKILL");
+    for (let i = 0; i < 20; i++) {
+      if (!isProcessRunning(pid)) break;
+      sleepSync(100);
+    }
+  }
+  try {
+    fs7.unlinkSync(TEST_PATHS.pidFile);
+  } catch {
+  }
+}
+async function withTestInstance(subName, fn) {
+  cleanupTestDir();
+  buildTestConfig(subName);
+  try {
+    await startTestInstance();
+    return await fn(TEST_API);
+  } finally {
+    stopTestInstance();
+    cleanupTestDir();
+  }
+}
+
 // src/commands/status.ts
 function printStatus() {
   const status = getStatus();
@@ -4656,8 +4782,7 @@ function printStatus() {
 }
 
 // src/commands/start.ts
-var AUTO_CLEAN_THRESHOLD = 100;
-var AUTO_CLEAN_THRESHOLD_FREE = 50;
+var AUTO_CLEAN_THRESHOLD = 50;
 function handleStopResult(result) {
   if (result.remaining && result.remaining.length > 0) {
     console.error(`${colors.red("\u90E8\u5206\u8FDB\u7A0B\u672A\u7EC8\u6B62:")} ${result.remaining.join(", ")}`);
@@ -4709,10 +4834,9 @@ async function cmdStart(args) {
     }
     process.exit(1);
   }
-  const cleanThreshold = sub.name.startsWith("free") ? AUTO_CLEAN_THRESHOLD_FREE : AUTO_CLEAN_THRESHOLD;
-  if (configInfo.proxies > cleanThreshold) {
+  if (configInfo.proxies > AUTO_CLEAN_THRESHOLD) {
     console.log("");
-    console.log(`\u8282\u70B9\u6570 ${configInfo.proxies} \u8D85\u8FC7 ${cleanThreshold}\uFF0C\u81EA\u52A8\u6E05\u7406...`);
+    console.log(`\u8282\u70B9\u6570 ${configInfo.proxies} \u8D85\u8FC7 ${AUTO_CLEAN_THRESHOLD}\uFF0C\u81EA\u52A8\u6E05\u7406...`);
     console.log("");
     await sleep(1e3);
     const cleanResult = await autoCleanSubscription(sub.name, { onResult: printTestResult });
@@ -4743,9 +4867,9 @@ function printTestResult(result, index, total) {
   const prefix = `[${index + 1}/${total}]`;
   if (result.delay !== null) {
     const delayColor = result.delay < 300 ? colors.green : result.delay < 800 ? colors.yellow : colors.red;
-    console.log(`  ${prefix} ${colors.green("\u2713")} ${result.name} ${delayColor(`${result.delay}ms`)}`);
+    console.log(`${prefix} ${colors.green("\u2713")} ${result.name} ${delayColor(`${result.delay}ms`)}`);
   } else {
-    console.log(`  ${prefix} ${colors.red("\u2717")} ${result.name} ${colors.gray(result.error || "timeout")}`);
+    console.log(`${prefix} ${colors.red("\u2717")} ${result.name} ${colors.gray(result.error || "timeout")}`);
   }
 }
 function formatCleanSummary(result) {
@@ -4762,7 +4886,7 @@ function githubRepoUrl(rawUrl) {
   if (match) return `https://github.com/${match[1]}`;
   return null;
 }
-function resolveActiveTestTarget(args) {
+function resolveTestTarget(args) {
   const subs = getSubscriptions();
   if (subs.length === 0) {
     console.error("\u9519\u8BEF: \u6CA1\u6709\u8BA2\u9605");
@@ -4771,28 +4895,18 @@ function resolveActiveTestTarget(args) {
   const nameArg = getNonFlagArg(args, 2);
   const timeout = parseIntArg(args, "-t", "--timeout", 2e3);
   const concurrency = parseIntArg(args, "-j", "--concurrency", 100);
-  const activeSub = getActiveSubscription();
   let target;
   if (nameArg) {
     const matches = findSubscriptionFuzzy(subs, nameArg);
     target = pickSingleSubscription(matches, nameArg);
   } else {
+    const activeSub = getActiveSubscription();
     if (!activeSub) {
-      console.error("\u9519\u8BEF: \u6CA1\u6709\u6D3B\u8DC3\u8BA2\u9605");
+      console.error("\u9519\u8BEF: \u6CA1\u6709\u6D3B\u8DC3\u8BA2\u9605\uFF0C\u8BF7\u6307\u5B9A\u8BA2\u9605\u540D\u79F0");
       process.exit(1);
     }
     target = activeSub;
   }
-  const status = getStatus();
-  if (!status.running) {
-    console.error("\u9519\u8BEF: mihomo \u672A\u8FD0\u884C\uFF0C\u8BF7\u5148\u542F\u52A8 (mihomo start)");
-    process.exit(1);
-  }
-  if (!activeSub || activeSub.name !== target.name) {
-    console.error(`\u9519\u8BEF: \u5F53\u524D\u4F7F\u7528\u7684\u8BA2\u9605\u662F "${activeSub?.name}"\uFF0C\u4E0D\u662F "${target.name}"`);
-    console.log(`\u8BF7\u5148\u5207\u6362: mihomo sub use ${target.name}`);
-    process.exit(1);
-  }
   return { target, timeout, concurrency };
 }
 async function printSubscriptionList(options) {
@@ -4901,36 +5015,6 @@ async function addFreeSubscription(freeId) {
   console.log("");
   await printSubscriptionList();
 }
-function printBestSourceList() {
-  const bestSources = getBestSubscriptionSources();
-  for (let i = 0; i < bestSources.length; i++) {
-    console.log(`  ${i + 1}  ${bestSources[i].name} \u2014 ${bestSources[i].description}`);
-  }
-}
-async function addBestSubscription(bestId) {
-  const bestSources = getBestSubscriptionSources();
-  if (bestId < 1 || bestId > bestSources.length) {
-    console.error(`\u9519\u8BEF: best \u8BA2\u9605 ID \u8303\u56F4 1-${bestSources.length}`);
-    console.log("\n\u53EF\u7528\u6E90:");
-    printBestSourceList();
-    process.exit(1);
-  }
-  const source = bestSources[bestId - 1];
-  const name = `best${bestId}`;
-  console.log(`\u6DFB\u52A0 best \u8BA2\u9605: ${name} (${source.description})`);
-  try {
-    addSubscription(source.url, name);
-    const info = await downloadSubscription(source.url, name);
-    setDefaultSubscription(name);
-    saveSubscriptionCache(name, { web_page_url: "https://github.com/imaex/mihomo-free-sub" });
-    console.log(`\u5DF2\u6DFB\u52A0\u5E76\u5207\u6362\u5230 "${name}" (${formatProxySummary(info)})`);
-  } catch (e) {
-    console.error(`\u6DFB\u52A0\u5931\u8D25: ${e.message}`);
-    process.exit(1);
-  }
-  console.log("");
-  await printSubscriptionList();
-}
 async function cmdSubscription(args) {
   const action = args[1];
   if (!action || action === "list") {
@@ -4948,17 +5032,6 @@ async function cmdSubscription(args) {
     await addFreeSubscription(id);
     return;
   }
-  if (action === "best") {
-    const id = parseInt(args[2], 10);
-    if (Number.isNaN(id)) {
-      console.log("\u7528\u6CD5: mihomo sub best <id>\n");
-      console.log("\u53EF\u7528\u6E90:");
-      printBestSourceList();
-      process.exit(1);
-    }
-    await addBestSubscription(id);
-    return;
-  }
   if (action === "add") {
     const freeId = parseIntArg(args, "--free", "--free", -1);
     if (freeId > 0) {
@@ -5157,14 +5230,17 @@ async function cmdSubscription(args) {
     return;
   }
   if (action === "clean") {
-    const { target, timeout, concurrency } = resolveActiveTestTarget(args);
+    const { target, timeout, concurrency } = resolveTestTarget(args);
     console.log(`\u6E05\u7406\u8BA2\u9605 "${target.name}"...`);
     console.log(`\u8D85\u65F6: ${timeout}ms  \u5E76\u53D1: ${concurrency}`);
     console.log("");
-    const result = await autoCleanSubscription(target.name, {
-      timeout,
-      concurrency,
-      onResult: printTestResult
+    const result = await withTestInstance(target.name, async (apiBase) => {
+      return autoCleanSubscription(target.name, {
+        timeout,
+        concurrency,
+        apiBase,
+        onResult: printTestResult
+      });
     });
     console.log("");
     console.log(formatTestSummary(result.summary));
@@ -5173,20 +5249,26 @@ async function cmdSubscription(args) {
       console.log(colors.yellow("\u5B58\u6D3B\u8282\u70B9\u4E0D\u8DB3 1%\uFF0C\u8DF3\u8FC7\u6E05\u7406\u3002\u8BF7\u68C0\u67E5\u539F\u59CB\u8BA2\u9605\u662F\u5426\u6709\u6548"));
     } else if (result.removedProxies > 0) {
       console.log(`${colors.green("\u5DF2\u6E05\u7406")}: ${formatCleanSummary(result)}`);
-      console.log("");
-      console.log("\u63D0\u793A: \u9700\u8981\u91CD\u542F mihomo \u4F7F\u66F4\u6539\u751F\u6548 (mihomo start)");
+      const status = getStatus();
+      if (status.running) {
+        console.log("");
+        console.log("\u63D0\u793A: \u9700\u8981\u91CD\u542F mihomo \u4F7F\u66F4\u6539\u751F\u6548 (mihomo start)");
+      }
     }
     return;
   }
   if (action === "test") {
-    const { target, timeout, concurrency } = resolveActiveTestTarget(args);
+    const { target, timeout, concurrency } = resolveTestTarget(args);
     console.log(`\u6D4B\u8BD5\u8BA2\u9605 "${target.name}" \u7684\u8282\u70B9\u8FDE\u901A\u6027...`);
     console.log(`\u8D85\u65F6: ${timeout}ms  \u5E76\u53D1: ${concurrency}`);
     console.log("");
-    const summary = await testSubscriptionProxies(target.name, {
-      timeout,
-      concurrency,
-      onResult: printTestResult
+    const summary = await withTestInstance(target.name, async (apiBase) => {
+      return testSubscriptionProxies(target.name, {
+        timeout,
+        concurrency,
+        apiBase,
+        onResult: printTestResult
+      });
     });
     console.log("");
     console.log(formatTestSummary(summary));
@@ -5433,6 +5515,8 @@ ${colors.cyan("\u8BA2\u9605:")}
   ${colors.bold("subscription")} web [name]      \u6253\u5F00\u8BA2\u9605\u9875\u9762
   ${colors.bold("subscription")} test [name]     \u6D4B\u8BD5\u8282\u70B9\u8FDE\u901A\u6027
   ${colors.bold("subscription")} clean [name]    \u6D4B\u901F\u5E76\u6E05\u7406\u5931\u8D25\u8282\u70B9
+  ${colors.bold("test")} [-t ms] [-j N]           \u5FEB\u901F\u6D4B\u8BD5\u5F53\u524D\u8282\u70B9\u8FDE\u901A\u6027
+  ${colors.bold("clean")} [-t ms] [-j N]          \u6E05\u7406\u5931\u8D25\u8282\u70B9\u5E76\u81EA\u52A8\u91CD\u542F
   ${colors.bold("bench")} [name] [-t ms] [-j N]  \u6D4B\u8BD5\u514D\u8D39\u8BA2\u9605\u6E90\u8D28\u91CF\u6392\u540D
 
 ${colors.cyan("\u914D\u7F6E:")}
@@ -5474,8 +5558,8 @@ function printVersion() {
 
 // src/kernel.ts
 import { execSync as execSync4, spawnSync } from "child_process";
-import fs7 from "fs";
-import path5 from "path";
+import fs8 from "fs";
+import path6 from "path";
 
 // node_modules/compare-versions/lib/esm/utils.js
 var semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
@@ -5600,10 +5684,10 @@ async function checkUpdate(mirror) {
   };
 }
 function findBinaryInDir(dir) {
-  const files = fs7.readdirSync(dir);
+  const files = fs8.readdirSync(dir);
   for (const f of files) {
-    const fullPath = path5.join(dir, f);
-    const stat = fs7.statSync(fullPath);
+    const fullPath = path6.join(dir, f);
+    const stat = fs8.statSync(fullPath);
     if (stat.isDirectory()) {
       const found = findBinaryInDir(fullPath);
       if (found) return found;
@@ -5629,7 +5713,7 @@ async function downloadKernel(progressCallback, mirror, releaseInfo) {
   \u5E73\u53F0: ${platform}, \u67B6\u6784: ${arch}${hint}`);
   }
   const downloadUrl = withMirror(asset.browser_download_url, mirror);
-  const tempPath = path5.join(DIRS.kernel, asset.name);
+  const tempPath = path6.join(DIRS.kernel, asset.name);
   const sizeMB = (asset.size / 1024 / 1024).toFixed(2);
   if (progressCallback) {
     progressCallback(`\u4E0B\u8F7D\u5185\u6838: ${asset.name} (${sizeMB} MB)`);
@@ -5641,12 +5725,12 @@ async function downloadKernel(progressCallback, mirror, releaseInfo) {
   );
   if (curlResult.status !== 0) {
     try {
-      fs7.unlinkSync(tempPath);
+      fs8.unlinkSync(tempPath);
     } catch {
     }
     throw new Error(`\u4E0B\u8F7D\u5931\u8D25 (curl \u9000\u51FA\u7801 ${curlResult.status})`);
   }
-  if (!fs7.existsSync(tempPath)) {
+  if (!fs8.existsSync(tempPath)) {
     throw new Error("\u4E0B\u8F7D\u5931\u8D25: \u6587\u4EF6\u672A\u751F\u6210");
   }
   if (progressCallback) {
@@ -5658,14 +5742,14 @@ async function downloadKernel(progressCallback, mirror, releaseInfo) {
     if (tempPath.endsWith(".tar.gz") || tempPath.endsWith(".tgz")) {
       execSync4(`tar -xzf "${tempPath}" -C "${extractPath}"`, { stdio: ["pipe", "pipe", "inherit"] });
     } else if (tempPath.endsWith(".gz")) {
-      const baseName = path5.basename(tempPath, ".gz");
-      const outputPath = path5.join(extractPath, baseName);
+      const baseName = path6.basename(tempPath, ".gz");
+      const outputPath = path6.join(extractPath, baseName);
       execSync4(`gzip -dc "${tempPath}" > "${outputPath}"`, { stdio: ["pipe", "pipe", "inherit"] });
       extractedBinary = outputPath;
     }
   } catch (e) {
     try {
-      fs7.unlinkSync(tempPath);
+      fs8.unlinkSync(tempPath);
     } catch {
     }
     throw new Error(`\u89E3\u538B\u5931\u8D25: ${e.message}`);
@@ -5673,25 +5757,25 @@ async function downloadKernel(progressCallback, mirror, releaseInfo) {
   const foundBinary = extractedBinary || findBinaryInDir(extractPath);
   if (!foundBinary) {
     try {
-      fs7.unlinkSync(tempPath);
+      fs8.unlinkSync(tempPath);
     } catch {
     }
     throw new Error("\u89E3\u538B\u540E\u672A\u627E\u5230\u53EF\u6267\u884C\u6587\u4EF6");
   }
   const targetPath = PATHS.mihomoBinary;
   if (foundBinary !== targetPath) {
-    if (fs7.existsSync(targetPath)) {
-      fs7.chmodSync(targetPath, 493);
+    if (fs8.existsSync(targetPath)) {
+      fs8.chmodSync(targetPath, 493);
       try {
-        fs7.unlinkSync(targetPath);
+        fs8.unlinkSync(targetPath);
       } catch {
       }
     }
-    fs7.renameSync(foundBinary, targetPath);
+    fs8.renameSync(foundBinary, targetPath);
   }
-  fs7.chmodSync(targetPath, 493);
+  fs8.chmodSync(targetPath, 493);
   try {
-    fs7.unlinkSync(tempPath);
+    fs8.unlinkSync(tempPath);
   } catch {
   }
   clearKernelVersionCache();
@@ -5832,7 +5916,7 @@ function cmdLogs(args) {
 }
 
 // src/commands/overwrite.ts
-import path6 from "path";
+import path7 from "path";
 function printOverwriteList() {
   const info = listOverwriteFile();
   const statusText = info.enabled ? colors.green("\u5DF2\u542F\u7528") : colors.yellow("\u5DF2\u7981\u7528");
@@ -5842,8 +5926,8 @@ function printOverwriteList() {
   if (info.files.length === 0) {
     console.log("\u6682\u65E0\u8986\u5199\u6587\u4EF6");
     console.log("");
-    console.log(`\u7528\u6CD5\u793A\u4F8B: \u521B\u5EFA\u6587\u4EF6 ${path6.join(info.dir, "overwrite.yaml")}`);
-    console.log(`         \u6216        ${path6.join(info.dir, "overwrite.dns.yaml")}`);
+    console.log(`\u7528\u6CD5\u793A\u4F8B: \u521B\u5EFA\u6587\u4EF6 ${path7.join(info.dir, "overwrite.yaml")}`);
+    console.log(`         \u6216        ${path7.join(info.dir, "overwrite.dns.yaml")}`);
     console.log("");
   } else {
     console.log(`${colors.cyan("\u8986\u5199\u6587\u4EF6")} (${info.files.length} \u4E2A\uFF0C\u6309\u987A\u5E8F\u52A0\u8F7D):`);
@@ -5907,7 +5991,7 @@ async function cmdOverwrite(args) {
 }
 
 // src/commands/reset.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import readline from "readline";
 var RESET_TARGETS = [
   {
@@ -5962,8 +6046,8 @@ var RESET_TARGETS = [
     label: "\u8986\u5199",
     paths: () => {
       const dir = USER_DATA_DIR;
-      if (!fs8.existsSync(dir)) return [];
-      return fs8.readdirSync(dir).filter((f) => f === "overwrite.yaml" || /^overwrite\..+\.ya?ml$/.test(f)).map((f) => `${dir}/${f}`);
+      if (!fs9.existsSync(dir)) return [];
+      return fs9.readdirSync(dir).filter((f) => f === "overwrite.yaml" || /^overwrite\..+\.ya?ml$/.test(f)).map((f) => `${dir}/${f}`);
     },
     needsStop: false
   }
@@ -6079,6 +6163,69 @@ async function cmdStop() {
   console.log(colors.green("\u5DF2\u505C\u6B62\u8FDB\u7A0B"));
 }
 
+// src/commands/test.ts
+function requireRunning() {
+  const status = getStatus();
+  if (!status.running) {
+    console.error("\u9519\u8BEF: mihomo \u672A\u8FD0\u884C\uFF0C\u8BF7\u5148\u542F\u52A8 (mihomo start)");
+    process.exit(1);
+  }
+}
+function requireActiveSub() {
+  const activeSub = getActiveSubscription();
+  if (!activeSub) {
+    console.error("\u9519\u8BEF: \u6CA1\u6709\u6D3B\u8DC3\u8BA2\u9605");
+    process.exit(1);
+  }
+  return activeSub;
+}
+async function cmdTest(args) {
+  requireRunning();
+  const activeSub = requireActiveSub();
+  const timeout = parseIntArg(args, "-t", "--timeout", 1500);
+  const concurrency = parseIntArg(args, "-j", "--concurrency", 100);
+  console.log(`\u6D4B\u8BD5 "${activeSub.name}" \u8282\u70B9\u8FDE\u901A\u6027...`);
+  console.log(`\u8D85\u65F6: ${timeout}ms  \u5E76\u53D1: ${concurrency}`);
+  console.log("");
+  const summary = await testSubscriptionProxies(activeSub.name, {
+    timeout,
+    concurrency,
+    onResult: printTestResult
+  });
+  console.log("");
+  console.log(formatTestSummary(summary));
+}
+async function cmdClean(args) {
+  requireRunning();
+  const activeSub = requireActiveSub();
+  const timeout = parseIntArg(args, "-t", "--timeout", 1500);
+  const concurrency = parseIntArg(args, "-j", "--concurrency", 100);
+  console.log(`\u6E05\u7406 "${activeSub.name}" \u5931\u8D25\u8282\u70B9...`);
+  console.log(`\u8D85\u65F6: ${timeout}ms  \u5E76\u53D1: ${concurrency}`);
+  console.log("");
+  const result = await autoCleanSubscription(activeSub.name, {
+    timeout,
+    concurrency,
+    onResult: printTestResult
+  });
+  console.log("");
+  console.log(formatTestSummary(result.summary));
+  if (result.skipped) {
+    console.log("");
+    console.log("\u5B58\u6D3B\u8282\u70B9\u4E0D\u8DB3 1%\uFF0C\u8DF3\u8FC7\u6E05\u7406\u3002\u8BF7\u68C0\u67E5\u539F\u59CB\u8BA2\u9605\u662F\u5426\u6709\u6548");
+  } else if (result.removedProxies === 0) {
+    console.log("\u6240\u6709\u8282\u70B9\u6B63\u5E38\uFF0C\u65E0\u9700\u6E05\u7406");
+  } else {
+    console.log(`${colors.green("\u5DF2\u6E05\u7406")}: ${formatCleanSummary(result)}`);
+    console.log("");
+    console.log("\u91CD\u542F mihomo \u4F7F\u66F4\u6539\u751F\u6548...");
+    stop();
+    const configInfo = prepareConfigForStart("mixed", activeSub.name);
+    const startResult = await start("mixed");
+    console.log(`${colors.green("\u5DF2\u91CD\u542F")} (PID ${startResult.pid}) \xB7 ${formatProxySummary(configInfo)}`);
+  }
+}
+
 // src/commands/ui.ts
 function cmdUI(args) {
   const uiName = args[1] || "zash";
@@ -6097,7 +6244,7 @@ function cmdUI(args) {
 }
 
 // src/commands/update.ts
-import { exec, spawn as spawn3 } from "child_process";
+import { exec, spawn as spawn4 } from "child_process";
 import { promisify } from "util";
 var execAsync = promisify(exec);
 async function cmdUpdate() {
@@ -6106,7 +6253,7 @@ async function cmdUpdate() {
   console.log("\u6B63\u5728\u66F4\u65B0 mihomo-cli...");
   console.log("");
   await new Promise((resolve) => {
-    const npm = spawn3("npm", ["install", "-g", "mihomo-cli"], { stdio: "inherit" });
+    const npm = spawn4("npm", ["install", "-g", "mihomo-cli"], { stdio: "inherit" });
     npm.on("close", (code) => {
       if (code === 0) {
         resolve();
@@ -6254,6 +6401,12 @@ async function main() {
     case "bench":
       await cmdBench(args);
       break;
+    case "test":
+      await cmdTest(args);
+      break;
+    case "clean":
+      await cmdClean(args);
+      break;
     default:
       console.error(`\u672A\u77E5\u547D\u4EE4: ${cmd}`);
       console.error('\u4F7F\u7528 "mihomo help" \u67E5\u770B\u5E2E\u52A9');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mihomo-cli",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "type": "module",
   "description": "A terminal-based mihomo (Clash.Meta) client for macOS",
   "bin": {