mihomo-cli 2.2.4 → 2.3.1

package/dist/index.js

@@ -1,65 +1,10 @@
 #!/usr/bin/env node
 
-// src/paths.ts
-import fs from "fs";
-import os from "os";
-import path from "path";
-function getUserDataDir() {
-  if (process.env.MIHOMO_CLI_DIR) {
-    return process.env.MIHOMO_CLI_DIR;
-  }
-  return path.join(os.homedir(), ".mihomo-cli");
-}
-var USER_DATA_DIR = getUserDataDir();
-var DIRS = {
-  kernel: path.join(USER_DATA_DIR, "kernel"),
-  subscriptions: path.join(USER_DATA_DIR, "subscriptions"),
-  logs: path.join(USER_DATA_DIR, "logs"),
-  data: path.join(USER_DATA_DIR, "data"),
-  runtime: path.join(USER_DATA_DIR, "runtime")
-};
-var PATHS = {
-  mihomoBinary: path.join(DIRS.kernel, "mihomo"),
-  settingsFile: path.join(USER_DATA_DIR, "settings.json"),
-  subscriptionsCacheFile: path.join(DIRS.subscriptions, "cache.json"),
-  configFile: path.join(DIRS.runtime, "config.yaml"),
-  logFile: path.join(DIRS.logs, "mihomo.log"),
-  pidFile: path.join(DIRS.runtime, "pid"),
-  configStage1Subscription: path.join(DIRS.runtime, "1.subscription.yaml"),
-  configStage2Overwrite: path.join(DIRS.runtime, "2.overwrite.yaml"),
-  configStage3System: path.join(DIRS.runtime, "3.system.yaml")
-};
-var DIRECTORY_TARGETS = {
-  root: { path: null, label: "\u6839\u76EE\u5F55" },
-  subs: { path: DIRS.subscriptions, label: "\u8BA2\u9605\u76EE\u5F55" },
-  logs: { path: DIRS.logs, label: "\u65E5\u5FD7\u76EE\u5F55" },
-  data: { path: DIRS.data, label: "mihomo \u6570\u636E\u76EE\u5F55" },
-  runtime: { path: DIRS.runtime, label: "\u8FD0\u884C\u65F6\u76EE\u5F55" },
-  kernel: { path: DIRS.kernel, label: "\u5185\u6838\u76EE\u5F55" }
-};
-function ensureDirs() {
-  for (const dir of Object.values(DIRS)) {
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true, mode: 448 });
-    }
-  }
-}
-function fsExistsSync(p) {
-  return fs.existsSync(p);
-}
-function rmrf(dir) {
-  fs.rmSync(dir, { recursive: true, force: true });
-}
-
-// src/process.ts
-import { execSync as execSync3, spawn } from "child_process";
+// src/bench.ts
+import { spawn } from "child_process";
 import fs5 from "fs";
 import path3 from "path";
 
