mihomo-cli 3.5.0 → 3.6.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [3.6.0] - 2026-08-15
+
+### 修复
+
+- **`sub add` 重名时误删既有同名订阅** - 回滚逻辑包住了入库步骤，添加重名订阅时「已存在」错误同样触发 `removeSubscription`，把用户既有的同名订阅（含缓存与配置文件）删掉。现入库移出 try 块，回滚仅覆盖「入库成功后下载失败」
+- **`start` 拼错模式名静默按 Mixed 启动** - `mihomo start tn` 之类只判 `=== 'tun'`，拼错不报错，用户会误以为已切到 TUN。现校验模式参数并报错，参数校验先于内核/订阅环境检查
+- **pidFile 运行判定可被 PID 复用欺骗** - 只检查 pid 存活，系统重启后残留 pid 文件里的 pid 可能已被无关进程复用，被误判成运行中的 mihomo。现同时校验进程命令行包含内核路径（与测速实例防护同口径）
+- **数据层预期错误打印堆栈** - 订阅名称非法/重名、未找到订阅配置、无有效节点、内核/配置缺失等用户可见的预期错误仍抛裸 `Error`，经统一收口后打印堆栈。现全部迁移为 `CliError`
+
+### 新增
+
+- **did-you-mean 纠错** - 未知命令与 `sub`/`daemon` 未知子命令按前缀 + 编辑距离给出纠错建议（如 `mihomo strt` -> `是否想输入: start / stop?`）
+- **`update` 更新前检查最新版** - 先查 npm registry，已是最新版本则跳过重装；查询失败（15s 超时）降级为直接安装
+- **`status` 显示订阅流量与到期** - 复用订阅缓存的响应头数据，有则展示
+- **场景化提醒** - `ui` 在 mihomo 未运行时提示先启动；`kernel` 更新成功后运行中实例提示需重启生效
+
+### 内部
+
+- **utils 按职责拆分** - `colors.ts`（颜色）、`errors.ts`（CliError/TimeoutError/withTimeout）、`http.ts`（HTTP 客户端）独立成模块；`isProcess*` 进程探测归入 `process.ts`，`isProxyValid` 归入其唯一消费者 `test-instance.ts`；`VERSION`/`PKG_NAME` 移入 `constants.ts`。`utils.ts` 只留无副作用的纯函数（sleep、转义、格式化、flag 解析、纠错建议）
+- **补充单元测试** - 新增 `suggestSimilar`（did-you-mean）单测，总计 55 个
+
 ## [3.5.0] - 2026-08-15
 
 ### 变更

package/README.md

@@ -13,10 +13,11 @@
 - 🚀 **进程管理** - 启动/停止/切换模式，自动清理残留进程
 - 🛡️ **进程保活** - 基于 launchd（root），崩溃/开机自动拉起，代理后台常驻（`daemon on`）
 - 🔄 **双模式支持** - Mixed 模式和 TUN 透明代理模式
-- 📊 **状态监控** - 查看运行状态、内存占用
+- 📊 **状态监控** - 查看运行状态、内存占用、订阅流量与到期时间
 - 📝 **日志管理** - 实时日志 + 历史日志归档（自动轮转，保留7天）
 - 🎨 **Web UI** - 一键打开 Web 控制面板 (zash/metacubexd/yacd)
 - 🔄 **内核更新** - 自动检查更新，支持 GitHub 镜像加速
+- 💡 **容错提示** - 命令/子命令拼错时给出 did-you-mean 纠错建议
 - ⌨️ **命令别名** - `mihomo` / `mhm` / `mh` 均可调用
 
 ## 安装
@@ -86,7 +87,7 @@ mihomo ui yacd     # YACD
 | --------------------------- | ---------------------------------------------------------------------------- |
 | `mihomo start [tun\|mixed]` | 启动/重启/切换代理模式（`-s` 跳过更新，`-u` 更新超时，`-r` 清理轮次，`-t` 超时，`-j` 并发，`--no-clean` 跳过启动自动清理） |
 | `mihomo stop`               | 停止代理                                                                     |
-| `mihomo status`             | 查看运行状态                                                                 |
+| `mihomo status`             | 查看运行状态（含订阅流量、到期时间）                                         |
 | `mihomo log`                | 实时查看日志 (`-o` 用系统编辑器打开)                                         |
 | `mihomo logs`               | 列出所有日志（当前 + 历史归档）                                              |
 | `mihomo logs <编号>`        | 查看指定日志（`0`=当前日志，`1+`=归档日志，支持 `-n N` 指定行数、`-o` 打开） |
@@ -119,9 +120,9 @@ mihomo ui yacd     # YACD
 
 | 命令                              | 说明                                                                |
 | --------------------------------- | ------------------------------------------------------------------- |
-| `mihomo kernel [--mirror [镜像]]` | 更新内核（默认直连，`--mirror` 使用镜像）                           |
+| `mihomo kernel [--mirror [镜像]]` | 更新内核（默认直连，`--mirror` 使用镜像；更新后运行中实例需重启生效） |
 | `mihomo daemon [on\|off\|status]` | 进程保活：开机自启 + 崩溃自动重启（仅 Mixed 模式，on/off 需管理员密码）  |
