mihomo-cli 3.4.0 → 3.6.0

package/dist/index.js

@@ -1,7 +1,22 @@
 #!/usr/bin/env node
 
+// src/colors.ts
+var NO_COLOR = process.env.NO_COLOR !== void 0 || !process.stdout.isTTY;
+function colorize(code, str) {
+  if (NO_COLOR) return String(str);
+  return `${code + String(str)}\x1B[0m`;
+}
+var colors = {
+  bold: (s) => colorize("\x1B[1m", s),
+  red: (s) => colorize("\x1B[31m", s),
+  green: (s) => colorize("\x1B[32m", s),
+  yellow: (s) => colorize("\x1B[33m", s),
+  cyan: (s) => colorize("\x1B[36m", s),
+  gray: (s) => colorize("\x1B[90m", s)
+};
+
 // src/config.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync } from "child_process";
 import fs4 from "fs";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
@@ -3040,6 +3055,11 @@ var CHOMPING_STRIP = CHOMPING_MODE.STRIP;
 var CHOMPING_KEEP = CHOMPING_MODE.KEEP;
 
 // src/constants.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var VERSION = pkg.version;
+var PKG_NAME = pkg.name;
 var AVAILABLE_MIRRORS = ["v6.gh-proxy.org", "gh-proxy.org", "hk.gh-proxy.org", "cdn.gh-proxy.org"];
 var DEFAULT_MIRROR = "https://v6.gh-proxy.org/";
 var UI_URLS = {
@@ -3171,6 +3191,43 @@ function rmrf(dir) {
 // src/settings.ts
 import fs2 from "fs";
 import path2 from "path";
+
+// src/errors.ts
+var TimeoutError = class extends Error {
+  constructor() {
+    super("timeout");
+    this.name = "TimeoutError";
+  }
+};
+var CliError = class extends Error {
+  hint;
+  label;
+  exitCode;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "CliError";
+    this.label = options.label ?? "\u9519\u8BEF";
+    this.hint = options.hint === void 0 ? [] : Array.isArray(options.hint) ? options.hint : [options.hint];
+    this.exitCode = options.exitCode ?? 1;
+  }
+};
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new TimeoutError()), ms);
+    promise.then(
+      (v) => {
+        clearTimeout(timer);
+        resolve(v);
+      },
+      (e) => {
+        clearTimeout(timer);
+        reject(e);
+      }
+    );
+  });
+}
+
+// src/settings.ts
 var settingsCache = null;
 function readSettings() {
   if (settingsCache !== null) return settingsCache;
@@ -3274,7 +3331,7 @@ function getSubscriptionsWithCache() {
 var SAFE_NAME_RE = /^[\w\-\p{Unified_Ideograph}]{1,64}$/u;
 function validateSubscriptionName(name) {
   if (!name || !SAFE_NAME_RE.test(name)) {
-    throw new Error(`\u8BA2\u9605\u540D\u79F0\u65E0\u6548: "${name}"\uFF0C\u53EA\u5141\u8BB8\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u3001\u77ED\u6A2A\u7EBF\u548C\u4E2D\u6587\uFF08\u6700\u957F 64 \u5B57\u7B26\uFF09`);
+    throw new CliError(`\u8BA2\u9605\u540D\u79F0\u65E0\u6548: "${name}"\uFF0C\u53EA\u5141\u8BB8\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u3001\u77ED\u6A2A\u7EBF\u548C\u4E2D\u6587\uFF08\u6700\u957F 64 \u5B57\u7B26\uFF09`);
   }
 }
 function addSubscription(url, name = "default") {
@@ -3282,7 +3339,7 @@ function addSubscription(url, name = "default") {
   const settings = readSettings();
   const subs = [...settings.subscriptions || []];
   if (subs.some((s) => s.name === name)) {
-    throw new Error(`\u8BA2\u9605 "${name}" \u5DF2\u5B58\u5728\uFF0C\u8BF7\u6362\u4E2A\u540D\u79F0\uFF08mihomo sub add <url> <\u540D\u79F0>\uFF09\uFF0C\u6216\u5148\u5220\u9664\uFF08mihomo sub remove ${name}\uFF09`);
+    throw new CliError(`\u8BA2\u9605 "${name}" \u5DF2\u5B58\u5728\uFF0C\u8BF7\u6362\u4E2A\u540D\u79F0\uFF08mihomo sub add <url> <\u540D\u79F0>\uFF09\uFF0C\u6216\u5148\u5220\u9664\uFF08mihomo sub remove ${name}\uFF09`);
   }
   subs.push({ name, url });
   const updates = { subscriptions: subs };
@@ -3326,7 +3383,7 @@ function setDefaultSubscription(name) {
 }
 function getSubscriptionRawConfigPath(subName) {
   if (!SAFE_NAME_RE.test(subName)) {
-    throw new Error(`\u8BA2\u9605\u540D\u79F0\u65E0\u6548: "${subName}"`);
+    throw new CliError(`\u8BA2\u9605\u540D\u79F0\u65E0\u6548: "${subName}"`);
   }
   return path2.join(DIRS.subscriptions, `${subName}.yaml`);
 }
@@ -3564,26 +3621,7 @@ function listOverwriteFile() {
 }
 
 // src/utils.ts
-import { spawnSync } from "child_process";
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../package.json");
-var VERSION = pkg.version;
-var MAX_RESPONSE_BYTES = 50 * 1024 * 1024;
 var sleepBuf = new Int32Array(new SharedArrayBuffer(4));
-var NO_COLOR = process.env.NO_COLOR !== void 0 || !process.stdout.isTTY;
-function colorize(code, str) {
-  if (NO_COLOR) return String(str);
-  return `${code + String(str)}\x1B[0m`;
-}
-var colors = {
-  bold: (s) => colorize("\x1B[1m", s),
-  red: (s) => colorize("\x1B[31m", s),
-  green: (s) => colorize("\x1B[32m", s),
-  yellow: (s) => colorize("\x1B[33m", s),
-  cyan: (s) => colorize("\x1B[36m", s),
-  gray: (s) => colorize("\x1B[90m", s)
-};
 function sleepSync(ms) {
   Atomics.wait(sleepBuf, 0, 0, ms);
 }
@@ -3596,27 +3634,6 @@ function escapeRegExp(s) {
 function shellQuote(s) {
   return `'${s.replace(/'/g, "'\\''")}'`;
 }
-var TimeoutError = class extends Error {
-  constructor() {
-    super("timeout");
-    this.name = "TimeoutError";
-  }
-};
-function withTimeout(promise, ms) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new TimeoutError()), ms);
-    promise.then(
-      (v) => {
-        clearTimeout(timer);
-        resolve(v);
-      },
-      (e) => {
-        clearTimeout(timer);
-        reject(e);
-      }
-    );
-  });
-}
 function formatBytes(bytes) {
   if (bytes === void 0 || bytes === null) return "\u672A\u77E5";
   const num = Number(bytes);
@@ -3696,90 +3713,35 @@ function getNonFlagArg(args, startIdx, valueFlags = VALUE_FLAGS) {
   }
   return null;
 }
-function isProcessRunning(pid) {
-  if (!pid) return false;
-  try {
-    const result = spawnSync("ps", ["-p", String(pid), "-o", "pid="], { encoding: "utf8", timeout: 5e3 });
-    return (result.stdout || "").trim().length > 0;
-  } catch {
-    return false;
-  }
-}
-function isProcessCommandMatching(pid, needle) {
-  if (!pid) return false;
-  try {
-    const result = spawnSync("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf8", timeout: 5e3 });
-    return (result.stdout || "").includes(needle);
-  } catch {
-    return false;
-  }
-}
-function isProcessRoot(pid) {
-  if (!pid) return false;
-  try {
-    const result = spawnSync("ps", ["-p", String(pid), "-o", "uid="], { encoding: "utf8", timeout: 5e3 });
-    return (result.stdout || "").trim() === "0";
-  } catch {
-    return false;
-  }
-}
-function createHttpClient(options = {}) {
-  const { timeout = 6e4, secret } = options;
-  const authHeaders = secret ? { Authorization: `Bearer ${secret}` } : {};
-  return {
-    async get(url, config) {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), timeout);
-      const signal = config?.signal ? AbortSignal.any([controller.signal, config.signal]) : controller.signal;
-      try {
-        const response = await fetch(url, {
-          signal,
-          headers: { "User-Agent": `mihomo-cli/${VERSION}`, ...authHeaders }
-        });
-        if (!response.ok) {
-          const error = new Error(`HTTP ${response.status}`);
-          error.response = { status: response.status };
-          try {
-            error.response.data = await response.json();
-          } catch {
-          }
-          throw error;
-        }
-        const declaredLen = Number(response.headers.get("content-length"));
-        if (Number.isFinite(declaredLen) && declaredLen > MAX_RESPONSE_BYTES) {
-          throw new Error(`\u54CD\u5E94\u4F53\u8FC7\u5927\uFF08${formatBytes(declaredLen)}\uFF0C\u4E0A\u9650 ${formatBytes(MAX_RESPONSE_BYTES)}\uFF09`);
-        }
-        const text = await readBodyWithLimit(response, controller);
-        const data = config?.responseType === "json" ? JSON.parse(text) : text;
-        return { data, headers: response.headers, status: response.status };
-      } finally {
-        clearTimeout(timer);
-      }
+function levenshtein(a, b) {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const curr = [i];
+    for (let j = 1; j <= b.length; j++) {
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
     }
-  };
+    prev = curr;
+  }
+  return prev[b.length];
 }