-// src/config.ts
-import { execSync } from "child_process";
-import fs4 from "fs";
-
 // node_modules/js-yaml/dist/js-yaml.mjs
 function isNothing(subject) {
   return typeof subject === "undefined" || subject === null;
@@ -2684,6 +2629,10 @@ var jsYaml = {
   safeDump
 };
 
+// src/config.ts
+import { execSync } from "child_process";
+import fs4 from "fs";
+
 // src/constants.ts
 var AVAILABLE_MIRRORS = ["gh-proxy.org", "v6.gh-proxy.org", "hk.gh-proxy.org", "cdn.gh-proxy.org"];
 var UI_URLS = {
@@ -2701,6 +2650,44 @@ var TUN_CONFIG = {
     "strict-route": true
   }
 };
+function getFreeSubscriptionSources() {
+  return [
+    // 完整配置（DNS + 分组 + rule-provider, 29 组）
+    { name: "FreeSubsCheck", url: "https://gh-proxy.org/raw.githubusercontent.com/kooker/FreeSubsCheck/main/mihomo.yaml" },
+    { name: "shaoyouvip", url: "https://gh-proxy.org/raw.githubusercontent.com/shaoyouvip/free/main/mihomo.yaml" },
+    { name: "freeSub", url: "https://gh-proxy.org/raw.githubusercontent.com/Ruk1ng001/freeSub/main/clash.yaml" },
+    // 完整配置（13 组）
+    { name: "PuddinCat", url: "https://gh-proxy.org/raw.githubusercontent.com/PuddinCat/BestClash/refs/heads/main/proxies.yaml" },
+    { name: "cn-news", url: "https://gh-proxy.org/raw.githubusercontent.com/hello-world-1989/cn-news/refs/heads/main/clash.yaml" },
+    // 基础分组（10-11 组）
+    { name: "naidounode", url: "https://gh-proxy.org/raw.githubusercontent.com/xiaoji235/airport-free/main/clash/naidounode.txt" },
+    { name: "v2rayshare", url: "https://gh-proxy.org/raw.githubusercontent.com/xiaoji235/airport-free/main/clash/v2rayshare.txt" },
+    // 简单配置（2 组）
+    { name: "proxypool", url: "https://gh-proxy.org/raw.githubusercontent.com/snakem982/proxypool/main/source/clash-meta.yaml" },
+    { name: "chromego", url: "https://gh-proxy.org/raw.githubusercontent.com/Misaka-blog/chromego_merge/main/sub/merged_proxies_new.yaml" },
+    // 纯节点列表
+    { name: "awesome-vpn", url: "https://gh-proxy.org/raw.githubusercontent.com/awesome-vpn/awesome-vpn/master/clash.yaml" },
+    { name: "V2RayAggregator", url: "https://gh-proxy.org/raw.githubusercontent.com/mahdibland/V2RayAggregator/master/Eternity.yml" },
+    { name: "Pawdroid", url: "https://gh-proxy.org/raw.githubusercontent.com/Pawdroid/Free-servers/main/sub" },
+    { name: "ermaozi", url: "https://gh-proxy.org/raw.githubusercontent.com/ermaozi/get_subscribe/main/subscribe/clash.yml" },
+    { name: "v2rayfree", url: "https://gh-proxy.org/raw.githubusercontent.com/v2raynnodes/v2rayfree/main/nodes/clashmeta.yaml" },
+    { name: "yudou66", url: "https://gh-proxy.org/raw.githubusercontent.com/Barabama/FreeNodes/main/nodes/yudou66.yaml" },
+    { name: "wenode", url: "https://gh-proxy.org/raw.githubusercontent.com/Barabama/FreeNodes/main/nodes/wenode.yaml" },
+    { name: "dongtai-sub", url: "https://gh-proxy.org/raw.githubusercontent.com/wenxig/dongtai-sub/refs/heads/main/data/sub.yaml" },
+    { name: "kasesm", url: "https://gh-proxy.org/raw.githubusercontent.com/kasesm/Free-Config/refs/heads/main/all_raw.txt" },
+    { name: "Au1rxx", url: "https://gh-proxy.org/raw.githubusercontent.com/Au1rxx/free-vpn-subscriptions/main/output/clash.yaml" },
+    // 完整配置但需要完整版 GeoSite.dat（geosite-lite 不兼容, 22 组）
+    { name: "NoMoreWalls", url: "https://gh-proxy.org/raw.githubusercontent.com/peasoft/NoMoreWalls/master/list.meta.yml" }
+  ];
+}
+var BENCH_CONFIG = {
+  "allow-lan": false,
+  "external-controller": "127.0.0.1:19090",
+  port: 17890,
+  "socks-port": 17891,
+  "log-level": "error",
+  "geodata-mode": true
+};
 var BASE_CONFIG = {
   "allow-lan": false,
   "external-controller": "127.0.0.1:9090",
@@ -2721,6 +2708,57 @@ var BASE_CONFIG = {
 import fs3 from "fs";
 import path2 from "path";
 
+// src/paths.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+function getUserDataDir() {
+  if (process.env.MIHOMO_CLI_DIR) {
+    return process.env.MIHOMO_CLI_DIR;
+  }
+  return path.join(os.homedir(), ".mihomo-cli");
+}
+var USER_DATA_DIR = getUserDataDir();
+var DIRS = {
+  kernel: path.join(USER_DATA_DIR, "kernel"),
+  subscriptions: path.join(USER_DATA_DIR, "subscriptions"),
+  logs: path.join(USER_DATA_DIR, "logs"),
+  data: path.join(USER_DATA_DIR, "data"),
+  runtime: path.join(USER_DATA_DIR, "runtime")
+};
+var PATHS = {
+  mihomoBinary: path.join(DIRS.kernel, "mihomo"),
+  settingsFile: path.join(USER_DATA_DIR, "settings.json"),
+  subscriptionsCacheFile: path.join(DIRS.subscriptions, "cache.json"),
+  configFile: path.join(DIRS.runtime, "config.yaml"),
+  logFile: path.join(DIRS.logs, "mihomo.log"),
+  pidFile: path.join(DIRS.runtime, "pid"),
+  configStage1Subscription: path.join(DIRS.runtime, "1.subscription.yaml"),
+  configStage2Overwrite: path.join(DIRS.runtime, "2.overwrite.yaml"),
+  configStage3System: path.join(DIRS.runtime, "3.system.yaml")
+};
+var DIRECTORY_TARGETS = {
+  root: { path: null, label: "\u6839\u76EE\u5F55" },
+  subs: { path: DIRS.subscriptions, label: "\u8BA2\u9605\u76EE\u5F55" },
+  logs: { path: DIRS.logs, label: "\u65E5\u5FD7\u76EE\u5F55" },
+  data: { path: DIRS.data, label: "mihomo \u6570\u636E\u76EE\u5F55" },
+  runtime: { path: DIRS.runtime, label: "\u8FD0\u884C\u65F6\u76EE\u5F55" },
+  kernel: { path: DIRS.kernel, label: "\u5185\u6838\u76EE\u5F55" }
+};
+function ensureDirs() {
+  for (const dir of Object.values(DIRS)) {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true, mode: 448 });
+    }
+  }
+}
+function fsExistsSync(p) {
+  return fs.existsSync(p);
+}
+function rmrf(dir) {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
 // src/settings.ts
 import fs2 from "fs";
 var settingsCache = null;
@@ -2757,6 +2795,9 @@ function invalidateSettingsCache() {
 }
 function maskUrl(url) {
   if (!url) return url;
+  if (url.includes(",")) {
+    return url.split(",").map((u) => maskUrl(u.trim())).join(", ");
+  }
   try {
     const parsed = new URL(url);
     const tokenKeys = ["token", "key", "secret", "pass", "password", "auth", "access_token", "api_key"];
@@ -3022,6 +3063,37 @@ function parseYamlOrJson(content, errorMsg) {
     throw new Error(`${errorMsg || "\u5185\u5BB9"}\u683C\u5F0F\u9519\u8BEF\uFF0C\u65E0\u6CD5\u89E3\u6790\u4E3A YAML \u6216 JSON`);
   }
 }
+function collectOverwriteProxyNames(overwriteFiles) {
+  const names = [];
+  for (const file of overwriteFiles) {
+    for (const [key, value] of Object.entries(file.config)) {
+      if ((key === "+proxies" || key === "proxies+") && Array.isArray(value)) {
+        for (const proxy of value) {
+          if (proxy && typeof proxy === "object" && "name" in proxy) {
+            names.push(proxy.name);
+          }
+        }
+      }
+    }
+  }
+  return names;
+}
+function excludeOverwriteProxiesFromIncludeAll(config, overwriteFiles) {
+  const injectedNames = collectOverwriteProxyNames(overwriteFiles);
+  if (injectedNames.length === 0) return;
+  const groups = config["proxy-groups"];
+  if (!groups) return;
+  const excludePattern = injectedNames.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  for (const group of groups) {
+    if (!group["include-all"] && !group["include-all-proxies"]) continue;
+    const existing = group["exclude-filter"];
+    if (existing) {
+      group["exclude-filter"] = `${existing}|${excludePattern}`;
+    } else {
+      group["exclude-filter"] = excludePattern;
+    }
+  }
+}
 function buildConfig(subRawContent, mode) {
   const subscriptionConfig = parseYamlOrJson(subRawContent, "\u8BA2\u9605\u5185\u5BB9");
   if (!subscriptionConfig) {
@@ -3030,6 +3102,9 @@ function buildConfig(subRawContent, mode) {
   const overwriteEnabled = isOverwriteEnabled();
   const overwriteFiles = overwriteEnabled ? loadOverwriteFile() : [];
   const withOverwrites = applyOverwrite(subscriptionConfig, overwriteFiles);
+  if (overwriteFiles.length > 0) {
+    excludeOverwriteProxiesFromIncludeAll(withOverwrites, overwriteFiles);
+  }
   const systemConfig = {};
   for (const [key, value] of Object.entries(BASE_CONFIG)) {
     if (!(key in withOverwrites)) {
@@ -3188,6 +3263,18 @@ function formatDate(dateOrIso) {
     return "\u672A\u77E5";
   }
 }
+function displayWidth(str2) {
+  let w = 0;
+  for (const ch of str2) {
+    const code = ch.codePointAt(0);
+    if (code >= 4352 && (code <= 4447 || code === 9001 || code === 9002 || code >= 11904 && code <= 42191 && code !== 12351 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65040 && code <= 65135 || code >= 65281 && code <= 65376 || code >= 65504 && code <= 65510 || code >= 131072 && code <= 196605 || code >= 196608 && code <= 262141)) {
+      w += 2;
+    } else {
+      w += 1;
+    }
+  }
+  return w;
+}
 function hasFlag(args, short, long) {
   return !!args && (args.includes(short) || args.includes(long));
 }
@@ -3296,7 +3383,345 @@ function parseMirrorArg(args) {
   return { mirror: null, isOverride: false, type: "download" };
 }
 
+// src/bench.ts
+var BENCH_DIR = path3.join(USER_DATA_DIR, "bench");
+var BENCH_DIRS = {
+  data: path3.join(BENCH_DIR, "data"),
+  runtime: path3.join(BENCH_DIR, "runtime")
+};
+var BENCH_PATHS = {
+  configFile: path3.join(BENCH_DIRS.runtime, "config.yaml"),
+  pidFile: path3.join(BENCH_DIRS.runtime, "pid"),
+  logFile: path3.join(BENCH_DIR, "bench.log")
+};
+var BENCH_API = `http://${BENCH_CONFIG["external-controller"]}`;
+var BENCH_TEST_URL = "http://www.gstatic.com/generate_204";
+function ensureBenchDirs() {
+  for (const dir of Object.values(BENCH_DIRS)) {
+    if (!fs5.existsSync(dir)) {
+      fs5.mkdirSync(dir, { recursive: true, mode: 448 });
+    }
+  }
+}
+function cleanupBenchDir() {
+  if (fs5.existsSync(BENCH_DIR)) {
+    fs5.rmSync(BENCH_DIR, { recursive: true, force: true });
+  }
+}
+function tryDecodeBase64Content(content) {
+  const trimmed = content.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("proxies") || trimmed.includes("proxy-groups")) return null;
+  try {
+    const decoded = Buffer.from(trimmed, "base64").toString("utf8");
+    if (decoded.includes("://")) return decoded;
+  } catch {
+  }
+  return null;
+}
+function parseVmessUri(uri) {
+  try {
+    const b64 = uri.slice("vmess://".length);
+    const json2 = JSON.parse(Buffer.from(b64, "base64").toString("utf8"));
+    return {
+      name: json2.ps || json2.add || "vmess",
+      type: "vmess",
+      server: json2.add,
+      port: Number(json2.port),
+      uuid: json2.id,
+      alterId: Number(json2.aid) || 0,
+      cipher: json2.security || "auto",
+      tls: json2.tls === "tls",
+      network: json2.net || "tcp",
+      ...json2.net === "ws" && { "ws-opts": { path: json2.path || "/", headers: json2.host ? { Host: json2.host } : void 0 } }
+    };
+  } catch {
+    return null;
+  }
+}
+function parseSsUri(uri) {
+  try {
+    const hashIdx = uri.indexOf("#");
+    const name = hashIdx >= 0 ? decodeURIComponent(uri.slice(hashIdx + 1)) : "ss";
+    const main2 = uri.slice("ss://".length, hashIdx >= 0 ? hashIdx : void 0);
+    let decoded;
+    const atIdx = main2.indexOf("@");
+    if (atIdx >= 0) {
+      const methodPassword2 = Buffer.from(main2.slice(0, atIdx), "base64").toString("utf8");
+      decoded = `${methodPassword2}@${main2.slice(atIdx + 1)}`;
+    } else {
+      decoded = Buffer.from(main2, "base64").toString("utf8");
+    }
+    const [methodPassword, serverPort] = decoded.split("@");
+    if (!methodPassword || !serverPort) return null;
+    const colonIdx = methodPassword.indexOf(":");
+    const method = methodPassword.slice(0, colonIdx);
+    const password = methodPassword.slice(colonIdx + 1);
+    const lastColon = serverPort.lastIndexOf(":");
+    const server = serverPort.slice(0, lastColon);
+    const port = Number(serverPort.slice(lastColon + 1));
+    return { name, type: "ss", server, port, cipher: method, password };
+  } catch {
+    return null;
+  }
+}
+function parseTrojanUri(uri) {
+  try {
+    const hashIdx = uri.indexOf("#");
+    const name = hashIdx >= 0 ? decodeURIComponent(uri.slice(hashIdx + 1)) : "trojan";
+    const main2 = uri.slice("trojan://".length, hashIdx >= 0 ? hashIdx : void 0);
+    const atIdx = main2.indexOf("@");
+    if (atIdx < 0) return null;
+    const password = main2.slice(0, atIdx);
+    const rest = main2.slice(atIdx + 1).split("?")[0];
+    const lastColon = rest.lastIndexOf(":");
+    const server = rest.slice(0, lastColon);
+    const port = Number(rest.slice(lastColon + 1));
+    return { name, type: "trojan", server, port, password, sni: server };
+  } catch {
+    return null;
+  }
+}
+function parseProxyUris(content) {
+  const lines = content.split("\n").map((l) => l.trim()).filter(Boolean);
+  const proxies = [];
+  for (const line of lines) {
+    let proxy = null;
+    if (line.startsWith("vmess://")) proxy = parseVmessUri(line);
+    else if (line.startsWith("ss://")) proxy = parseSsUri(line);
+    else if (line.startsWith("trojan://")) proxy = parseTrojanUri(line);
+    if (proxy?.name && proxy?.server) proxies.push(proxy);
+  }
+  return proxies;
+}
+async function downloadAllSources(sources, onProgress) {
+  const savedProxy = { http: process.env.http_proxy, https: process.env.https_proxy, HTTP: process.env.HTTP_PROXY, HTTPS: process.env.HTTPS_PROXY };
+  delete process.env.http_proxy;
+  delete process.env.https_proxy;
+  delete process.env.HTTP_PROXY;
+  delete process.env.HTTPS_PROXY;
+  try {
+    const client = createHttpClient({ timeout: 3e4 });
+    const tasks = sources.map(async (source) => {
+      const entry = { name: source.name, url: source.url, proxies: [], proxyGroups: 0 };
+      try {
+        const response = await client.get(source.url, { responseType: "text" });
+        const content = response.data;
+        if (!content?.trim()) throw new Error("\u5185\u5BB9\u4E3A\u7A7A");
+        let proxies;
+        try {
+          const parsed = parseYamlOrJson(content, "\u8BA2\u9605\u5185\u5BB9");
+          proxies = parsed.proxies || [];
+          const groups = parsed["proxy-groups"];
+          if (groups) entry.proxyGroups = groups.length;
+        } catch {
+          const decoded = tryDecodeBase64Content(content);
+          if (decoded) {
+            proxies = parseProxyUris(decoded);
+          } else {
+            proxies = parseProxyUris(content);
+          }
+          if (proxies.length === 0) throw new Error("\u65E0\u6CD5\u89E3\u6790\u8BA2\u9605\u5185\u5BB9\uFF08\u975E YAML/JSON/Base64\uFF09");
+        }
+        entry.proxies = proxies.map((p) => ({ ...p, name: `[${source.name}] ${p.name}` }));
+        onProgress?.(source.name, true, proxies.length, entry.proxyGroups);
+      } catch (e) {
+        entry.error = e.message;
+        onProgress?.(source.name, false, 0, 0, entry.error);
+      }
+      return entry;
+    });
+    return await Promise.all(tasks);
+  } finally {
+    for (const [key, val] of Object.entries(savedProxy)) {
+      if (val !== void 0) process.env[key] = val;
+    }
+  }
+}
+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);
+  const removed = allProxies.length - validProxies.length;
+  const nameCount = /* @__PURE__ */ new Map();
+  for (const proxy of validProxies) {
+    const originalName = proxy.name;
+    const count = (nameCount.get(originalName) || 0) + 1;
+    nameCount.set(originalName, count);
+    if (count > 1) {
+      proxy.name = `${originalName} #${count}`;
+    }
+  }
+  const config = {
+    ...BENCH_CONFIG,
+    proxies: validProxies,
+    "proxy-groups": [
+      {
+        name: "PROXY",
+        type: "select",
+        proxies: validProxies.map((p) => p.name)
+      }
+    ],
+    rules: ["MATCH,PROXY"]
+  };
+  const content = jsYaml.dump(config, { indent: 2, lineWidth: -1, noCompatMode: true });
+  fs5.writeFileSync(BENCH_PATHS.configFile, content, { mode: 384 });
+  allProxies.length = 0;
+  allProxies.push(...validProxies);
+  return removed;
+}
+async function startBenchInstance() {
+  const binary2 = PATHS.mihomoBinary;
+  if (!fs5.existsSync(binary2)) throw new Error("\u672A\u627E\u5230 mihomo \u5185\u6838");
+  const logFd = fs5.openSync(BENCH_PATHS.logFile, "a");
+  const child = spawn(binary2, ["-d", BENCH_DIRS.data, "-f", BENCH_PATHS.configFile], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd]
+  });
+  fs5.closeSync(logFd);
+  child.unref();
+  const pid = child.pid;
+  fs5.writeFileSync(BENCH_PATHS.pidFile, pid.toString(), { mode: 384 });
+  const client = createHttpClient({ timeout: 2e3 });
+  let ready = false;
+  for (let i = 0; i < 60; i++) {
+    await sleep(500);
+    if (!isProcessRunning(pid)) break;
+    try {
+      await client.get(`${BENCH_API}/version`);
+      ready = true;
+      break;
+    } catch {
+    }
+  }
+  if (!isProcessRunning(pid)) {
+    let errorDetail = "";
+    if (fs5.existsSync(BENCH_PATHS.logFile)) {
+      try {
+        errorDetail = fs5.readFileSync(BENCH_PATHS.logFile, "utf8").slice(-1e3);
+      } catch {
+      }
+    }
+    throw new Error(`bench \u5B9E\u4F8B\u542F\u52A8\u5931\u8D25${errorDetail ? `
+${errorDetail}` : ""}`);
+  }
+  if (!ready) {
+    throw new Error("bench \u5B9E\u4F8B\u542F\u52A8\u8D85\u65F6\uFF0CAPI \u672A\u54CD\u5E94");
+  }
+  return pid;
+}
+function stopBenchInstance() {
+  if (!fs5.existsSync(BENCH_PATHS.pidFile)) return;
+  try {
+    const pid = parseInt(fs5.readFileSync(BENCH_PATHS.pidFile, "utf8").trim(), 10);
+    if (pid > 0 && isProcessRunning(pid)) {
+      process.kill(pid, "SIGKILL");
+      for (let i = 0; i < 20; i++) {
+        if (!isProcessRunning(pid)) break;
+        sleepSync(100);
+      }
+    }
+  } catch {
+  }
+  try {
+    fs5.unlinkSync(BENCH_PATHS.pidFile);
+  } catch {
+  }
+}
+async function testBenchProxy(proxyName, timeout, client) {
+  const encodedName = encodeURIComponent(proxyName);
+  const url = `${BENCH_API}/proxies/${encodedName}/delay?timeout=${timeout}&url=${encodeURIComponent(BENCH_TEST_URL)}`;
+  try {
+    const response = await client.get(url);
+    const data = JSON.parse(response.data);
+    if (data.delay && data.delay > 0) {
+      return { name: proxyName, delay: data.delay };
+    }
+    return { name: proxyName, delay: null, error: data.message || "no delay" };
+  } catch (e) {
+    const err = e;
+    let errorMsg = "timeout";
+    if (err.response?.data?.message) {
+      errorMsg = String(err.response.data.message);
+    } else if (err.message) {
+      errorMsg = err.message;
+    }
+    return { name: proxyName, delay: null, error: errorMsg };
+  }
+}
+async function testBenchProxies(proxyNames, options = {}) {
+  const { timeout = 3e3, concurrency = 100, onResult, onBatch } = options;
+  const client = createHttpClient({ timeout: timeout + 3e3 });
+  const results = [];
+  let completedCount = 0;
+  let aliveCount = 0;
+  const delays = [];
+  const totalBatches = Math.ceil(proxyNames.length / concurrency);
+  for (let i = 0; i < proxyNames.length; i += concurrency) {
+    const batch = proxyNames.slice(i, i + concurrency);
+    const batchResults = await Promise.all(batch.map((name) => testBenchProxy(name, timeout, client)));
+    for (const result of batchResults) {
+      results.push(result);
+      if (result.delay !== null) {
+        aliveCount++;
+        delays.push(result.delay);
+      }
+      onResult?.(result, completedCount, proxyNames.length);
+      completedCount++;
+    }
+    delays.sort((a, b) => a - b);
+    const median = delays.length > 0 ? delays[Math.floor(delays.length / 2)] : 0;
+    onBatch?.(Math.floor(i / concurrency) + 1, totalBatches, aliveCount, completedCount, median);
+  }
+  return results;
+}
+function computeSourceResult(source, resultsByName) {
+  const proxyNames = source.proxies.map((p) => p.name);
+  const sourceResults = proxyNames.map((n) => resultsByName.get(n)).filter((r) => r !== void 0);
+  const delays = sourceResults.filter((r) => r.delay !== null).map((r) => r.delay);
+  const alive = delays.length;
+  const dead = sourceResults.length - alive;
+  if (alive === 0) {
+    return {
+      name: source.name,
+      url: source.url,
+      downloadOk: !source.error,
+      downloadError: source.error,
+      totalProxies: source.proxies.length,
+      proxyGroups: source.proxyGroups,
+      alive: 0,
+      dead,
+      avgDelay: 0,
+      minDelay: 0,
+      medianDelay: 0
+    };
+  }
+  delays.sort((a, b) => a - b);
+  return {
+    name: source.name,
+    url: source.url,
+    downloadOk: true,
+    totalProxies: source.proxies.length,
+    proxyGroups: source.proxyGroups,
+    alive,
+    dead,
+    avgDelay: Math.round(delays.reduce((sum, d) => sum + d, 0) / alive),
+    minDelay: delays[0],
+    medianDelay: delays[Math.floor(delays.length / 2)]
+  };
+}
+
 // src/process.ts
+import { execSync as execSync3, spawn as spawn2 } from "child_process";
+import fs6 from "fs";
+import path4 from "path";
 var PROCESS_WAIT_ATTEMPTS = 50;
 var PROCESS_WAIT_INTERVAL = 100;
 var STARTUP_WAIT_MS = 800;
@@ -3305,15 +3730,15 @@ var TUN_MODE_POST_WAIT_MS = 500;
 var BATCH_KILL_THRESHOLD = 3;
 var DEFAULT_LOG_RETENTION_DAYS = 7;
 function clearRuntime() {
-  if (fs5.existsSync(DIRS.runtime)) {
+  if (fs6.existsSync(DIRS.runtime)) {
     rmrf(DIRS.runtime);
   }
   ensureDirs();
 }
 function getPid() {
-  if (!fs5.existsSync(PATHS.pidFile)) return null;
+  if (!fs6.existsSync(PATHS.pidFile)) return null;
   try {
-    const pid = parseInt(fs5.readFileSync(PATHS.pidFile, "utf8").trim(), 10);
+    const pid = parseInt(fs6.readFileSync(PATHS.pidFile, "utf8").trim(), 10);
     return pid > 0 ? pid : null;
   } catch {
     return null;
@@ -3334,9 +3759,9 @@ function getAllMihomoPids() {
   }
 }
 function isPidFileOwnedByRoot() {
-  if (!fs5.existsSync(PATHS.pidFile)) return false;
+  if (!fs6.existsSync(PATHS.pidFile)) return false;
   try {
-    const stat = fs5.statSync(PATHS.pidFile);
+    const stat = fs6.statSync(PATHS.pidFile);
     return stat.uid === 0;
   } catch {
     return false;
@@ -3356,10 +3781,10 @@ function checkStaleState() {
 }
 function savePid(pid) {
   ensureDirs();
-  fs5.writeFileSync(PATHS.pidFile, pid.toString(), { mode: 384 });
+  fs6.writeFileSync(PATHS.pidFile, pid.toString(), { mode: 384 });
 }
 function clearPid() {
-  if (!fs5.existsSync(PATHS.pidFile)) return;
+  if (!fs6.existsSync(PATHS.pidFile)) return;
   if (isPidFileOwnedByRoot()) {
     try {
       execSync3(`sudo rm -f "${PATHS.pidFile}" 2>/dev/null`, { stdio: "inherit", timeout: 1e4 });
@@ -3367,7 +3792,7 @@ function clearPid() {
     }
   } else {
     try {
-      fs5.unlinkSync(PATHS.pidFile);
+      fs6.unlinkSync(PATHS.pidFile);
     } catch {
     }
   }
@@ -3492,8 +3917,8 @@ echo "--- \u65E5\u5FD7 ---"
 tail -25 "\${LOG_FILE}" 2>/dev/null
 exit 1
 `;
-  const scriptPath = path3.join(DIRS.runtime, "launch-tun.sh");
-  fs5.writeFileSync(scriptPath, scriptContent, { mode: 448 });
+  const scriptPath = path4.join(DIRS.runtime, "launch-tun.sh");
+  fs6.writeFileSync(scriptPath, scriptContent, { mode: 448 });
   return scriptPath;
 }
 function getProcessInfo(pid) {
@@ -3534,11 +3959,11 @@ async function start(mode = "mixed") {
   ensureDirs();
   rotateAndCleanupLogs();
   const binary2 = PATHS.mihomoBinary;
-  if (!fs5.existsSync(binary2)) {
+  if (!fs6.existsSync(binary2)) {
     throw new Error("\u672A\u627E\u5230 mihomo \u5185\u6838\uFF0C\u8BF7\u5148\u4E0B\u8F7D\u5185\u6838");
   }
   const configFile = PATHS.configFile;
-  if (!fs5.existsSync(configFile)) {
+  if (!fs6.existsSync(configFile)) {
     throw new Error("\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605\u5E76\u542F\u52A8");
   }
   const staleState = checkStaleState();
@@ -3567,12 +3992,12 @@ async function startMixedMode(staleState) {
   const configFile = PATHS.configFile;
   const logFile = PATHS.logFile;
   const args = ["-d", DIRS.data, "-f", configFile];
-  const logFd = fs5.openSync(logFile, "a");
-  const child = spawn(PATHS.mihomoBinary, args, {
+  const logFd = fs6.openSync(logFile, "a");
+  const child = spawn2(PATHS.mihomoBinary, args, {
     detached: true,
     stdio: ["ignore", logFd, logFd]
   });
-  fs5.closeSync(logFd);
+  fs6.closeSync(logFd);
   child.unref();
   const pid = child.pid;
   savePid(pid);
@@ -3580,9 +4005,9 @@ async function startMixedMode(staleState) {
   if (!isRunning()) {
     clearPid();
     let errorMsg = "\u542F\u52A8\u5931\u8D25";
-    if (fs5.existsSync(logFile)) {
+    if (fs6.existsSync(logFile)) {
       try {
-        const logs = fs5.readFileSync(logFile, "utf8").slice(-3e3);
+        const logs = fs6.readFileSync(logFile, "utf8").slice(-3e3);
         if (logs.trim()) {
           errorMsg += "\n\u6700\u8FD1\u7684\u65E5\u5FD7:\n" + logs.split("\n").map((l) => `  ${l}`).join("\n");
         }
@@ -3603,7 +4028,7 @@ async function startTunMode(staleState) {
     execSync3(`sudo "${launchScript}"`, { stdio: "inherit", timeout: SUDO_TIMEOUT_MS });
   } catch (e) {
     try {
-      fs5.unlinkSync(launchScript);
+      fs6.unlinkSync(launchScript);
     } catch {
     }
     if (e.status === 1) {
@@ -3612,7 +4037,7 @@ async function startTunMode(staleState) {
     throw new Error(e.message);
   }
   try {
-    fs5.unlinkSync(launchScript);
+    fs6.unlinkSync(launchScript);
   } catch {
   }
   await new Promise((resolve) => setTimeout(resolve, TUN_MODE_POST_WAIT_MS));
@@ -3651,19 +4076,19 @@ function getLogPath() {
 }
 function rotateLog() {
   const logFile = PATHS.logFile;
-  if (!fs5.existsSync(logFile)) return null;
-  const stat = fs5.statSync(logFile);
+  if (!fs6.existsSync(logFile)) return null;
+  const stat = fs6.statSync(logFile);
   if (stat.size === 0) return null;
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/T/, "_").replace(/:/g, "-").replace(/\..+/, "");
   const rotatedName = `mihomo.${timestamp2}.log`;
-  const rotatedPath = path3.join(DIRS.logs, rotatedName);
-  fs5.renameSync(logFile, rotatedPath);
+  const rotatedPath = path4.join(DIRS.logs, rotatedName);
+  fs6.renameSync(logFile, rotatedPath);
   return rotatedPath;
 }
 function cleanupOldLogs(maxAgeDays = DEFAULT_LOG_RETENTION_DAYS) {
   const logsDir = DIRS.logs;
-  if (!fs5.existsSync(logsDir)) return { deleted: 0, errors: 0 };
-  const files = fs5.readdirSync(logsDir);
+  if (!fs6.existsSync(logsDir)) return { deleted: 0, errors: 0 };
+  const files = fs6.readdirSync(logsDir);
   const now = Date.now();
   const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1e3;
   let deleted = 0;
@@ -3671,10 +4096,10 @@ function cleanupOldLogs(maxAgeDays = DEFAULT_LOG_RETENTION_DAYS) {
   for (const file of files) {
     if (!file.match(/^mihomo\.\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}\.log$/)) continue;
     try {
-      const filePath = path3.join(logsDir, file);
-      const stat = fs5.statSync(filePath);
+      const filePath = path4.join(logsDir, file);
+      const stat = fs6.statSync(filePath);
       if (now - stat.mtimeMs > maxAgeMs) {
-        fs5.unlinkSync(filePath);
+        fs6.unlinkSync(filePath);
         deleted++;
       }
     } catch {
@@ -3686,8 +4111,8 @@ function cleanupOldLogs(maxAgeDays = DEFAULT_LOG_RETENTION_DAYS) {
 function listLogs() {
   const logsDir = DIRS.logs;
   const result = { current: null, archives: [] };
-  if (fs5.existsSync(PATHS.logFile)) {
-    const stat = fs5.statSync(PATHS.logFile);
+  if (fs6.existsSync(PATHS.logFile)) {
+    const stat = fs6.statSync(PATHS.logFile);
     result.current = {
       name: "mihomo.log (\u5F53\u524D)",
       path: PATHS.logFile,
@@ -3696,14 +4121,14 @@ function listLogs() {
       isCurrent: true
     };
   }
-  if (!fs5.existsSync(logsDir)) return result;
-  const files = fs5.readdirSync(logsDir);
+  if (!fs6.existsSync(logsDir)) return result;
+  const files = fs6.readdirSync(logsDir);
   for (const file of files) {
     const match = file.match(/^mihomo\.(\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2})\.log$/);
     if (!match) continue;
     try {
-      const filePath = path3.join(logsDir, file);
-      const stat = fs5.statSync(filePath);
+      const filePath = path4.join(logsDir, file);
+      const stat = fs6.statSync(filePath);
       result.archives.push({
         name: file,
         path: filePath,
@@ -3718,22 +4143,22 @@ function listLogs() {
   return result;
 }
 function isPathUnderDir(filePath, baseDir) {
-  const resolvedPath = path3.resolve(filePath);
-  const resolvedBase = path3.resolve(baseDir);
-  return resolvedPath === resolvedBase || resolvedPath.startsWith(resolvedBase + path3.sep);
+  const resolvedPath = path4.resolve(filePath);
+  const resolvedBase = path4.resolve(baseDir);
+  return resolvedPath === resolvedBase || resolvedPath.startsWith(resolvedBase + path4.sep);
 }
 function getLogPathByName(name) {
   const logsDir = DIRS.logs;
   let targetName = name;
   if (!name.endsWith(".log")) targetName = `mihomo.${name}.log`;
   if (!targetName.startsWith("mihomo.")) targetName = `mihomo.${targetName}`;
-  const filePath = path3.join(logsDir, targetName);
-  if (fs5.existsSync(filePath) && isPathUnderDir(filePath, logsDir)) return filePath;
-  if (fs5.existsSync(logsDir)) {
-    const files = fs5.readdirSync(logsDir);
+  const filePath = path4.join(logsDir, targetName);
+  if (fs6.existsSync(filePath) && isPathUnderDir(filePath, logsDir)) return filePath;
+  if (fs6.existsSync(logsDir)) {
+    const files = fs6.readdirSync(logsDir);
     for (const file of files) {
       if (file.includes(name)) {
-        const candidatePath = path3.join(logsDir, file);
+        const candidatePath = path4.join(logsDir, file);
         if (isPathUnderDir(candidatePath, logsDir)) return candidatePath;
       }
     }
@@ -3742,7 +4167,7 @@ function getLogPathByName(name) {
 }
 function openUrl(url) {
   try {
-    const child = spawn("open", [url], { stdio: "ignore", detached: true });
+    const child = spawn2("open", [url], { stdio: "ignore", detached: true });
     child.unref();
     child.on("error", () => {
     });
@@ -3773,7 +4198,7 @@ function viewLogWithTail(logPath, options) {
   if (follow) tailArgs.push("-f");
   tailArgs.push("-n", lines.toString());
   tailArgs.push(logPath);
-  const tail = spawn("tail", tailArgs, { stdio: "inherit" });
+  const tail = spawn2("tail", tailArgs, { stdio: "inherit" });
   tail.on("close", () => process.exit(0));
   tail.on("error", (e) => {
     console.error(`\u65E0\u6CD5\u8BFB\u53D6\u65E5\u5FD7: ${e.message}`);
@@ -3781,1268 +4206,1588 @@ function viewLogWithTail(logPath, options) {
   });
 }
 
-// src/commands/directory.ts
-function cmdDirectory(args) {
-  const action = args?.[1];
-  if (action === "open") {
-    const target = args[2];
-    if (!target || target === "root") {
-      console.log("\u6B63\u5728\u6253\u5F00: \u6839\u76EE\u5F55");
-      const success = openUrl(USER_DATA_DIR);
-      if (!success) {
-        console.log(`\u8BF7\u624B\u52A8\u6253\u5F00: ${USER_DATA_DIR}`);
-      }
-      return;
-    }
-    const targetInfo = DIRECTORY_TARGETS[target.toLowerCase()];
-    if (targetInfo) {
-      const targetPath = targetInfo.path || USER_DATA_DIR;
-      console.log(`\u6B63\u5728\u6253\u5F00: ${targetInfo.label}`);
-      const success = openUrl(targetPath);
-      if (!success) {
-        console.log(`\u8BF7\u624B\u52A8\u6253\u5F00: ${targetPath}`);
-      }
-      return;
-    }
-    console.error(`\u9519\u8BEF: \u672A\u77E5\u7684\u76EE\u5F55\u76EE\u6807 "${target}"`);
-    console.log("");
-    console.log("\u53EF\u7528\u76EE\u6807:");
-    console.log("  root (\u9ED8\u8BA4)   \u6839\u76EE\u5F55");
-    for (const [key, val] of Object.entries(DIRECTORY_TARGETS)) {
-      if (key !== "root") {
-        console.log(`  ${key.padEnd(14)}${val.label}`);
-      }
+// src/subscription.ts
+var DEFAULT_UPDATE_INTERVAL_HOURS = 12;
+var YAML_DUMP_OPTS = { indent: 2, lineWidth: -1, noCompatMode: true };
+var HTTP_CLIENT = createHttpClient({ timeout: 6e4 });
+function isMultiUrl(url) {
+  return url.includes(",");
+}
+function splitUrls(url) {
+  return url.split(",").map((u) => u.trim()).filter(Boolean);
+}
+function loadSubscriptionConfig(subName) {
+  const rawContent = readSubscriptionRawConfig(subName);
+  if (!rawContent) {
+    throw new Error(`\u672A\u627E\u5230\u8BA2\u9605\u914D\u7F6E "${subName}"`);
+  }
+  const raw = parseYamlOrJson(rawContent, "\u8BA2\u9605\u5185\u5BB9");
+  return {
+    raw,
+    proxies: raw.proxies || [],
+    proxyGroups: raw["proxy-groups"] || []
+  };
+}
+function saveSubscriptionConfig(subName, parsed) {
+  normalizeProxyNamesBeforeSave(parsed);
+  parsed.raw.proxies = parsed.proxies;
+  parsed.raw["proxy-groups"] = parsed.proxyGroups;
+  saveSubscriptionRawConfig(subName, jsYaml.dump(parsed.raw, YAML_DUMP_OPTS));
+}
+function parseUserInfo(header) {
+  if (!header) return null;
+  const info = {};
+  const parts = header.split(";").map((p) => p.trim());
+  for (const part of parts) {
+    const [key, val] = part.split("=").map((s) => s.trim());
+    if (key && val !== void 0) {
+      const numVal = parseFloat(val);
+      info[key] = Number.isNaN(numVal) ? 0 : numVal;
     }
-    console.log("");
-    process.exit(1);
   }
-  console.log("");
-  console.log("\u6570\u636E\u76EE\u5F55\u4F4D\u7F6E:");
-  console.log(`  \u6839\u76EE\u5F55: ${USER_DATA_DIR}`);
-  console.log(`  \u5168\u5C40\u8BBE\u7F6E: ${PATHS.settingsFile}`);
-  console.log(`  \u5185\u6838\u76EE\u5F55: ${DIRS.kernel}`);
-  console.log(`  \u5185\u6838\u6587\u4EF6: ${PATHS.mihomoBinary}`);
-  console.log(`  \u8BA2\u9605\u76EE\u5F55: ${DIRS.subscriptions}`);
-  console.log("    - cache.json (\u8BA2\u9605\u7F13\u5B58\uFF1A\u66F4\u65B0\u65F6\u95F4\u3001\u6D41\u91CF\u7B49)");
-  console.log("    - xxx.yaml (\u8BA2\u9605\u539F\u59CB\u914D\u7F6E)");
-  console.log(`  \u8FD0\u884C\u65F6\u76EE\u5F55: ${DIRS.runtime}`);
-  console.log("    - config.yaml (\u542F\u52A8\u65F6\u751F\u6210\uFF0Cstop \u81EA\u52A8\u6E05\u9664)");
-  console.log("    - pid (PID \u6587\u4EF6\uFF0Cstop \u81EA\u52A8\u6E05\u9664)");
-  console.log(`  \u65E5\u5FD7\u6587\u4EF6: ${PATHS.logFile}`);
-  console.log(`  mihomo \u6570\u636E: ${DIRS.data}`);
-  console.log("    - cache.db, Geo*.dat \u7B49 (mihomo \u81EA\u884C\u7BA1\u7406)");
-  console.log("");
-  console.log("\u6253\u5F00\u76EE\u5F55:");
-  console.log("  mihomo dir open                \u6253\u5F00\u6839\u76EE\u5F55");
-  console.log("  mihomo dir open subs           \u6253\u5F00\u8BA2\u9605\u76EE\u5F55");
-  console.log("  mihomo dir open logs           \u6253\u5F00\u65E5\u5FD7\u76EE\u5F55");
-  console.log("  mihomo dir open runtime        \u6253\u5F00\u8FD0\u884C\u65F6\u76EE\u5F55");
-  console.log("  mihomo dir open kernel         \u6253\u5F00\u5185\u6838\u76EE\u5F55");
-  console.log("");
-  console.log("\u73AF\u5883\u53D8\u91CF:");
-  console.log("  MIHOMO_CLI_DIR: \u81EA\u5B9A\u4E49\u6839\u76EE\u5F55\u4F4D\u7F6E");
-  console.log("");
+  return info;
 }
-
-// src/commands/help.ts
-function printShortHelp() {
-  console.log(`
-${colors.cyan(colors.bold(`mihomo-cli v${VERSION}`))}  (mihomo help \u67E5\u770B\u5B8C\u6574\u5E2E\u52A9)
-`);
-  console.log(
-    `\u5E38\u7528\u547D\u4EE4:
-  ${colors.bold("start")} [tun|mixed]    \u542F\u52A8/\u5207\u6362\u4EE3\u7406
-  ${colors.bold("sub")} [use|update]     \u8BA2\u9605\u7BA1\u7406
-  ${colors.bold("ow")} [on|off]          \u8986\u5199\u914D\u7F6E
-  ${colors.bold("ui")} [zash|dash|yacd]  \u6253\u5F00 Web UI
-`
-  );
+function parseUsernameFromContentDisposition(header) {
+  if (!header) return null;
+  const match = header.match(/filename\s*=\s*["']?([^"';\s]+)["']?/i);
+  if (!match) return null;
+  const filename = match[1];
+  const parts = filename.split("/");
+  return parts[parts.length - 1] || null;
 }
-function printHelp() {
-  console.log(
-    `
-${colors.cyan(colors.bold(`mihomo-cli v${VERSION}`))}
-
-\u547D\u4EE4\u522B\u540D: mihomo, mhm, mh
-
-\u7528\u6CD5:
-  mihomo <\u547D\u4EE4> [\u9009\u9879]
-
-${colors.cyan("\u63A7\u5236:")}
-  ${colors.bold("start")} [tun|mixed]            \u542F\u52A8/\u5207\u6362\u4EE3\u7406 (\u9ED8\u8BA4 mixed)
-  ${colors.bold("stop")}                         \u505C\u6B62\u4EE3\u7406
-  ${colors.bold("status")}                       \u67E5\u770B\u72B6\u6001
-
-${colors.cyan("\u754C\u9762:")}
-  ${colors.bold("ui")} [zash|dash|yacd]          \u6253\u5F00 Web UI (\u9ED8\u8BA4 zash)
-  ${colors.bold("log")} [-o]                     \u5B9E\u65F6\u65E5\u5FD7\uFF08-o \u6253\u5F00\u6587\u4EF6\uFF09
-  ${colors.bold("logs")} [\u7F16\u53F7] [-n N] [-o]      \u65E5\u5FD7\u5217\u8868\uFF080=\u5F53\u524D\uFF0C1+=\u5F52\u6863\uFF09
-
-${colors.cyan("\u8BA2\u9605:")}
-  ${colors.bold("subscription")}                 \u5217\u51FA\u6240\u6709\u8BA2\u9605\uFF08\u522B\u540D sub\uFF09
-  ${colors.bold("subscription")} use <name>      \u5207\u6362\u5F53\u524D\u8BA2\u9605
-  ${colors.bold("subscription")} add <url> [name]  \u6DFB\u52A0\u8BA2\u9605
-  ${colors.bold("subscription")} update [name]   \u66F4\u65B0\u8BA2\u9605\uFF08\u65E0\u53C2\u66F4\u65B0\u6240\u6709\uFF09
-  ${colors.bold("subscription")} remove <name>   \u5220\u9664\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.cyan("\u914D\u7F6E:")}
-  ${colors.bold("overwrite")}                   \u67E5\u770B\u8986\u5199\u72B6\u6001\uFF08\u522B\u540D ow\uFF09
-  ${colors.bold("overwrite")} on|off            \u542F\u7528/\u7981\u7528\u8986\u5199\u914D\u7F6E
-  ${colors.bold("directory")}                   \u663E\u793A\u6570\u636E\u76EE\u5F55\u4F4D\u7F6E\uFF08\u522B\u540D dir\uFF09
-  ${colors.bold("directory")} open [target]     \u6253\u5F00\u76EE\u5F55: root|subs|logs|runtime|...
-
-${colors.cyan("\u7CFB\u7EDF:")}
-  ${colors.bold("kernel")} [--mirror [\u955C\u50CF]]         \u66F4\u65B0\u5185\u6838\uFF08\u9ED8\u8BA4\u76F4\u8FDE\uFF0C--mirror \u4F7F\u7528 v6\uFF09
-  ${colors.bold("update")}                       \u66F4\u65B0 mihomo-cli (npm install -g)
-  ${colors.bold("reset")} [\u76EE\u6807...] [--full]   \u91CD\u7F6E: \u7559\u7A7A\u4FDD\u7559\u8BBE\u7F6E/\u5185\u6838/\u8986\u5199, \u6307\u5B9A\u76EE\u6807\u5220\u5BF9\u5E94\u9879, --full \u5220\u5168\u90E8
-  ${colors.bold("help")}, -h                     \u663E\u793A\u5E2E\u52A9
-  ${colors.bold("version")}, -v                  \u663E\u793A\u7248\u672C
-
-${colors.cyan("\u793A\u4F8B:")}
-  mihomo start              # \u542F\u52A8/\u91CD\u542F Mixed \u6A21\u5F0F
-  mihomo start tun          # \u5207\u6362\u5230 TUN \u900F\u660E\u4EE3\u7406\u6A21\u5F0F
-  mihomo sub add <url>      # \u6DFB\u52A0\u8BA2\u9605 (sub \u662F subscription \u522B\u540D)
-  mihomo ui                 # \u6253\u5F00 Web UI
-
-${colors.cyan("\u6A21\u5F0F\u8BF4\u660E:")}
-  mixed  HTTP + SOCKS5 \u6DF7\u5408\u7AEF\u53E3 (\u9ED8\u8BA4)
-  tun    \u900F\u660E\u4EE3\u7406\uFF0C\u5168\u5C40\u81EA\u52A8\u8DEF\u7531\uFF0C\u9700\u8981 sudo
-
-${colors.cyan("\u6570\u636E\u76EE\u5F55:")}
-  \u73AF\u5883\u53D8\u91CF MIHOMO_CLI_DIR \u53EF\u81EA\u5B9A\u4E49\u4F4D\u7F6E
-  \u9ED8\u8BA4: ${USER_DATA_DIR}
-`
-  );
+function formatProxySummary(info) {
+  const parts = [];
+  if (info.proxyGroups && info.proxyGroups > 0) parts.push(`${info.proxyGroups} \u7EC4`);
+  parts.push(`${info.proxies || 0} \u8282\u70B9`);
+  return parts.join(", ");
 }
-function printVersion() {
-  const kv = getKernelVersion() || "\u672A\u5B89\u88C5";
-  console.log(colors.cyan(colors.bold(`mihomo-cli v${VERSION}`)));
-  console.log(`${colors.gray("\u5185\u6838: ")}${kv}`);
-  console.log(`${colors.gray("\u6570\u636E\u76EE\u5F55: ")}${USER_DATA_DIR}`);
+function getActiveSubscription() {
+  const subs = getSubscriptions();
+  if (subs.length === 0) return null;
+  const settings = readSettings();
+  const activeName = settings.active_subscription;
+  if (activeName) {
+    const found = subs.find((s) => s.name === activeName);
+    if (found) return found;
+  }
+  return subs[0];
 }
-
-// src/kernel.ts
-import { execSync as execSync4, spawnSync } from "child_process";
-import fs6 from "fs";
-import path4 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;
-var validateAndParse = (version) => {
-  if (typeof version !== "string") {
-    throw new TypeError("Invalid argument expected string");
+function findSubscriptionFuzzy(subs, pattern) {
+  const lowerPattern = pattern.toLowerCase();
+  const exact = [];
+  const prefix = [];
+  const includes = [];
+  for (const s of subs) {
+    const name = s.name.toLowerCase();
+    if (name === lowerPattern) {
+      exact.push(s);
+    } else if (name.startsWith(lowerPattern)) {
+      prefix.push(s);
+    } else if (name.includes(lowerPattern)) {
+      includes.push(s);
+    }
   }
-  const match = version.match(semver);
-  if (!match) {
-    throw new Error(`Invalid argument not valid semver ('${version}' received)`);
+  if (exact.length > 0) return exact;
+  if (prefix.length > 0) return prefix;
+  return includes;
+}
+function pickSingleSubscription(subs, pattern) {
+  if (subs.length === 0) {
+    console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u5339\u914D "${pattern}" \u7684\u8BA2\u9605`);
+    process.exit(1);
   }
-  match.shift();
-  return match;
-};
-var isWildcard = (s) => s === "*" || s === "x" || s === "X";
-var tryParse = (v) => {
-  const n = parseInt(v, 10);
-  return isNaN(n) ? v : n;
-};
-var forceType = (a, b) => typeof a !== typeof b ? [String(a), String(b)] : [a, b];
-var compareStrings = (a, b) => {
-  if (isWildcard(a) || isWildcard(b))
-    return 0;
-  const [ap, bp] = forceType(tryParse(a), tryParse(b));
-  if (ap > bp)
-    return 1;
-  if (ap < bp)
-    return -1;
-  return 0;
-};
-var compareSegments = (a, b) => {
-  for (let i = 0; i < Math.max(a.length, b.length); i++) {
-    const r = compareStrings(a[i] || "0", b[i] || "0");
-    if (r !== 0)
-      return r;
+  if (subs.length === 1) return subs[0];
+  console.error("\u9519\u8BEF: \u5339\u914D\u5230\u591A\u4E2A\u8BA2\u9605\uFF0C\u8BF7\u66F4\u7CBE\u786E\u6307\u5B9A");
+  console.log("\n\u5339\u914D\u7684\u8BA2\u9605:");
+  for (const s of subs) console.log(`  ${s.name}`);
+  process.exit(1);
+}
+async function downloadSubscription(url, subName = "default") {
+  let response;
+  try {
+    response = await HTTP_CLIENT.get(url, { responseType: "text" });
+  } catch (e) {
+    const maskedUrl = maskUrl(url);
+    let errorMsg = `\u83B7\u53D6\u8BA2\u9605\u5931\u8D25: ${e.message}`;
+    const err = e;
+    if (err.response) {
+      errorMsg += ` (HTTP ${err.response.status})`;
+    }
+    errorMsg += `
+  URL: ${maskedUrl}`;
+    throw new Error(errorMsg);
   }
-  return 0;
-};
-
-// node_modules/compare-versions/lib/esm/compareVersions.js
-var compareVersions = (v1, v2) => {
-  const n1 = validateAndParse(v1);
-  const n2 = validateAndParse(v2);
-  const p1 = n1.pop();
-  const p2 = n2.pop();
-  const r = compareSegments(n1, n2);
-  if (r !== 0)
-    return r;
-  if (p1 && p2) {
-    return compareSegments(p1.split("."), p2.split("."));
-  } else if (p1 || p2) {
-    return p1 ? -1 : 1;
+  const content = response.data;
+  if (!content?.trim()) {
+    throw new Error("\u8BA2\u9605\u5185\u5BB9\u4E3A\u7A7A");
   }
-  return 0;
-};
-
-// src/kernel.ts
-var GITHUB_REPO = "MetaCubeX/mihomo";
-var KERNEL_HTTP_TIMEOUT = 12e4;
-var KERNEL_DOWNLOAD_TIMEOUT = 18e4;
-var HTTP_CLIENT = createHttpClient({ timeout: KERNEL_HTTP_TIMEOUT });
-function withMirror(url, mirror) {
-  if (mirror && (url.startsWith("https://github.com/") || url.startsWith("https://api.github.com/"))) {
-    return mirror + url;
+  const parsed = parseYamlOrJson(content, "\u8BA2\u9605\u5185\u5BB9");
+  if (!parsed) throw new Error("\u8BA2\u9605\u5185\u5BB9\u4E3A\u7A7A");
+  saveSubscriptionRawConfig(subName, content);
+  const headers = response.headers;
+  const userInfo = parseUserInfo(headers.get("subscription-userinfo"));
+  const updateIntervalHeader = headers.get("profile-update-interval");
+  const updateInterval = updateIntervalHeader ? parseInt(updateIntervalHeader, 10) : null;
+  const webPageUrl = headers.get("profile-web-page-url") || null;
+  const username = parseUsernameFromContentDisposition(headers.get("content-disposition"));
+  const cacheData = { updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+  if (userInfo) {
+    cacheData.upload = userInfo.upload;
+    cacheData.download = userInfo.download;
+    cacheData.total = userInfo.total;
+    cacheData.expire = userInfo.expire;
   }
-  return url;
-}
-function getArch() {
-  const arch = process.arch;
-  if (arch === "arm64") return "arm64";
-  if (arch === "x64") return "amd64";
-  return arch;
+  if (updateInterval) cacheData.update_interval = updateInterval;
+  if (webPageUrl) cacheData.web_page_url = webPageUrl;
+  if (username) cacheData.username = username;
+  saveSubscriptionCache(subName, cacheData);
+  const proxies = parsed.proxies;
+  const proxyGroups = parsed["proxy-groups"];
+  return {
+    proxies: proxies ? proxies.length : 0,
+    proxyGroups: proxyGroups ? proxyGroups.length : 0,
+    userInfo,
+    updateInterval,
+    webPageUrl,
+    username
+  };
 }
-function findMatchingAsset(assets, platform, arch) {
-  const prefix = `mihomo-${platform}-${arch}`;
-  const matchingAssets = assets.filter(
-    (a) => a.name.startsWith(prefix) && a.name.endsWith(".gz") || a.name.startsWith(`${prefix}-`) && a.name.endsWith(".gz")
+async function downloadMergedSubscription(urls, subName) {
+  const responses = await Promise.all(
+    urls.map(async (url, index) => {
+      try {
+        const response = await HTTP_CLIENT.get(url, { responseType: "text" });
+        return { url, index, response, error: null };
+      } catch (e) {
+        return { url, index, response: null, error: e };
+      }
+    })
   );
-  if (matchingAssets.length === 0) return null;
-  if (matchingAssets.length === 1) return matchingAssets[0];
-  const standardAsset = matchingAssets.find((a) => {
-    const nameWithoutGz = a.name.slice(0, -3);
-    const parts = nameWithoutGz.split("-");
-    const lastPart = parts[parts.length - 1];
-    return /^v?\d+\.\d+\.\d+/.test(lastPart) && !nameWithoutGz.includes("-go");
+  for (const r of responses) {
+    if (r.error) {
+      const maskedUrl = maskUrl(r.url);
+      throw new Error(`\u5408\u5E76\u8BA2\u9605\u7B2C ${r.index + 1} \u4E2A URL \u83B7\u53D6\u5931\u8D25: ${r.error.message}
+  URL: ${maskedUrl}`);
+    }
+  }
+  const parsed = responses.map((r, i) => {
+    const content = r.response?.data;
+    if (!content?.trim()) throw new Error(`\u5408\u5E76\u8BA2\u9605\u7B2C ${i + 1} \u4E2A URL \u5185\u5BB9\u4E3A\u7A7A`);
+    return parseYamlOrJson(content, `\u5408\u5E76\u8BA2\u9605\u7B2C ${i + 1} \u4E2A`);
   });
-  return standardAsset || matchingAssets[0];
-}
-async function getLatestRelease(repo, mirror) {
-  const url = withMirror(`https://api.github.com/repos/${repo}/releases`, mirror);
-  const response = await HTTP_CLIENT.get(url, { responseType: "json" });
-  const releases = response.data;
-  if (!Array.isArray(releases) || releases.length === 0) {
-    throw new Error("\u65E0\u6CD5\u83B7\u53D6\u7248\u672C\u4FE1\u606F");
+  const base = parsed[0];
+  const baseProxies = base.proxies || [];
+  const seenNames = new Set(baseProxies.map((p) => p.name));
+  for (let i = 1; i < parsed.length; i++) {
+    const extraProxies = parsed[i].proxies || [];
+    for (const proxy of extraProxies) {
+      if (!seenNames.has(proxy.name)) {
+        baseProxies.push(proxy);
+        seenNames.add(proxy.name);
+      }
+    }
   }
-  const stableReleases = releases.filter(
-    (r) => !r.prerelease && !r.tag_name.toLowerCase().includes("alpha") && !r.tag_name.toLowerCase().includes("beta") && !r.tag_name.toLowerCase().includes("prerelease")
-  );
-  return stableReleases.length > 0 ? stableReleases[0] : releases[0];
+  base.proxies = baseProxies;
+  const mergedContent = jsYaml.dump(base, YAML_DUMP_OPTS);
+  saveSubscriptionRawConfig(subName, mergedContent);
+  const firstHeaders = responses[0].response?.headers;
+  const userInfo = parseUserInfo(firstHeaders?.get("subscription-userinfo") ?? null);
+  const updateIntervalHeader = firstHeaders?.get("profile-update-interval");
+  const updateInterval = updateIntervalHeader ? parseInt(updateIntervalHeader, 10) : null;
+  const webPageUrl = firstHeaders?.get("profile-web-page-url") || null;
+  const username = parseUsernameFromContentDisposition(firstHeaders?.get("content-disposition") ?? null);
+  const cacheData = { updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+  if (userInfo) {
+    cacheData.upload = userInfo.upload;
+    cacheData.download = userInfo.download;
+    cacheData.total = userInfo.total;
+    cacheData.expire = userInfo.expire;
+  }
+  if (updateInterval) cacheData.update_interval = updateInterval;
+  if (webPageUrl) cacheData.web_page_url = webPageUrl;
+  if (username) cacheData.username = username;
+  saveSubscriptionCache(subName, cacheData);
+  const proxyGroups = base["proxy-groups"];
+  return {
+    proxies: baseProxies.length,
+    proxyGroups: proxyGroups ? proxyGroups.length : 0,
+    userInfo,
+    updateInterval,
+    webPageUrl,
+    username
+  };
 }
-async function checkUpdate(mirror) {
-  const currentVersion = getKernelVersion();
-  const latest = await getLatestRelease(GITHUB_REPO, mirror);
-  const latestVersion = latest.tag_name;
-  let needsUpdate = false;
-  const currentDisplay = currentVersion || "\u672A\u5B89\u88C5";
-  if (!currentVersion) {
-    needsUpdate = true;
-  } else {
-    try {
-      needsUpdate = compareVersions(latestVersion.replace(/^v/, ""), currentVersion.replace(/^v/, "")) > 0;
-    } catch {
-      needsUpdate = latestVersion !== currentVersion;
-    }
+function prepareConfigForStart(mode, subName = "default") {
+  const rawContent = readSubscriptionRawConfig(subName);
+  if (!rawContent) {
+    throw new Error(`\u672A\u627E\u5230\u8BA2\u9605\u914D\u7F6E "${subName}"\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605`);
   }
+  const buildResult = buildConfig(rawContent, mode);
+  writeMihomoConfig(buildResult.config);
+  writeDebugConfig(buildResult);
+  const proxies = buildResult.config.proxies;
+  const proxyGroups = buildResult.config["proxy-groups"];
   return {
-    current: currentDisplay,
-    latest: latestVersion,
-    needsUpdate,
-    assets: latest.assets,
-    release: latest
+    proxies: proxies ? proxies.length : 0,
+    proxyGroups: proxyGroups ? proxyGroups.length : 0
   };
 }
-function findBinaryInDir(dir) {
-  const files = fs6.readdirSync(dir);
-  for (const f of files) {
-    const fullPath = path4.join(dir, f);
-    const stat = fs6.statSync(fullPath);
-    if (stat.isDirectory()) {
-      const found = findBinaryInDir(fullPath);
-      if (found) return found;
-      continue;
+function needsAutoUpdate(sub) {
+  if (!sub.updated_at) return true;
+  const lastUpdate = new Date(sub.updated_at).getTime();
+  if (Number.isNaN(lastUpdate)) return true;
+  const intervalHours = sub.update_interval || DEFAULT_UPDATE_INTERVAL_HOURS;
+  const intervalMs = intervalHours * 60 * 60 * 1e3;
+  return Date.now() - lastUpdate > intervalMs;
+}
+async function tryUpdateOne(sub) {
+  try {
+    let info;
+    if (isMultiUrl(sub.url)) {
+      info = await downloadMergedSubscription(splitUrls(sub.url), sub.name);
+    } else {
+      info = await downloadSubscription(sub.url, sub.name);
     }
-    if (f === "mihomo") return fullPath;
-    if (f.includes("mihomo") && !f.endsWith(".gz")) return fullPath;
+    return { name: sub.name, success: true, proxies: info.proxies, proxyGroups: info.proxyGroups };
+  } catch (e) {
+    return { name: sub.name, success: false, error: e.message };
   }
-  return null;
 }
-async function downloadKernel(progressCallback, mirror, releaseInfo) {
-  ensureDirs();
-  const latest = releaseInfo || await getLatestRelease(GITHUB_REPO, mirror);
-  const arch = getArch();
-  const platform = process.platform;
-  const asset = findMatchingAsset(latest.assets, platform, arch);
-  if (!asset) {
-    const available = latest.assets.map((a) => a.name).join(", ");
-    let hint = "";
-    if (available) hint = `
-  \u53EF\u7528\u7248\u672C: ${available}`;
-    throw new Error(`\u672A\u627E\u5230\u5339\u914D\u7684\u5185\u6838\u6587\u4EF6
-  \u5E73\u53F0: ${platform}, \u67B6\u6784: ${arch}${hint}`);
-  }
-  const downloadUrl = withMirror(asset.browser_download_url, mirror);
-  const tempPath = path4.join(DIRS.kernel, asset.name);
-  const sizeMB = (asset.size / 1024 / 1024).toFixed(2);
-  if (progressCallback) {
-    progressCallback(`\u4E0B\u8F7D\u5185\u6838: ${asset.name} (${sizeMB} MB)`);
-  }
-  const curlResult = spawnSync(
-    "curl",
-    ["-L", "--progress-bar", "--connect-timeout", "30", "--max-time", String(Math.floor(KERNEL_DOWNLOAD_TIMEOUT / 1e3)), "-o", tempPath, downloadUrl],
-    { stdio: "inherit" }
-  );
-  if (curlResult.status !== 0) {
-    try {
-      fs6.unlinkSync(tempPath);
-    } catch {
-    }
-    throw new Error(`\u4E0B\u8F7D\u5931\u8D25 (curl \u9000\u51FA\u7801 ${curlResult.status})`);
+async function autoUpdateStaleSubscription() {
+  const allSubs = getSubscriptionsWithCache();
+  const staleSubs = allSubs.filter(needsAutoUpdate);
+  if (staleSubs.length === 0) {
+    return { total: 0, updated: 0, failed: 0 };
   }
-  if (!fs6.existsSync(tempPath)) {
-    throw new Error("\u4E0B\u8F7D\u5931\u8D25: \u6587\u4EF6\u672A\u751F\u6210");
+  if (staleSubs.length === 1) {
+    const sub = staleSubs[0];
+    const interval = sub.update_interval || DEFAULT_UPDATE_INTERVAL_HOURS;
+    console.log(`\u8BA2\u9605 "${sub.name}" \u8D85\u8FC7 ${interval} \u5C0F\u65F6\u672A\u66F4\u65B0\uFF0C\u6B63\u5728\u66F4\u65B0...`);
+  } else {
+    console.log(`\u68C0\u67E5\u5230 ${staleSubs.length} \u4E2A\u8BA2\u9605\u9700\u8981\u66F4\u65B0\uFF0C\u6B63\u5728\u5E76\u884C\u66F4\u65B0...`);
   }
-  if (progressCallback) {
-    progressCallback("\u89E3\u538B\u5185\u6838...");
+  const results = await Promise.all(staleSubs.map(tryUpdateOne));
+  let updatedCount = 0;
+  for (const r of results) {
+    if (r.success) {
+      updatedCount++;
+      console.log(`${colors.green("\u2713")} ${r.name}: ${colors.green("\u5DF2\u66F4\u65B0")} (${formatProxySummary(r)})`);
+    } else {
+      console.log(`${colors.red("\u2717")} ${r.name}: ${colors.red("\u5931\u8D25")} (${(r.error || "").split("\n")[0]})`);
+    }
   }
-  const extractPath = DIRS.kernel;
-  let extractedBinary = null;
+  return { total: staleSubs.length, updated: updatedCount, failed: staleSubs.length - updatedCount };
+}
+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) {
+  const encodedName = encodeURIComponent(proxyName);
+  const url = `${API_BASE}/proxies/${encodedName}/delay?timeout=${timeout}&url=${encodeURIComponent(testUrl)}`;
   try {
-    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 = path4.basename(tempPath, ".gz");
-      const outputPath = path4.join(extractPath, baseName);
-      execSync4(`gzip -dc "${tempPath}" > "${outputPath}"`, { stdio: ["pipe", "pipe", "inherit"] });
-      extractedBinary = outputPath;
+    const response = await client.get(url);
+    const data = JSON.parse(response.data);
+    if (data.delay && data.delay > 0) {
+      return { name: proxyName, delay: data.delay };
     }
+    return { name: proxyName, delay: null, error: data.message || "no delay" };
   } catch (e) {
-    try {
-      fs6.unlinkSync(tempPath);
-    } catch {
+    const err = e;
+    let errorMsg = "timeout";
+    if (err.response?.data?.message) {
+      errorMsg = String(err.response.data.message);
+    } else if (err.message) {
+      errorMsg = err.message;
     }
-    throw new Error(`\u89E3\u538B\u5931\u8D25: ${e.message}`);
+    return { name: proxyName, delay: null, error: errorMsg };
   }
-  const foundBinary = extractedBinary || findBinaryInDir(extractPath);
-  if (!foundBinary) {
-    try {
-      fs6.unlinkSync(tempPath);
-    } catch {
-    }
-    throw new Error("\u89E3\u538B\u540E\u672A\u627E\u5230\u53EF\u6267\u884C\u6587\u4EF6");
+}
+async function testSubscriptionProxies(subName, options = {}) {
+  const { timeout = 2e3, concurrency = 100, testUrl = DEFAULT_TEST_URL, onResult } = options;
+  const { proxies } = options.parsed || loadSubscriptionConfig(subName);
+  if (proxies.length === 0) {
+    return { total: 0, alive: 0, dead: 0, results: [] };
   }
-  const targetPath = PATHS.mihomoBinary;
-  if (foundBinary !== targetPath) {
-    if (fs6.existsSync(targetPath)) {
-      fs6.chmodSync(targetPath, 493);
-      try {
-        fs6.unlinkSync(targetPath);
-      } catch {
-      }
+  const client = createHttpClient({ timeout: timeout + 3e3 });
+  const results = [];
+  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)));
+    for (const result of batchResults) {
+      results.push(result);
+      onResult?.(result, completedCount, proxies.length);
+      completedCount++;
     }
-    fs6.renameSync(foundBinary, targetPath);
-  }
-  fs6.chmodSync(targetPath, 493);
-  try {
-    fs6.unlinkSync(tempPath);
-  } catch {
   }
-  clearKernelVersionCache();
-  return { version: latest.tag_name, path: targetPath };
+  const alive = results.filter((r) => r.delay !== null).length;
+  return { total: results.length, alive, dead: results.length - alive, results };
 }
-
-// src/commands/kernel.ts
-async function cmdKernel(args) {
-  const mirrorInfo = parseMirrorArg(args);
-  const effectiveMirror = mirrorInfo.mirror;
-  if (effectiveMirror) {
-    const mirrorDesc = mirrorInfo.type === "all" ? " (API\u548C\u4E0B\u8F7D\u5747\u4F7F\u7528\u955C\u50CF)" : " (\u4E0B\u8F7D\u65F6\u4F7F\u7528\u955C\u50CF)";
-    console.log(`\u955C\u50CF: ${effectiveMirror}${mirrorDesc}`);
+function normalizeProxyNamesBeforeSave(parsed) {
+  const { proxies, proxyGroups } = parsed;
+  const renameMap = /* @__PURE__ */ new Map();
+  const usedNames = /* @__PURE__ */ new Set();
+  for (const proxy of proxies) {
+    const shortened = proxy.name.replace(/_github\.com\/[^_]+/, "");
+    if (shortened !== proxy.name && !usedNames.has(shortened)) {
+      renameMap.set(proxy.name, shortened);
+      usedNames.add(shortened);
+    } else {
+      usedNames.add(proxy.name);
+    }
   }
-  console.log("\n\u63D0\u793A: \u5982\u679C\u4E0B\u8F7D\u901F\u5EA6\u8FC7\u6162\u6216\u76F4\u8FDE\u5931\u8D25\uFF0C\u53EF\u4F7F\u7528 --mirror \u53C2\u6570\u901A\u8FC7\u955C\u50CF\u4E0B\u8F7D");
-  console.log("\n\u7528\u6CD5:");
-  console.log("  mihomo kernel                    # \u76F4\u8FDE");
-  console.log("  mihomo kernel --mirror           # \u4E0B\u8F7D\u4F7F\u7528\u9ED8\u8BA4\u955C\u50CF (v6.gh-proxy.org)");
-  console.log("  mihomo kernel --mirror hk.gh-proxy.org  # \u4E0B\u8F7D\u4F7F\u7528\u6307\u5B9A\u955C\u50CF");
-  console.log("  mihomo kernel --mirror-all       # API\u8BF7\u6C42\u548C\u4E0B\u8F7D\u90FD\u4F7F\u7528\u9ED8\u8BA4\u955C\u50CF");
-  console.log("  mihomo kernel --mirror-all hk.gh-proxy.org  # API\u548C\u4E0B\u8F7D\u90FD\u4F7F\u7528\u6307\u5B9A\u955C\u50CF");
-  console.log("\n\u53EF\u7528\u955C\u50CF:");
-  for (const m of AVAILABLE_MIRRORS) {
-    const isCurrent = effectiveMirror && (effectiveMirror.includes(`//${m}/`) || effectiveMirror.includes(`//${m}:`) || effectiveMirror.endsWith(`//${m}`));
-    console.log(`  ${m}${isCurrent ? " (\u5F53\u524D)" : ""}`);
+  if (renameMap.size === 0) return 0;
+  for (const proxy of proxies) {
+    const newName = renameMap.get(proxy.name);
+    if (newName) proxy.name = newName;
   }
-  console.log("");
-  console.log("\u68C0\u67E5\u5185\u6838\u66F4\u65B0...");
-  try {
-    const apiMirror = mirrorInfo.type === "all" ? effectiveMirror : null;
-    const info = await checkUpdate(apiMirror);
-    console.log(`\u5F53\u524D: ${info.current}`);
-    console.log(`\u6700\u65B0: ${info.latest}`);
-    if (!info.needsUpdate) {
-      console.log("\u5DF2\u662F\u6700\u65B0\u7248\u672C");
-    } else {
-      console.log("\n\u6B63\u5728\u4E0B\u8F7D...");
-      const result = await downloadKernel((msg) => console.log(msg), mirrorInfo.mirror, info.release);
-      console.log(`
-\u5DF2\u66F4\u65B0\u5230 ${result.version}`);
+  for (const group of proxyGroups) {
+    if (Array.isArray(group.proxies)) {
+      group.proxies = group.proxies.map((name) => renameMap.get(name) || name);
     }
-  } catch (e) {
-    console.error(`
-\u66F4\u65B0\u5931\u8D25: ${e.message}`);
-    const err = e;
-    if (err.response?.data) {
-      if (err.response.data.message) {
-        console.error(`\u539F\u56E0: ${err.response.data.message}`);
+  }
+  return renameMap.size;
+}
+function cleanDeadProxies(parsed, deadNames) {
+  const { proxies, proxyGroups } = parsed;
+  const originalCount = proxies.length;
+  parsed.proxies = proxies.filter((p) => !deadNames.has(p.name));
+  const removedProxies = originalCount - parsed.proxies.length;
+  let updatedGroups = 0;
+  const removedGroupNames = /* @__PURE__ */ new Set();
+  for (const group of proxyGroups) {
+    if (Array.isArray(group.proxies)) {
+      const before = group.proxies.length;
+      group.proxies = group.proxies.filter((name) => !deadNames.has(name));
+      if (group.proxies.length < before) {
+        updatedGroups++;
       }
-      if (err.response.data.documentation_url) {
-        console.error(`\u6587\u6863: ${err.response.data.documentation_url}`);
+      if (group.proxies.length === 0) {
+        removedGroupNames.add(group.name);
       }
     }
-    process.exit(1);
   }
-}
-
-// src/commands/log.ts
-function cmdLog(args) {
-  const logPath = getLogPath();
-  if (hasFlag(args, "-o", "--open")) {
-    openLogFile(logPath);
-    return;
+  if (removedGroupNames.size > 0) {
+    parsed.proxyGroups = proxyGroups.filter((g) => !removedGroupNames.has(g.name));
+    for (const group of parsed.proxyGroups) {
+      if (Array.isArray(group.proxies)) {
+        group.proxies = group.proxies.filter((name) => !removedGroupNames.has(name));
+      }
+    }
   }
-  viewLogWithTail(logPath, { follow: true, lines: 50 });
+  return { removedProxies, updatedGroups, removedGroups: removedGroupNames.size };
 }
-function cmdLogs(args) {
-  const targetName = getNonFlagArg(args, 1);
-  const lines = parseIntArg(args, "-n", "--lines", 100);
-  const openInViewer = hasFlag(args, "-o", "--open");
-  if (targetName) {
-    let logPath;
-    if (targetName === "current" || targetName === "0") {
-      logPath = getLogPath();
+async function autoCleanSubscription(subName, options = {}) {
+  const parsed = loadSubscriptionConfig(subName);
+  const summary = await testSubscriptionProxies(subName, { ...options, parsed });
+  let removedProxies = 0;
+  let updatedGroups = 0;
+  let removedGroups = 0;
+  let skipped = false;
+  if (summary.dead > 0) {
+    if (summary.alive === 0 || summary.alive / summary.total < 0.01) {
+      skipped = true;
     } else {
-      const parsedIdx = parseInt(targetName, 10);
-      if (!Number.isNaN(parsedIdx) && parsedIdx > 0 && String(parsedIdx) === targetName) {
-        const archiveLogs = listLogs();
-        const archive = archiveLogs.archives[parsedIdx - 1];
-        if (!archive) {
-          console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u65E5\u5FD7 "${targetName}"`);
-          console.log('\u4F7F\u7528 "mihomo logs" \u67E5\u770B\u53EF\u7528\u65E5\u5FD7\u5217\u8868');
-          process.exit(1);
-        }
-        logPath = archive.path;
-      } else {
-        logPath = getLogPathByName(targetName);
-      }
-    }
-    if (!logPath) {
-      console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u65E5\u5FD7 "${targetName}"`);
-      console.log('\u4F7F\u7528 "mihomo logs" \u67E5\u770B\u53EF\u7528\u65E5\u5FD7\u5217\u8868');
-      process.exit(1);
-    }
-    if (openInViewer) {
-      openLogFile(logPath);
-      return;
+      const deadNames = new Set(summary.results.filter((r) => r.delay === null).map((r) => r.name));
+      const cleanResult = cleanDeadProxies(parsed, deadNames);
+      removedProxies = cleanResult.removedProxies;
+      updatedGroups = cleanResult.updatedGroups;
+      removedGroups = cleanResult.removedGroups;
     }
-    viewLogWithTail(logPath, { follow: false, lines });
-    return;
   }
-  const logs = listLogs();
-  const all = [];
-  if (logs.current) all.push(logs.current);
-  all.push(...logs.archives);
-  if (all.length === 0) {
-    console.log("\u6682\u65E0\u65E5\u5FD7");
-    return;
+  if (!skipped) {
+    saveSubscriptionConfig(subName, parsed);
   }
+  return { summary, removedProxies, updatedGroups, removedGroups, skipped };
+}
+
+// src/commands/status.ts
+function printStatus() {
+  const status = getStatus();
+  const info = getConfigInfo();
+  const overwriteEnabled = isOverwriteEnabled();
+  const overwriteFiles = listOverwriteFile().files;
+  const activeSub = getActiveSubscription();
   console.log("");
-  console.log("\u65E5\u5FD7\u5217\u8868:");
-  console.log("");
-  let archiveCounter = 0;
-  for (const log of all) {
-    let num;
-    if (log.isCurrent) {
-      num = " 0";
+  let modeLabel = "";
+  if (info && status.running) {
+    modeLabel = colors.cyan(info.tun ? " (TUN)" : " (Mixed)");
+  }
+  const statusText = status.running ? colors.green("\u25CF \u8FD0\u884C\u4E2D") : colors.yellow("\u4E0D\u5728\u8FD0\u884C");
+  console.log(`${colors.gray("\u72B6\u6001: ")}${statusText}${modeLabel}`);
+  console.log(`${colors.gray("\u5185\u6838: ")}${status.kernelVersion || "\u672A\u5B89\u88C5"}`);
+  if (status.pid) {
+    console.log(`${colors.gray("PID:  ")}${status.pid}`);
+    if (status.processInfo) {
+      console.log(`${colors.gray("\u5185\u5B58: ")}${status.processInfo.memory}`);
+    }
+  }
+  if (info) {
+    if (info.mixedPort) {
+      console.log(`${colors.gray("\u7AEF\u53E3: ")}${info.mixedPort}`);
     } else {
-      archiveCounter++;
-      num = archiveCounter < 10 ? ` ${archiveCounter}` : `${archiveCounter}`;
+      const ports = [];
+      if (info.httpPort) ports.push(`HTTP:${info.httpPort}`);
+      if (info.socksPort) ports.push(`SOCKS:${info.socksPort}`);
+      console.log(`${colors.gray("\u7AEF\u53E3: ")}${ports.length > 0 ? ports.join(", ") : "\u672A\u77E5"}`);
     }
-    const time = formatDate(log.mtime);
-    const size = formatBytes(log.size);
-    const name = log.isCurrent ? "mihomo.log (\u5F53\u524D\u8FD0\u884C\u4E2D)" : log.name;
-    console.log(` ${num}. ${name}`);
-    console.log(`    \u65F6\u95F4: ${time}  \u5927\u5C0F: ${size}`);
-    if (!log.isCurrent) {
-      console.log(`    \u67E5\u770B: mihomo logs ${archiveCounter}  \u6216  mihomo logs ${archiveCounter} -o`);
+  }
+  if (activeSub) {
+    let subLine = `${colors.gray("\u8BA2\u9605: ")}${activeSub.name}`;
+    if (info) {
+      subLine += ` (${formatProxySummary(info)})`;
     }
-    console.log("");
+    console.log(subLine);
+  } else {
+    console.log(`${colors.gray("\u8BA2\u9605: ")}\u672A\u914D\u7F6E`);
+  }
+  if (overwriteEnabled && overwriteFiles.length > 0) {
+    const names = overwriteFiles.map((f) => f.name.replace(/^overwrite\.?/, "").replace(/\.ya?ml$/, "") || "\u4E3B\u6587\u4EF6").join(", ");
+    console.log(`${colors.gray("\u8986\u5199: ")}${colors.green("\u5DF2\u542F\u7528")} (${names})`);
+  } else if (overwriteEnabled) {
+    console.log(`${colors.gray("\u8986\u5199: ")}${colors.green("\u5DF2\u542F\u7528")} (\u65E0\u6587\u4EF6)`);
+  } else {
+    console.log(`${colors.gray("\u8986\u5199: ")}${colors.yellow("\u5DF2\u7981\u7528")}`);
   }
-  console.log("\u7528\u6CD5:");
-  console.log("  mihomo logs 0          # \u67E5\u770B\u5F53\u524D\u65E5\u5FD7 (\u6700\u540E 100 \u884C)");
-  console.log("  mihomo logs 1          # \u67E5\u770B\u7B2C 1 \u4E2A\u5F52\u6863\u65E5\u5FD7\uFF08\u6700\u65B0\uFF09");
-  console.log("  mihomo logs 1 -n 200   # \u67E5\u770B 200 \u884C");
-  console.log("  mihomo logs 1 -o       # \u7528\u7CFB\u7EDF\u9ED8\u8BA4\u7A0B\u5E8F\u6253\u5F00");
   console.log("");
 }
 
-// src/commands/overwrite.ts
-import path5 from "path";
-
-// src/subscription.ts
-var DEFAULT_UPDATE_INTERVAL_HOURS = 12;
-var YAML_DUMP_OPTS = { indent: 2, lineWidth: -1, noCompatMode: true };
-var HTTP_CLIENT2 = createHttpClient({ timeout: 6e4 });
-function loadSubscriptionConfig(subName) {
-  const rawContent = readSubscriptionRawConfig(subName);
-  if (!rawContent) {
-    throw new Error(`\u672A\u627E\u5230\u8BA2\u9605\u914D\u7F6E "${subName}"`);
+// src/commands/start.ts
+var AUTO_CLEAN_THRESHOLD = 100;
+var AUTO_CLEAN_THRESHOLD_FREE = 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(", ")}`);
+    console.error("\u8BF7\u624B\u52A8\u8FD0\u884C: sudo pkill -9 mihomo");
+    process.exit(1);
   }
-  const raw = parseYamlOrJson(rawContent, "\u8BA2\u9605\u5185\u5BB9");
-  return {
-    raw,
-    proxies: raw.proxies || [],
-    proxyGroups: raw["proxy-groups"] || []
-  };
-}
-function saveSubscriptionConfig(subName, parsed) {
-  normalizeProxyNamesBeforeSave(parsed);
-  parsed.raw.proxies = parsed.proxies;
-  parsed.raw["proxy-groups"] = parsed.proxyGroups;
-  saveSubscriptionRawConfig(subName, jsYaml.dump(parsed.raw, YAML_DUMP_OPTS));
 }
-function parseUserInfo(header) {
-  if (!header) return null;
-  const info = {};
-  const parts = header.split(";").map((p) => p.trim());
-  for (const part of parts) {
-    const [key, val] = part.split("=").map((s) => s.trim());
-    if (key && val !== void 0) {
-      const numVal = parseFloat(val);
-      info[key] = Number.isNaN(numVal) ? 0 : numVal;
+async function cmdStart(args) {
+  if (!hasKernel()) {
+    console.error('\u9519\u8BEF: \u672A\u627E\u5230\u5185\u6838\uFF0C\u8BF7\u8FD0\u884C "mihomo kernel"');
+    process.exit(1);
+  }
+  const targetMode = args[1] === "tun" ? "tun" : "mixed";
+  const sub = getActiveSubscription();
+  if (!sub) {
+    console.error("\u9519\u8BEF: \u6CA1\u6709\u8BA2\u9605\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605");
+    process.exit(1);
+  }
+  await autoUpdateStaleSubscription();
+  const status = getStatus();
+  const hasProcess = status.running || status.allProcesses.length > 0;
+  if (hasProcess) {
+    const count = status.allProcesses.length > 0 ? status.allProcesses.length : 1;
+    console.log(`\u505C\u6B62 ${count} \u4E2A\u8FDB\u7A0B...`);
+  }
+  handleStopResult(stop());
+  if (hasProcess) {
+    console.log(`${colors.green("\u5DF2\u505C\u6B62\u8FDB\u7A0B")}
+`);
+  }
+  let configInfo;
+  try {
+    configInfo = prepareConfigForStart(targetMode, sub.name);
+  } catch (e) {
+    console.error(`${colors.red("\u914D\u7F6E\u9519\u8BEF:")} ${e.message}`);
+    process.exit(1);
+  }
+  const modeLabel = targetMode === "tun" ? "TUN" : "Mixed";
+  console.log([colors.cyan(modeLabel), sub.name, formatProxySummary(configInfo)].join(" \xB7 "));
+  try {
+    const result = await start(targetMode);
+    console.log(`${colors.green("\u5DF2\u542F\u52A8")} (PID ${result.pid})`);
+  } catch (e) {
+    const msg = e.message;
+    const lines = msg.split("\n");
+    console.error(`${colors.red("\u542F\u52A8\u5931\u8D25:")} ${lines[0]}`);
+    if (lines.length > 1) {
+      for (const line of lines.slice(1)) console.error(line);
     }
+    process.exit(1);
   }
-  return info;
+  const cleanThreshold = sub.name.startsWith("free") ? AUTO_CLEAN_THRESHOLD_FREE : AUTO_CLEAN_THRESHOLD;
+  if (configInfo.proxies > cleanThreshold) {
+    console.log("");
+    console.log(`\u8282\u70B9\u6570 ${configInfo.proxies} \u8D85\u8FC7 ${cleanThreshold}\uFF0C\u81EA\u52A8\u6E05\u7406...`);
+    console.log("");
+    await sleep(1e3);
+    const cleanResult = await autoCleanSubscription(sub.name, { onResult: printTestResult });
+    console.log("");
+    console.log(formatTestSummary(cleanResult.summary));
+    if (cleanResult.skipped) {
+      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 (cleanResult.removedProxies > 0) {
+      console.log(`${colors.green("\u5DF2\u6E05\u7406")}: ${formatCleanSummary(cleanResult)}`);
+      console.log("");
+      console.log("\u91CD\u65B0\u52A0\u8F7D\u914D\u7F6E...");
+      handleStopResult(stop());
+      try {
+        configInfo = prepareConfigForStart(targetMode, sub.name);
+        const result = await start(targetMode);
+        console.log(`${colors.green("\u5DF2\u91CD\u542F")} (PID ${result.pid}) \xB7 ${formatProxySummary(configInfo)}`);
+      } catch (e) {
+        console.error(`${colors.red("\u91CD\u542F\u5931\u8D25:")} ${e.message.split("\n")[0]}`);
+        process.exit(1);
+      }
+    }
+  }
+  printStatus();
 }
-function parseUsernameFromContentDisposition(header) {
-  if (!header) return null;
-  const match = header.match(/filename\s*=\s*["']?([^"';\s]+)["']?/i);
-  if (!match) return null;
-  const filename = match[1];
-  const parts = filename.split("/");
-  return parts[parts.length - 1] || null;
+
+// src/commands/subscription.ts
+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`)}`);
+  } else {
+    console.log(`  ${prefix} ${colors.red("\u2717")} ${result.name} ${colors.gray(result.error || "timeout")}`);
+  }
 }
-function formatProxySummary(info) {
-  const parts = [];
-  if (info.proxyGroups && info.proxyGroups > 0) parts.push(`${info.proxyGroups} \u7EC4`);
-  parts.push(`${info.proxies || 0} \u8282\u70B9`);
+function formatCleanSummary(result) {
+  const parts = [`\u79FB\u9664 ${result.removedProxies} \u4E2A\u8282\u70B9`];
+  if (result.removedGroups > 0) parts.push(`\u5220\u9664 ${result.removedGroups} \u4E2A\u7A7A\u5206\u7EC4`);
+  if (result.updatedGroups > 0) parts.push(`\u66F4\u65B0 ${result.updatedGroups} \u4E2A\u5206\u7EC4`);
   return parts.join(", ");
 }
-function getActiveSubscription() {
+function formatTestSummary(summary) {
+  return `\u7ED3\u679C: ${colors.green(`${summary.alive} \u5B58\u6D3B`)} / ${colors.red(`${summary.dead} \u5931\u8D25`)} / ${summary.total} \u603B\u8BA1`;
+}
+function githubRepoUrl(rawUrl) {
+  const match = rawUrl.match(/raw\.githubusercontent\.com\/([^/]+\/[^/]+)/);
+  if (match) return `https://github.com/${match[1]}`;
+  return null;
+}
+function resolveActiveTestTarget(args) {
   const subs = getSubscriptions();
-  if (subs.length === 0) return null;
-  const settings = readSettings();
-  const activeName = settings.active_subscription;
-  if (activeName) {
-    const found = subs.find((s) => s.name === activeName);
-    if (found) return found;
+  if (subs.length === 0) {
+    console.error("\u9519\u8BEF: \u6CA1\u6709\u8BA2\u9605");
+    process.exit(1);
   }
-  return subs[0];
+  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 {
+    if (!activeSub) {
+      console.error("\u9519\u8BEF: \u6CA1\u6709\u6D3B\u8DC3\u8BA2\u9605");
+      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 };
 }
-function findSubscriptionFuzzy(subs, pattern) {
-  const lowerPattern = pattern.toLowerCase();
-  const exact = [];
-  const prefix = [];
-  const includes = [];
-  for (const s of subs) {
-    const name = s.name.toLowerCase();
-    if (name === lowerPattern) {
-      exact.push(s);
-    } else if (name.startsWith(lowerPattern)) {
-      prefix.push(s);
-    } else if (name.includes(lowerPattern)) {
-      includes.push(s);
+async function printSubscriptionList(options) {
+  if (options?.autoUpdate !== false) {
+    const updateResult = await autoUpdateStaleSubscription();
+    if (updateResult.total > 0) console.log("");
+  }
+  const subs = getSubscriptionsWithCache();
+  if (subs.length === 0) {
+    console.log("\u6CA1\u6709\u8BA2\u9605");
+    console.log("");
+    console.log("\u6DFB\u52A0\u8BA2\u9605: mihomo sub add <url> [name]");
+    console.log("");
+    return;
+  }
+  const activeSub = getActiveSubscription();
+  console.log(colors.cyan("\u8BA2\u9605\u5217\u8868:"));
+  subs.forEach((s, i) => {
+    const time = formatDate(s.updated_at);
+    const defaultMark = activeSub && s.name === activeSub.name ? colors.green(" [\u4F7F\u7528\u4E2D]") : "";
+    const mergeBadge = isMultiUrl(s.url) ? colors.cyan(` [\u5408\u5E76 ${splitUrls(s.url).length} \u6E90]`) : "";
+    const interval = s.update_interval || DEFAULT_UPDATE_INTERVAL_HOURS;
+    console.log(`  ${i + 1}. ${s.name}${defaultMark}${mergeBadge}`);
+    console.log(`    ${colors.gray("\u66F4\u65B0: ")}${time} (\u95F4\u9694: ${interval}h)`);
+    if (s.username) {
+      console.log(`    ${colors.gray("\u7528\u6237: ")}${s.username}`);
+    }
+    if (s.download !== void 0 || s.total !== void 0) {
+      const used = (s.upload || 0) + (s.download || 0);
+      const usedStr = formatBytes(used);
+      const totalStr = formatBytes(s.total);
+      let percentStr = "";
+      if (s.total && s.total > 0) {
+        const percent = Math.min(used / s.total * 100, 100);
+        percentStr = ` (${percent.toFixed(1)}%)`;
+      }
+      console.log(`    ${colors.gray("\u6D41\u91CF: ")}${usedStr} / ${totalStr}${percentStr}`);
+    }
+    if (s.expire !== void 0) {
+      console.log(`    ${colors.gray("\u5230\u671F: ")}${formatTimestamp(s.expire)}`);
+    }
+    if (s.web_page_url) {
+      console.log(`    ${colors.gray("\u9875\u9762: ")}${s.web_page_url}`);
+    }
+  });
+  console.log("");
+  console.log("\u5207\u6362\u8BA2\u9605: mihomo sub use <name>");
+  console.log("\u65B0\u589E\u8BA2\u9605: mihomo sub add <url> [name]");
+  console.log("\u66F4\u65B0\u8BA2\u9605: mihomo sub update [name]");
+  console.log("\u5220\u9664\u8BA2\u9605: mihomo sub remove <name>");
+  console.log("\u6D4B\u8BD5\u8282\u70B9: mihomo sub test [name]");
+  console.log("\u6E05\u7406\u8282\u70B9: mihomo sub clean [name]");
+  console.log("\u6253\u5F00\u9875\u9762: mihomo sub web [name]");
+  console.log("");
+}
+function printFreeSourceList() {
+  const freeSources = getFreeSubscriptionSources();
+  console.log(`  00  \u5408\u5E76 #1 + #2 (\u8282\u70B9\u66F4\u591A)`);
+  for (let i = 0; i < freeSources.length; i++) {
+    console.log(`  ${String(i + 1).padStart(2, "0")}  ${freeSources[i].name}`);
+  }
+}
+async function addFreeSubscription(freeId) {
+  const freeSources = getFreeSubscriptionSources();
+  if (freeId === 0) {
+    const sources = [freeSources[0], freeSources[1]];
+    const urls = sources.map((s) => s.url);
+    const mergedUrl = urls.join(",");
+    const name2 = "free0";
+    console.log(`\u6DFB\u52A0\u5408\u5E76\u514D\u8D39\u8BA2\u9605: ${name2} (${sources.map((s) => s.name).join(" + ")})`);
+    try {
+      addSubscription(mergedUrl, name2);
+      setDefaultSubscription(name2);
+      const info = await downloadMergedSubscription(urls, name2);
+      const repoUrls = sources.map((s) => githubRepoUrl(s.url)).filter(Boolean);
+      if (repoUrls.length > 0) saveSubscriptionCache(name2, { web_page_url: repoUrls.join(", ") });
+      console.log(`\u5DF2\u6DFB\u52A0\u5E76\u5207\u6362\u5230 "${name2}" (${formatProxySummary(info)}, \u5408\u5E76 ${sources.length} \u6E90)`);
+    } catch (e) {
+      console.error(`\u6DFB\u52A0\u5931\u8D25: ${e.message}`);
+      process.exit(1);
     }
+    console.log("");
+    await printSubscriptionList();
+    return;
   }
-  if (exact.length > 0) return exact;
-  if (prefix.length > 0) return prefix;
-  return includes;
-}
-function pickSingleSubscription(subs, pattern) {
-  if (subs.length === 0) {
-    console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u5339\u914D "${pattern}" \u7684\u8BA2\u9605`);
+  if (freeId < 1 || freeId > freeSources.length) {
+    console.error(`\u9519\u8BEF: \u514D\u8D39\u8BA2\u9605 ID \u8303\u56F4 0-${freeSources.length}`);
+    console.log("\n\u53EF\u7528\u6E90:");
+    printFreeSourceList();
     process.exit(1);
   }
-  if (subs.length === 1) return subs[0];
-  console.error("\u9519\u8BEF: \u5339\u914D\u5230\u591A\u4E2A\u8BA2\u9605\uFF0C\u8BF7\u66F4\u7CBE\u786E\u6307\u5B9A");
-  console.log("\n\u5339\u914D\u7684\u8BA2\u9605:");
-  for (const s of subs) console.log(`  ${s.name}`);
-  process.exit(1);
-}
-async function downloadSubscription(url, subName = "default") {
-  let response;
+  const source = freeSources[freeId - 1];
+  const name = `free${freeId}`;
+  console.log(`\u6DFB\u52A0\u514D\u8D39\u8BA2\u9605: ${name}`);
   try {
-    response = await HTTP_CLIENT2.get(url, { responseType: "text" });
+    addSubscription(source.url, name);
+    setDefaultSubscription(name);
+    const info = await downloadSubscription(source.url, name);
+    const repoUrl = githubRepoUrl(source.url);
+    if (repoUrl) saveSubscriptionCache(name, { web_page_url: repoUrl });
+    console.log(`\u5DF2\u6DFB\u52A0\u5E76\u5207\u6362\u5230 "${name}" (${formatProxySummary(info)})`);
   } catch (e) {
-    const maskedUrl = maskUrl(url);
-    let errorMsg = `\u83B7\u53D6\u8BA2\u9605\u5931\u8D25: ${e.message}`;
-    const err = e;
-    if (err.response) {
-      errorMsg += ` (HTTP ${err.response.status})`;
-    }
-    errorMsg += `
-  URL: ${maskedUrl}`;
-    throw new Error(errorMsg);
-  }
-  const content = response.data;
-  if (!content?.trim()) {
-    throw new Error("\u8BA2\u9605\u5185\u5BB9\u4E3A\u7A7A");
-  }
-  const parsed = parseYamlOrJson(content, "\u8BA2\u9605\u5185\u5BB9");
-  if (!parsed) throw new Error("\u8BA2\u9605\u5185\u5BB9\u4E3A\u7A7A");
-  saveSubscriptionRawConfig(subName, content);
-  const headers = response.headers;
-  const userInfo = parseUserInfo(headers.get("subscription-userinfo"));
-  const updateIntervalHeader = headers.get("profile-update-interval");
-  const updateInterval = updateIntervalHeader ? parseInt(updateIntervalHeader, 10) : null;
-  const webPageUrl = headers.get("profile-web-page-url") || null;
-  const username = parseUsernameFromContentDisposition(headers.get("content-disposition"));
-  const cacheData = { updated_at: (/* @__PURE__ */ new Date()).toISOString() };
-  if (userInfo) {
-    cacheData.upload = userInfo.upload;
-    cacheData.download = userInfo.download;
-    cacheData.total = userInfo.total;
-    cacheData.expire = userInfo.expire;
+    console.error(`\u6DFB\u52A0\u5931\u8D25: ${e.message}`);
+    process.exit(1);
   }
-  if (updateInterval) cacheData.update_interval = updateInterval;
-  if (webPageUrl) cacheData.web_page_url = webPageUrl;
-  if (username) cacheData.username = username;
-  saveSubscriptionCache(subName, cacheData);
-  const proxies = parsed.proxies;
-  const proxyGroups = parsed["proxy-groups"];
-  return {
-    proxies: proxies ? proxies.length : 0,
-    proxyGroups: proxyGroups ? proxyGroups.length : 0,
-    userInfo,
-    updateInterval,
-    webPageUrl,
-    username
-  };
+  console.log("");
+  await printSubscriptionList();
 }
-function prepareConfigForStart(mode, subName = "default") {
-  const rawContent = readSubscriptionRawConfig(subName);
-  if (!rawContent) {
-    throw new Error(`\u672A\u627E\u5230\u8BA2\u9605\u914D\u7F6E "${subName}"\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605`);
+async function cmdSubscription(args) {
+  const action = args[1];
+  if (!action || action === "list") {
+    await printSubscriptionList();
+    return;
   }
-  const buildResult = buildConfig(rawContent, mode);
-  writeMihomoConfig(buildResult.config);
-  writeDebugConfig(buildResult);
-  const proxies = buildResult.config.proxies;
-  const proxyGroups = buildResult.config["proxy-groups"];
-  return {
-    proxies: proxies ? proxies.length : 0,
-    proxyGroups: proxyGroups ? proxyGroups.length : 0
-  };
-}
-function needsAutoUpdate(sub) {
-  if (!sub.updated_at) return true;
-  const lastUpdate = new Date(sub.updated_at).getTime();
-  if (Number.isNaN(lastUpdate)) return true;
-  const intervalHours = sub.update_interval || DEFAULT_UPDATE_INTERVAL_HOURS;
-  const intervalMs = intervalHours * 60 * 60 * 1e3;
-  return Date.now() - lastUpdate > intervalMs;
-}
-async function tryUpdateOne(sub) {
-  try {
-    const info = await downloadSubscription(sub.url, sub.name);
-    return { name: sub.name, success: true, proxies: info.proxies, proxyGroups: info.proxyGroups };
-  } catch (e) {
-    return { name: sub.name, success: false, error: e.message };
+  if (action === "free") {
+    const id = parseInt(args[2], 10);
+    if (Number.isNaN(id)) {
+      console.log("\u7528\u6CD5: mihomo sub free <id>\n");
+      console.log("\u53EF\u7528\u6E90:");
+      printFreeSourceList();
+      process.exit(1);
+    }
+    await addFreeSubscription(id);
+    return;
   }
-}
-async function autoUpdateStaleSubscription() {
-  const allSubs = getSubscriptionsWithCache();
-  const staleSubs = allSubs.filter(needsAutoUpdate);
-  if (staleSubs.length === 0) {
-    return { total: 0, updated: 0, failed: 0 };
+  if (action === "add") {
+    const freeId = parseIntArg(args, "--free", "--free", -1);
+    if (freeId > 0) {
+      await addFreeSubscription(freeId);
+      return;
+    }
+    const url = args[2];
+    const name = args[3] || "default";
+    if (!url) {
+      console.error("\u9519\u8BEF: \u8BF7\u63D0\u4F9B\u6709\u6548\u7684\u8BA2\u9605 URL");
+      process.exit(1);
+    }
+    if (isMultiUrl(url)) {
+      const urls = splitUrls(url);
+      for (const u of urls) {
+        if (!u.startsWith("http")) {
+          console.error(`\u9519\u8BEF: \u65E0\u6548\u7684 URL: ${u}`);
+          process.exit(1);
+        }
+      }
+      console.log(`\u6DFB\u52A0\u5408\u5E76\u8BA2\u9605: ${name} (${urls.length} \u4E2A\u6E90)`);
+      try {
+        addSubscription(url, name);
+        setDefaultSubscription(name);
+        const info = await downloadMergedSubscription(urls, name);
+        console.log(`\u5DF2\u6DFB\u52A0\u5E76\u5207\u6362\u5230 "${name}" (${formatProxySummary(info)}, \u5408\u5E76 ${urls.length} \u6E90)`);
+      } catch (e) {
+        console.error(`\u6DFB\u52A0\u5931\u8D25: ${e.message}`);
+        process.exit(1);
+      }
+    } else {
+      if (!url.startsWith("http")) {
+        console.error("\u9519\u8BEF: \u8BF7\u63D0\u4F9B\u6709\u6548\u7684\u8BA2\u9605 URL");
+        process.exit(1);
+      }
+      console.log(`\u6DFB\u52A0\u8BA2\u9605: ${name}`);
+      try {
+        addSubscription(url, name);
+        setDefaultSubscription(name);
+        const info = await downloadSubscription(url, name);
+        const repoUrl = githubRepoUrl(url);
+        if (repoUrl) saveSubscriptionCache(name, { web_page_url: repoUrl });
+        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();
+    return;
   }
-  if (staleSubs.length === 1) {
-    const sub = staleSubs[0];
-    const interval = sub.update_interval || DEFAULT_UPDATE_INTERVAL_HOURS;
-    console.log(`\u8BA2\u9605 "${sub.name}" \u8D85\u8FC7 ${interval} \u5C0F\u65F6\u672A\u66F4\u65B0\uFF0C\u6B63\u5728\u66F4\u65B0...`);
-  } else {
-    console.log(`\u68C0\u67E5\u5230 ${staleSubs.length} \u4E2A\u8BA2\u9605\u9700\u8981\u66F4\u65B0\uFF0C\u6B63\u5728\u5E76\u884C\u66F4\u65B0...`);
+  if (action === "update") {
+    const name = args[2];
+    const subs = getSubscriptions();
+    if (subs.length === 0) {
+      console.error("\u9519\u8BEF: \u6CA1\u6709\u8BA2\u9605");
+      process.exit(1);
+    }
+    if (!name) {
+      console.log(`\u66F4\u65B0\u6240\u6709 ${subs.length} \u4E2A\u8BA2\u9605...`);
+      const results = await Promise.all(subs.map(tryUpdateOne));
+      let ok = 0;
+      for (const r of results) {
+        if (r.success) {
+          ok++;
+          console.log(`${colors.green("\u2713")} ${r.name}: ${colors.green("\u5DF2\u66F4\u65B0")} (${formatProxySummary(r)})`);
+        } else {
+          console.log(`${colors.red("\u2717")} ${r.name}: ${colors.red("\u5931\u8D25")} (${(r.error || "").split("\n")[0]})`);
+        }
+      }
+      if (ok === 0) process.exit(1);
+      console.log("");
+      await printSubscriptionList();
+      return;
+    }
+    const matches = findSubscriptionFuzzy(subs, name);
+    const target = pickSingleSubscription(matches, name);
+    console.log(`\u66F4\u65B0\u8BA2\u9605: ${target.name}`);
+    try {
+      let info;
+      if (isMultiUrl(target.url)) {
+        const urls = splitUrls(target.url);
+        info = await downloadMergedSubscription(urls, target.name);
+      } else {
+        info = await downloadSubscription(target.url, target.name);
+      }
+      console.log(`\u5DF2\u66F4\u65B0 (${formatProxySummary(info)})`);
+    } catch (e) {
+      console.error(`\u66F4\u65B0\u5931\u8D25: ${e.message}`);
+      process.exit(1);
+    }
+    console.log("");
+    await printSubscriptionList();
+    return;
   }
-  const results = await Promise.all(staleSubs.map(tryUpdateOne));
-  let updatedCount = 0;
-  for (const r of results) {
-    if (r.success) {
-      updatedCount++;
-      console.log(`${colors.green("\u2713")} ${r.name}: ${colors.green("\u5DF2\u66F4\u65B0")} (${formatProxySummary(r)})`);
+  if (action === "use") {
+    const name = args[2];
+    const subs = getSubscriptions();
+    if (!name) {
+      console.error("\u9519\u8BEF: \u8BF7\u6307\u5B9A\u8BA2\u9605\u540D\u79F0");
+      if (subs.length > 0) {
+        console.log("\n\u53EF\u7528\u8BA2\u9605:");
+        for (const s of subs) console.log(`  ${s.name}`);
+      }
+      process.exit(1);
+    }
+    const matches = findSubscriptionFuzzy(subs, name);
+    const target = pickSingleSubscription(matches, name);
+    const currentDefault = getActiveSubscription();
+    const isAlreadyDefault = currentDefault && currentDefault.name === target.name;
+    if (isAlreadyDefault) {
+      console.log(`"${target.name}" \u5DF2\u662F\u5F53\u524D\u4F7F\u7528\u7684\u8BA2\u9605`);
+      console.log("");
+      await printSubscriptionList();
+      return;
+    }
+    const status = getStatus();
+    const configInfo = getConfigInfo();
+    const currentMode = configInfo?.tun ? "tun" : "mixed";
+    const success = setDefaultSubscription(target.name);
+    if (success) {
+      console.log(`\u5DF2\u5207\u6362\u5230 "${target.name}"`);
     } else {
-      console.log(`${colors.red("\u2717")} ${r.name}: ${colors.red("\u5931\u8D25")} (${(r.error || "").split("\n")[0]})`);
+      console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u8BA2\u9605 "${name}"`);
+      process.exit(1);
+    }
+    if (status.running) {
+      console.log("");
+      await cmdStart(["start", currentMode]);
+      return;
+    }
+    console.log("");
+    await printSubscriptionList();
+    return;
+  }
+  if (action === "web" || action === "open") {
+    const name = args[2];
+    const subs = getSubscriptionsWithCache();
+    if (subs.length === 0) {
+      console.error("\u9519\u8BEF: \u6CA1\u6709\u8BA2\u9605");
+      process.exit(1);
+    }
+    let target;
+    if (name) {
+      const matches = findSubscriptionFuzzy(subs, name);
+      target = pickSingleSubscription(matches, name);
+    } else {
+      target = subs[0];
+    }
+    const cached = getSubscriptionsWithCache().find((s) => s.name === target.name);
+    let webPageUrl = cached?.web_page_url;
+    if (!webPageUrl) {
+      console.log("\u8BA2\u9605\u4FE1\u606F\u4E2D\u7F3A\u5C11\u9875\u9762\u5730\u5740\uFF0C\u6B63\u5728\u66F4\u65B0\u8BA2\u9605...");
+      try {
+        await downloadSubscription(target.url, target.name);
+        const cache = readSubscriptionCache();
+        if (cache[target.name]?.web_page_url) {
+          webPageUrl = cache[target.name].web_page_url;
+        } else {
+          console.error("\u9519\u8BEF: \u8BE5\u8BA2\u9605\u6CA1\u6709\u63D0\u4F9B\u9875\u9762\u5730\u5740");
+          process.exit(1);
+        }
+      } catch (e) {
+        console.error(`\u66F4\u65B0\u5931\u8D25: ${e.message}`);
+        process.exit(1);
+      }
+    }
+    console.log(`\u6253\u5F00\u8BA2\u9605\u9875\u9762: ${webPageUrl}`);
+    const opened = openUrl(webPageUrl);
+    if (!opened) {
+      console.log("\u8BF7\u624B\u52A8\u8BBF\u95EE\u4E0A\u9762\u7684\u5730\u5740");
     }
+    return;
   }
-  return { total: staleSubs.length, updated: updatedCount, failed: staleSubs.length - updatedCount };
-}
-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) {
-  const encodedName = encodeURIComponent(proxyName);
-  const url = `${API_BASE}/proxies/${encodedName}/delay?timeout=${timeout}&url=${encodeURIComponent(testUrl)}`;
-  try {
-    const response = await client.get(url);
-    const data = JSON.parse(response.data);
-    if (data.delay && data.delay > 0) {
-      return { name: proxyName, delay: data.delay };
+  if (action === "remove" || action === "rm" || action === "delete") {
+    const name = args[2];
+    const subs = getSubscriptions();
+    if (!name) {
+      console.error("\u9519\u8BEF: \u8BF7\u6307\u5B9A\u8981\u5220\u9664\u7684\u8BA2\u9605\u540D\u79F0");
+      if (subs.length > 0) {
+        console.log("\n\u53EF\u7528\u8BA2\u9605:");
+        for (const s of subs) console.log(`  ${s.name}`);
+      }
+      process.exit(1);
     }
-    return { name: proxyName, delay: null, error: data.message || "no delay" };
-  } catch (e) {
-    const err = e;
-    let errorMsg = "timeout";
-    if (err.response?.data?.message) {
-      errorMsg = String(err.response.data.message);
-    } else if (err.message) {
-      errorMsg = err.message;
+    const matches = findSubscriptionFuzzy(subs, name);
+    const target = pickSingleSubscription(matches, name);
+    const switchedTo = removeSubscription(target.name);
+    console.log(`\u5DF2\u5220\u9664\u8BA2\u9605 "${target.name}"`);
+    if (switchedTo) {
+      console.log(`\u5DF2\u81EA\u52A8\u5207\u6362\u5230 "${switchedTo}"`);
     }
-    return { name: proxyName, delay: null, error: errorMsg };
+    console.log("");
+    await printSubscriptionList({ autoUpdate: false });
+    return;
+  }
+  if (action === "clean") {
+    const { target, timeout, concurrency } = resolveActiveTestTarget(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
+    });
+    console.log("");
+    console.log(formatTestSummary(result.summary));
+    if (result.skipped) {
+      console.log("");
+      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)");
+    }
+    return;
+  }
+  if (action === "test") {
+    const { target, timeout, concurrency } = resolveActiveTestTarget(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
+    });
+    console.log("");
+    console.log(formatTestSummary(summary));
+    return;
   }
+  console.error("\u9519\u8BEF: \u672A\u77E5\u7684\u8BA2\u9605\u547D\u4EE4");
+  console.log("\u7528\u6CD5: mihomo sub [list|use|add|update|remove|web|test|clean]");
+  process.exit(1);
 }
-async function testSubscriptionProxies(subName, options = {}) {
-  const { timeout = 2e3, concurrency = 100, testUrl = DEFAULT_TEST_URL, onResult } = options;
-  const { proxies } = options.parsed || loadSubscriptionConfig(subName);
-  if (proxies.length === 0) {
-    return { total: 0, alive: 0, dead: 0, results: [] };
+
+// src/commands/bench.ts
+function printRanking(results, sourceOrder) {
+  const valid = results.filter((r) => r.downloadOk && r.alive > 0).sort((a, b) => {
+    const rateA = a.alive / a.totalProxies;
+    const rateB = b.alive / b.totalProxies;
+    if (Math.abs(rateA - rateB) > 0.1) return rateB - rateA;
+    return a.medianDelay - b.medianDelay;
+  });
+  if (valid.length === 0) {
+    console.log(colors.yellow("\u6CA1\u6709\u53EF\u7528\u7684\u8BA2\u9605\u6E90"));
+    return;
   }
-  const client = createHttpClient({ timeout: timeout + 3e3 });
-  const results = [];
-  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)));
-    for (const result of batchResults) {
-      results.push(result);
-      onResult?.(result, completedCount, proxies.length);
-      completedCount++;
-    }
+  console.log(colors.cyan("\u6392\u540D:"));
+  console.log("");
+  const namedResults = valid.map((r) => {
+    const idx = sourceOrder.get(r.name) ?? 0;
+    return { ...r, displayName: `${String(idx + 1).padStart(2, "0")}-${r.name}` };
+  });
+  const nameWidth = Math.max(12, ...namedResults.map((r) => r.displayName.length));
+  const h = (s, w) => s + " ".repeat(Math.max(0, w - displayWidth(s)));
+  console.log(
+    `  ${"#".padStart(3)}  ${h("\u540D\u79F0", nameWidth)}  ${h("\u5B58\u6D3B\u7387", 8)}  ${h("\u5B58\u6D3B", 6)}  ${h("\u603B\u6570", 6)}  ${h("\u5206\u7EC4", 6)}  ${h("\u4E2D\u4F4D", 7)}  ${h("\u5E73\u5747", 7)}`
+  );
+  console.log(
+    `  ${"\u2500".repeat(3)}  ${"\u2500".repeat(nameWidth)}  ${"\u2500".repeat(8)}  ${"\u2500".repeat(6)}  ${"\u2500".repeat(6)}  ${"\u2500".repeat(6)}  ${"\u2500".repeat(7)}  ${"\u2500".repeat(7)}`
+  );
+  for (let i = 0; i < namedResults.length; i++) {
+    const r = namedResults[i];
+    const rate = (r.alive / r.totalProxies * 100).toFixed(1);
+    const rateColor = r.alive / r.totalProxies > 0.3 ? colors.green : colors.yellow;
+    const groups = r.proxyGroups > 0 ? String(r.proxyGroups) : "-";
+    console.log(
+      `  ${String(i + 1).padStart(3)}  ${r.displayName.padEnd(nameWidth)}  ${rateColor(h(`${rate}%`, 8))}  ${String(r.alive).padEnd(6)}  ${String(r.totalProxies).padEnd(6)}  ${groups.padEnd(6)}  ${h(`${r.medianDelay}ms`, 7)}  ${h(`${r.avgDelay}ms`, 7)}`
+    );
+  }
+  console.log("");
+  const failed = results.filter((r) => !r.downloadOk);
+  const noAlive = results.filter((r) => r.downloadOk && r.alive === 0);
+  if (failed.length > 0) {
+    const names = failed.map((r) => `${String((sourceOrder.get(r.name) ?? 0) + 1).padStart(2, "0")}-${r.name}`);
+    console.log(colors.gray(`\u4E0B\u8F7D\u5931\u8D25: ${names.join(", ")}`));
+  }
+  if (noAlive.length > 0) {
+    const names = noAlive.map((r) => `${String((sourceOrder.get(r.name) ?? 0) + 1).padStart(2, "0")}-${r.name}`);
+    console.log(colors.gray(`\u65E0\u5B58\u6D3B\u8282\u70B9: ${names.join(", ")}`));
   }
-  const alive = results.filter((r) => r.delay !== null).length;
-  return { total: results.length, alive, dead: results.length - alive, results };
 }
-function normalizeProxyNamesBeforeSave(parsed) {
-  const { proxies, proxyGroups } = parsed;
-  const renameMap = /* @__PURE__ */ new Map();
-  const usedNames = /* @__PURE__ */ new Set();
-  for (const proxy of proxies) {
-    const shortened = proxy.name.replace(/_github\.com\/[^_]+/, "");
-    if (shortened !== proxy.name && !usedNames.has(shortened)) {
-      renameMap.set(proxy.name, shortened);
-      usedNames.add(shortened);
-    } else {
-      usedNames.add(proxy.name);
-    }
+async function cmdBench(args) {
+  if (!hasKernel()) {
+    console.error('\u9519\u8BEF: \u672A\u627E\u5230\u5185\u6838\uFF0C\u8BF7\u8FD0\u884C "mihomo kernel"');
+    process.exit(1);
   }
-  if (renameMap.size === 0) return 0;
-  for (const proxy of proxies) {
-    const newName = renameMap.get(proxy.name);
-    if (newName) proxy.name = newName;
+  const timeout = parseIntArg(args, "-t", "--timeout", 1500);
+  const concurrency = parseIntArg(args, "-j", "--concurrency", 100);
+  const nameFilter = getNonFlagArg(args, 1);
+  const allSources = getFreeSubscriptionSources();
+  const sourceOrder = new Map(allSources.map((s, i) => [s.name, i]));
+  let sources = allSources;
+  if (nameFilter) {
+    const lower = nameFilter.toLowerCase();
+    sources = sources.filter((s) => s.name.toLowerCase().includes(lower));
+    if (sources.length === 0) {
+      console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u5339\u914D "${nameFilter}" \u7684\u8BA2\u9605\u6E90`);
+      console.log("\n\u53EF\u7528\u6E90:");
+      for (const s of allSources) console.log(`  ${s.name}`);
+      process.exit(1);
+    }
   }
-  for (const group of proxyGroups) {
-    if (Array.isArray(group.proxies)) {
-      group.proxies = group.proxies.map((name) => renameMap.get(name) || name);
+  console.log(colors.cyan(`\u57FA\u51C6\u6D4B\u8BD5 ${sources.length} \u4E2A\u514D\u8D39\u8BA2\u9605\u6E90`));
+  console.log(`\u8D85\u65F6: ${timeout}ms  \u5E76\u53D1: ${concurrency}`);
+  console.log("");
+  try {
+    console.log(colors.cyan("\u4E0B\u8F7D\u8BA2\u9605..."));
+    const downloaded = await downloadAllSources(sources, (name, ok, count, groups, error) => {
+      const idx = String((sourceOrder.get(name) ?? 0) + 1).padStart(2, "0");
+      if (ok) {
+        const groupsInfo = groups > 0 ? ` ${groups}\u7EC4` : "";
+        console.log(`  ${colors.green("\u2713")} ${idx}-${name}: ${count} \u4E2A\u8282\u70B9${groupsInfo}`);
+      } else {
+        console.log(`  ${colors.red("\u2717")} ${idx}-${name}: ${colors.gray(error || "\u5931\u8D25")}`);
+      }
+    });
+    const allProxies = downloaded.flatMap((d) => d.proxies);
+    const successSources = downloaded.filter((d) => d.proxies.length > 0);
+    if (allProxies.length === 0) {
+      console.log("");
+      console.log(colors.red("\u6240\u6709\u8BA2\u9605\u6E90\u4E0B\u8F7D\u5931\u8D25\u6216\u65E0\u8282\u70B9"));
+      return;
     }
+    console.log("");
+    console.log(`\u5171 ${allProxies.length} \u4E2A\u8282\u70B9\uFF0C\u6765\u81EA ${successSources.length} \u4E2A\u6E90`);
+    console.log("");
+    const filtered = buildMergedBenchConfig(allProxies);
+    if (filtered > 0) {
+      console.log(colors.gray(`\u8FC7\u6EE4 ${filtered} \u4E2A\u65E0\u6548\u8282\u70B9\uFF0C\u5269\u4F59 ${allProxies.length} \u4E2A`));
+    }
+    const survivingSet = new Set(allProxies);
+    for (const d of downloaded) {
+      d.proxies = d.proxies.filter((p) => survivingSet.has(p));
+    }
+    const benchPort = BENCH_CONFIG.port;
+    const benchApi = BENCH_CONFIG["external-controller"];
+    console.log(colors.cyan("\u542F\u52A8\u6D4B\u8BD5\u5B9E\u4F8B..."));
+    await startBenchInstance();
+    console.log(`${colors.green("\u5DF2\u542F\u52A8")} (\u7AEF\u53E3 ${benchPort}/${benchApi.split(":")[1]})`);
+    console.log("");
+    console.log(colors.cyan("\u6D4B\u8BD5\u8282\u70B9\u5EF6\u8FDF..."));
+    const allNames = allProxies.map((p) => p.name);
+    const testResults = await testBenchProxies(allNames, {
+      timeout,
+      concurrency,
+      onBatch: (batch, total, alive, tested, median) => {
+        const pct = (tested / allNames.length * 100).toFixed(0);
+        process.stdout.write(`\r  \u6279\u6B21 ${batch}/${total}  \u8FDB\u5EA6 ${pct}%  \u5DF2\u6D4B ${tested}  \u5B58\u6D3B ${colors.green(String(alive))}  \u4E2D\u4F4D\u5EF6\u8FDF ${median}ms`);
+      }
+    });
+    process.stdout.write(`\r${" ".repeat(80)}\r`);
+    const totalAlive = testResults.filter((r) => r.delay !== null).length;
+    const summary = { alive: totalAlive, dead: testResults.length - totalAlive, total: testResults.length };
+    console.log(formatTestSummary(summary));
+    console.log("");
+    const resultsByName = new Map(testResults.map((r) => [r.name, r]));
+    const results = downloaded.map((source) => computeSourceResult(source, resultsByName));
+    printRanking(results, sourceOrder);
+  } finally {
+    stopBenchInstance();
+    cleanupBenchDir();
   }
-  return renameMap.size;
 }
-function cleanDeadProxies(parsed, deadNames) {
-  const { proxies, proxyGroups } = parsed;
-  const originalCount = proxies.length;
-  parsed.proxies = proxies.filter((p) => !deadNames.has(p.name));
-  const removedProxies = originalCount - parsed.proxies.length;
-  let updatedGroups = 0;
-  const removedGroupNames = /* @__PURE__ */ new Set();
-  for (const group of proxyGroups) {
-    if (Array.isArray(group.proxies)) {
-      const before = group.proxies.length;
-      group.proxies = group.proxies.filter((name) => !deadNames.has(name));
-      if (group.proxies.length < before) {
-        updatedGroups++;
+
+// src/commands/directory.ts
+function cmdDirectory(args) {
+  const action = args?.[1];
+  if (action === "open") {
+    const target = args[2];
+    if (!target || target === "root") {
+      console.log("\u6B63\u5728\u6253\u5F00: \u6839\u76EE\u5F55");
+      const success = openUrl(USER_DATA_DIR);
+      if (!success) {
+        console.log(`\u8BF7\u624B\u52A8\u6253\u5F00: ${USER_DATA_DIR}`);
       }
-      if (group.proxies.length === 0) {
-        removedGroupNames.add(group.name);
+      return;
+    }
+    const targetInfo = DIRECTORY_TARGETS[target.toLowerCase()];
+    if (targetInfo) {
+      const targetPath = targetInfo.path || USER_DATA_DIR;
+      console.log(`\u6B63\u5728\u6253\u5F00: ${targetInfo.label}`);
+      const success = openUrl(targetPath);
+      if (!success) {
+        console.log(`\u8BF7\u624B\u52A8\u6253\u5F00: ${targetPath}`);
       }
+      return;
     }
-  }
-  if (removedGroupNames.size > 0) {
-    parsed.proxyGroups = proxyGroups.filter((g) => !removedGroupNames.has(g.name));
-    for (const group of parsed.proxyGroups) {
-      if (Array.isArray(group.proxies)) {
-        group.proxies = group.proxies.filter((name) => !removedGroupNames.has(name));
+    console.error(`\u9519\u8BEF: \u672A\u77E5\u7684\u76EE\u5F55\u76EE\u6807 "${target}"`);
+    console.log("");
+    console.log("\u53EF\u7528\u76EE\u6807:");
+    console.log("  root (\u9ED8\u8BA4)   \u6839\u76EE\u5F55");
+    for (const [key, val] of Object.entries(DIRECTORY_TARGETS)) {
+      if (key !== "root") {
+        console.log(`  ${key.padEnd(14)}${val.label}`);
       }
     }
+    console.log("");
+    process.exit(1);
   }
-  return { removedProxies, updatedGroups, removedGroups: removedGroupNames.size };
+  console.log("");
+  console.log("\u6570\u636E\u76EE\u5F55\u4F4D\u7F6E:");
+  console.log(`  \u6839\u76EE\u5F55: ${USER_DATA_DIR}`);
+  console.log(`  \u5168\u5C40\u8BBE\u7F6E: ${PATHS.settingsFile}`);
+  console.log(`  \u5185\u6838\u76EE\u5F55: ${DIRS.kernel}`);
+  console.log(`  \u5185\u6838\u6587\u4EF6: ${PATHS.mihomoBinary}`);
+  console.log(`  \u8BA2\u9605\u76EE\u5F55: ${DIRS.subscriptions}`);
+  console.log("    - cache.json (\u8BA2\u9605\u7F13\u5B58\uFF1A\u66F4\u65B0\u65F6\u95F4\u3001\u6D41\u91CF\u7B49)");
+  console.log("    - xxx.yaml (\u8BA2\u9605\u539F\u59CB\u914D\u7F6E)");
+  console.log(`  \u8FD0\u884C\u65F6\u76EE\u5F55: ${DIRS.runtime}`);
+  console.log("    - config.yaml (\u542F\u52A8\u65F6\u751F\u6210\uFF0Cstop \u81EA\u52A8\u6E05\u9664)");
+  console.log("    - pid (PID \u6587\u4EF6\uFF0Cstop \u81EA\u52A8\u6E05\u9664)");
+  console.log(`  \u65E5\u5FD7\u6587\u4EF6: ${PATHS.logFile}`);
+  console.log(`  mihomo \u6570\u636E: ${DIRS.data}`);
+  console.log("    - cache.db, Geo*.dat \u7B49 (mihomo \u81EA\u884C\u7BA1\u7406)");
+  console.log("");
+  console.log("\u6253\u5F00\u76EE\u5F55:");
+  console.log("  mihomo dir open                \u6253\u5F00\u6839\u76EE\u5F55");
+  console.log("  mihomo dir open subs           \u6253\u5F00\u8BA2\u9605\u76EE\u5F55");
+  console.log("  mihomo dir open logs           \u6253\u5F00\u65E5\u5FD7\u76EE\u5F55");
+  console.log("  mihomo dir open runtime        \u6253\u5F00\u8FD0\u884C\u65F6\u76EE\u5F55");
+  console.log("  mihomo dir open kernel         \u6253\u5F00\u5185\u6838\u76EE\u5F55");
+  console.log("");
+  console.log("\u73AF\u5883\u53D8\u91CF:");
+  console.log("  MIHOMO_CLI_DIR: \u81EA\u5B9A\u4E49\u6839\u76EE\u5F55\u4F4D\u7F6E");
+  console.log("");
+}
+
+// src/commands/help.ts
+function printShortHelp() {
+  console.log(`
+${colors.cyan(colors.bold(`mihomo-cli v${VERSION}`))}  (mihomo help \u67E5\u770B\u5B8C\u6574\u5E2E\u52A9)
+`);
+  console.log(
+    `\u5E38\u7528\u547D\u4EE4:
+  ${colors.bold("start")} [tun|mixed]    \u542F\u52A8/\u5207\u6362\u4EE3\u7406
+  ${colors.bold("sub")} [use|update]     \u8BA2\u9605\u7BA1\u7406
+  ${colors.bold("ow")} [on|off]          \u8986\u5199\u914D\u7F6E
+  ${colors.bold("ui")} [zash|dash|yacd]  \u6253\u5F00 Web UI
+`
+  );
 }
-async function autoCleanSubscription(subName, options = {}) {
-  const parsed = loadSubscriptionConfig(subName);
-  const summary = await testSubscriptionProxies(subName, { ...options, parsed });
-  let removedProxies = 0;
-  let updatedGroups = 0;
-  let removedGroups = 0;
-  let skipped = false;
-  if (summary.dead > 0) {
-    if (summary.alive === 0 || summary.alive / summary.total < 0.01) {
-      skipped = true;
-    } else {
-      const deadNames = new Set(summary.results.filter((r) => r.delay === null).map((r) => r.name));
-      const cleanResult = cleanDeadProxies(parsed, deadNames);
-      removedProxies = cleanResult.removedProxies;
-      updatedGroups = cleanResult.updatedGroups;
-      removedGroups = cleanResult.removedGroups;
-    }
-  }
-  if (!skipped) {
-    saveSubscriptionConfig(subName, parsed);
-  }
-  return { summary, removedProxies, updatedGroups, removedGroups, skipped };
+function printHelp() {
+  console.log(
+    `
+${colors.cyan(colors.bold(`mihomo-cli v${VERSION}`))}
+
+\u547D\u4EE4\u522B\u540D: mihomo, mhm, mh
+
+\u7528\u6CD5:
+  mihomo <\u547D\u4EE4> [\u9009\u9879]
+
+${colors.cyan("\u63A7\u5236:")}
+  ${colors.bold("start")} [tun|mixed]            \u542F\u52A8/\u5207\u6362\u4EE3\u7406 (\u9ED8\u8BA4 mixed)
+  ${colors.bold("stop")}                         \u505C\u6B62\u4EE3\u7406
+  ${colors.bold("status")}                       \u67E5\u770B\u72B6\u6001
+
+${colors.cyan("\u754C\u9762:")}
+  ${colors.bold("ui")} [zash|dash|yacd]          \u6253\u5F00 Web UI (\u9ED8\u8BA4 zash)
+  ${colors.bold("log")} [-o]                     \u5B9E\u65F6\u65E5\u5FD7\uFF08-o \u6253\u5F00\u6587\u4EF6\uFF09
+  ${colors.bold("logs")} [\u7F16\u53F7] [-n N] [-o]      \u65E5\u5FD7\u5217\u8868\uFF080=\u5F53\u524D\uFF0C1+=\u5F52\u6863\uFF09
+
+${colors.cyan("\u8BA2\u9605:")}
+  ${colors.bold("subscription")}                 \u5217\u51FA\u6240\u6709\u8BA2\u9605\uFF08\u522B\u540D sub\uFF09
+  ${colors.bold("subscription")} use <name>      \u5207\u6362\u5F53\u524D\u8BA2\u9605
+  ${colors.bold("subscription")} add <url> [name]  \u6DFB\u52A0\u8BA2\u9605
+  ${colors.bold("subscription")} update [name]   \u66F4\u65B0\u8BA2\u9605\uFF08\u65E0\u53C2\u66F4\u65B0\u6240\u6709\uFF09
+  ${colors.bold("subscription")} remove <name>   \u5220\u9664\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("bench")} [name] [-t ms] [-j N]  \u6D4B\u8BD5\u514D\u8D39\u8BA2\u9605\u6E90\u8D28\u91CF\u6392\u540D
+
+${colors.cyan("\u914D\u7F6E:")}
+  ${colors.bold("overwrite")}                   \u67E5\u770B\u8986\u5199\u72B6\u6001\uFF08\u522B\u540D ow\uFF09
+  ${colors.bold("overwrite")} on|off            \u542F\u7528/\u7981\u7528\u8986\u5199\u914D\u7F6E
+  ${colors.bold("directory")}                   \u663E\u793A\u6570\u636E\u76EE\u5F55\u4F4D\u7F6E\uFF08\u522B\u540D dir\uFF09
+  ${colors.bold("directory")} open [target]     \u6253\u5F00\u76EE\u5F55: root|subs|logs|runtime|...
+
+${colors.cyan("\u7CFB\u7EDF:")}
+  ${colors.bold("kernel")} [--mirror [\u955C\u50CF]]         \u66F4\u65B0\u5185\u6838\uFF08\u9ED8\u8BA4\u76F4\u8FDE\uFF0C--mirror \u4F7F\u7528 v6\uFF09
+  ${colors.bold("update")}                       \u66F4\u65B0 mihomo-cli (npm install -g)
+  ${colors.bold("reset")} [\u76EE\u6807...] [--full]   \u91CD\u7F6E: \u7559\u7A7A\u4FDD\u7559\u8BBE\u7F6E/\u5185\u6838/\u8986\u5199, \u6307\u5B9A\u76EE\u6807\u5220\u5BF9\u5E94\u9879, --full \u5220\u5168\u90E8
+  ${colors.bold("help")}, -h                     \u663E\u793A\u5E2E\u52A9
+  ${colors.bold("version")}, -v                  \u663E\u793A\u7248\u672C
+
+${colors.cyan("\u793A\u4F8B:")}
+  mihomo start              # \u542F\u52A8/\u91CD\u542F Mixed \u6A21\u5F0F
+  mihomo start tun          # \u5207\u6362\u5230 TUN \u900F\u660E\u4EE3\u7406\u6A21\u5F0F
+  mihomo sub add <url>      # \u6DFB\u52A0\u8BA2\u9605 (sub \u662F subscription \u522B\u540D)
+  mihomo bench              # \u6D4B\u8BD5\u6240\u6709\u514D\u8D39\u8BA2\u9605\u6E90
+  mihomo ui                 # \u6253\u5F00 Web UI
+
+${colors.cyan("\u6A21\u5F0F\u8BF4\u660E:")}
+  mixed  HTTP + SOCKS5 \u6DF7\u5408\u7AEF\u53E3 (\u9ED8\u8BA4)
+  tun    \u900F\u660E\u4EE3\u7406\uFF0C\u5168\u5C40\u81EA\u52A8\u8DEF\u7531\uFF0C\u9700\u8981 sudo
+
+${colors.cyan("\u6570\u636E\u76EE\u5F55:")}
+  \u73AF\u5883\u53D8\u91CF MIHOMO_CLI_DIR \u53EF\u81EA\u5B9A\u4E49\u4F4D\u7F6E
+  \u9ED8\u8BA4: ${USER_DATA_DIR}
+`
+  );
+}
+function printVersion() {
+  const kv = getKernelVersion() || "\u672A\u5B89\u88C5";
+  console.log(colors.cyan(colors.bold(`mihomo-cli v${VERSION}`)));
+  console.log(`${colors.gray("\u5185\u6838: ")}${kv}`);
+  console.log(`${colors.gray("\u6570\u636E\u76EE\u5F55: ")}${USER_DATA_DIR}`);
 }
 
-// src/commands/status.ts
-function printStatus() {
-  const status = getStatus();
-  const info = getConfigInfo();
-  const overwriteEnabled = isOverwriteEnabled();
-  const overwriteFiles = listOverwriteFile().files;
-  const activeSub = getActiveSubscription();
-  console.log("");
-  let modeLabel = "";
-  if (info && status.running) {
-    modeLabel = colors.cyan(info.tun ? " (TUN)" : " (Mixed)");
-  }
-  const statusText = status.running ? colors.green("\u25CF \u8FD0\u884C\u4E2D") : colors.yellow("\u4E0D\u5728\u8FD0\u884C");
-  console.log(`${colors.gray("\u72B6\u6001: ")}${statusText}${modeLabel}`);
-  console.log(`${colors.gray("\u5185\u6838: ")}${status.kernelVersion || "\u672A\u5B89\u88C5"}`);
-  if (status.pid) {
-    console.log(`${colors.gray("PID:  ")}${status.pid}`);
-    if (status.processInfo) {
-      console.log(`${colors.gray("\u5185\u5B58: ")}${status.processInfo.memory}`);
-    }
+// src/kernel.ts
+import { execSync as execSync4, spawnSync } from "child_process";
+import fs7 from "fs";
+import path5 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;
+var validateAndParse = (version) => {
+  if (typeof version !== "string") {
+    throw new TypeError("Invalid argument expected string");
   }
-  if (info) {
-    if (info.mixedPort) {
-      console.log(`${colors.gray("\u7AEF\u53E3: ")}${info.mixedPort}`);
-    } else {
-      const ports = [];
-      if (info.httpPort) ports.push(`HTTP:${info.httpPort}`);
-      if (info.socksPort) ports.push(`SOCKS:${info.socksPort}`);
-      console.log(`${colors.gray("\u7AEF\u53E3: ")}${ports.length > 0 ? ports.join(", ") : "\u672A\u77E5"}`);
-    }
+  const match = version.match(semver);
+  if (!match) {
+    throw new Error(`Invalid argument not valid semver ('${version}' received)`);
   }
-  if (activeSub) {
-    let subLine = `${colors.gray("\u8BA2\u9605: ")}${activeSub.name}`;
-    if (info) {
-      subLine += ` (${formatProxySummary(info)})`;
-    }
-    console.log(subLine);
-  } else {
-    console.log(`${colors.gray("\u8BA2\u9605: ")}\u672A\u914D\u7F6E`);
+  match.shift();
+  return match;
+};
+var isWildcard = (s) => s === "*" || s === "x" || s === "X";
+var tryParse = (v) => {
+  const n = parseInt(v, 10);
+  return isNaN(n) ? v : n;
+};
+var forceType = (a, b) => typeof a !== typeof b ? [String(a), String(b)] : [a, b];
+var compareStrings = (a, b) => {
+  if (isWildcard(a) || isWildcard(b))
+    return 0;
+  const [ap, bp] = forceType(tryParse(a), tryParse(b));
+  if (ap > bp)
+    return 1;
+  if (ap < bp)
+    return -1;
+  return 0;
+};
+var compareSegments = (a, b) => {
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const r = compareStrings(a[i] || "0", b[i] || "0");
+    if (r !== 0)
+      return r;
   }
-  if (overwriteEnabled && overwriteFiles.length > 0) {
-    const names = overwriteFiles.map((f) => f.name.replace(/^overwrite\.?/, "").replace(/\.ya?ml$/, "") || "\u4E3B\u6587\u4EF6").join(", ");
-    console.log(`${colors.gray("\u8986\u5199: ")}${colors.green("\u5DF2\u542F\u7528")} (${names})`);
-  } else if (overwriteEnabled) {
-    console.log(`${colors.gray("\u8986\u5199: ")}${colors.green("\u5DF2\u542F\u7528")} (\u65E0\u6587\u4EF6)`);
-  } else {
-    console.log(`${colors.gray("\u8986\u5199: ")}${colors.yellow("\u5DF2\u7981\u7528")}`);
+  return 0;
+};
+
+// node_modules/compare-versions/lib/esm/compareVersions.js
+var compareVersions = (v1, v2) => {
+  const n1 = validateAndParse(v1);
+  const n2 = validateAndParse(v2);
+  const p1 = n1.pop();
+  const p2 = n2.pop();
+  const r = compareSegments(n1, n2);
+  if (r !== 0)
+    return r;
+  if (p1 && p2) {
+    return compareSegments(p1.split("."), p2.split("."));
+  } else if (p1 || p2) {
+    return p1 ? -1 : 1;
   }
-  console.log("");
-}
+  return 0;
+};
 
-// src/commands/subscription.ts
-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`)}`);
-  } else {
-    console.log(`  ${prefix} ${colors.red("\u2717")} ${result.name} ${colors.gray(result.error || "timeout")}`);
+// src/kernel.ts
+var GITHUB_REPO = "MetaCubeX/mihomo";
+var KERNEL_HTTP_TIMEOUT = 12e4;
+var KERNEL_DOWNLOAD_TIMEOUT = 18e4;
+var HTTP_CLIENT2 = createHttpClient({ timeout: KERNEL_HTTP_TIMEOUT });
+function withMirror(url, mirror) {
+  if (mirror && (url.startsWith("https://github.com/") || url.startsWith("https://api.github.com/"))) {
+    return mirror + url;
   }
+  return url;
 }
-function formatCleanSummary(result) {
-  const parts = [`\u79FB\u9664 ${result.removedProxies} \u4E2A\u8282\u70B9`];
-  if (result.removedGroups > 0) parts.push(`\u5220\u9664 ${result.removedGroups} \u4E2A\u7A7A\u5206\u7EC4`);
-  if (result.updatedGroups > 0) parts.push(`\u66F4\u65B0 ${result.updatedGroups} \u4E2A\u5206\u7EC4`);
-  return parts.join(", ");
+function getArch() {
+  const arch = process.arch;
+  if (arch === "arm64") return "arm64";
+  if (arch === "x64") return "amd64";
+  return arch;
 }
-function formatTestSummary(summary) {
-  return `\u7ED3\u679C: ${colors.green(`${summary.alive} \u5B58\u6D3B`)} / ${colors.red(`${summary.dead} \u5931\u8D25`)} / ${summary.total} \u603B\u8BA1`;
+function findMatchingAsset(assets, platform, arch) {
+  const prefix = `mihomo-${platform}-${arch}`;
+  const matchingAssets = assets.filter(
+    (a) => a.name.startsWith(prefix) && a.name.endsWith(".gz") || a.name.startsWith(`${prefix}-`) && a.name.endsWith(".gz")
+  );
+  if (matchingAssets.length === 0) return null;
+  if (matchingAssets.length === 1) return matchingAssets[0];
+  const standardAsset = matchingAssets.find((a) => {
+    const nameWithoutGz = a.name.slice(0, -3);
+    const parts = nameWithoutGz.split("-");
+    const lastPart = parts[parts.length - 1];
+    return /^v?\d+\.\d+\.\d+/.test(lastPart) && !nameWithoutGz.includes("-go");
+  });
+  return standardAsset || matchingAssets[0];
 }
-function resolveActiveTestTarget(args) {
-  const subs = getSubscriptions();
-  if (subs.length === 0) {
-    console.error("\u9519\u8BEF: \u6CA1\u6709\u8BA2\u9605");
-    process.exit(1);
+async function getLatestRelease(repo, mirror) {
+  const url = withMirror(`https://api.github.com/repos/${repo}/releases`, mirror);
+  const response = await HTTP_CLIENT2.get(url, { responseType: "json" });
+  const releases = response.data;
+  if (!Array.isArray(releases) || releases.length === 0) {
+    throw new Error("\u65E0\u6CD5\u83B7\u53D6\u7248\u672C\u4FE1\u606F");
   }
-  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);
+  const stableReleases = releases.filter(
+    (r) => !r.prerelease && !r.tag_name.toLowerCase().includes("alpha") && !r.tag_name.toLowerCase().includes("beta") && !r.tag_name.toLowerCase().includes("prerelease")
+  );
+  return stableReleases.length > 0 ? stableReleases[0] : releases[0];
+}
+async function checkUpdate(mirror) {
+  const currentVersion = getKernelVersion();
+  const latest = await getLatestRelease(GITHUB_REPO, mirror);
+  const latestVersion = latest.tag_name;
+  let needsUpdate = false;
+  const currentDisplay = currentVersion || "\u672A\u5B89\u88C5";
+  if (!currentVersion) {
+    needsUpdate = true;
   } else {
-    if (!activeSub) {
-      console.error("\u9519\u8BEF: \u6CA1\u6709\u6D3B\u8DC3\u8BA2\u9605");
-      process.exit(1);
+    try {
+      needsUpdate = compareVersions(latestVersion.replace(/^v/, ""), currentVersion.replace(/^v/, "")) > 0;
+    } catch {
+      needsUpdate = latestVersion !== currentVersion;
     }
-    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 };
+  return {
+    current: currentDisplay,
+    latest: latestVersion,
+    needsUpdate,
+    assets: latest.assets,
+    release: latest
+  };
 }
-async function printSubscriptionList(options) {
-  if (options?.autoUpdate !== false) {
-    const updateResult = await autoUpdateStaleSubscription();
-    if (updateResult.total > 0) console.log("");
-  }
-  const subs = getSubscriptionsWithCache();
-  if (subs.length === 0) {
-    console.log("\u6CA1\u6709\u8BA2\u9605");
-    console.log("");
-    console.log("\u6DFB\u52A0\u8BA2\u9605: mihomo sub add <url> [name]");
-    console.log("");
-    return;
-  }
-  const activeSub = getActiveSubscription();
-  console.log(colors.cyan("\u8BA2\u9605\u5217\u8868:"));
-  subs.forEach((s, i) => {
-    const time = formatDate(s.updated_at);
-    const defaultMark = activeSub && s.name === activeSub.name ? colors.green(" [\u4F7F\u7528\u4E2D]") : "";
-    const interval = s.update_interval || DEFAULT_UPDATE_INTERVAL_HOURS;
-    console.log(`  ${i + 1}. ${s.name}${defaultMark}`);
-    console.log(`    ${colors.gray("\u66F4\u65B0: ")}${time} (\u95F4\u9694: ${interval}h)`);
-    if (s.username) {
-      console.log(`    ${colors.gray("\u7528\u6237: ")}${s.username}`);
-    }
-    if (s.download !== void 0 || s.total !== void 0) {
-      const used = (s.upload || 0) + (s.download || 0);
-      const usedStr = formatBytes(used);
-      const totalStr = formatBytes(s.total);
-      let percentStr = "";
-      if (s.total && s.total > 0) {
-        const percent = Math.min(used / s.total * 100, 100);
-        percentStr = ` (${percent.toFixed(1)}%)`;
-      }
-      console.log(`    ${colors.gray("\u6D41\u91CF: ")}${usedStr} / ${totalStr}${percentStr}`);
-    }
-    if (s.expire !== void 0) {
-      console.log(`    ${colors.gray("\u5230\u671F: ")}${formatTimestamp(s.expire)}`);
-    }
-    if (s.web_page_url) {
-      console.log(`    ${colors.gray("\u9875\u9762: ")}${s.web_page_url}`);
+function findBinaryInDir(dir) {
+  const files = fs7.readdirSync(dir);
+  for (const f of files) {
+    const fullPath = path5.join(dir, f);
+    const stat = fs7.statSync(fullPath);
+    if (stat.isDirectory()) {
+      const found = findBinaryInDir(fullPath);
+      if (found) return found;
+      continue;
     }
-  });
-  console.log("");
-  console.log("\u5207\u6362\u8BA2\u9605: mihomo sub use <name>");
-  console.log("\u65B0\u589E\u8BA2\u9605: mihomo sub add <url> [name]");
-  console.log("\u66F4\u65B0\u8BA2\u9605: mihomo sub update [name]");
-  console.log("\u5220\u9664\u8BA2\u9605: mihomo sub remove <name>");
-  console.log("\u6D4B\u8BD5\u8282\u70B9: mihomo sub test [name]");
-  console.log("\u6E05\u7406\u8282\u70B9: mihomo sub clean [name]");
-  console.log("\u6253\u5F00\u9875\u9762: mihomo sub web [name]");
-  console.log("");
+    if (f === "mihomo") return fullPath;
+    if (f.includes("mihomo") && !f.endsWith(".gz")) return fullPath;
+  }
+  return null;
 }
-async function cmdSubscription(args) {
-  const action = args[1];
-  if (!action || action === "list") {
-    await printSubscriptionList();
-    return;
+async function downloadKernel(progressCallback, mirror, releaseInfo) {
+  ensureDirs();
+  const latest = releaseInfo || await getLatestRelease(GITHUB_REPO, mirror);
+  const arch = getArch();
+  const platform = process.platform;
+  const asset = findMatchingAsset(latest.assets, platform, arch);
+  if (!asset) {
+    const available = latest.assets.map((a) => a.name).join(", ");
+    let hint = "";
+    if (available) hint = `
+  \u53EF\u7528\u7248\u672C: ${available}`;
+    throw new Error(`\u672A\u627E\u5230\u5339\u914D\u7684\u5185\u6838\u6587\u4EF6
+  \u5E73\u53F0: ${platform}, \u67B6\u6784: ${arch}${hint}`);
   }
-  if (action === "add") {
-    const url = args[2];
-    const name = args[3] || "default";
-    if (!url?.startsWith("http")) {
-      console.error("\u9519\u8BEF: \u8BF7\u63D0\u4F9B\u6709\u6548\u7684\u8BA2\u9605 URL");
-      process.exit(1);
-    }
-    console.log(`\u6DFB\u52A0\u8BA2\u9605: ${name}`);
-    try {
-      addSubscription(url, name);
-      setDefaultSubscription(name);
-      const info = await downloadSubscription(url, name);
-      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();
-    return;
+  const downloadUrl = withMirror(asset.browser_download_url, mirror);
+  const tempPath = path5.join(DIRS.kernel, asset.name);
+  const sizeMB = (asset.size / 1024 / 1024).toFixed(2);
+  if (progressCallback) {
+    progressCallback(`\u4E0B\u8F7D\u5185\u6838: ${asset.name} (${sizeMB} MB)`);
   }
-  if (action === "update") {
-    const name = args[2];
-    const subs = getSubscriptions();
-    if (subs.length === 0) {
-      console.error("\u9519\u8BEF: \u6CA1\u6709\u8BA2\u9605");
-      process.exit(1);
-    }
-    if (!name) {
-      console.log(`\u66F4\u65B0\u6240\u6709 ${subs.length} \u4E2A\u8BA2\u9605...`);
-      const results = await Promise.all(subs.map(tryUpdateOne));
-      let ok = 0;
-      for (const r of results) {
-        if (r.success) {
-          ok++;
-          console.log(`${colors.green("\u2713")} ${r.name}: ${colors.green("\u5DF2\u66F4\u65B0")} (${formatProxySummary(r)})`);
-        } else {
-          console.log(`${colors.red("\u2717")} ${r.name}: ${colors.red("\u5931\u8D25")} (${(r.error || "").split("\n")[0]})`);
-        }
-      }
-      if (ok === 0) process.exit(1);
-      console.log("");
-      await printSubscriptionList();
-      return;
-    }
-    const matches = findSubscriptionFuzzy(subs, name);
-    const target = pickSingleSubscription(matches, name);
-    console.log(`\u66F4\u65B0\u8BA2\u9605: ${target.name}`);
+  const curlResult = spawnSync(
+    "curl",
+    ["-L", "--progress-bar", "--connect-timeout", "30", "--max-time", String(Math.floor(KERNEL_DOWNLOAD_TIMEOUT / 1e3)), "-o", tempPath, downloadUrl],
+    { stdio: "inherit" }
+  );
+  if (curlResult.status !== 0) {
     try {
-      const info = await downloadSubscription(target.url, target.name);
-      console.log(`\u5DF2\u66F4\u65B0 (${formatProxySummary(info)})`);
-    } catch (e) {
-      console.error(`\u66F4\u65B0\u5931\u8D25: ${e.message}`);
-      process.exit(1);
+      fs7.unlinkSync(tempPath);
+    } catch {
     }
-    console.log("");
-    await printSubscriptionList();
-    return;
+    throw new Error(`\u4E0B\u8F7D\u5931\u8D25 (curl \u9000\u51FA\u7801 ${curlResult.status})`);
   }
-  if (action === "use") {
-    const name = args[2];
-    const subs = getSubscriptions();
-    if (!name) {
-      console.error("\u9519\u8BEF: \u8BF7\u6307\u5B9A\u8BA2\u9605\u540D\u79F0");
-      if (subs.length > 0) {
-        console.log("\n\u53EF\u7528\u8BA2\u9605:");
-        for (const s of subs) console.log(`  ${s.name}`);
-      }
-      process.exit(1);
-    }
-    const matches = findSubscriptionFuzzy(subs, name);
-    const target = pickSingleSubscription(matches, name);
-    const currentDefault = getActiveSubscription();
-    const isAlreadyDefault = currentDefault && currentDefault.name === target.name;
-    if (isAlreadyDefault) {
-      console.log(`"${target.name}" \u5DF2\u662F\u5F53\u524D\u4F7F\u7528\u7684\u8BA2\u9605`);
-      console.log("");
-      await printSubscriptionList();
-      return;
-    }
-    const status = getStatus();
-    const configInfo = getConfigInfo();
-    const currentMode = configInfo?.tun ? "tun" : "mixed";
-    const success = setDefaultSubscription(target.name);
-    if (success) {
-      console.log(`\u5DF2\u5207\u6362\u5230 "${target.name}"`);
-    } else {
-      console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u8BA2\u9605 "${name}"`);
-      process.exit(1);
-    }
-    if (status.running) {
-      console.log("");
-      await cmdStart(["start", currentMode]);
-      return;
-    }
-    console.log("");
-    await printSubscriptionList();
-    return;
+  if (!fs7.existsSync(tempPath)) {
+    throw new Error("\u4E0B\u8F7D\u5931\u8D25: \u6587\u4EF6\u672A\u751F\u6210");
   }
-  if (action === "web" || action === "open") {
-    const name = args[2];
-    const subs = getSubscriptionsWithCache();
-    if (subs.length === 0) {
-      console.error("\u9519\u8BEF: \u6CA1\u6709\u8BA2\u9605");
-      process.exit(1);
-    }
-    let target;
-    if (name) {
-      const matches = findSubscriptionFuzzy(subs, name);
-      target = pickSingleSubscription(matches, name);
-    } else {
-      target = subs[0];
-    }
-    const cached = getSubscriptionsWithCache().find((s) => s.name === target.name);
-    let webPageUrl = cached?.web_page_url;
-    if (!webPageUrl) {
-      console.log("\u8BA2\u9605\u4FE1\u606F\u4E2D\u7F3A\u5C11\u9875\u9762\u5730\u5740\uFF0C\u6B63\u5728\u66F4\u65B0\u8BA2\u9605...");
-      try {
-        await downloadSubscription(target.url, target.name);
-        const cache = readSubscriptionCache();
-        if (cache[target.name]?.web_page_url) {
-          webPageUrl = cache[target.name].web_page_url;
-        } else {
-          console.error("\u9519\u8BEF: \u8BE5\u8BA2\u9605\u6CA1\u6709\u63D0\u4F9B\u9875\u9762\u5730\u5740");
-          process.exit(1);
-        }
-      } catch (e) {
-        console.error(`\u66F4\u65B0\u5931\u8D25: ${e.message}`);
-        process.exit(1);
-      }
+  if (progressCallback) {
+    progressCallback("\u89E3\u538B\u5185\u6838...");
+  }
+  const extractPath = DIRS.kernel;
+  let extractedBinary = null;
+  try {
+    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);
+      execSync4(`gzip -dc "${tempPath}" > "${outputPath}"`, { stdio: ["pipe", "pipe", "inherit"] });
+      extractedBinary = outputPath;
     }
-    console.log(`\u6253\u5F00\u8BA2\u9605\u9875\u9762: ${webPageUrl}`);
-    const opened = openUrl(webPageUrl);
-    if (!opened) {
-      console.log("\u8BF7\u624B\u52A8\u8BBF\u95EE\u4E0A\u9762\u7684\u5730\u5740");
+  } catch (e) {
+    try {
+      fs7.unlinkSync(tempPath);
+    } catch {
     }
-    return;
+    throw new Error(`\u89E3\u538B\u5931\u8D25: ${e.message}`);
   }
-  if (action === "remove" || action === "rm" || action === "delete") {
-    const name = args[2];
-    const subs = getSubscriptions();
-    if (!name) {
-      console.error("\u9519\u8BEF: \u8BF7\u6307\u5B9A\u8981\u5220\u9664\u7684\u8BA2\u9605\u540D\u79F0");
-      if (subs.length > 0) {
-        console.log("\n\u53EF\u7528\u8BA2\u9605:");
-        for (const s of subs) console.log(`  ${s.name}`);
-      }
-      process.exit(1);
-    }
-    const matches = findSubscriptionFuzzy(subs, name);
-    const target = pickSingleSubscription(matches, name);
-    const switchedTo = removeSubscription(target.name);
-    console.log(`\u5DF2\u5220\u9664\u8BA2\u9605 "${target.name}"`);
-    if (switchedTo) {
-      console.log(`\u5DF2\u81EA\u52A8\u5207\u6362\u5230 "${switchedTo}"`);
+  const foundBinary = extractedBinary || findBinaryInDir(extractPath);
+  if (!foundBinary) {
+    try {
+      fs7.unlinkSync(tempPath);
+    } catch {
     }
-    console.log("");
-    await printSubscriptionList({ autoUpdate: false });
-    return;
+    throw new Error("\u89E3\u538B\u540E\u672A\u627E\u5230\u53EF\u6267\u884C\u6587\u4EF6");
   }
-  if (action === "clean") {
-    const { target, timeout, concurrency } = resolveActiveTestTarget(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
-    });
-    console.log("");
-    console.log(formatTestSummary(result.summary));
-    if (result.skipped) {
-      console.log("");
-      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 targetPath = PATHS.mihomoBinary;
+  if (foundBinary !== targetPath) {
+    if (fs7.existsSync(targetPath)) {
+      fs7.chmodSync(targetPath, 493);
+      try {
+        fs7.unlinkSync(targetPath);
+      } catch {
+      }
     }
-    return;
+    fs7.renameSync(foundBinary, targetPath);
   }
-  if (action === "test") {
-    const { target, timeout, concurrency } = resolveActiveTestTarget(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
-    });
-    console.log("");
-    console.log(formatTestSummary(summary));
-    return;
+  fs7.chmodSync(targetPath, 493);
+  try {
+    fs7.unlinkSync(tempPath);
+  } catch {
   }
-  console.error("\u9519\u8BEF: \u672A\u77E5\u7684\u8BA2\u9605\u547D\u4EE4");
-  console.log("\u7528\u6CD5: mihomo sub [list|use|add|update|remove|web|test|clean]");
-  process.exit(1);
+  clearKernelVersionCache();
+  return { version: latest.tag_name, path: targetPath };
 }
 
-// src/commands/start.ts
-var AUTO_CLEAN_THRESHOLD = 100;
-function handleStopResult(result) {
-  if (result.remaining && result.remaining.length > 0) {
-    console.error(`${colors.red("\u90E8\u5206\u8FDB\u7A0B\u672A\u7EC8\u6B62:")} ${result.remaining.join(", ")}`);
-    console.error("\u8BF7\u624B\u52A8\u8FD0\u884C: sudo pkill -9 mihomo");
-    process.exit(1);
-  }
-}
-async function cmdStart(args) {
-  if (!hasKernel()) {
-    console.error('\u9519\u8BEF: \u672A\u627E\u5230\u5185\u6838\uFF0C\u8BF7\u8FD0\u884C "mihomo kernel"');
-    process.exit(1);
-  }
-  const targetMode = args[1] === "tun" ? "tun" : "mixed";
-  const sub = getActiveSubscription();
-  if (!sub) {
-    console.error("\u9519\u8BEF: \u6CA1\u6709\u8BA2\u9605\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605");
-    process.exit(1);
-  }
-  await autoUpdateStaleSubscription();
-  const status = getStatus();
-  const hasProcess = status.running || status.allProcesses.length > 0;
-  if (hasProcess) {
-    const count = status.allProcesses.length > 0 ? status.allProcesses.length : 1;
-    console.log(`\u505C\u6B62 ${count} \u4E2A\u8FDB\u7A0B...`);
+// src/commands/kernel.ts
+async function cmdKernel(args) {
+  const mirrorInfo = parseMirrorArg(args);
+  const effectiveMirror = mirrorInfo.mirror;
+  if (effectiveMirror) {
+    const mirrorDesc = mirrorInfo.type === "all" ? " (API\u548C\u4E0B\u8F7D\u5747\u4F7F\u7528\u955C\u50CF)" : " (\u4E0B\u8F7D\u65F6\u4F7F\u7528\u955C\u50CF)";
+    console.log(`\u955C\u50CF: ${effectiveMirror}${mirrorDesc}`);
   }
-  handleStopResult(stop());
-  if (hasProcess) {
-    console.log(`${colors.green("\u5DF2\u505C\u6B62\u8FDB\u7A0B")}
-`);
+  console.log("\n\u63D0\u793A: \u5982\u679C\u4E0B\u8F7D\u901F\u5EA6\u8FC7\u6162\u6216\u76F4\u8FDE\u5931\u8D25\uFF0C\u53EF\u4F7F\u7528 --mirror \u53C2\u6570\u901A\u8FC7\u955C\u50CF\u4E0B\u8F7D");
+  console.log("\n\u7528\u6CD5:");
+  console.log("  mihomo kernel                    # \u76F4\u8FDE");
+  console.log("  mihomo kernel --mirror           # \u4E0B\u8F7D\u4F7F\u7528\u9ED8\u8BA4\u955C\u50CF (v6.gh-proxy.org)");
+  console.log("  mihomo kernel --mirror hk.gh-proxy.org  # \u4E0B\u8F7D\u4F7F\u7528\u6307\u5B9A\u955C\u50CF");
+  console.log("  mihomo kernel --mirror-all       # API\u8BF7\u6C42\u548C\u4E0B\u8F7D\u90FD\u4F7F\u7528\u9ED8\u8BA4\u955C\u50CF");
+  console.log("  mihomo kernel --mirror-all hk.gh-proxy.org  # API\u548C\u4E0B\u8F7D\u90FD\u4F7F\u7528\u6307\u5B9A\u955C\u50CF");
+  console.log("\n\u53EF\u7528\u955C\u50CF:");
+  for (const m of AVAILABLE_MIRRORS) {
+    const isCurrent = effectiveMirror && (effectiveMirror.includes(`//${m}/`) || effectiveMirror.includes(`//${m}:`) || effectiveMirror.endsWith(`//${m}`));
+    console.log(`  ${m}${isCurrent ? " (\u5F53\u524D)" : ""}`);
   }
-  let configInfo;
+  console.log("");
+  console.log("\u68C0\u67E5\u5185\u6838\u66F4\u65B0...");
   try {
-    configInfo = prepareConfigForStart(targetMode, sub.name);
+    const apiMirror = mirrorInfo.type === "all" ? effectiveMirror : null;
+    const info = await checkUpdate(apiMirror);
+    console.log(`\u5F53\u524D: ${info.current}`);
+    console.log(`\u6700\u65B0: ${info.latest}`);
+    if (!info.needsUpdate) {
+      console.log("\u5DF2\u662F\u6700\u65B0\u7248\u672C");
+    } else {
+      console.log("\n\u6B63\u5728\u4E0B\u8F7D...");
+      const result = await downloadKernel((msg) => console.log(msg), mirrorInfo.mirror, info.release);
+      console.log(`
+\u5DF2\u66F4\u65B0\u5230 ${result.version}`);
+    }
   } catch (e) {
-    console.error(`${colors.red("\u914D\u7F6E\u9519\u8BEF:")} ${e.message}`);
+    console.error(`
+\u66F4\u65B0\u5931\u8D25: ${e.message}`);
+    const err = e;
+    if (err.response?.data) {
+      if (err.response.data.message) {
+        console.error(`\u539F\u56E0: ${err.response.data.message}`);
+      }
+      if (err.response.data.documentation_url) {
+        console.error(`\u6587\u6863: ${err.response.data.documentation_url}`);
+      }
+    }
     process.exit(1);
   }
-  const modeLabel = targetMode === "tun" ? "TUN" : "Mixed";
-  console.log([colors.cyan(modeLabel), sub.name, formatProxySummary(configInfo)].join(" \xB7 "));
-  try {
-    const result = await start(targetMode);
-    console.log(`${colors.green("\u5DF2\u542F\u52A8")} (PID ${result.pid})`);
-  } catch (e) {
-    console.error(`${colors.red("\u542F\u52A8\u5931\u8D25:")} ${e.message.split("\n")[0]}`);
-    process.exit(1);
+}
+
+// src/commands/log.ts
+function cmdLog(args) {
+  const logPath = getLogPath();
+  if (hasFlag(args, "-o", "--open")) {
+    openLogFile(logPath);
+    return;
   }
-  if (configInfo.proxies > AUTO_CLEAN_THRESHOLD) {
-    console.log("");
-    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 });
-    console.log("");
-    console.log(formatTestSummary(cleanResult.summary));
-    if (cleanResult.skipped) {
-      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 (cleanResult.removedProxies > 0) {
-      console.log(`${colors.green("\u5DF2\u6E05\u7406")}: ${formatCleanSummary(cleanResult)}`);
-      console.log("");
-      console.log("\u91CD\u65B0\u52A0\u8F7D\u914D\u7F6E...");
-      handleStopResult(stop());
-      try {
-        configInfo = prepareConfigForStart(targetMode, sub.name);
-        const result = await start(targetMode);
-        console.log(`${colors.green("\u5DF2\u91CD\u542F")} (PID ${result.pid}) \xB7 ${formatProxySummary(configInfo)}`);
-      } catch (e) {
-        console.error(`${colors.red("\u91CD\u542F\u5931\u8D25:")} ${e.message.split("\n")[0]}`);
-        process.exit(1);
+  viewLogWithTail(logPath, { follow: true, lines: 50 });
+}
+function cmdLogs(args) {
+  const targetName = getNonFlagArg(args, 1);
+  const lines = parseIntArg(args, "-n", "--lines", 100);
+  const openInViewer = hasFlag(args, "-o", "--open");
+  if (targetName) {
+    let logPath;
+    if (targetName === "current" || targetName === "0") {
+      logPath = getLogPath();
+    } else {
+      const parsedIdx = parseInt(targetName, 10);
+      if (!Number.isNaN(parsedIdx) && parsedIdx > 0 && String(parsedIdx) === targetName) {
+        const archiveLogs = listLogs();
+        const archive = archiveLogs.archives[parsedIdx - 1];
+        if (!archive) {
+          console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u65E5\u5FD7 "${targetName}"`);
+          console.log('\u4F7F\u7528 "mihomo logs" \u67E5\u770B\u53EF\u7528\u65E5\u5FD7\u5217\u8868');
+          process.exit(1);
+        }
+        logPath = archive.path;
+      } else {
+        logPath = getLogPathByName(targetName);
       }
     }
+    if (!logPath) {
+      console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u65E5\u5FD7 "${targetName}"`);
+      console.log('\u4F7F\u7528 "mihomo logs" \u67E5\u770B\u53EF\u7528\u65E5\u5FD7\u5217\u8868');
+      process.exit(1);
+    }
+    if (openInViewer) {
+      openLogFile(logPath);
+      return;
+    }
+    viewLogWithTail(logPath, { follow: false, lines });
+    return;
   }
-  printStatus();
+  const logs = listLogs();
+  const all = [];
+  if (logs.current) all.push(logs.current);
+  all.push(...logs.archives);
+  if (all.length === 0) {
+    console.log("\u6682\u65E0\u65E5\u5FD7");
+    return;
+  }
+  console.log("");
+  console.log("\u65E5\u5FD7\u5217\u8868:");
+  console.log("");
+  let archiveCounter = 0;
+  for (const log of all) {
+    let num;
+    if (log.isCurrent) {
+      num = " 0";
+    } else {
+      archiveCounter++;
+      num = archiveCounter < 10 ? ` ${archiveCounter}` : `${archiveCounter}`;
+    }
+    const time = formatDate(log.mtime);
+    const size = formatBytes(log.size);
+    const name = log.isCurrent ? "mihomo.log (\u5F53\u524D\u8FD0\u884C\u4E2D)" : log.name;
+    console.log(` ${num}. ${name}`);
+    console.log(`    \u65F6\u95F4: ${time}  \u5927\u5C0F: ${size}`);
+    if (!log.isCurrent) {
+      console.log(`    \u67E5\u770B: mihomo logs ${archiveCounter}  \u6216  mihomo logs ${archiveCounter} -o`);
+    }
+    console.log("");
+  }
+  console.log("\u7528\u6CD5:");
+  console.log("  mihomo logs 0          # \u67E5\u770B\u5F53\u524D\u65E5\u5FD7 (\u6700\u540E 100 \u884C)");
+  console.log("  mihomo logs 1          # \u67E5\u770B\u7B2C 1 \u4E2A\u5F52\u6863\u65E5\u5FD7\uFF08\u6700\u65B0\uFF09");
+  console.log("  mihomo logs 1 -n 200   # \u67E5\u770B 200 \u884C");
+  console.log("  mihomo logs 1 -o       # \u7528\u7CFB\u7EDF\u9ED8\u8BA4\u7A0B\u5E8F\u6253\u5F00");
+  console.log("");
 }
 
 // src/commands/overwrite.ts
+import path6 from "path";
 function printOverwriteList() {
   const info = listOverwriteFile();
   const statusText = info.enabled ? colors.green("\u5DF2\u542F\u7528") : colors.yellow("\u5DF2\u7981\u7528");
@@ -5052,8 +5797,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 ${path5.join(info.dir, "overwrite.yaml")}`);
-    console.log(`         \u6216        ${path5.join(info.dir, "overwrite.dns.yaml")}`);
+    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("");
   } else {
     console.log(`${colors.cyan("\u8986\u5199\u6587\u4EF6")} (${info.files.length} \u4E2A\uFF0C\u6309\u987A\u5E8F\u52A0\u8F7D):`);
@@ -5117,7 +5862,7 @@ async function cmdOverwrite(args) {
 }
 
 // src/commands/reset.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import readline from "readline";
 var RESET_TARGETS = [
   {
@@ -5172,8 +5917,8 @@ var RESET_TARGETS = [
     label: "\u8986\u5199",
     paths: () => {
       const dir = USER_DATA_DIR;
-      if (!fs7.existsSync(dir)) return [];
-      return fs7.readdirSync(dir).filter((f) => f === "overwrite.yaml" || /^overwrite\..+\.ya?ml$/.test(f)).map((f) => `${dir}/${f}`);
+      if (!fs8.existsSync(dir)) return [];
+      return fs8.readdirSync(dir).filter((f) => f === "overwrite.yaml" || /^overwrite\..+\.ya?ml$/.test(f)).map((f) => `${dir}/${f}`);
     },
     needsStop: false
   }
@@ -5307,7 +6052,7 @@ function cmdUI(args) {
 }
 
 // src/commands/update.ts
-import { exec, spawn as spawn2 } from "child_process";
+import { exec, spawn as spawn3 } from "child_process";
 import { promisify } from "util";
 var execAsync = promisify(exec);
 async function cmdUpdate() {
@@ -5316,7 +6061,7 @@ async function cmdUpdate() {
   console.log("\u6B63\u5728\u66F4\u65B0 mihomo-cli...");
   console.log("");
   await new Promise((resolve) => {
-    const npm = spawn2("npm", ["install", "-g", "mihomo-cli"], { stdio: "inherit" });
+    const npm = spawn3("npm", ["install", "-g", "mihomo-cli"], { stdio: "inherit" });
     npm.on("close", (code) => {
       if (code === 0) {
         resolve();
@@ -5452,6 +6197,9 @@ async function main() {
     case "overwrite":
       await cmdOverwrite(args);
       break;
+    case "bench":
+      await cmdBench(args);
+      break;
     default:
       console.error(`\u672A\u77E5\u547D\u4EE4: ${cmd}`);
       console.error('\u4F7F\u7528 "mihomo help" \u67E5\u770B\u5E2E\u52A9');