-| `mihomo update`                   | 更新 mihomo-cli (npm install -g)                                    |
+| `mihomo update`                   | 更新 mihomo-cli（先查 npm 最新版，已是最新则跳过重装）              |
 | `mihomo ui [zash\|dash\|yacd]`    | 打开 Web UI                                                         |
 | `mihomo dir`                      | 显示数据目录位置                                                    |
 | `mihomo dir open [target]`        | 打开指定目录（`root`, `subs`, `logs`, `kernel` 等）                 |

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,39 +3634,6 @@ function escapeRegExp(s) {
 function shellQuote(s) {
   return `'${s.replace(/'/g, "'\\''")}'`;
 }
-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);
-      }
-    );
-  });
-}
 function formatBytes(bytes) {
   if (bytes === void 0 || bytes === null) return "\u672A\u77E5";
   const num = Number(bytes);
@@ -3708,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;
@@ -3834,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 };
@@ -4097,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]+/);
@@ -4191,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";
 
@@ -4233,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)) {
@@ -4251,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);
@@ -4295,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 {
@@ -4317,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;
@@ -4420,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);
@@ -4454,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) {
@@ -4535,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");
@@ -4775,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) {
@@ -4809,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");
@@ -4917,6 +4887,67 @@ async function restartDaemon() {
   cleanupOldLogs();
 }
 
+// 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);
+      }
+    }
+  };
+}
+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;
@@ -4949,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 {
@@ -5165,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 });
@@ -5574,6 +5605,18 @@ function printStatus() {
       subLine += ` (${formatProxySummary(info)})`;
     }
     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)}%)`;
+      }
+      console.log(trafficLine);
+    }
+    if (cached?.expire !== void 0) {
+      console.log(`${colors.gray("\u5230\u671F: ")}${formatTimestamp(cached.expire)}`);
+    }
   } else {
     console.log(`${colors.gray("\u8BA2\u9605: ")}\u672A\u914D\u7F6E`);
   }
@@ -5615,10 +5658,14 @@ async function cmdStop() {
 
 // 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 targetMode = args[1] === "tun" ? "tun" : "mixed";
   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" });
@@ -5812,7 +5859,11 @@ async function cmdDaemon(args) {
     // 无 action → 显示状态；未知 action → 报错
     fallback: printStatusView,
     onUnknown: (action) => {
-      throw new CliError(`\u672A\u77E5\u7684 daemon \u5B50\u547D\u4EE4: ${action}`, { hint: ["", "\u53EF\u7528\u5B50\u547D\u4EE4: on, off, status"] });
+      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"]
+      });
     }
   });
 }
@@ -5882,7 +5933,7 @@ function cmdDirectory(args) {
 }
 
 // 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";
 
@@ -6047,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" }
@@ -6075,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);
@@ -6084,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 });
@@ -6126,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 {
@@ -6171,6 +6222,9 @@ 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) {
     if (e instanceof CliError) throw e;
@@ -6530,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"),
@@ -6553,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) {
@@ -6585,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], {
@@ -6597,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;
@@ -6617,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() {
@@ -6759,8 +6822,8 @@ async function subAdd(args) {
     }
     const normalizedUrl = urls.join(",");
     console.log(`\u6DFB\u52A0\u5408\u5E76\u8BA2\u9605: ${name} (${urls.length} \u4E2A\u6E90)`);
+    addSubscription(normalizedUrl, name);
     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)`);
@@ -6773,8 +6836,8 @@ async function subAdd(args) {
       throw new CliError("\u8BF7\u63D0\u4F9B\u6709\u6548\u7684\u8BA2\u9605 URL\uFF08\u9700\u4EE5 http:// \u6216 https:// \u5F00\u5934\uFF09");
     }
     console.log(`\u6DFB\u52A0\u8BA2\u9605: ${name}`);
+    addSubscription(url, name);
     try {
-      addSubscription(url, name);
       setDefaultSubscription(name);
       const info = await downloadSubscription(url, name);
       const repoUrl = githubRepoUrl(url);
@@ -6956,8 +7019,12 @@ async function cmdSubscription(args) {
   await dispatchSubcommand(args, SUBCOMMANDS4, {
     // 无子命令 → 列表；未知子命令 → 报错
     fallback: printSubscriptionList,
-    onUnknown: () => {
-      throw new CliError("\u672A\u77E5\u7684\u8BA2\u9605\u547D\u4EE4", { hint: "\u7528\u6CD5: mihomo sub [list|use|add|update|remove|web|test|clean]" });
+    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]"]
+      });
     }
   });
 }
@@ -7034,6 +7101,10 @@ function cmdUI(args) {
   if (!Object.hasOwn(UI_URLS, uiName)) {
     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}`);
   console.log(`\u5730\u5740: ${url}`);
@@ -7048,16 +7119,38 @@ 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, reject) => {
-    const npm = spawn3("npm", ["install", "-g", "mihomo-cli"], { stdio: "inherit" });
+    const npm = spawn3("npm", ["install", "-g", PKG_NAME], { stdio: "inherit" });
     npm.on("close", (code) => {
       if (code === 0) {
         resolve();
@@ -7071,9 +7164,9 @@ async function cmdUpdate() {
     });
   });
   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)}`);
@@ -7278,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", () => {
@@ -7327,7 +7423,10 @@ async function main() {
   const token = args[0].toLowerCase();
   const command = findCommand(token);
   if (!command) {
-    throw new CliError(`\u672A\u77E5\u547D\u4EE4: ${token}`, { hint: '\u4F7F\u7528 "mihomo help" \u67E5\u770B\u5E2E\u52A9' });
+    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);
 }

package/package.json

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