-async function readBodyWithLimit(response, controller) {
-  if (!response.body) return response.text();
-  const reader = response.body.getReader();
-  const chunks = [];
-  let total = 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (value) {
-        total += value.byteLength;
-        if (total > MAX_RESPONSE_BYTES) {
-          controller.abort();
-          throw new Error(`\u54CD\u5E94\u4F53\u8D85\u8FC7\u5927\u5C0F\u4E0A\u9650\uFF08${formatBytes(MAX_RESPONSE_BYTES)}\uFF09`);
-        }
-        chunks.push(value);
-      }
+function suggestSimilar(input, candidates) {
+  const lower = input.toLowerCase();
+  const scored = [];
+  for (const cand of candidates) {
+    const c = cand.toLowerCase();
+    if (cand === input) continue;
+    if (c.startsWith(lower)) {
+      scored.push({ name: cand, score: 0, lenDiff: Math.abs(cand.length - input.length) });
+    } else if (lower.length >= 3) {
+      const d = levenshtein(lower, c);
+      if (d <= 2) scored.push({ name: cand, score: d, lenDiff: Math.abs(cand.length - input.length) });
     }
-  } finally {
-    reader.releaseLock();
   }
-  return Buffer.concat(chunks).toString("utf8");
+  scored.sort((a, b) => a.score - b.score || a.lenDiff - b.lenDiff);
+  return scored.slice(0, 3).map((s) => s.name);
 }
 function normalizeMirrorUrl(val) {
   if (!val) return null;
@@ -3822,15 +3784,6 @@ function parseMirrorArg(args) {
   }
   return { mirror: null, isOverride: false, type: "download" };
 }
-function isProxyValid(proxy) {
-  if (!proxy.name || !proxy.server || !proxy.port) return false;
-  if (!proxy.type) return false;
-  if (proxy.type === "ss" && typeof proxy.cipher === "string" && proxy.cipher.startsWith("2022-blake3")) {
-    const pw = String(proxy.password || "");
-    if (!/^[A-Za-z0-9+/\-_]+=*$/.test(pw) || pw.length < 20) return false;
-  }
-  return true;
-}
 
 // src/config.ts
 var SAFE_YAML_LOAD_OPTIONS = { maxAliases: 200 };
@@ -4085,7 +4038,7 @@ function getKernelVersion() {
   }
   if (kernelVersionCached) return kernelVersionCache;
   try {
-    const result = spawnSync2(PATHS.mihomoBinary, ["-v"], { encoding: "utf8", timeout: 5e3 });
+    const result = spawnSync(PATHS.mihomoBinary, ["-v"], { encoding: "utf8", timeout: 5e3 });
     const output = `${result.stdout || ""}${result.stderr || ""}`.trim();
     if (output) {
       const match = output.match(/v?[\d]+\.[\d]+\.[\d]+/);
@@ -4179,12 +4132,12 @@ function printVersion() {
 }
 
 // src/daemon.ts
-import { spawnSync as spawnSync4 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import fs6 from "fs";
 import path5 from "path";
 
 // src/process.ts
-import { spawn, spawnSync as spawnSync3 } from "child_process";
+import { spawn, spawnSync as spawnSync2 } from "child_process";
 import fs5 from "fs";
 import path4 from "path";
 
@@ -4221,6 +4174,34 @@ var SUDO_TIMEOUT_MS = 6e4;
 var TUN_MODE_POST_WAIT_MS = 500;
 var BATCH_KILL_THRESHOLD = 3;
 var DEFAULT_LOG_RETENTION_DAYS = 7;
+var PS_TIMEOUT_MS = 5e3;
+function isProcessRunning(pid) {
+  if (!pid) return false;
+  try {
+    const result = spawnSync2("ps", ["-p", String(pid), "-o", "pid="], { encoding: "utf8", timeout: PS_TIMEOUT_MS });
+    return (result.stdout || "").trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function isProcessCommandMatching(pid, needle) {
+  if (!pid) return false;
+  try {
+    const result = spawnSync2("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf8", timeout: PS_TIMEOUT_MS });
+    return (result.stdout || "").includes(needle);
+  } catch {
+    return false;
+  }
+}
+function isProcessRoot(pid) {
+  if (!pid) return false;
+  try {
+    const result = spawnSync2("ps", ["-p", String(pid), "-o", "uid="], { encoding: "utf8", timeout: PS_TIMEOUT_MS });
+    return (result.stdout || "").trim() === "0";
+  } catch {
+    return false;
+  }
+}
 var MAIN_INSTANCE_PATTERN = `${escapeRegExp(PATHS.mihomoBinary)}.*${escapeRegExp(PATHS.configFile)}`;
 function clearRuntime() {
   if (fs5.existsSync(DIRS.runtime)) {
@@ -4239,11 +4220,12 @@ function getPid() {
 }
 function isRunning() {
   const pid = getPid();
-  return pid ? isProcessRunning(pid) : false;
+  if (!pid) return false;
+  return isProcessRunning(pid) && isProcessCommandMatching(pid, PATHS.mihomoBinary);
 }
 function getMihomoPids() {
   try {
-    const result = spawnSync3("pgrep", ["-f", MAIN_INSTANCE_PATTERN], { encoding: "utf8", timeout: 1e4 });
+    const result = spawnSync2("pgrep", ["-f", MAIN_INSTANCE_PATTERN], { encoding: "utf8", timeout: 1e4 });
     const output = (result.stdout || "").trim();
     if (!output) return [];
     return output.split("\n").filter(Boolean).map((p) => parseInt(p, 10)).filter((p) => Number.isInteger(p) && p > 0);
@@ -4283,7 +4265,7 @@ function clearPid() {
   if (!fs5.existsSync(PATHS.pidFile)) return;
   if (isPidFileOwnedByRoot()) {
     try {
-      spawnSync3("sudo", ["rm", "-f", PATHS.pidFile], { stdio: "inherit", timeout: 1e4 });
+      spawnSync2("sudo", ["rm", "-f", PATHS.pidFile], { stdio: "inherit", timeout: 1e4 });
     } catch {
     }
   } else {
@@ -4305,14 +4287,14 @@ function killAllMihomo(forceSudo = false) {
   const pattern = MAIN_INSTANCE_PATTERN;
   if (forceSudo) {
     try {
-      spawnSync3("sudo", ["pkill", "-9", "-f", pattern], { stdio: "inherit", timeout: 15e3 });
+      spawnSync2("sudo", ["pkill", "-9", "-f", pattern], { stdio: "inherit", timeout: 15e3 });
       return true;
     } catch {
       return false;
     }
   } else {
     try {
-      spawnSync3("pkill", ["-9", "-f", pattern], { timeout: 1e4 });
+      spawnSync2("pkill", ["-9", "-f", pattern], { timeout: 1e4 });
       return true;
     } catch {
       return false;
@@ -4408,7 +4390,7 @@ exit 2
 }
 function getProcessInfo(pid) {
   try {
-    const result = spawnSync3("ps", ["-p", String(pid), "-o", "rss="], { encoding: "utf8", timeout: 5e3 });
+    const result = spawnSync2("ps", ["-p", String(pid), "-o", "rss="], { encoding: "utf8", timeout: 5e3 });
     const psOutput = (result.stdout || "").trim();
     if (!psOutput) return null;
     const rss = parseInt(psOutput, 10);
@@ -4442,11 +4424,11 @@ async function start(mode = "mixed") {
   rotateAndCleanupLogs();
   const binary = PATHS.mihomoBinary;
   if (!fs5.existsSync(binary)) {
-    throw new Error("\u672A\u627E\u5230 mihomo \u5185\u6838\uFF0C\u8BF7\u5148\u4E0B\u8F7D\u5185\u6838");
+    throw new CliError("\u672A\u627E\u5230 mihomo \u5185\u6838\uFF0C\u8BF7\u5148\u4E0B\u8F7D\u5185\u6838");
   }
   const configFile = PATHS.configFile;
   if (!fs5.existsSync(configFile)) {
-    throw new Error("\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605\u5E76\u542F\u52A8");
+    throw new CliError("\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605\u5E76\u542F\u52A8");
   }
   const staleState = checkStaleState();
   if (isTunMode) {
@@ -4523,7 +4505,7 @@ async function startTunMode(staleState) {
   }
   console.log("TUN \u6A21\u5F0F\u9700\u8981 sudo \u6743\u9650...");
   try {
-    const result = spawnSync3("sudo", [launchScript], { stdio: "inherit", timeout: SUDO_TIMEOUT_MS });
+    const result = spawnSync2("sudo", [launchScript], { stdio: "inherit", timeout: SUDO_TIMEOUT_MS });
     if (result.error) throw result.error;
     if (result.status !== 0) {
       const err = new Error("TUN \u542F\u52A8\u811A\u672C\u6267\u884C\u5931\u8D25");
@@ -4763,7 +4745,7 @@ function runSudoScript(scriptBody, opts) {
   const scriptPath = path5.join(DIRS.runtime, opts.file);
   fs6.writeFileSync(scriptPath, scriptBody, { mode: 448 });
   try {
-    const result = spawnSync4("sudo", [scriptPath], { stdio: "inherit", timeout: SUDO_TIMEOUT_MS });
+    const result = spawnSync3("sudo", [scriptPath], { stdio: "inherit", timeout: SUDO_TIMEOUT_MS });
     if (result.error) throw result.error;
     if (result.status !== 0) {
       if (result.status === 1) {
@@ -4797,10 +4779,10 @@ function isDaemonRunning(status) {
 }
 function enableDaemon() {
   if (!fs6.existsSync(PATHS.mihomoBinary)) {
-    throw new Error("\u672A\u627E\u5230 mihomo \u5185\u6838\uFF0C\u8BF7\u5148\u4E0B\u8F7D\u5185\u6838");
+    throw new CliError("\u672A\u627E\u5230 mihomo \u5185\u6838\uFF0C\u8BF7\u5148\u4E0B\u8F7D\u5185\u6838");
   }
   if (!fs6.existsSync(PATHS.configFile)) {
-    throw new Error("\u672A\u627E\u5230\u8FD0\u884C\u65F6\u914D\u7F6E\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605");
+    throw new CliError("\u672A\u627E\u5230\u8FD0\u884C\u65F6\u914D\u7F6E\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605");
   }
   ensureDirs();
   const stagePath = path5.join(DIRS.runtime, "daemon.plist.stage");
@@ -4905,25 +4887,86 @@ async function restartDaemon() {
   cleanupOldLogs();
 }
 
-// src/subscription.ts
-function isGithubUrl(url) {
-  const githubRe = /github\.com|raw\.githubusercontent\.com/i;
-  if (isMultiUrl(url)) {
-    return splitUrls(url).every((u) => githubRe.test(u));
-  }
-  return githubRe.test(url);
-}
-function getDefaultUpdateInterval(url) {
-  return isGithubUrl(url) ? DEFAULT_UPDATE_INTERVAL_HOURS_GITHUB : DEFAULT_UPDATE_INTERVAL_HOURS;
-}
-function resolveUpdateInterval(url, cachedInterval) {
-  return cachedInterval && cachedInterval > 0 ? cachedInterval : getDefaultUpdateInterval(url);
-}
-var HTTP_CLIENT = createHttpClient({ timeout: 6e4 });
-function isMultiUrl(url) {
-  return url.includes(",");
+// src/http.ts
+var MAX_RESPONSE_BYTES = 50 * 1024 * 1024;
+function createHttpClient(options = {}) {
+  const { timeout = 6e4, secret } = options;
+  const authHeaders = secret ? { Authorization: `Bearer ${secret}` } : {};
+  return {
+    async get(url, config) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      const signal = config?.signal ? AbortSignal.any([controller.signal, config.signal]) : controller.signal;
+      try {
+        const response = await fetch(url, {
+          signal,
+          headers: { "User-Agent": `mihomo-cli/${VERSION}`, ...authHeaders }
+        });
+        if (!response.ok) {
+          const error = new Error(`HTTP ${response.status}`);
+          error.response = { status: response.status };
+          try {
+            error.response.data = await response.json();
+          } catch {
+          }
+          throw error;
+        }
+        const declaredLen = Number(response.headers.get("content-length"));
+        if (Number.isFinite(declaredLen) && declaredLen > MAX_RESPONSE_BYTES) {
+          throw new Error(`\u54CD\u5E94\u4F53\u8FC7\u5927\uFF08${formatBytes(declaredLen)}\uFF0C\u4E0A\u9650 ${formatBytes(MAX_RESPONSE_BYTES)}\uFF09`);
+        }
+        const text = await readBodyWithLimit(response, controller);
+        const data = config?.responseType === "json" ? JSON.parse(text) : text;
+        return { data, headers: response.headers, status: response.status };
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
 }
-function isValidHttpUrl(url) {
+async function readBodyWithLimit(response, controller) {
+  if (!response.body) return response.text();
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value) {
+        total += value.byteLength;
+        if (total > MAX_RESPONSE_BYTES) {
+          controller.abort();
+          throw new Error(`\u54CD\u5E94\u4F53\u8D85\u8FC7\u5927\u5C0F\u4E0A\u9650\uFF08${formatBytes(MAX_RESPONSE_BYTES)}\uFF09`);
+        }
+        chunks.push(value);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+// src/subscription.ts
+function isGithubUrl(url) {
+  const githubRe = /github\.com|raw\.githubusercontent\.com/i;
+  if (isMultiUrl(url)) {
+    return splitUrls(url).every((u) => githubRe.test(u));
+  }
+  return githubRe.test(url);
+}
+function getDefaultUpdateInterval(url) {
+  return isGithubUrl(url) ? DEFAULT_UPDATE_INTERVAL_HOURS_GITHUB : DEFAULT_UPDATE_INTERVAL_HOURS;
+}
+function resolveUpdateInterval(url, cachedInterval) {
+  return cachedInterval && cachedInterval > 0 ? cachedInterval : getDefaultUpdateInterval(url);
+}
+var HTTP_CLIENT = createHttpClient({ timeout: 6e4 });
+function isMultiUrl(url) {
+  return url.includes(",");
+}
+function isValidHttpUrl(url) {
   try {
     const u = new URL(url.trim());
     return u.protocol === "http:" || u.protocol === "https:";
@@ -4937,7 +4980,7 @@ function splitUrls(url) {
 function loadSubscriptionConfig(subName) {
   const rawContent = readSubscriptionRawConfig(subName);
   if (!rawContent) {
-    throw new Error(`\u672A\u627E\u5230\u8BA2\u9605\u914D\u7F6E "${subName}"`);
+    throw new CliError(`\u672A\u627E\u5230\u8BA2\u9605\u914D\u7F6E "${subName}"\uFF0C\u8BF7\u5148\u66F4\u65B0\u8BA2\u9605\uFF08mihomo sub update ${subName}\uFF09`);
   }
   const raw = parseYamlOrJson(rawContent, "\u8BA2\u9605\u5185\u5BB9");
   return {
@@ -5016,6 +5059,13 @@ function getActiveSubscription() {
   }
   return subs[0];
 }
+function requireActiveSubscription(emptyMsg = "\u6CA1\u6709\u8BA2\u9605\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605") {
+  const sub = getActiveSubscription();
+  if (!sub) {
+    throw new CliError(emptyMsg);
+  }
+  return sub;
+}
 function findSubscriptionFuzzy(subs, pattern) {
   const lowerPattern = pattern.toLowerCase();
   const exact = [];
@@ -5037,14 +5087,15 @@ function findSubscriptionFuzzy(subs, pattern) {
 }
 function pickSingleSubscription(subs, pattern) {
   if (subs.length === 0) {
-    console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u5339\u914D "${pattern}" \u7684\u8BA2\u9605`);
-    process.exit(1);
+    throw new CliError(`\u672A\u627E\u5230\u5339\u914D "${pattern}" \u7684\u8BA2\u9605`);
   }
   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);
+  throw new CliError("\u5339\u914D\u5230\u591A\u4E2A\u8BA2\u9605\uFF0C\u8BF7\u66F4\u7CBE\u786E\u6307\u5B9A", {
+    hint: ["", "\u5339\u914D\u7684\u8BA2\u9605:", ...subs.map((s) => `  ${s.name}`)]
+  });
+}
+function resolveSubscription(subs, pattern) {
+  return pickSingleSubscription(findSubscriptionFuzzy(subs, pattern), pattern);
 }
 async function downloadSubscription(url, subName = "default", signal, persist = true) {
   let response;
@@ -5145,7 +5196,7 @@ async function downloadMergedSubscription(urls, subName, signal, persist = true)
 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`);
+    throw new CliError(`\u672A\u627E\u5230\u8BA2\u9605\u914D\u7F6E "${subName}"\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605`);
   }
   const subUrl = getSubscriptions().find((s) => s.name === subName)?.url;
   const buildResult = buildConfig(rawContent, mode, { subName, subUrl });
@@ -5414,144 +5465,461 @@ async function autoCleanSubscription(subName, options = {}) {
   return { summary, removedProxies, updatedGroups, removedGroups, skipped };
 }
 
-// src/commands/daemon.ts
-function printDaemonStatus() {
-  const status = getDaemonStatus();
-  const stateText = status.enabled ? colors.green("\u5DF2\u542F\u7528") : colors.yellow("\u5DF2\u7981\u7528");
-  console.log(`${colors.gray("\u4FDD\u6D3B: ")}${stateText}`);
-  if (status.enabled) {
-    const runText = isDaemonRunning(status) ? colors.green(`\u8FD0\u884C\u4E2D (PID ${status.pid})`) : colors.yellow("\u672A\u8FD0\u884C");
-    console.log(`${colors.gray("\u5185\u6838: ")}${runText}`);
-  }
-  console.log("");
-  if (status.enabled) {
-    console.log("\u5173\u95ED\u4FDD\u6D3B: mihomo daemon off");
-  } else {
-    console.log("\u5F00\u542F\u4FDD\u6D3B: mihomo daemon on");
-    console.log(colors.gray("  \u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u81EA\u52A8\u91CD\u542F\uFF08\u4EC5 Mixed \u6A21\u5F0F\uFF09"));
+// src/runtime.ts
+function getRuntimeMode() {
+  if (isDaemonEnabled()) return "mixed";
+  return getConfigInfo()?.tun ? "tun" : "mixed";
+}
+function getRunningState() {
+  if (isDaemonEnabled()) {
+    const daemon = getDaemonStatus();
+    return { running: isDaemonRunning(daemon), pid: daemon.pid, daemon: true };
   }
-  console.log("");
+  const status = getStatus();
+  return { running: status.running, pid: status.pid, daemon: false };
 }
-async function cmdDaemon(args) {
-  const action = args?.[1];
-  if (action === "on" || action === "enable") {
-    if (!hasKernel()) {
-      console.error('\u9519\u8BEF: \u672A\u627E\u5230\u5185\u6838\uFF0C\u8BF7\u8FD0\u884C "mihomo kernel"');
-      process.exit(1);
-    }
-    const sub = getActiveSubscription();
-    if (!sub) {
-      console.error("\u9519\u8BEF: \u6CA1\u6709\u8BA2\u9605\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605");
-      process.exit(1);
-    }
-    let configInfo;
-    try {
-      configInfo = prepareConfigForStart("mixed", sub.name);
-    } catch (e) {
-      console.error(`${colors.red("\u914D\u7F6E\u9519\u8BEF:")} ${e.message}`);
-      process.exit(1);
-    }
-    console.log(colors.gray("\u5C06\u8BF7\u6C42\u7BA1\u7406\u5458\u6743\u9650\u4EE5\u5B89\u88C5\u7CFB\u7EDF\u7EA7\u4FDD\u6D3B\u670D\u52A1\uFF08LaunchDaemon\uFF09"));
-    console.log(colors.gray("\u7CFB\u7EDF\u7EA7\u4FDD\u6D3B\u9700\u8981 root\uFF0C\u4EE5\u89E3\u51B3\u5C40\u57DF\u7F51\u8BBF\u95EE\u53D7\u9650\u95EE\u9898"));
-    try {
-      enableDaemon();
-    } catch (e) {
-      console.error(`${colors.red("\u542F\u7528\u4FDD\u6D3B\u5931\u8D25:")} ${e.message}`);
-      process.exit(1);
-    }
-    console.log(`${colors.green("\u5DF2\u542F\u7528\u4FDD\u6D3B")} \xB7 ${sub.name} \xB7 ${formatProxySummary(configInfo)}`);
-    console.log(colors.gray("\u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u81EA\u52A8\u91CD\u542F\uFF0C\u4EE3\u7406\u5C06\u5728\u540E\u53F0\u5E38\u9A7B"));
-    console.log("");
+function isRestartNeededOnChange() {
+  return isDaemonEnabled() || getStatus().running;
+}
+async function launchOrRestart(mode) {
+  if (isDaemonEnabled()) {
+    await restartDaemon();
     await sleep(DAEMON_BOOT_WAIT_MS);
-    printDaemonStatus();
-    return;
+    return getDaemonStatus().pid;
+  }
+  const result = await start(mode);
+  return result.pid;
+}
+
+// src/progress.ts
+var IS_TTY = process.stdout.isTTY === true;
+var BAR_WIDTH = 20;
+function createProgressPrinter(totalRounds = 1) {
+  let alive = 0;
+  let dead = 0;
+  const resultMap = /* @__PURE__ */ new Map();
+  function render(done, total) {
+    if (!IS_TTY) return;
+    const pct = Math.round(done / total * 100);
+    const filled = Math.round(done / total * BAR_WIDTH);
+    const bar = "\u2588".repeat(filled) + "\u2591".repeat(BAR_WIDTH - filled);
+    process.stdout.write(`\r${bar} ${done}/${total} (${pct}%) | ${colors.green(`\u2713${alive}`)} ${colors.red(`\u2717${dead}`)}`);
   }
-  if (action === "off" || action === "disable") {
-    if (!isDaemonEnabled()) {
-      console.log("\u4FDD\u6D3B\u5DF2\u662F\u5173\u95ED\u72B6\u6001");
+  return {
+    onResult(result, index, total, round = 1) {
+      if (resultMap.size === 0 && totalRounds > 1) {
+        console.log(`--- \u7B2C 1 \u8F6E\u6D4B\u8BD5 (${total} \u4E2A\u8282\u70B9) ---`);
+      }
+      const prev = resultMap.get(result.name);
+      if (prev) {
+        if (prev.result.delay !== null) alive--;
+        else dead--;
+      }
+      if (result.delay !== null) alive++;
+      else dead++;
+      resultMap.set(result.name, { result, round });
+      render(index + 1, total);
+    },
+    onRetryRound(round, count) {
+      if (IS_TTY) {
+        process.stdout.write("\n");
+      }
+      console.log(`--- \u7B2C ${round} \u8F6E\u91CD\u8BD5 (${count} \u4E2A\u8282\u70B9) ---`);
+      alive = 0;
+      dead = 0;
+    },
+    finish() {
+      if (IS_TTY) {
+        process.stdout.write("\n");
+      }
+      console.log("");
+      if (!IS_TTY) return;
+      const entries = [...resultMap.values()];
+      entries.sort((a, b) => a.result.name.localeCompare(b.result.name));
+      const total = entries.length;
+      console.log("\u8282\u70B9\u6700\u7EC8\u72B6\u6001:");
+      for (let i = 0; i < entries.length; i++) {
+        const { result, round } = entries[i];
+        const prefix = `[${i + 1}/${total}]`;
+        if (result.delay !== null) {
+          const delayColor = result.delay < 300 ? colors.green : result.delay < 800 ? colors.yellow : colors.red;
+          const retryNote = round > 1 ? colors.gray(` (\u7B2C${round}\u8F6E\u901A\u8FC7)`) : "";
+          console.log(`${prefix} ${colors.green("\u2713")} ${result.name} ${delayColor(`${result.delay}ms`)}${retryNote}`);
+        } else {
+          console.log(`${prefix} ${colors.red("\u2717")} ${result.name} ${colors.gray(result.error || "timeout")}`);
+        }
+      }
       console.log("");
-      printDaemonStatus();
-      return;
     }
-    console.log(colors.gray("\u5C06\u8BF7\u6C42\u7BA1\u7406\u5458\u6743\u9650\u4EE5\u79FB\u9664\u7CFB\u7EDF\u7EA7\u4FDD\u6D3B\u670D\u52A1"));
-    try {
-      disableDaemon();
-    } catch (e) {
-      console.error(`${colors.red("\u5173\u95ED\u4FDD\u6D3B\u5931\u8D25:")} ${e.message}`);
-      process.exit(1);
+  };
+}
+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 formatTestSummary(summary) {
+  return `\u7ED3\u679C: ${colors.green(`${summary.alive} \u5B58\u6D3B`)} / ${colors.red(`${summary.dead} \u5931\u8D25`)} / ${summary.total} \u603B\u8BA1`;
+}
+
+// src/commands/status.ts
+function printStatus() {
+  const status = getStatus();
+  const state = getRunningState();
+  const info = getConfigInfo();
+  const overwriteEnabled = isOverwriteEnabled();
+  const overwriteFiles = listOverwriteFile().files;
+  const activeSub = getActiveSubscription();
+  const { running, pid, daemon: daemonManaged } = state;
+  console.log("");
+  let modeLabel = "";
+  if (info) {
+    modeLabel = colors.cyan(info.tun ? " (TUN)" : " (Mixed)");
+  }
+  const statusText = 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 (pid) {
+    console.log(`${colors.gray("PID:  ")}${pid}`);
+    if (!daemonManaged && status.processInfo) {
+      console.log(`${colors.gray("\u5185\u5B58: ")}${status.processInfo.memory}`);
     }
-    console.log(`${colors.green("\u5DF2\u5173\u95ED\u4FDD\u6D3B")}\uFF0C\u4EE3\u7406\u5DF2\u505C\u6B62`);
-    console.log(colors.gray("\u91CD\u65B0\u542F\u7528: mihomo daemon on"));
-    console.log("");
-    return;
   }
-  if (action !== void 0 && action !== "status") {
-    console.error(`\u9519\u8BEF: \u672A\u77E5\u7684 daemon \u5B50\u547D\u4EE4: ${action}`);
-    console.log("");
-    console.log("\u53EF\u7528\u5B50\u547D\u4EE4: on, off, status");
-    process.exit(1);
+  if (info) {
+    if (info.tun) {
+      const extra = info.mixedPort ? `\uFF0C\u53E6\u76D1\u542C ${info.mixedPort}` : "";
+      console.log(`${colors.gray("\u7AEF\u53E3: ")}TUN \u63A5\u7BA1${extra}`);
+    } else 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"}`);
+    }
   }
-  console.log("");
-  printDaemonStatus();
-}
-
-// 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;
+  if (activeSub) {
+    let subLine = `${colors.gray("\u8BA2\u9605: ")}${activeSub.name}`;
+    if (info) {
+      subLine += ` (${formatProxySummary(info)})`;
     }
-    const key = target.toLowerCase();
-    const targetInfo = Object.hasOwn(DIRECTORY_TARGETS, key) ? DIRECTORY_TARGETS[key] : void 0;
-    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}`);
+    console.log(subLine);
+    const cached = getSubscriptionsWithCache().find((s) => s.name === activeSub.name);
+    if (cached && (cached.download !== void 0 || cached.total !== void 0)) {
+      const used = (cached.upload || 0) + (cached.download || 0);
+      let trafficLine = `${colors.gray("\u6D41\u91CF: ")}${formatBytes(used)} / ${formatBytes(cached.total)}`;
+      if (cached.total && cached.total > 0) {
+        trafficLine += ` (${Math.min(used / cached.total * 100, 100).toFixed(1)}%)`;
       }
-      return;
+      console.log(trafficLine);
     }
-    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 [key2, val] of Object.entries(DIRECTORY_TARGETS)) {
-      if (key2 !== "root") {
-        console.log(`  ${key2.padEnd(14)}${val.label}`);
-      }
+    if (cached?.expire !== void 0) {
+      console.log(`${colors.gray("\u5230\u671F: ")}${formatTimestamp(cached.expire)}`);
     }
-    console.log("");
-    process.exit(1);
+  } 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")}`);
+  }
+  if (isDaemonEnabled()) {
+    console.log(`${colors.gray("\u4FDD\u6D3B: ")}${colors.green("\u5DF2\u542F\u7528")} ${colors.gray("(\u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u91CD\u542F)")}`);
   }
   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 data           \u6253\u5F00 mihomo \u6570\u636E\u76EE\u5F55");
+}
+
+// src/commands/stop.ts
+function handleStopResult(result) {
+  if (result.remaining && result.remaining.length > 0) {
+    throw new CliError(result.remaining.join(", "), { label: "\u90E8\u5206\u8FDB\u7A0B\u672A\u7EC8\u6B62", hint: "\u8BF7\u624B\u52A8\u8FD0\u884C: sudo pkill -9 mihomo" });
+  }
+}
+async function cmdStop() {
+  if (isDaemonEnabled()) {
+    console.log(colors.yellow("\u4FDD\u6D3B\u5DF2\u542F\u7528\uFF0C\u4EE3\u7406\u7531 launchd \u6258\u7BA1"));
+    console.log("\u76F4\u63A5\u505C\u6B62\u4F1A\u88AB\u81EA\u52A8\u91CD\u65B0\u62C9\u8D77\uFF0C\u8BF7\u7528: mihomo daemon off");
+    return;
+  }
+  const pids = getMihomoPids();
+  if (pids.length === 0) {
+    console.log(colors.yellow("\u4E0D\u5728\u8FD0\u884C"));
+    return;
+  }
+  console.log(`\u505C\u6B62 ${pids.length} \u4E2A\u8FDB\u7A0B...`);
+  handleStopResult(stop());
+  console.log(colors.green("\u5DF2\u505C\u6B62\u8FDB\u7A0B"));
+}
+
+// src/commands/start.ts
+async function cmdStart(args) {
+  const modeToken = args[1] && !args[1].startsWith("-") ? args[1].toLowerCase() : void 0;
+  if (modeToken !== void 0 && modeToken !== "tun" && modeToken !== "mixed") {
+    throw new CliError(`\u672A\u77E5\u7684\u542F\u52A8\u6A21\u5F0F: ${args[1]}`, { hint: "\u7528\u6CD5: mihomo start [tun|mixed]\uFF08\u9ED8\u8BA4 mixed\uFF09" });
+  }
+  const targetMode = modeToken === "tun" ? "tun" : "mixed";
+  if (!hasKernel()) {
+    throw new CliError('\u672A\u627E\u5230\u5185\u6838\uFF0C\u8BF7\u8FD0\u884C "mihomo kernel"');
+  }
+  const daemonEnabled = isDaemonEnabled();
+  if (targetMode === "tun" && daemonEnabled) {
+    throw new CliError("\u4FDD\u6D3B\u5DF2\u542F\u7528\uFF08\u4EC5\u652F\u6301 Mixed \u6A21\u5F0F\uFF09\uFF0C\u65E0\u6CD5\u542F\u52A8 TUN", { hint: "\u8BF7\u5148\u5173\u95ED\u4FDD\u6D3B: mihomo daemon off" });
+  }
+  const rounds = parseIntArg(args, "-r", "--rounds", DEFAULT_CLEAN_ROUNDS);
+  const timeout = parseIntArg(args, "-t", "--timeout", DEFAULT_TEST_TIMEOUT);
+  const concurrency = parseIntArg(args, "-j", "--concurrency", DEFAULT_TEST_CONCURRENCY);
+  const skipUpdate = hasFlag(args, "-s", "--no-update");
+  const skipClean = hasFlag(args, "--no-clean");
+  const updateTimeout = parseIntArg(args, "-u", "--update-timeout", DEFAULT_AUTO_UPDATE_TIMEOUT);
+  const sub = requireActiveSubscription("\u6CA1\u6709\u8BA2\u9605\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605");
+  if (!skipUpdate) {
+    await autoUpdateStaleSubscription({ timeout: updateTimeout });
+  }
+  if (!daemonEnabled) {
+    if (hasRootResidue()) {
+      throw new CliError("\u5B58\u5728\u9700\u8981 root \u6743\u9650\u6E05\u7406\u7684\u6B8B\u7559\u8FDB\u7A0B/\u6587\u4EF6", {
+        hint: [`\u8BF7\u5148\u624B\u52A8\u6E05\u7406: sudo pkill -9 mihomo && sudo rm -f ${PATHS.pidFile}`, "\u6216\u5207\u6362\u5230 TUN \u6A21\u5F0F\u542F\u52A8\uFF08\u81EA\u52A8\u6E05\u7406\uFF09: mihomo start tun"]
+      });
+    }
+    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) {
+    if (e instanceof CliError) throw e;
+    throw new CliError(e.message, { label: "\u914D\u7F6E\u9519\u8BEF" });
+  }
+  const modeLabel = targetMode === "tun" ? "TUN" : "Mixed";
+  console.log([colors.cyan(modeLabel), sub.name, formatProxySummary(configInfo)].join(" \xB7 "));
+  try {
+    const pid = await launchOrRestart(targetMode);
+    const label = daemonEnabled ? "\u5DF2\u542F\u52A8 (\u4FDD\u6D3B)" : "\u5DF2\u542F\u52A8";
+    console.log(`${colors.green(label)}${pid ? ` (PID ${pid})` : ""}`);
+  } catch (e) {
+    if (e instanceof CliError) throw e;
+    const lines = e.message.split("\n");
+    throw new CliError(lines[0], { label: "\u542F\u52A8\u5931\u8D25", hint: lines.slice(1) });
+  }
+  const cleanThreshold = isGithubUrl(sub.url) ? AUTO_CLEAN_THRESHOLD_GITHUB : AUTO_CLEAN_THRESHOLD;
+  if (!skipClean && configInfo.proxies > cleanThreshold) {
+    const cache = readSubscriptionCache();
+    const lastCleanAt = cache[sub.name]?.last_auto_clean_at;
+    const withinCooldown = !!lastCleanAt && Date.now() - new Date(lastCleanAt).getTime() < AUTO_CLEAN_COOLDOWN_HOURS * 60 * 60 * 1e3;
+    if (!withinCooldown) {
+      console.log("");
+      console.log(`\u8282\u70B9\u6570 ${configInfo.proxies} \u8D85\u8FC7 ${cleanThreshold}\uFF0C\u81EA\u52A8\u6E05\u7406\uFF08${AUTO_CLEAN_COOLDOWN_HOURS}h \u5185\u4EC5\u4E00\u6B21\uFF0C--no-clean \u8DF3\u8FC7\uFF09...`);
+      console.log("");
+      await sleep(1e3);
+      const progress = createProgressPrinter(rounds);
+      const cleanResult = await autoCleanSubscription(sub.name, {
+        timeout,
+        concurrency,
+        rounds,
+        onResult: progress.onResult,
+        onRetryRound: progress.onRetryRound
+      });
+      progress.finish();
+      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...");
+        if (!daemonEnabled) handleStopResult(stop());
+        try {
+          configInfo = prepareConfigForStart(targetMode, sub.name);
+          const pid = await launchOrRestart(targetMode);
+          console.log(`${colors.green("\u5DF2\u91CD\u542F")}${pid ? ` (PID ${pid})` : ""} \xB7 ${formatProxySummary(configInfo)}`);
+        } catch (e) {
+          if (e instanceof CliError) throw e;
+          throw new CliError(e.message.split("\n")[0], { label: "\u91CD\u542F\u5931\u8D25" });
+        }
+      }
+      saveSubscriptionCache(sub.name, { last_auto_clean_at: (/* @__PURE__ */ new Date()).toISOString() });
+    }
+  }
+  printStatus();
+}
+
+// src/commands/shared.ts
+async function dispatchSubcommand(args, table, options) {
+  const action = args[1];
+  if (action) {
+    const cmd = table.find((c) => c.name === action || c.aliases?.includes(action));
+    if (cmd) return cmd.handler(args);
+    if (options.onUnknown) return options.onUnknown(action);
+  }
+  return options.fallback(args);
+}
+function requireRunning() {
+  const state = getRunningState();
+  if (!state.running) {
+    const hint = state.daemon ? "mihomo daemon on" : "mihomo start";
+    throw new CliError(`mihomo \u672A\u8FD0\u884C\uFF0C\u8BF7\u5148\u542F\u52A8 (${hint})`);
+  }
+}
+async function restartToApply(args) {
+  if (!isRestartNeededOnChange()) return false;
+  const currentMode = getRuntimeMode();
+  console.log("");
+  await cmdStart(["start", currentMode, ...extractStartOptions(args)]);
+  return true;
+}
+
+// src/commands/daemon.ts
+function printDaemonStatus() {
+  const status = getDaemonStatus();
+  const stateText = status.enabled ? colors.green("\u5DF2\u542F\u7528") : colors.yellow("\u5DF2\u7981\u7528");
+  console.log(`${colors.gray("\u4FDD\u6D3B: ")}${stateText}`);
+  if (status.enabled) {
+    const runText = isDaemonRunning(status) ? colors.green(`\u8FD0\u884C\u4E2D (PID ${status.pid})`) : colors.yellow("\u672A\u8FD0\u884C");
+    console.log(`${colors.gray("\u5185\u6838: ")}${runText}`);
+  }
+  console.log("");
+  if (status.enabled) {
+    console.log("\u5173\u95ED\u4FDD\u6D3B: mihomo daemon off");
+  } else {
+    console.log("\u5F00\u542F\u4FDD\u6D3B: mihomo daemon on");
+    console.log(colors.gray("  \u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u81EA\u52A8\u91CD\u542F\uFF08\u4EC5 Mixed \u6A21\u5F0F\uFF09"));
+  }
+  console.log("");
+}
+async function daemonOn() {
+  if (!hasKernel()) {
+    throw new CliError('\u672A\u627E\u5230\u5185\u6838\uFF0C\u8BF7\u8FD0\u884C "mihomo kernel"');
+  }
+  const sub = requireActiveSubscription("\u6CA1\u6709\u8BA2\u9605\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605");
+  let configInfo;
+  try {
+    configInfo = prepareConfigForStart("mixed", sub.name);
+  } catch (e) {
+    if (e instanceof CliError) throw e;
+    throw new CliError(e.message, { label: "\u914D\u7F6E\u9519\u8BEF" });
+  }
+  console.log(colors.gray("\u5C06\u8BF7\u6C42\u7BA1\u7406\u5458\u6743\u9650\u4EE5\u5B89\u88C5\u7CFB\u7EDF\u7EA7\u4FDD\u6D3B\u670D\u52A1\uFF08LaunchDaemon\uFF09"));
+  console.log(colors.gray("\u7CFB\u7EDF\u7EA7\u4FDD\u6D3B\u9700\u8981 root\uFF0C\u4EE5\u89E3\u51B3\u5C40\u57DF\u7F51\u8BBF\u95EE\u53D7\u9650\u95EE\u9898"));
+  try {
+    enableDaemon();
+  } catch (e) {
+    if (e instanceof CliError) throw e;
+    throw new CliError(e.message, { label: "\u542F\u7528\u4FDD\u6D3B\u5931\u8D25" });
+  }
+  console.log(`${colors.green("\u5DF2\u542F\u7528\u4FDD\u6D3B")} \xB7 ${sub.name} \xB7 ${formatProxySummary(configInfo)}`);
+  console.log(colors.gray("\u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u81EA\u52A8\u91CD\u542F\uFF0C\u4EE3\u7406\u5C06\u5728\u540E\u53F0\u5E38\u9A7B"));
+  console.log("");
+  await sleep(DAEMON_BOOT_WAIT_MS);
+  printDaemonStatus();
+}
+function daemonOff() {
+  if (!isDaemonEnabled()) {
+    console.log("\u4FDD\u6D3B\u5DF2\u662F\u5173\u95ED\u72B6\u6001");
+    console.log("");
+    printDaemonStatus();
+    return;
+  }
+  console.log(colors.gray("\u5C06\u8BF7\u6C42\u7BA1\u7406\u5458\u6743\u9650\u4EE5\u79FB\u9664\u7CFB\u7EDF\u7EA7\u4FDD\u6D3B\u670D\u52A1"));
+  try {
+    disableDaemon();
+  } catch (e) {
+    if (e instanceof CliError) throw e;
+    throw new CliError(e.message, { label: "\u5173\u95ED\u4FDD\u6D3B\u5931\u8D25" });
+  }
+  console.log(`${colors.green("\u5DF2\u5173\u95ED\u4FDD\u6D3B")}\uFF0C\u4EE3\u7406\u5DF2\u505C\u6B62`);
+  console.log(colors.gray("\u91CD\u65B0\u542F\u7528: mihomo daemon on"));
+  console.log("");
+}
+function printStatusView() {
+  console.log("");
+  printDaemonStatus();
+}
+var SUBCOMMANDS = [
+  { name: "on", aliases: ["enable"], handler: daemonOn },
+  { name: "off", aliases: ["disable"], handler: daemonOff },
+  { name: "status", handler: printStatusView }
+];
+async function cmdDaemon(args) {
+  await dispatchSubcommand(args, SUBCOMMANDS, {
+    // 无 action → 显示状态；未知 action → 报错
+    fallback: printStatusView,
+    onUnknown: (action) => {
+      const names = SUBCOMMANDS.flatMap((c) => [c.name, ...c.aliases ?? []]);
+      const suggestion = suggestSimilar(action, names);
+      throw new CliError(`\u672A\u77E5\u7684 daemon \u5B50\u547D\u4EE4: ${action}`, {
+        hint: [...suggestion.length > 0 ? [`\u662F\u5426\u60F3\u8F93\u5165: ${suggestion.join(" / ")}?`] : [], "", "\u53EF\u7528\u5B50\u547D\u4EE4: on, off, status"]
+      });
+    }
+  });
+}
+
+// src/commands/directory.ts
+function openDirectory(args) {
+  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 key = target.toLowerCase();
+  const targetInfo = Object.hasOwn(DIRECTORY_TARGETS, key) ? DIRECTORY_TARGETS[key] : void 0;
+  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;
+  }
+  const hint = ["", "\u53EF\u7528\u76EE\u6807:", "  root (\u9ED8\u8BA4)   \u6839\u76EE\u5F55"];
+  for (const [k, val] of Object.entries(DIRECTORY_TARGETS)) {
+    if (k !== "root") {
+      hint.push(`  ${k.padEnd(14)}${val.label}`);
+    }
+  }
+  throw new CliError(`\u672A\u77E5\u7684\u76EE\u5F55\u76EE\u6807 "${target}"`, { hint });
+}
+function printDirectoryInfo() {
+  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 data           \u6253\u5F00 mihomo \u6570\u636E\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("");
@@ -5559,9 +5927,13 @@ function cmdDirectory(args) {
   console.log("  MIHOMO_CLI_DIR: \u81EA\u5B9A\u4E49\u6839\u76EE\u5F55\u4F4D\u7F6E");
   console.log("");
 }
+var SUBCOMMANDS2 = [{ name: "open", handler: openDirectory }];
+function cmdDirectory(args) {
+  void dispatchSubcommand(args, SUBCOMMANDS2, { fallback: printDirectoryInfo });
+}
 
 // src/kernel.ts
-import { spawnSync as spawnSync5 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 import fs7 from "fs";
 import path6 from "path";
 
@@ -5726,7 +6098,7 @@ async function downloadKernel(progressCallback, mirror, releaseInfo) {
   if (progressCallback) {
     progressCallback(`\u4E0B\u8F7D\u5185\u6838: ${asset.name} (${sizeMB} MB)`);
   }
-  const curlResult = spawnSync5(
+  const curlResult = spawnSync4(
     "curl",
     ["-L", "--progress-bar", "--connect-timeout", "30", "--max-time", String(Math.floor(KERNEL_DOWNLOAD_TIMEOUT / 1e3)), "-o", tempPath, downloadUrl],
     { stdio: "inherit" }
@@ -5754,7 +6126,7 @@ async function downloadKernel(progressCallback, mirror, releaseInfo) {
   let extractedBinary = null;
   try {
     if (tempPath.endsWith(".tar.gz") || tempPath.endsWith(".tgz")) {
-      const listResult = spawnSync5("tar", ["-tzf", tempPath], { encoding: "utf8", timeout: 6e4 });
+      const listResult = spawnSync4("tar", ["-tzf", tempPath], { encoding: "utf8", timeout: 6e4 });
       if (listResult.error) throw listResult.error;
       if (listResult.status !== 0) throw new Error(`tar \u5217\u8868\u9000\u51FA\u7801 ${listResult.status}`);
       const entries = (listResult.stdout || "").split("\n").filter(Boolean);
@@ -5763,13 +6135,13 @@ async function downloadKernel(progressCallback, mirror, releaseInfo) {
           throw new Error(`\u5F52\u6863\u542B\u975E\u6CD5\u8DEF\u5F84\u6761\u76EE: ${entry}`);
         }
       }
-      const tarResult = spawnSync5("tar", ["-xzf", tempPath, "-C", extractPath], { stdio: ["ignore", "ignore", "inherit"], timeout: 6e4 });
+      const tarResult = spawnSync4("tar", ["-xzf", tempPath, "-C", extractPath], { stdio: ["ignore", "ignore", "inherit"], timeout: 6e4 });
       if (tarResult.error) throw tarResult.error;
       if (tarResult.status !== 0) throw new Error(`tar \u9000\u51FA\u7801 ${tarResult.status}`);
     } else if (tempPath.endsWith(".gz")) {
       const baseName = path6.basename(tempPath, ".gz");
       const outputPath = path6.join(extractPath, baseName);
-      const gzipResult = spawnSync5("gzip", ["-dc", tempPath], { maxBuffer: 256 * 1024 * 1024, timeout: 6e4 });
+      const gzipResult = spawnSync4("gzip", ["-dc", tempPath], { maxBuffer: 256 * 1024 * 1024, timeout: 6e4 });
       if (gzipResult.error) throw gzipResult.error;
       if (gzipResult.status !== 0) throw new Error(`gzip \u9000\u51FA\u7801 ${gzipResult.status}`);
       fs7.writeFileSync(outputPath, gzipResult.stdout, { mode: 493 });
@@ -5805,7 +6177,7 @@ async function downloadKernel(progressCallback, mirror, releaseInfo) {
   if (progressCallback) {
     progressCallback("\u6821\u9A8C\u5185\u6838...");
   }
-  const check = spawnSync5(targetPath, ["-v"], { encoding: "utf8", timeout: 5e3 });
+  const check = spawnSync4(targetPath, ["-v"], { encoding: "utf8", timeout: 5e3 });
   const checkOutput = `${check.stdout || ""}${check.stderr || ""}`.trim();
   if (check.error || check.status !== 0 || !/v?\d+\.\d+\.\d+/.test(checkOutput)) {
     try {
@@ -5850,27 +6222,30 @@ async function cmdKernel(args) {
       const result = await downloadKernel((msg) => console.log(msg), mirrorInfo.mirror, info.release);
       console.log(`
 \u5DF2\u66F4\u65B0\u5230 ${result.version}`);
+      if (getRunningState().running) {
+        console.log(colors.yellow("\u63D0\u793A: \u8FD0\u884C\u4E2D\u7684\u5185\u6838\u4ECD\u662F\u65E7\u7248\u672C\uFF0C\u6267\u884C mihomo start \u91CD\u542F\u540E\u751F\u6548"));
+      }
     }
   } catch (e) {
-    console.error(`
-\u66F4\u65B0\u5931\u8D25: ${e.message}`);
+    if (e instanceof CliError) throw e;
     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}`);
-      }
+    const hint = [];
+    if (err.response?.data?.message) {
+      hint.push(`\u539F\u56E0: ${err.response.data.message}`);
+    }
+    if (err.response?.data?.documentation_url) {
+      hint.push(`\u6587\u6863: ${err.response.data.documentation_url}`);
     }
     if (!effectiveMirror) {
-      console.error("");
-      console.error("\u63D0\u793A: \u76F4\u8FDE\u5931\u8D25\u6216\u4E0B\u8F7D\u8FC7\u6162\u65F6\u53EF\u4F7F\u7528\u955C\u50CF:");
-      console.error("  mihomo kernel --mirror [\u955C\u50CF]     # \u4E0B\u8F7D\u8D70\u955C\u50CF\uFF08\u9ED8\u8BA4 v6.gh-proxy.org\uFF09");
-      console.error("  mihomo kernel --mirror-all [\u955C\u50CF] # API \u548C\u4E0B\u8F7D\u90FD\u8D70\u955C\u50CF");
-      console.error(`  \u53EF\u7528\u955C\u50CF: ${AVAILABLE_MIRRORS.join(", ")}`);
+      hint.push(
+        "",
+        "\u63D0\u793A: \u76F4\u8FDE\u5931\u8D25\u6216\u4E0B\u8F7D\u8FC7\u6162\u65F6\u53EF\u4F7F\u7528\u955C\u50CF:",
+        "  mihomo kernel --mirror [\u955C\u50CF]     # \u4E0B\u8F7D\u8D70\u955C\u50CF\uFF08\u9ED8\u8BA4 v6.gh-proxy.org\uFF09",
+        "  mihomo kernel --mirror-all [\u955C\u50CF] # API \u548C\u4E0B\u8F7D\u90FD\u8D70\u955C\u50CF",
+        `  \u53EF\u7528\u955C\u50CF: ${AVAILABLE_MIRRORS.join(", ")}`
+      );
     }
-    process.exit(1);
+    throw new CliError(err.message, { label: "\u66F4\u65B0\u5931\u8D25", hint });
   }
 }
 
@@ -5887,370 +6262,73 @@ 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;
-  }
-  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 path7 from "path";
-
-// src/runtime.ts
-function getRuntimeMode() {
-  if (isDaemonEnabled()) return "mixed";
-  return getConfigInfo()?.tun ? "tun" : "mixed";
-}
-function getRunningState() {
-  if (isDaemonEnabled()) {
-    const daemon = getDaemonStatus();
-    return { running: isDaemonRunning(daemon), pid: daemon.pid, daemon: true };
-  }
-  const status = getStatus();
-  return { running: status.running, pid: status.pid, daemon: false };
-}
-function isRestartNeededOnChange() {
-  return isDaemonEnabled() || getStatus().running;
-}
-async function launchOrRestart(mode) {
-  if (isDaemonEnabled()) {
-    await restartDaemon();
-    await sleep(DAEMON_BOOT_WAIT_MS);
-    return getDaemonStatus().pid;
-  }
-  const result = await start(mode);
-  return result.pid;
-}
-
-// src/progress.ts
-var IS_TTY = process.stdout.isTTY === true;
-var BAR_WIDTH = 20;
-function createProgressPrinter(totalRounds = 1) {
-  let alive = 0;
-  let dead = 0;
-  const resultMap = /* @__PURE__ */ new Map();
-  function render(done, total) {
-    if (!IS_TTY) return;
-    const pct = Math.round(done / total * 100);
-    const filled = Math.round(done / total * BAR_WIDTH);
-    const bar = "\u2588".repeat(filled) + "\u2591".repeat(BAR_WIDTH - filled);
-    process.stdout.write(`\r${bar} ${done}/${total} (${pct}%) | ${colors.green(`\u2713${alive}`)} ${colors.red(`\u2717${dead}`)}`);
-  }
-  return {
-    onResult(result, index, total, round = 1) {
-      if (resultMap.size === 0 && totalRounds > 1) {
-        console.log(`--- \u7B2C 1 \u8F6E\u6D4B\u8BD5 (${total} \u4E2A\u8282\u70B9) ---`);
-      }
-      const prev = resultMap.get(result.name);
-      if (prev) {
-        if (prev.result.delay !== null) alive--;
-        else dead--;
-      }
-      if (result.delay !== null) alive++;
-      else dead++;
-      resultMap.set(result.name, { result, round });
-      render(index + 1, total);
-    },
-    onRetryRound(round, count) {
-      if (IS_TTY) {
-        process.stdout.write("\n");
-      }
-      console.log(`--- \u7B2C ${round} \u8F6E\u91CD\u8BD5 (${count} \u4E2A\u8282\u70B9) ---`);
-      alive = 0;
-      dead = 0;
-    },
-    finish() {
-      if (IS_TTY) {
-        process.stdout.write("\n");
-      }
-      console.log("");
-      if (!IS_TTY) return;
-      const entries = [...resultMap.values()];
-      entries.sort((a, b) => a.result.name.localeCompare(b.result.name));
-      const total = entries.length;
-      console.log("\u8282\u70B9\u6700\u7EC8\u72B6\u6001:");
-      for (let i = 0; i < entries.length; i++) {
-        const { result, round } = entries[i];
-        const prefix = `[${i + 1}/${total}]`;
-        if (result.delay !== null) {
-          const delayColor = result.delay < 300 ? colors.green : result.delay < 800 ? colors.yellow : colors.red;
-          const retryNote = round > 1 ? colors.gray(` (\u7B2C${round}\u8F6E\u901A\u8FC7)`) : "";
-          console.log(`${prefix} ${colors.green("\u2713")} ${result.name} ${delayColor(`${result.delay}ms`)}${retryNote}`);
-        } else {
-          console.log(`${prefix} ${colors.red("\u2717")} ${result.name} ${colors.gray(result.error || "timeout")}`);
-        }
-      }
-      console.log("");
-    }
-  };
-}
-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 formatTestSummary(summary) {
-  return `\u7ED3\u679C: ${colors.green(`${summary.alive} \u5B58\u6D3B`)} / ${colors.red(`${summary.dead} \u5931\u8D25`)} / ${summary.total} \u603B\u8BA1`;
-}
-
-// src/commands/status.ts
-function printStatus() {
-  const status = getStatus();
-  const state = getRunningState();
-  const info = getConfigInfo();
-  const overwriteEnabled = isOverwriteEnabled();
-  const overwriteFiles = listOverwriteFile().files;
-  const activeSub = getActiveSubscription();
-  const { running, pid, daemon: daemonManaged } = state;
-  console.log("");
-  let modeLabel = "";
-  if (info) {
-    modeLabel = colors.cyan(info.tun ? " (TUN)" : " (Mixed)");
-  }
-  const statusText = 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 (pid) {
-    console.log(`${colors.gray("PID:  ")}${pid}`);
-    if (!daemonManaged && status.processInfo) {
-      console.log(`${colors.gray("\u5185\u5B58: ")}${status.processInfo.memory}`);
-    }
-  }
-  if (info) {
-    if (info.tun) {
-      const extra = info.mixedPort ? `\uFF0C\u53E6\u76D1\u542C ${info.mixedPort}` : "";
-      console.log(`${colors.gray("\u7AEF\u53E3: ")}TUN \u63A5\u7BA1${extra}`);
-    } else 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"}`);
-    }
-  }
-  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`);
-  }
-  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")}`);
-  }
-  if (isDaemonEnabled()) {
-    console.log(`${colors.gray("\u4FDD\u6D3B: ")}${colors.green("\u5DF2\u542F\u7528")} ${colors.gray("(\u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u91CD\u542F)")}`);
-  }
-  console.log("");
-}
-
-// src/commands/stop.ts
-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 cmdStop() {
-  if (isDaemonEnabled()) {
-    console.log(colors.yellow("\u4FDD\u6D3B\u5DF2\u542F\u7528\uFF0C\u4EE3\u7406\u7531 launchd \u6258\u7BA1"));
-    console.log("\u76F4\u63A5\u505C\u6B62\u4F1A\u88AB\u81EA\u52A8\u91CD\u65B0\u62C9\u8D77\uFF0C\u8BF7\u7528: mihomo daemon off");
-    return;
-  }
-  const pids = getMihomoPids();
-  if (pids.length === 0) {
-    console.log(colors.yellow("\u4E0D\u5728\u8FD0\u884C"));
-    return;
-  }
-  console.log(`\u505C\u6B62 ${pids.length} \u4E2A\u8FDB\u7A0B...`);
-  handleStopResult(stop());
-  console.log(colors.green("\u5DF2\u505C\u6B62\u8FDB\u7A0B"));
-}
-
-// src/commands/start.ts
-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 daemonEnabled = isDaemonEnabled();
-  if (targetMode === "tun" && daemonEnabled) {
-    console.error(`${colors.red("\u9519\u8BEF:")} \u4FDD\u6D3B\u5DF2\u542F\u7528\uFF08\u4EC5\u652F\u6301 Mixed \u6A21\u5F0F\uFF09\uFF0C\u65E0\u6CD5\u542F\u52A8 TUN`);
-    console.error("\u8BF7\u5148\u5173\u95ED\u4FDD\u6D3B: mihomo daemon off");
-    process.exit(1);
-  }
-  const rounds = parseIntArg(args, "-r", "--rounds", DEFAULT_CLEAN_ROUNDS);
-  const timeout = parseIntArg(args, "-t", "--timeout", DEFAULT_TEST_TIMEOUT);
-  const concurrency = parseIntArg(args, "-j", "--concurrency", DEFAULT_TEST_CONCURRENCY);
-  const skipUpdate = hasFlag(args, "-s", "--no-update");
-  const skipClean = hasFlag(args, "--no-clean");
-  const updateTimeout = parseIntArg(args, "-u", "--update-timeout", DEFAULT_AUTO_UPDATE_TIMEOUT);
-  const sub = getActiveSubscription();
-  if (!sub) {
-    console.error("\u9519\u8BEF: \u6CA1\u6709\u8BA2\u9605\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605");
-    process.exit(1);
-  }
-  if (!skipUpdate) {
-    await autoUpdateStaleSubscription({ timeout: updateTimeout });
-  }
-  if (!daemonEnabled) {
-    if (hasRootResidue()) {
-      console.error(`${colors.red("\u9519\u8BEF:")} \u5B58\u5728\u9700\u8981 root \u6743\u9650\u6E05\u7406\u7684\u6B8B\u7559\u8FDB\u7A0B/\u6587\u4EF6`);
-      console.error(`\u8BF7\u5148\u624B\u52A8\u6E05\u7406: sudo pkill -9 mihomo && sudo rm -f ${PATHS.pidFile}`);
-      console.error("\u6216\u5207\u6362\u5230 TUN \u6A21\u5F0F\u542F\u52A8\uFF08\u81EA\u52A8\u6E05\u7406\uFF09: mihomo start tun");
-      process.exit(1);
-    }
-    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 pid = await launchOrRestart(targetMode);
-    const label = daemonEnabled ? "\u5DF2\u542F\u52A8 (\u4FDD\u6D3B)" : "\u5DF2\u542F\u52A8";
-    console.log(`${colors.green(label)}${pid ? ` (PID ${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);
-  }
-  const cleanThreshold = isGithubUrl(sub.url) ? AUTO_CLEAN_THRESHOLD_GITHUB : AUTO_CLEAN_THRESHOLD;
-  if (!skipClean && configInfo.proxies > cleanThreshold) {
-    const cache = readSubscriptionCache();
-    const lastCleanAt = cache[sub.name]?.last_auto_clean_at;
-    const withinCooldown = !!lastCleanAt && Date.now() - new Date(lastCleanAt).getTime() < AUTO_CLEAN_COOLDOWN_HOURS * 60 * 60 * 1e3;
-    if (!withinCooldown) {
-      console.log("");
-      console.log(`\u8282\u70B9\u6570 ${configInfo.proxies} \u8D85\u8FC7 ${cleanThreshold}\uFF0C\u81EA\u52A8\u6E05\u7406\uFF08${AUTO_CLEAN_COOLDOWN_HOURS}h \u5185\u4EC5\u4E00\u6B21\uFF0C--no-clean \u8DF3\u8FC7\uFF09...`);
-      console.log("");
-      await sleep(1e3);
-      const progress = createProgressPrinter(rounds);
-      const cleanResult = await autoCleanSubscription(sub.name, {
-        timeout,
-        concurrency,
-        rounds,
-        onResult: progress.onResult,
-        onRetryRound: progress.onRetryRound
-      });
-      progress.finish();
-      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...");
-        if (!daemonEnabled) handleStopResult(stop());
-        try {
-          configInfo = prepareConfigForStart(targetMode, sub.name);
-          const pid = await launchOrRestart(targetMode);
-          console.log(`${colors.green("\u5DF2\u91CD\u542F")}${pid ? ` (PID ${pid})` : ""} \xB7 ${formatProxySummary(configInfo)}`);
-        } catch (e) {
-          console.error(`${colors.red("\u91CD\u542F\u5931\u8D25:")} ${e.message.split("\n")[0]}`);
-          process.exit(1);
+  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) {
+          throw new CliError(`\u672A\u627E\u5230\u65E5\u5FD7 "${targetName}"`, { hint: '\u4F7F\u7528 "mihomo logs" \u67E5\u770B\u53EF\u7528\u65E5\u5FD7\u5217\u8868' });
         }
+        logPath = archive.path;
+      } else {
+        logPath = getLogPathByName(targetName);
       }
-      saveSubscriptionCache(sub.name, { last_auto_clean_at: (/* @__PURE__ */ new Date()).toISOString() });
     }
+    if (!logPath) {
+      throw new CliError(`\u672A\u627E\u5230\u65E5\u5FD7 "${targetName}"`, { hint: '\u4F7F\u7528 "mihomo logs" \u67E5\u770B\u53EF\u7528\u65E5\u5FD7\u5217\u8868' });
+    }
+    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 path7 from "path";
 function printOverwriteList() {
   const info = listOverwriteFile();
   const statusText = info.enabled ? colors.green("\u5DF2\u542F\u7528") : colors.yellow("\u5DF2\u7981\u7528");
@@ -6282,48 +6360,30 @@ function printOverwriteList() {
   console.log("\u7981\u7528\u8986\u5199: mihomo ow off");
   console.log("");
 }
-async function cmdOverwrite(args) {
-  const action = args?.[1];
-  const currentMode = getRuntimeMode();
-  const restartNeeded = isRestartNeededOnChange();
-  if (action === "on" || action === "enable") {
-    if (isOverwriteEnabled()) {
-      console.log("\u8986\u5199\u914D\u7F6E\u5DF2\u662F\u542F\u7528\u72B6\u6001");
-      console.log("");
-      printOverwriteList();
-      return;
-    }
-    setOverwriteEnabled(true);
-    console.log("\u5DF2\u542F\u7528\u8986\u5199\u914D\u7F6E");
-    if (restartNeeded) {
-      console.log("");
-      await cmdStart(["start", currentMode, ...extractStartOptions(args)]);
-      return;
-    }
+async function setOverwrite(enabled, args) {
+  if (isOverwriteEnabled() === enabled) {
+    console.log(`\u8986\u5199\u914D\u7F6E\u5DF2\u662F${enabled ? "\u542F\u7528" : "\u7981\u7528"}\u72B6\u6001`);
     console.log("");
     printOverwriteList();
     return;
   }
-  if (action === "off" || action === "disable") {
-    if (!isOverwriteEnabled()) {
-      console.log("\u8986\u5199\u914D\u7F6E\u5DF2\u662F\u7981\u7528\u72B6\u6001");
+  setOverwriteEnabled(enabled);
+  console.log(`\u5DF2${enabled ? "\u542F\u7528" : "\u7981\u7528"}\u8986\u5199\u914D\u7F6E`);
+  if (await restartToApply(args)) return;
+  console.log("");
+  printOverwriteList();
+}
+var SUBCOMMANDS3 = [
+  { name: "on", aliases: ["enable"], handler: (args) => setOverwrite(true, args) },
+  { name: "off", aliases: ["disable"], handler: (args) => setOverwrite(false, args) }
+];
+async function cmdOverwrite(args) {
+  await dispatchSubcommand(args, SUBCOMMANDS3, {
+    fallback: () => {
       console.log("");
       printOverwriteList();
-      return;
-    }
-    setOverwriteEnabled(false);
-    console.log("\u5DF2\u7981\u7528\u8986\u5199\u914D\u7F6E");
-    if (restartNeeded) {
-      console.log("");
-      await cmdStart(["start", currentMode, ...extractStartOptions(args)]);
-      return;
     }
-    console.log("");
-    printOverwriteList();
-    return;
-  }
-  console.log("");
-  printOverwriteList();
+  });
 }
 
 // src/commands/reset.ts
@@ -6433,10 +6493,7 @@ async function cmdReset(args) {
   const KNOWN_FLAGS = /* @__PURE__ */ new Set(["--full", "--yes", "-y"]);
   const unknownFlags = flags.filter((f) => !KNOWN_FLAGS.has(f));
   if (unknownFlags.length > 0) {
-    console.error(`\u9519\u8BEF: \u672A\u77E5\u7684\u9009\u9879: ${unknownFlags.join(", ")}`);
-    console.log("");
-    console.log("\u53EF\u7528\u9009\u9879: --full\uFF08\u5220\u5168\u90E8\uFF09, -y/--yes\uFF08\u8DF3\u8FC7\u786E\u8BA4\uFF09");
-    process.exit(1);
+    throw new CliError(`\u672A\u77E5\u7684\u9009\u9879: ${unknownFlags.join(", ")}`, { hint: ["", "\u53EF\u7528\u9009\u9879: --full\uFF08\u5220\u5168\u90E8\uFF09, -y/--yes\uFF08\u8DF3\u8FC7\u786E\u8BA4\uFF09"] });
   }
   const fullReset = flags.includes("--full");
   const skipConfirm = flags.includes("--yes") || flags.includes("-y");
@@ -6446,16 +6503,18 @@ async function cmdReset(args) {
   } else if (names.length > 0) {
     const { matched, unmatched } = resolveResetTargets(names);
     if (unmatched.length > 0) {
-      console.error(`\u9519\u8BEF: \u672A\u77E5\u7684\u91CD\u7F6E\u76EE\u6807: ${unmatched.join(", ")}`);
-      console.log("");
-      console.log(`\u53EF\u7528\u76EE\u6807: ${RESET_TARGETS.map((t) => t.aliases[0]).join(", ")}`);
-      console.log("");
-      console.log("\u793A\u4F8B:");
-      console.log("  mihomo reset sub log      # \u5220\u9664\u8BA2\u9605\u548C\u65E5\u5FD7");
-      console.log("  mihomo reset kernel       # \u53EA\u5220\u5185\u6838");
-      console.log("  mihomo reset --full       # \u5220\u9664\u5168\u90E8");
-      console.log("  mihomo reset              # \u5220\u9664\u5168\u90E8\uFF08\u4FDD\u7559\u8BBE\u7F6E\u3001\u5185\u6838\u3001\u8986\u5199\uFF09");
-      process.exit(1);
+      throw new CliError(`\u672A\u77E5\u7684\u91CD\u7F6E\u76EE\u6807: ${unmatched.join(", ")}`, {
+        hint: [
+          "",
+          `\u53EF\u7528\u76EE\u6807: ${RESET_TARGETS.map((t) => t.aliases[0]).join(", ")}`,
+          "",
+          "\u793A\u4F8B:",
+          "  mihomo reset sub log      # \u5220\u9664\u8BA2\u9605\u548C\u65E5\u5FD7",
+          "  mihomo reset kernel       # \u53EA\u5220\u5185\u6838",
+          "  mihomo reset --full       # \u5220\u9664\u5168\u90E8",
+          "  mihomo reset              # \u5220\u9664\u5168\u90E8\uFF08\u4FDD\u7559\u8BBE\u7F6E\u3001\u5185\u6838\u3001\u8986\u5199\uFF09"
+        ]
+      });
     }
     targets = matched;
   } else {
@@ -6525,6 +6584,15 @@ async function cmdReset(args) {
 import { spawn as spawn2 } from "child_process";
 import fs9 from "fs";
 import path8 from "path";
+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;
+}
 var TEST_DIR = path8.join(USER_DATA_DIR, "test");
 var TEST_DIRS = {
   data: path8.join(TEST_DIR, "data"),
@@ -6548,12 +6616,12 @@ function buildTestConfig(subName) {
   ensureTestDirs();
   const rawContent = readSubscriptionRawConfig(subName);
   if (!rawContent) {
-    throw new Error(`\u672A\u627E\u5230\u8BA2\u9605\u914D\u7F6E "${subName}"`);
+    throw new CliError(`\u672A\u627E\u5230\u8BA2\u9605\u914D\u7F6E "${subName}"\uFF0C\u8BF7\u5148\u66F4\u65B0\u8BA2\u9605\uFF08mihomo sub update ${subName}\uFF09`);
   }
   const parsed = parseYamlOrJson(rawContent, "\u8BA2\u9605\u5185\u5BB9");
   const proxies = (parsed.proxies || []).filter(isProxyValid);
   if (proxies.length === 0) {
-    throw new Error(`\u8BA2\u9605 "${subName}" \u6CA1\u6709\u6709\u6548\u8282\u70B9`);
+    throw new CliError(`\u8BA2\u9605 "${subName}" \u6CA1\u6709\u6709\u6548\u8282\u70B9`);
   }
   const nameCount = /* @__PURE__ */ new Map();
   for (const proxy of proxies) {
@@ -6580,7 +6648,7 @@ function buildTestConfig(subName) {
 }
 async function startTestInstance() {
   const binary = PATHS.mihomoBinary;
-  if (!fs9.existsSync(binary)) throw new Error('\u672A\u627E\u5230 mihomo \u5185\u6838\uFF0C\u8BF7\u5148\u8FD0\u884C "mihomo kernel" \u4E0B\u8F7D');
+  if (!fs9.existsSync(binary)) throw new CliError('\u672A\u627E\u5230 mihomo \u5185\u6838\uFF0C\u8BF7\u5148\u8FD0\u884C "mihomo kernel" \u4E0B\u8F7D');
   stopTestInstance();
   const logFd = fs9.openSync(TEST_PATHS.logFile, "a");
   const child = spawn2(binary, ["-d", TEST_DIRS.data, "-f", TEST_PATHS.configFile], {
@@ -6592,7 +6660,7 @@ async function startTestInstance() {
   fs9.closeSync(logFd);
   child.unref();
   const pid = child.pid;
-  if (!pid) throw new Error("\u6D4B\u8BD5\u5B9E\u4F8B\u542F\u52A8\u5931\u8D25\uFF1A\u65E0\u6CD5\u521B\u5EFA\u8FDB\u7A0B\uFF08\u5185\u6838\u4E8C\u8FDB\u5236\u53EF\u80FD\u4E0D\u53EF\u6267\u884C\uFF09");
+  if (!pid) throw new CliError("\u6D4B\u8BD5\u5B9E\u4F8B\u542F\u52A8\u5931\u8D25\uFF1A\u65E0\u6CD5\u521B\u5EFA\u8FDB\u7A0B\uFF08\u5185\u6838\u4E8C\u8FDB\u5236\u53EF\u80FD\u4E0D\u53EF\u6267\u884C\uFF09");
   fs9.writeFileSync(TEST_PATHS.pidFile, pid.toString(), { mode: 384 });
   const client = createHttpClient({ timeout: 2e3 });
   let ready = false;
@@ -6612,11 +6680,11 @@ async function startTestInstance() {
       errorDetail = fs9.readFileSync(TEST_PATHS.logFile, "utf8").slice(-1e3);
     } catch {
     }
-    throw new Error(`\u6D4B\u8BD5\u5B9E\u4F8B\u542F\u52A8\u5931\u8D25${errorDetail ? `
+    throw new CliError(`\u6D4B\u8BD5\u5B9E\u4F8B\u542F\u52A8\u5931\u8D25${errorDetail ? `
 ${errorDetail}` : ""}`);
   }
   if (!ready) {
-    throw new Error("\u6D4B\u8BD5\u5B9E\u4F8B\u542F\u52A8\u8D85\u65F6\uFF0CAPI \u672A\u54CD\u5E94");
+    throw new CliError("\u6D4B\u8BD5\u5B9E\u4F8B\u542F\u52A8\u8D85\u65F6\uFF0CAPI \u672A\u54CD\u5E94");
   }
 }
 function stopTestInstance() {
@@ -6664,21 +6732,18 @@ function githubRepoUrl(rawUrl) {
 function resolveTestTarget(args) {
   const subs = getSubscriptions();
   if (subs.length === 0) {
-    console.error("\u9519\u8BEF: \u6CA1\u6709\u8BA2\u9605");
-    process.exit(1);
+    throw new CliError("\u6CA1\u6709\u8BA2\u9605");
   }
   const nameArg = getNonFlagArg(args, 2);
   const timeout = parseIntArg(args, "-t", "--timeout", DEFAULT_TEST_TIMEOUT);
   const concurrency = parseIntArg(args, "-j", "--concurrency", DEFAULT_TEST_CONCURRENCY);
   let target;
   if (nameArg) {
-    const matches = findSubscriptionFuzzy(subs, nameArg);
-    target = pickSingleSubscription(matches, nameArg);
+    target = resolveSubscription(subs, nameArg);
   } else {
     const activeSub = getActiveSubscription();
     if (!activeSub) {
-      console.error("\u9519\u8BEF: \u6CA1\u6709\u6D3B\u8DC3\u8BA2\u9605\uFF0C\u8BF7\u6307\u5B9A\u8BA2\u9605\u540D\u79F0");
-      process.exit(1);
+      throw new CliError("\u6CA1\u6709\u6D3B\u8DC3\u8BA2\u9605\uFF0C\u8BF7\u6307\u5B9A\u8BA2\u9605\u540D\u79F0");
     }
     target = activeSub;
   }
@@ -6739,274 +6804,235 @@ function printSubscriptionList() {
   console.log("\u6253\u5F00\u9875\u9762: mihomo sub web [name]");
   console.log("");
 }
-async function cmdSubscription(args) {
-  const action = args[1];
-  if (!action || action === "list") {
-    printSubscriptionList();
-    return;
+async function subAdd(args) {
+  const url = args[2]?.trim();
+  const name = args[3] || "default";
+  if (!url) {
+    throw new CliError("\u8BF7\u63D0\u4F9B\u6709\u6548\u7684\u8BA2\u9605 URL");
   }
-  if (action === "add") {
-    const url = args[2]?.trim();
-    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);
-      if (urls.length === 0) {
-        console.error("\u9519\u8BEF: \u8BF7\u63D0\u4F9B\u6709\u6548\u7684\u8BA2\u9605 URL");
-        process.exit(1);
-      }
-      for (const u of urls) {
-        if (!isValidHttpUrl(u)) {
-          console.error(`\u9519\u8BEF: \u65E0\u6548\u7684 URL: ${u}`);
-          process.exit(1);
-        }
-      }
-      const normalizedUrl = urls.join(",");
-      console.log(`\u6DFB\u52A0\u5408\u5E76\u8BA2\u9605: ${name} (${urls.length} \u4E2A\u6E90)`);
-      try {
-        addSubscription(normalizedUrl, 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) {
-        removeSubscription(name);
-        console.error(`\u6DFB\u52A0\u5931\u8D25: ${e.message}`);
-        process.exit(1);
-      }
-    } else {
-      if (!isValidHttpUrl(url)) {
-        console.error("\u9519\u8BEF: \u8BF7\u63D0\u4F9B\u6709\u6548\u7684\u8BA2\u9605 URL\uFF08\u9700\u4EE5 http:// \u6216 https:// \u5F00\u5934\uFF09");
-        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) {
-        removeSubscription(name);
-        console.error(`\u6DFB\u52A0\u5931\u8D25: ${e.message}`);
-        process.exit(1);
-      }
+  if (isMultiUrl(url)) {
+    const urls = splitUrls(url);
+    if (urls.length === 0) {
+      throw new CliError("\u8BF7\u63D0\u4F9B\u6709\u6548\u7684\u8BA2\u9605 URL");
     }
-    console.log("");
-    printSubscriptionList();
-    return;
-  }
-  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((sub) => tryUpdateOne(sub)));
-      let ok = 0;
-      for (const r of results) {
-        if (r.success) ok++;
-        printUpdateResult(r);
+    for (const u of urls) {
+      if (!isValidHttpUrl(u)) {
+        throw new CliError(`\u65E0\u6548\u7684 URL: ${u}`);
       }
-      if (ok === 0) process.exit(1);
-      console.log("");
-      printRestartHintIfRunning();
-      printSubscriptionList();
-      return;
     }
-    const matches = findSubscriptionFuzzy(subs, name);
-    const target = pickSingleSubscription(matches, name);
-    console.log(`\u66F4\u65B0\u8BA2\u9605: ${target.name}`);
-    const result = await tryUpdateOne(target);
-    if (!result.success) {
-      console.error(`\u66F4\u65B0\u5931\u8D25: ${(result.error || "").split("\n")[0]}`);
-      process.exit(1);
+    const normalizedUrl = urls.join(",");
+    console.log(`\u6DFB\u52A0\u5408\u5E76\u8BA2\u9605: ${name} (${urls.length} \u4E2A\u6E90)`);
+    addSubscription(normalizedUrl, name);
+    try {
+      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) {
+      removeSubscription(name);
+      throw new CliError(e.message, { label: "\u6DFB\u52A0\u5931\u8D25" });
     }
-    console.log(`\u5DF2\u66F4\u65B0 (${formatProxySummary(result)})`);
-    console.log("");
-    printRestartHintIfRunning();
-    printSubscriptionList();
-    return;
-  }
-  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("");
-      printSubscriptionList();
-      return;
+  } else {
+    if (!isValidHttpUrl(url)) {
+      throw new CliError("\u8BF7\u63D0\u4F9B\u6709\u6548\u7684\u8BA2\u9605 URL\uFF08\u9700\u4EE5 http:// \u6216 https:// \u5F00\u5934\uFF09");
     }
-    const currentMode = getRuntimeMode();
-    const restartNeeded = isRestartNeededOnChange();
-    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);
+    console.log(`\u6DFB\u52A0\u8BA2\u9605: ${name}`);
+    addSubscription(url, name);
+    try {
+      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) {
+      removeSubscription(name);
+      throw new CliError(e.message, { label: "\u6DFB\u52A0\u5931\u8D25" });
     }
-    if (restartNeeded) {
-      console.log("");
-      await cmdStart(["start", currentMode, ...extractStartOptions(args)]);
-      return;
+  }
+  console.log("");
+  printSubscriptionList();
+}
+async function subUpdate(args) {
+  const name = args[2];
+  const subs = getSubscriptions();
+  if (subs.length === 0) {
+    throw new CliError("\u6CA1\u6709\u8BA2\u9605");
+  }
+  if (!name) {
+    console.log(`\u66F4\u65B0\u6240\u6709 ${subs.length} \u4E2A\u8BA2\u9605...`);
+    const results = await Promise.all(subs.map((sub) => tryUpdateOne(sub)));
+    let ok = 0;
+    for (const r of results) {
+      if (r.success) ok++;
+      printUpdateResult(r);
     }
+    if (ok === 0) throw new CliError("\u5168\u90E8\u8BA2\u9605\u66F4\u65B0\u5931\u8D25");
     console.log("");
+    printRestartHintIfRunning();
     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 = getActiveSubscription() || subs[0];
-    }
-    const cached = subs.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\u67E5\u8BE2\u8BA2\u9605...");
-      try {
-        const info = isMultiUrl(target.url) ? await downloadMergedSubscription(splitUrls(target.url), target.name, void 0, false) : await downloadSubscription(target.url, target.name, void 0, false);
-        if (info.webPageUrl) {
-          webPageUrl = info.webPageUrl;
-        } else {
-          console.error("\u9519\u8BEF: \u8BE5\u8BA2\u9605\u6CA1\u6709\u63D0\u4F9B\u9875\u9762\u5730\u5740");
-          process.exit(1);
-        }
-      } catch (e) {
-        console.error(`\u67E5\u8BE2\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;
+  const target = resolveSubscription(subs, name);
+  console.log(`\u66F4\u65B0\u8BA2\u9605: ${target.name}`);
+  const result = await tryUpdateOne(target);
+  if (!result.success) {
+    throw new CliError((result.error || "").split("\n")[0], { label: "\u66F4\u65B0\u5931\u8D25" });
   }
-  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}"`);
-    }
+  console.log(`\u5DF2\u66F4\u65B0 (${formatProxySummary(result)})`);
+  console.log("");
+  printRestartHintIfRunning();
+  printSubscriptionList();
+}
+async function subUse(args) {
+  const name = args[2];
+  const subs = getSubscriptions();
+  if (!name) {
+    throw new CliError("\u8BF7\u6307\u5B9A\u8BA2\u9605\u540D\u79F0", {
+      hint: subs.length > 0 ? ["", "\u53EF\u7528\u8BA2\u9605:", ...subs.map((s) => `  ${s.name}`)] : void 0
+    });
+  }
+  const target = resolveSubscription(subs, 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("");
     printSubscriptionList();
     return;
   }
-  if (action === "clean") {
-    const { target, timeout, concurrency } = resolveTestTarget(args);
-    const rounds = parseIntArg(args, "-r", "--rounds", DEFAULT_CLEAN_ROUNDS);
-    console.log(`\u6E05\u7406\u8BA2\u9605 "${target.name}"...`);
-    console.log(`\u8D85\u65F6: ${timeout}ms  \u5E76\u53D1: ${concurrency}`);
-    console.log("");
-    const progress = createProgressPrinter(rounds);
-    const result = await withTestInstance(target.name, async (apiBase) => {
-      return autoCleanSubscription(target.name, {
-        timeout,
-        concurrency,
-        rounds,
-        apiBase,
-        onResult: progress.onResult,
-        onRetryRound: progress.onRetryRound
-      });
-    });
-    progress.finish();
-    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)}`);
-      if (getRunningState().running) {
-        console.log("");
-        console.log("\u63D0\u793A: \u9700\u8981\u91CD\u542F mihomo \u4F7F\u66F4\u6539\u751F\u6548 (mihomo start)");
+  const success = setDefaultSubscription(target.name);
+  if (!success) {
+    throw new CliError(`\u672A\u627E\u5230\u8BA2\u9605 "${name}"`);
+  }
+  console.log(`\u5DF2\u5207\u6362\u5230 "${target.name}"`);
+  if (await restartToApply(args)) return;
+  console.log("");
+  printSubscriptionList();
+}
+async function subWeb(args) {
+  const name = args[2];
+  const subs = getSubscriptionsWithCache();
+  if (subs.length === 0) {
+    throw new CliError("\u6CA1\u6709\u8BA2\u9605");
+  }
+  let target;
+  if (name) {
+    target = resolveSubscription(subs, name);
+  } else {
+    target = getActiveSubscription() || subs[0];
+  }
+  const cached = subs.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\u67E5\u8BE2\u8BA2\u9605...");
+    try {
+      const info = isMultiUrl(target.url) ? await downloadMergedSubscription(splitUrls(target.url), target.name, void 0, false) : await downloadSubscription(target.url, target.name, void 0, false);
+      if (!info.webPageUrl) {
+        throw new CliError("\u8BE5\u8BA2\u9605\u6CA1\u6709\u63D0\u4F9B\u9875\u9762\u5730\u5740");
       }
+      webPageUrl = info.webPageUrl;
+    } catch (e) {
+      if (e instanceof CliError) throw e;
+      throw new CliError(e.message, { label: "\u67E5\u8BE2\u5931\u8D25" });
     }
-    return;
   }
-  if (action === "test") {
-    const { target, timeout, concurrency } = resolveTestTarget(args);
-    console.log(`\u6D4B\u8BD5\u8BA2\u9605 "${target.name}" \u7684\u8282\u70B9\u8FDE\u901A\u6027...`);
-    console.log(`\u8D85\u65F6: ${timeout}ms  \u5E76\u53D1: ${concurrency}`);
-    console.log("");
-    const progress = createProgressPrinter();
-    const summary = await withTestInstance(target.name, async (apiBase) => {
-      return testSubscriptionProxies(target.name, {
-        timeout,
-        concurrency,
-        apiBase,
-        onResult: progress.onResult
-      });
-    });
-    progress.finish();
-    console.log(formatTestSummary(summary));
-    return;
+  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");
   }
-  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);
 }
-
-// src/commands/test.ts
-function requireRunning() {
-  const state = getRunningState();
-  if (!state.running) {
-    const hint = state.daemon ? "mihomo daemon on" : "mihomo start";
-    console.error(`\u9519\u8BEF: mihomo \u672A\u8FD0\u884C\uFF0C\u8BF7\u5148\u542F\u52A8 (${hint})`);
-    process.exit(1);
+function subRemove(args) {
+  const name = args[2];
+  const subs = getSubscriptions();
+  if (!name) {
+    throw new CliError("\u8BF7\u6307\u5B9A\u8981\u5220\u9664\u7684\u8BA2\u9605\u540D\u79F0", {
+      hint: subs.length > 0 ? ["", "\u53EF\u7528\u8BA2\u9605:", ...subs.map((s) => `  ${s.name}`)] : void 0
+    });
+  }
+  const target = resolveSubscription(subs, 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}"`);
   }
+  console.log("");
+  printSubscriptionList();
 }
-function requireActiveSub() {
-  const activeSub = getActiveSubscription();
-  if (!activeSub) {
-    console.error("\u9519\u8BEF: \u6CA1\u6709\u6D3B\u8DC3\u8BA2\u9605");
-    process.exit(1);
+async function subClean(args) {
+  const { target, timeout, concurrency } = resolveTestTarget(args);
+  const rounds = parseIntArg(args, "-r", "--rounds", DEFAULT_CLEAN_ROUNDS);
+  console.log(`\u6E05\u7406\u8BA2\u9605 "${target.name}"...`);
+  console.log(`\u8D85\u65F6: ${timeout}ms  \u5E76\u53D1: ${concurrency}`);
+  console.log("");
+  const progress = createProgressPrinter(rounds);
+  const result = await withTestInstance(target.name, async (apiBase) => {
+    return autoCleanSubscription(target.name, {
+      timeout,
+      concurrency,
+      rounds,
+      apiBase,
+      onResult: progress.onResult,
+      onRetryRound: progress.onRetryRound
+    });
+  });
+  progress.finish();
+  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)}`);
+    if (getRunningState().running) {
+      console.log("");
+      console.log("\u63D0\u793A: \u9700\u8981\u91CD\u542F mihomo \u4F7F\u66F4\u6539\u751F\u6548 (mihomo start)");
+    }
   }
-  return activeSub;
 }
+async function subTest(args) {
+  const { target, timeout, concurrency } = resolveTestTarget(args);
+  console.log(`\u6D4B\u8BD5\u8BA2\u9605 "${target.name}" \u7684\u8282\u70B9\u8FDE\u901A\u6027...`);
+  console.log(`\u8D85\u65F6: ${timeout}ms  \u5E76\u53D1: ${concurrency}`);
+  console.log("");
+  const progress = createProgressPrinter();
+  const summary = await withTestInstance(target.name, async (apiBase) => {
+    return testSubscriptionProxies(target.name, {
+      timeout,
+      concurrency,
+      apiBase,
+      onResult: progress.onResult
+    });
+  });
+  progress.finish();
+  console.log(formatTestSummary(summary));
+}
+var SUBCOMMANDS4 = [
+  { name: "list", handler: printSubscriptionList },
+  { name: "add", handler: subAdd },
+  { name: "update", handler: subUpdate },
+  { name: "use", handler: subUse },
+  { name: "web", aliases: ["open"], handler: subWeb },
+  { name: "remove", aliases: ["rm", "delete"], handler: subRemove },
+  { name: "clean", handler: subClean },
+  { name: "test", handler: subTest }
+];
+async function cmdSubscription(args) {
+  await dispatchSubcommand(args, SUBCOMMANDS4, {
+    // 无子命令 → 列表；未知子命令 → 报错
+    fallback: printSubscriptionList,
+    onUnknown: (action) => {
+      const names = SUBCOMMANDS4.flatMap((c) => [c.name, ...c.aliases ?? []]);
+      const suggestion = suggestSimilar(action, names);
+      throw new CliError(`\u672A\u77E5\u7684\u8BA2\u9605\u547D\u4EE4: ${action}`, {
+        hint: [...suggestion.length > 0 ? [`\u662F\u5426\u60F3\u8F93\u5165: ${suggestion.join(" / ")}?`] : [], "\u7528\u6CD5: mihomo sub [list|use|add|update|remove|web|test|clean]"]
+      });
+    }
+  });
+}
+
+// src/commands/test.ts
 async function cmdTest(args) {
   requireRunning();
-  const activeSub = requireActiveSub();
+  const activeSub = requireActiveSubscription("\u6CA1\u6709\u6D3B\u8DC3\u8BA2\u9605");
   const timeout = parseIntArg(args, "-t", "--timeout", DEFAULT_TEST_TIMEOUT);
   const concurrency = parseIntArg(args, "-j", "--concurrency", DEFAULT_TEST_CONCURRENCY);
   console.log(`\u6D4B\u8BD5 "${activeSub.name}" \u8282\u70B9\u8FDE\u901A\u6027...`);
@@ -7023,7 +7049,7 @@ async function cmdTest(args) {
 }
 async function cmdClean(args) {
   requireRunning();
-  const activeSub = requireActiveSub();
+  const activeSub = requireActiveSubscription("\u6CA1\u6709\u6D3B\u8DC3\u8BA2\u9605");
   const timeout = parseIntArg(args, "-t", "--timeout", DEFAULT_TEST_TIMEOUT);
   const concurrency = parseIntArg(args, "-j", "--concurrency", DEFAULT_TEST_CONCURRENCY);
   const rounds = parseIntArg(args, "-r", "--rounds", DEFAULT_CLEAN_ROUNDS);
@@ -7054,9 +7080,7 @@ async function cmdClean(args) {
     try {
       if (!daemonManaged) {
         if (hasRootResidue()) {
-          console.error(`${colors.red("\u9519\u8BEF:")} \u4E3B\u5B9E\u4F8B\u4EE5 root \u8FD0\u884C\uFF08TUN\uFF09\uFF0C\u505C\u6B62\u5B83\u9700\u8981 sudo`);
-          console.error("\u8BF7\u6539\u7528 mihomo sub clean\uFF08\u9694\u79BB\u5B9E\u4F8B\u6D4B\u901F\uFF0C\u65E0\u9700\u505C\u6B62\u4E3B\u5B9E\u4F8B\uFF09");
-          process.exit(1);
+          throw new CliError("\u4E3B\u5B9E\u4F8B\u4EE5 root \u8FD0\u884C\uFF08TUN\uFF09\uFF0C\u505C\u6B62\u5B83\u9700\u8981 sudo", { hint: "\u8BF7\u6539\u7528 mihomo sub clean\uFF08\u9694\u79BB\u5B9E\u4F8B\u6D4B\u901F\uFF0C\u65E0\u9700\u505C\u6B62\u4E3B\u5B9E\u4F8B\uFF09" });
         }
         handleStopResult(stop());
       }
@@ -7065,8 +7089,8 @@ async function cmdClean(args) {
       const label = daemonManaged ? "\u5DF2\u91CD\u542F (\u4FDD\u6D3B)" : "\u5DF2\u91CD\u542F";
       console.log(`${colors.green(label)}${pid ? ` (PID ${pid})` : ""} \xB7 ${formatProxySummary(configInfo)}`);
     } catch (e) {
-      console.error(`${colors.red("\u91CD\u542F\u5931\u8D25:")} ${e.message.split("\n")[0]}`);
-      process.exit(1);
+      if (e instanceof CliError) throw e;
+      throw new CliError(e.message.split("\n")[0], { label: "\u91CD\u542F\u5931\u8D25" });
     }
   }
 }
@@ -7075,9 +7099,11 @@ async function cmdClean(args) {
 function cmdUI(args) {
   const uiName = args[1] || "zash";
   if (!Object.hasOwn(UI_URLS, uiName)) {
-    console.error(`\u9519\u8BEF: \u672A\u77E5\u7684 UI "${uiName}"`);
-    console.error("\u53EF\u7528 UI: zash (\u9ED8\u8BA4), dash, yacd");
-    process.exit(1);
+    throw new CliError(`\u672A\u77E5\u7684 UI "${uiName}"`, { hint: "\u53EF\u7528 UI: zash (\u9ED8\u8BA4), dash, yacd" });
+  }
+  if (!getRunningState().running) {
+    console.log(colors.yellow("\u63D0\u793A: mihomo \u672A\u8FD0\u884C\uFF0CUI \u6682\u65F6\u65E0\u6CD5\u8FDE\u63A5\uFF08\u5148\u6267\u884C mihomo start \u542F\u52A8\uFF09"));
+    console.log("");
   }
   const url = UI_URLS[uiName];
   console.log(`\u6253\u5F00 Web UI: ${uiName}`);
@@ -7093,37 +7119,54 @@ function cmdUI(args) {
 }
 
 // src/commands/update.ts
-import { exec, spawn as spawn3 } from "child_process";
+import { execFile, spawn as spawn3 } from "child_process";
 import { promisify } from "util";
-var execAsync = promisify(exec);
+var execFileAsync = promisify(execFile);
+var NPM_VIEW_TIMEOUT_MS = 15e3;
+async function getLatestNpmVersion() {
+  try {
+    const { stdout } = await execFileAsync("npm", ["view", PKG_NAME, "version"], { timeout: NPM_VIEW_TIMEOUT_MS });
+    const version = stdout.trim().split("\n").pop()?.trim();
+    return version || null;
+  } catch {
+    return null;
+  }
+}
 async function cmdUpdate() {
   console.log(`\u5F53\u524D\u7248\u672C: ${colors.cyan(VERSION)}`);
   console.log("");
+  console.log("\u6B63\u5728\u68C0\u67E5\u6700\u65B0\u7248\u672C...");
+  const latest = await getLatestNpmVersion();
+  if (latest && latest === VERSION) {
+    console.log(`\u5DF2\u662F\u6700\u65B0\u7248\u672C (${colors.green(VERSION)})\uFF0C\u65E0\u9700\u66F4\u65B0`);
+    return;
+  }
+  if (latest) {
+    console.log(`\u6700\u65B0\u7248\u672C: ${colors.cyan(latest)}`);
+  } else {
+    console.log(colors.yellow("\u65E0\u6CD5\u67E5\u8BE2\u6700\u65B0\u7248\u672C\uFF08\u7F51\u7EDC\u95EE\u9898\uFF1F\uFF09\uFF0C\u5C06\u76F4\u63A5\u5C1D\u8BD5\u91CD\u65B0\u5B89\u88C5"));
+  }
+  console.log("");
   console.log("\u6B63\u5728\u66F4\u65B0 mihomo-cli...");
   console.log("");
-  await new Promise((resolve) => {
-    const npm = spawn3("npm", ["install", "-g", "mihomo-cli"], { stdio: "inherit" });
+  await new Promise((resolve, reject) => {
+    const npm = spawn3("npm", ["install", "-g", PKG_NAME], { stdio: "inherit" });
     npm.on("close", (code) => {
       if (code === 0) {
         resolve();
       } else {
-        console.error("\u66F4\u65B0\u5931\u8D25\u3002\u82E5\u4E3A\u6743\u9650\u95EE\u9898\uFF08EACCES\uFF09\uFF0C\u53EF\u5C1D\u8BD5: sudo npm install -g mihomo-cli");
-        process.exit(code || 1);
+        reject(new CliError("\u66F4\u65B0\u5931\u8D25\u3002\u82E5\u4E3A\u6743\u9650\u95EE\u9898\uFF08EACCES\uFF09\uFF0C\u53EF\u5C1D\u8BD5: sudo npm install -g mihomo-cli", { exitCode: code || 1 }));
       }
     });
     npm.on("error", (e) => {
-      if (e.message.includes("EACCES") || e.message.includes("permission")) {
-        console.error("\u6743\u9650\u4E0D\u8DB3\uFF0C\u53EF\u5C1D\u8BD5: sudo npm install -g mihomo-cli");
-      } else {
-        console.error(`\u6267\u884C\u5931\u8D25: ${e.message}`);
-      }
-      process.exit(1);
+      const perm = e.message.includes("EACCES") || e.message.includes("permission");
+      reject(perm ? new CliError("\u6743\u9650\u4E0D\u8DB3\uFF0C\u53EF\u5C1D\u8BD5: sudo npm install -g mihomo-cli") : new CliError(`\u6267\u884C\u5931\u8D25: ${e.message}`));
     });
   });
   try {
-    const { stdout } = await execAsync("npm list -g mihomo-cli --json --depth=0");
+    const { stdout } = await execFileAsync("npm", ["list", "-g", PKG_NAME, "--json", "--depth=0"]);
     const result = JSON.parse(stdout);
-    const newVersion = result.dependencies?.["mihomo-cli"]?.version;
+    const newVersion = result.dependencies?.[PKG_NAME]?.version;
     console.log("");
     if (newVersion) {
       console.log(`\u66F4\u65B0\u5B8C\u6210\uFF0C\u6700\u65B0\u7248\u672C: ${colors.green(newVersion)}`);
@@ -7328,6 +7371,9 @@ var COMMAND_INDEX = (() => {
 function findCommand(token) {
   return COMMAND_INDEX.get(token);
 }
+function allCommandTokens() {
+  return [...COMMAND_INDEX.keys()];
+}
 
 // src/index.ts
 process.on("SIGINT", () => {
@@ -7377,14 +7423,23 @@ async function main() {
   const token = args[0].toLowerCase();
   const command = findCommand(token);
   if (!command) {
-    console.error(`\u672A\u77E5\u547D\u4EE4: ${token}`);
-    console.error('\u4F7F\u7528 "mihomo help" \u67E5\u770B\u5E2E\u52A9');
-    process.exit(1);
+    const suggestion = suggestSimilar(token, allCommandTokens());
+    throw new CliError(`\u672A\u77E5\u547D\u4EE4: ${token}`, {
+      hint: [suggestion.length > 0 ? `\u662F\u5426\u60F3\u8F93\u5165: ${suggestion.join(" / ")}?` : '\u4F7F\u7528 "mihomo help" \u67E5\u770B\u5E2E\u52A9']
+    });
   }
   await command.handler(command.rewrite ? command.rewrite(args) : args);
 }
 main().catch((e) => {
-  console.error(`\u9519\u8BEF: ${e.message}`);
+  if (e instanceof CliError) {
+    console.error(`${colors.red(`${e.label}:`)} ${e.message}`);
+    for (const line of e.hint) console.error(line);
+    runCleanup();
+    process.exit(e.exitCode);
+  }
+  const err = e;
+  console.error(`${colors.red("\u9519\u8BEF:")} ${err.message}`);
+  if (err.stack) console.error(err.stack.split("\n").slice(1).join("\n"));
   runCleanup();
   process.exit(1);
 });