mihomo-cli 3.0.0 → 3.2.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/config.ts
-import { spawnSync } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 import fs4 from "fs";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
@@ -2923,7 +2923,11 @@ var UI_URLS = {
   dash: "https://metacubex.github.io/metacubexd",
   yacd: "https://yacd.metacubex.one"
 };
-var LAUNCH_AGENT_LABEL = "com.mihomo-cli.daemon";
+var LAUNCH_DAEMON_LABEL = process.env.MIHOMO_CLI_DAEMON_LABEL || "com.mihomo-cli.daemon";
+var CONTROLLER_PORT = 9090;
+var CONTROLLER_ADDR = `127.0.0.1:${CONTROLLER_PORT}`;
+var CONTROLLER_BASE_URL = `http://${CONTROLLER_ADDR}`;
+var TEST_CONTROLLER_ADDR = "127.0.0.1:29090";
 var TUN_CONFIG = {
   tun: {
     enable: true,
@@ -2937,14 +2941,14 @@ var TUN_CONFIG = {
 var TEST_CONFIG = {
   "mixed-port": 27890,
   "allow-lan": false,
-  "external-controller": "127.0.0.1:29090",
+  "external-controller": TEST_CONTROLLER_ADDR,
   "log-level": "error",
   "geodata-mode": true
 };
 var BASE_CONFIG = {
   "mixed-port": 7890,
   "allow-lan": false,
-  "external-controller": "127.0.0.1:9090",
+  "external-controller": CONTROLLER_ADDR,
   "unified-delay": true,
   "tcp-concurrent": true,
   "geo-auto-update": true,
@@ -2973,7 +2977,7 @@ var AUTO_CLEAN_THRESHOLD_GITHUB = 50;
 
 // src/overwrite.ts
 import fs3 from "fs";
-import path2 from "path";
+import path3 from "path";
 
 // src/paths.ts
 import fs from "fs";
@@ -3003,8 +3007,8 @@ var PATHS = {
   configStage1Subscription: path.join(DIRS.runtime, "1.subscription.yaml"),
   configStage2Overwrite: path.join(DIRS.runtime, "2.overwrite.yaml"),
   configStage3System: path.join(DIRS.runtime, "3.system.yaml"),
-  // launchd LaunchAgent plist 必须位于真实用户主目录，不受 MIHOMO_CLI_DIR 影响
-  launchAgentPlist: path.join(os.homedir(), "Library", "LaunchAgents", `${LAUNCH_AGENT_LABEL}.plist`)
+  // launchd LaunchDaemon plist 位于系统级 /Library/LaunchDaemons/，root:wheel 拥有，与 homedir / MIHOMO_CLI_DIR 无关
+  launchDaemonPlist: path.join("/Library/LaunchDaemons", `${LAUNCH_DAEMON_LABEL}.plist`)
 };
 var DIRECTORY_TARGETS = {
   root: { path: null, label: "\u6839\u76EE\u5F55" },
@@ -3040,6 +3044,7 @@ function rmrf(dir) {
 
 // src/settings.ts
 import fs2 from "fs";
+import path2 from "path";
 var settingsCache = null;
 function readSettings() {
   if (settingsCache !== null) return settingsCache;
@@ -3143,12 +3148,10 @@ function addSubscription(url, name = "default") {
   validateSubscriptionName(name);
   const settings = readSettings();
   const subs = [...settings.subscriptions || []];
-  const existingIndex = subs.findIndex((s) => s.name === name);
-  if (existingIndex >= 0) {
-    subs[existingIndex] = { name, url };
-  } else {
-    subs.push({ name, url });
+  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`);
   }
+  subs.push({ name, url });
   const updates = { subscriptions: subs };
   if (!settings.active_subscription && subs.length === 1) {
     updates.active_subscription = name;
@@ -3173,7 +3176,10 @@ function removeSubscription(name) {
     delete cache[name];
     writeSubscriptionCache(cache);
   }
-  fs2.rmSync(getSubscriptionRawConfigPath(name), { force: true });
+  try {
+    fs2.rmSync(getSubscriptionRawConfigPath(name), { force: true });
+  } catch {
+  }
   return switchedTo;
 }
 function setDefaultSubscription(name) {
@@ -3186,7 +3192,10 @@ function setDefaultSubscription(name) {
   return true;
 }
 function getSubscriptionRawConfigPath(subName) {
-  return `${DIRS.subscriptions}/${subName}.yaml`;
+  if (!SAFE_NAME_RE.test(subName)) {
+    throw new Error(`\u8BA2\u9605\u540D\u79F0\u65E0\u6548: "${subName}"`);
+  }
+  return path2.join(DIRS.subscriptions, `${subName}.yaml`);
 }
 function saveSubscriptionRawConfig(subName, content) {
   ensureDirs();
@@ -3284,17 +3293,20 @@ function isOverwriteEnabled() {
 function setOverwriteEnabled(enabled) {
   writeSettings({ overwrite_enabled: enabled });
 }
+function isOverwriteFilename(filename) {
+  return filename === "overwrite.yaml" || /^overwrite\..+\.ya?ml$/.test(filename);
+}
 function loadOverwriteFile() {
   const dir = USER_DATA_DIR;
   if (!fs3.existsSync(dir)) return [];
-  const files = fs3.readdirSync(dir).filter((f) => f === "overwrite.yaml" || /^overwrite\..+\.ya?ml$/.test(f)).sort((a, b) => {
+  const files = fs3.readdirSync(dir).filter(isOverwriteFilename).sort((a, b) => {
     if (a === "overwrite.yaml") return -1;
     if (b === "overwrite.yaml") return 1;
     return a.localeCompare(b);
   });
   const results = [];
   for (const file of files) {
-    const filePath = path2.join(dir, file);
+    const filePath = path3.join(dir, file);
     try {
       const content = fs3.readFileSync(filePath, "utf8");
       const parsed = load(content);
@@ -3331,6 +3343,213 @@ 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 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);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+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);
+  if (!Number.isFinite(num) || num < 0) return "\u672A\u77E5";
+  if (num === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.min(Math.floor(Math.log(num) / Math.log(k)), sizes.length - 1);
+  return `${parseFloat((num / k ** i).toFixed(2))} ${sizes[i]}`;
+}
+function formatTimestamp(ts) {
+  if (ts === void 0 || ts === null) return "\u672A\u77E5";
+  try {
+    return new Date(ts * 1e3).toLocaleString("zh-CN");
+  } catch {
+    return "\u672A\u77E5";
+  }
+}
+function formatLocalTimestamp(d = /* @__PURE__ */ new Date()) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}_${p(d.getHours())}-${p(d.getMinutes())}-${p(d.getSeconds())}`;
+}
+function formatDate(dateOrIso) {
+  if (dateOrIso === void 0 || dateOrIso === null) return "\u672A\u77E5";
+  try {
+    const d = dateOrIso instanceof Date ? dateOrIso : new Date(dateOrIso);
+    if (Number.isNaN(d.getTime())) return "\u672A\u77E5";
+    return d.toLocaleString("zh-CN");
+  } catch {
+    return "\u672A\u77E5";
+  }
+}
+function hasFlag(args, short, long) {
+  return !!args && (args.includes(short) || args.includes(long));
+}
+function parseIntArg(args, short, long, defaultValue) {
+  if (!args) return defaultValue;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === short || args[i] === long) {
+      if (i + 1 < args.length) {
+        const val = parseInt(args[i + 1], 10);
+        return Number.isNaN(val) ? defaultValue : val;
+      }
+    }
+  }
+  return defaultValue;
+}
+var VALUE_FLAGS = /* @__PURE__ */ new Set(["-t", "--timeout", "-j", "--concurrency", "-r", "--rounds", "-n", "--lines", "-u", "--update-timeout"]);
+function getNonFlagArg(args, startIdx, valueFlags = VALUE_FLAGS) {
+  if (!args) return null;
+  for (let i = startIdx; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith("-")) {
+      if (valueFlags.has(a)) i++;
+      continue;
+    }
+    return a;
+  }
+  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 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 } = options;
+  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}` }
+        });
+        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 data = config?.responseType === "json" ? await response.json() : await response.text();
+        return { data, headers: response.headers, status: response.status };
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+function normalizeMirrorUrl(val) {
+  if (!val) return null;
+  if (val === "direct" || val === "no" || val === "none") return null;
+  let url = val;
+  if (!url.startsWith("http")) {
+    url = `https://${url}`;
+  }
+  if (!url.endsWith("/")) {
+    url += "/";
+  }
+  return url;
+}
+function parseMirrorArg(args) {
+  if (!args || args.length < 2) {
+    return { mirror: null, isOverride: false, type: "download" };
+  }
+  if (args.includes("--no-mirror") || args.includes("--direct")) {
+    return { mirror: null, isOverride: true, type: "download" };
+  }
+  const mirrorAllIdx = args.indexOf("--mirror-all");
+  if (mirrorAllIdx >= 0) {
+    const nextArg = args[mirrorAllIdx + 1];
+    if (!nextArg || nextArg.startsWith("-")) {
+      return { mirror: "https://v6.gh-proxy.org/", isOverride: true, type: "all" };
+    }
+    return { mirror: normalizeMirrorUrl(nextArg), isOverride: true, type: "all" };
+  }
+  const mirrorIdx = args.indexOf("--mirror");
+  if (mirrorIdx >= 0) {
+    const nextArg = args[mirrorIdx + 1];
+    if (!nextArg || nextArg.startsWith("-")) {
+      return { mirror: "https://v6.gh-proxy.org/", isOverride: true, type: "download" };
+    }
+    return { mirror: normalizeMirrorUrl(nextArg), isOverride: true, type: "download" };
+  }
+  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
 function parseYamlOrJson(content, errorMsg) {
   if (!content?.trim()) {
@@ -3347,6 +3566,9 @@ function parseYamlOrJson(content, errorMsg) {
     throw new Error(`${errorMsg || "\u5185\u5BB9"}\u683C\u5F0F\u9519\u8BEF\uFF0C\u65E0\u6CD5\u89E3\u6790\u4E3A YAML \u6216 JSON`);
   }
 }
+function dumpYaml(obj) {
+  return dump(obj, { indent: 2, lineWidth: -1, schema: CORE_SCHEMA });
+}
 function collectOverwriteProxyNames(overwriteFiles) {
   const names = [];
   for (const file of overwriteFiles) {
@@ -3367,7 +3589,7 @@ function excludeOverwriteProxiesFromIncludeAll(config, overwriteFiles) {
   if (injectedNames.length === 0) return;
   const groups = config["proxy-groups"];
   if (!groups) return;
-  const excludePattern = injectedNames.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  const excludePattern = injectedNames.map((n) => escapeRegExp(n)).join("|");
   for (const group of groups) {
     if (!group["include-all"] && !group["include-all-proxies"]) continue;
     const existing = group["exclude-filter"];
@@ -3392,6 +3614,15 @@ function deduplicateByName(items) {
   });
   return { result, names, duplicates };
 }
+function getRuleTarget(rule) {
+  const parts = rule.split(",");
+  if (parts.length < 2) return "";
+  const last = parts[parts.length - 1].trim();
+  if (last.toLowerCase() === "no-resolve" && parts.length >= 3) {
+    return parts[parts.length - 2].trim();
+  }
+  return last;
+}
 function validateConfig(config) {
   const warnings = [];
   const proxies = config.proxies || [];
@@ -3436,9 +3667,7 @@ function validateConfig(config) {
   if (rules.length > 0) {
     const removedRules = [];
     config.rules = rules.filter((rule) => {
-      const parts = rule.split(",");
-      if (parts.length < 2) return true;
-      const target = parts[parts.length - 1].trim();
+      const target = getRuleTarget(rule);
       if (!target || validNames.has(target)) return true;
       removedRules.push(rule);
       return false;
@@ -3485,6 +3714,8 @@ function buildConfig(subRawContent, mode) {
     if (Object.keys(dns).length > 0) {
       systemConfig.dns = dns;
     }
+  } else {
+    delete withOverwrites.tun;
   }
   const merged = { ...withOverwrites, ...systemConfig };
   if (systemConfig.dns) {
@@ -3507,20 +3738,19 @@ function buildConfig(subRawContent, mode) {
 }
 function writeMihomoConfig(configObj) {
   ensureDirs();
-  const content = dump(configObj, { indent: 2, lineWidth: -1, schema: CORE_SCHEMA });
+  const content = dumpYaml(configObj);
   atomicWriteFileSync(PATHS.configFile, content, { mode: 384 });
 }
 function writeDebugConfig(buildResult) {
   ensureDirs();
-  const dumpOpts = { indent: 2, lineWidth: -1, schema: CORE_SCHEMA };
-  fs4.writeFileSync(PATHS.configStage1Subscription, dump(buildResult.subscriptionConfig, dumpOpts), { mode: 384 });
+  fs4.writeFileSync(PATHS.configStage1Subscription, dumpYaml(buildResult.subscriptionConfig), { mode: 384 });
   const overwriteMerged = {};
   for (const f of buildResult.overwriteFiles) {
     Object.assign(overwriteMerged, f.config);
   }
-  const overwriteContent = buildResult.overwriteFiles.length > 0 ? dump(overwriteMerged, dumpOpts) : "# overwrite \u5DF2\u7981\u7528\u6216\u65E0\u8986\u5199\u6587\u4EF6\n";
+  const overwriteContent = buildResult.overwriteFiles.length > 0 ? dumpYaml(overwriteMerged) : "# overwrite \u5DF2\u7981\u7528\u6216\u65E0\u8986\u5199\u6587\u4EF6\n";
   fs4.writeFileSync(PATHS.configStage2Overwrite, overwriteContent, { mode: 384 });
-  fs4.writeFileSync(PATHS.configStage3System, dump(buildResult.systemConfig, dumpOpts), { mode: 384 });
+  fs4.writeFileSync(PATHS.configStage3System, dumpYaml(buildResult.systemConfig), { mode: 384 });
 }
 function hasConfig() {
   return fs4.existsSync(PATHS.configFile);
@@ -3560,7 +3790,7 @@ function getKernelVersion() {
   }
   if (kernelVersionCached) return kernelVersionCache;
   try {
-    const result = spawnSync(PATHS.mihomoBinary, ["-v"], { encoding: "utf8", timeout: 5e3 });
+    const result = spawnSync2(PATHS.mihomoBinary, ["-v"], { encoding: "utf8", timeout: 5e3 });
     const output = `${result.stdout || ""}${result.stderr || ""}`.trim();
     if (output) {
       const match = output.match(/v?[\d]+\.[\d]+\.[\d]+/);
@@ -3579,214 +3809,89 @@ function clearKernelVersionCache() {
   kernelVersionCached = false;
 }
 
+// src/commands/help.ts
+function printShortHelp() {
+  console.log(`
+${colors.cyan(colors.bold(`mihomo-cli v${VERSION}`))}  (mihomo help \u67E5\u770B\u5B8C\u6574\u5E2E\u52A9)
+`);
+  console.log(
+    `\u5E38\u7528\u547D\u4EE4:
+  ${colors.bold("start")} [tun|mixed]    \u542F\u52A8/\u5207\u6362\u4EE3\u7406
+  ${colors.bold("sub")} [use|update]     \u8BA2\u9605\u7BA1\u7406
+  ${colors.bold("ow")} [on|off]          \u8986\u5199\u914D\u7F6E
+  ${colors.bold("ui")} [zash|dash|yacd]  \u6253\u5F00 Web UI
+`
+  );
+}
+var GROUP_TITLES = [
+  ["control", "\u63A7\u5236:"],
+  ["interface", "\u754C\u9762:"],
+  ["subscription", "\u8BA2\u9605:"],
+  ["config", "\u914D\u7F6E:"],
+  ["system", "\u7CFB\u7EDF:"]
+];
+function printHelp(commands) {
+  const lines = [`
+${colors.cyan(colors.bold(`mihomo-cli v${VERSION}`))}`, "", "\u547D\u4EE4\u522B\u540D: mihomo, mhm, mh", "", "\u7528\u6CD5:", "  mihomo <\u547D\u4EE4> [\u9009\u9879]"];
+  for (const [group, title] of GROUP_TITLES) {
+    const usageLines = commands.filter((c) => c.group === group).flatMap((c) => c.usage);
+    if (usageLines.length === 0) continue;
+    lines.push("", colors.cyan(title));
+    for (const u of usageLines) {
+      lines.push(u.startsWith(" ") ? `  ${u}` : `  ${boldFirstToken(u)}`);
+    }
+  }
+  const meta = commands.filter((c) => c.group === "meta").flatMap((c) => c.usage);
+  if (meta.length > 0) {
+    lines.push("", colors.cyan("\u5143:"));
+    for (const u of meta) lines.push(`  ${boldFirstToken(u)}`);
+  }
+  lines.push(
+    "",
+    `${colors.cyan("\u793A\u4F8B:")}`,
+    "  mihomo start              # \u542F\u52A8/\u91CD\u542F Mixed \u6A21\u5F0F",
+    "  mihomo start tun          # \u5207\u6362\u5230 TUN \u900F\u660E\u4EE3\u7406\u6A21\u5F0F",
+    "  mihomo start -s           # \u8DF3\u8FC7\u81EA\u52A8\u66F4\u65B0\u8BA2\u9605",
+    "  mihomo start -u 30000     # \u81EA\u52A8\u66F4\u65B0\u8D85\u65F6 30 \u79D2 (\u9ED8\u8BA4 10s)",
+    "  mihomo daemon on          # \u5F00\u542F\u4FDD\u6D3B\uFF08\u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u91CD\u542F\uFF09",
+    "  mihomo sub add <url>      # \u6DFB\u52A0\u8BA2\u9605 (sub \u662F subscription \u522B\u540D)",
+    "  mihomo ui                 # \u6253\u5F00 Web UI",
+    "",
+    `${colors.cyan("\u5FEB\u6377\u547D\u4EE4:")}`,
+    "  tun = start tun   use = sub use   on/off = ow on/off   open = dir open",
+    "  up = start   down = stop   upd/upgrade = update",
+    "",
+    `${colors.cyan("\u6A21\u5F0F\u8BF4\u660E:")}`,
+    "  mixed  HTTP + SOCKS5 \u6DF7\u5408\u7AEF\u53E3 (\u9ED8\u8BA4)",
+    "  tun    \u900F\u660E\u4EE3\u7406\uFF0C\u5168\u5C40\u81EA\u52A8\u8DEF\u7531\uFF0C\u9700\u8981 sudo",
+    "",
+    `${colors.cyan("\u6570\u636E\u76EE\u5F55:")}`,
+    "  \u73AF\u5883\u53D8\u91CF MIHOMO_CLI_DIR \u53EF\u81EA\u5B9A\u4E49\u4F4D\u7F6E",
+    `  \u9ED8\u8BA4: ${USER_DATA_DIR}`
+  );
+  console.log(lines.join("\n"));
+}
+function boldFirstToken(usage) {
+  const spaceIdx = usage.indexOf(" ");
+  if (spaceIdx < 0) return colors.bold(usage);
+  return `${colors.bold(usage.slice(0, spaceIdx))}${usage.slice(spaceIdx)}`;
+}
+function printVersion() {
+  const kv = getKernelVersion() || "\u672A\u5B89\u88C5";
+  console.log(colors.cyan(colors.bold(`mihomo-cli v${VERSION}`)));
+  console.log(`${colors.gray("\u5185\u6838: ")}${kv}`);
+  console.log(`${colors.gray("\u6570\u636E\u76EE\u5F55: ")}${USER_DATA_DIR}`);
+}
+
 // src/daemon.ts
 import { spawnSync as spawnSync4 } from "child_process";
 import fs6 from "fs";
-import path4 from "path";
+import path5 from "path";
 
 // src/process.ts
 import { spawn, spawnSync as spawnSync3 } from "child_process";
 import fs5 from "fs";
-import path3 from "path";
-
-// src/utils.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../package.json");
-var VERSION = pkg.version;
-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);
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-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);
-  if (!Number.isFinite(num) || num < 0) return "\u672A\u77E5";
-  if (num === 0) return "0 B";
-  const k = 1024;
-  const sizes = ["B", "KB", "MB", "GB", "TB"];
-  const i = Math.min(Math.floor(Math.log(num) / Math.log(k)), sizes.length - 1);
-  return `${parseFloat((num / k ** i).toFixed(2))} ${sizes[i]}`;
-}
-function formatTimestamp(ts) {
-  if (ts === void 0 || ts === null) return "\u672A\u77E5";
-  try {
-    return new Date(ts * 1e3).toLocaleString("zh-CN");
-  } catch {
-    return "\u672A\u77E5";
-  }
-}
-function formatDate(dateOrIso) {
-  if (dateOrIso === void 0 || dateOrIso === null) return "\u672A\u77E5";
-  try {
-    const d = dateOrIso instanceof Date ? dateOrIso : new Date(dateOrIso);
-    if (Number.isNaN(d.getTime())) return "\u672A\u77E5";
-    return d.toLocaleString("zh-CN");
-  } catch {
-    return "\u672A\u77E5";
-  }
-}
-function hasFlag(args, short, long) {
-  return !!args && (args.includes(short) || args.includes(long));
-}
-function parseIntArg(args, short, long, defaultValue) {
-  if (!args) return defaultValue;
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === short || args[i] === long) {
-      if (i + 1 < args.length) {
-        const val = parseInt(args[i + 1], 10);
-        return Number.isNaN(val) ? defaultValue : val;
-      }
-    }
-  }
-  return defaultValue;
-}
-var VALUE_FLAGS = /* @__PURE__ */ new Set(["-t", "--timeout", "-j", "--concurrency", "-r", "--rounds", "-n", "--lines", "-u", "--update-timeout"]);
-function getNonFlagArg(args, startIdx, valueFlags = VALUE_FLAGS) {
-  if (!args) return null;
-  for (let i = startIdx; i < args.length; i++) {
-    const a = args[i];
-    if (a.startsWith("-")) {
-      if (valueFlags.has(a)) i++;
-      continue;
-    }
-    return a;
-  }
-  return null;
-}
-function isProcessRunning(pid) {
-  if (!pid) return false;
-  try {
-    const result = spawnSync2("ps", ["-p", String(pid), "-o", "pid="], { encoding: "utf8", timeout: 5e3 });
-    return (result.stdout || "").trim().length > 0;
-  } catch {
-    return false;
-  }
-}
-function isProcessRoot(pid) {
-  if (!pid) return false;
-  try {
-    const result = spawnSync2("ps", ["-p", String(pid), "-o", "uid="], { encoding: "utf8", timeout: 5e3 });
-    return (result.stdout || "").trim() === "0";
-  } catch {
-    return false;
-  }
-}
-function createHttpClient(options = {}) {
-  const { timeout = 6e4 } = options;
-  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}` }
-        });
-        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 data = config?.responseType === "json" ? await response.json() : await response.text();
-        return { data, headers: response.headers, status: response.status };
-      } finally {
-        clearTimeout(timer);
-      }
-    }
-  };
-}
-function normalizeMirrorUrl(val) {
-  if (!val) return null;
-  if (val === "direct" || val === "no" || val === "none") return null;
-  let url = val;
-  if (!url.startsWith("http")) {
-    url = `https://${url}`;
-  }
-  if (!url.endsWith("/")) {
-    url += "/";
-  }
-  return url;
-}
-function parseMirrorArg(args) {
-  if (!args || args.length < 2) {
-    return { mirror: null, isOverride: false, type: "download" };
-  }
-  if (args.includes("--no-mirror") || args.includes("--direct")) {
-    return { mirror: null, isOverride: true, type: "download" };
-  }
-  const mirrorAllIdx = args.indexOf("--mirror-all");
-  if (mirrorAllIdx >= 0) {
-    const nextArg = args[mirrorAllIdx + 1];
-    if (!nextArg || nextArg.startsWith("-")) {
-      return { mirror: "https://v6.gh-proxy.org/", isOverride: true, type: "all" };
-    }
-    return { mirror: normalizeMirrorUrl(nextArg), isOverride: true, type: "all" };
-  }
-  const mirrorIdx = args.indexOf("--mirror");
-  if (mirrorIdx >= 0) {
-    const nextArg = args[mirrorIdx + 1];
-    if (!nextArg || nextArg.startsWith("-")) {
-      return { mirror: "https://v6.gh-proxy.org/", isOverride: true, type: "download" };
-    }
-    return { mirror: normalizeMirrorUrl(nextArg), isOverride: true, type: "download" };
-  }
-  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/process.ts
+import path4 from "path";
 var PROCESS_WAIT_ATTEMPTS = 50;
 var PROCESS_WAIT_INTERVAL = 100;
 var STARTUP_WAIT_MS = 800;
@@ -3794,9 +3899,7 @@ var SUDO_TIMEOUT_MS = 6e4;
 var TUN_MODE_POST_WAIT_MS = 500;
 var BATCH_KILL_THRESHOLD = 3;
 var DEFAULT_LOG_RETENTION_DAYS = 7;
-function escapeForPgrep(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
+var MAIN_INSTANCE_PATTERN = `${escapeRegExp(PATHS.mihomoBinary)}.*${escapeRegExp(PATHS.configFile)}`;
 function clearRuntime() {
   if (fs5.existsSync(DIRS.runtime)) {
     rmrf(DIRS.runtime);
@@ -3816,10 +3919,9 @@ function isRunning() {
   const pid = getPid();
   return pid ? isProcessRunning(pid) : false;
 }
-function getAllMihomoPids() {
-  const binaryPath = PATHS.mihomoBinary;
+function getMihomoPids() {
   try {
-    const result = spawnSync3("pgrep", ["-f", escapeForPgrep(binaryPath)], { encoding: "utf8", timeout: 1e4 });
+    const result = spawnSync3("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);
@@ -3837,7 +3939,7 @@ function isPidFileOwnedByRoot() {
   }
 }
 function checkStaleState() {
-  const allPids = getAllMihomoPids();
+  const allPids = getMihomoPids();
   const hasRootProcess = allPids.some((p) => isProcessRoot(p));
   const hasRootPidFile = isPidFileOwnedByRoot();
   return {
@@ -3888,7 +3990,7 @@ function killProcess(pid, needsSudo = false) {
   }
 }
 function killAllMihomo(forceSudo = false) {
-  const pattern = escapeForPgrep(PATHS.mihomoBinary);
+  const pattern = MAIN_INSTANCE_PATTERN;
   if (forceSudo) {
     try {
       spawnSync3("sudo", ["pkill", "-9", "-f", pattern], { stdio: "inherit", timeout: 15e3 });
@@ -3906,7 +4008,7 @@ function killAllMihomo(forceSudo = false) {
   }
 }
 function cleanupAll(forceSudo = false) {
-  const pids = getAllMihomoPids();
+  const pids = getMihomoPids();
   if (pids.length === 0) {
     clearPid();
     return { killed: 0, failed: 0, remaining: [] };
@@ -3937,26 +4039,26 @@ function cleanupAll(forceSudo = false) {
     }
   }
   for (let i = 0; i < PROCESS_WAIT_ATTEMPTS; i++) {
-    if (getAllMihomoPids().length === 0) break;
+    if (getMihomoPids().length === 0) break;
     sleepSync(PROCESS_WAIT_INTERVAL);
   }
   clearPid();
-  return { killed: killedCount, failed: failedPids.length, remaining: getAllMihomoPids() };
+  return { killed: killedCount, failed: failedPids.length, remaining: getMihomoPids() };
 }
 function createTunLaunchScript() {
-  const binary = PATHS.mihomoBinary;
-  const configFile = PATHS.configFile;
-  const logFile = PATHS.logFile;
-  const pidFile = PATHS.pidFile;
-  const dataDir = DIRS.data;
-  const killPattern = escapeForPgrep(binary);
+  const binary = shellQuote(PATHS.mihomoBinary);
+  const configFile = shellQuote(PATHS.configFile);
+  const logFile = shellQuote(PATHS.logFile);
+  const pidFile = shellQuote(PATHS.pidFile);
+  const dataDir = shellQuote(DIRS.data);
+  const killPattern = shellQuote(MAIN_INSTANCE_PATTERN);
   const scriptContent = `#!/bin/bash
-BINARY="${binary}"
-CONFIG_FILE="${configFile}"
-LOG_FILE="${logFile}"
-PID_FILE="${pidFile}"
-DATA_DIR="${dataDir}"
-KILL_PATTERN='${killPattern}'
+BINARY=${binary}
+CONFIG_FILE=${configFile}
+LOG_FILE=${logFile}
+PID_FILE=${pidFile}
+DATA_DIR=${dataDir}
+KILL_PATTERN=${killPattern}
 
 # \u7EC8\u6B62\u65E7\u8FDB\u7A0B
 pkill -9 -f "\${KILL_PATTERN}" 2>/dev/null || true
@@ -3987,7 +4089,7 @@ echo "--- \u65E5\u5FD7 ---"
 tail -25 "\${LOG_FILE}" 2>/dev/null
 exit 1
 `;
-  const scriptPath = path3.join(DIRS.runtime, "launch-tun.sh");
+  const scriptPath = path4.join(DIRS.runtime, "launch-tun.sh");
   fs5.writeFileSync(scriptPath, scriptContent, { mode: 448 });
   return scriptPath;
 }
@@ -4009,7 +4111,7 @@ function getProcessInfo(pid) {
 function getStatus() {
   const running = isRunning();
   const pid = getPid();
-  const allPids = getAllMihomoPids();
+  const allPids = getMihomoPids();
   return {
     running,
     pid: running ? pid : null,
@@ -4059,6 +4161,16 @@ async function startMixedMode(staleState) {
   const configFile = PATHS.configFile;
   const logFile = PATHS.logFile;
   const args = ["-d", DIRS.data, "-f", configFile];
+  if (fs5.existsSync(logFile)) {
+    try {
+      fs5.accessSync(logFile, fs5.constants.W_OK);
+    } catch {
+      try {
+        fs5.unlinkSync(logFile);
+      } catch {
+      }
+    }
+  }
   const logFd = fs5.openSync(logFile, "a");
   const child = spawn(PATHS.mihomoBinary, args, {
     detached: true,
@@ -4121,14 +4233,14 @@ async function startTunMode(staleState) {
   return { success: true, pid: finalPid, mode: "tun" };
 }
 function stop(forceSudo = false) {
-  const allPids = getAllMihomoPids();
+  const allPids = getMihomoPids();
   if (allPids.length === 0) {
     clearPid();
     clearRuntime();
     return { success: true, notRunning: true };
   }
   const result = cleanupAll(forceSudo);
-  const remaining = getAllMihomoPids();
+  const remaining = getMihomoPids();
   if (remaining.length > 0) {
     console.log("");
     console.log("\u4ECD\u6709\u8FDB\u7A0B\u6B8B\u7559\uFF0C\u9700\u8981\u624B\u52A8\u6E05\u7406:");
@@ -4152,9 +4264,8 @@ function rotateLog() {
   if (!fs5.existsSync(logFile)) return null;
   const stat = fs5.statSync(logFile);
   if (stat.size === 0) return null;
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/T/, "_").replace(/:/g, "-").replace(/\..+/, "");
-  const rotatedName = `mihomo.${timestamp}.log`;
-  const rotatedPath = path3.join(DIRS.logs, rotatedName);
+  const rotatedName = `mihomo.${formatLocalTimestamp()}.log`;
+  const rotatedPath = path4.join(DIRS.logs, rotatedName);
   fs5.renameSync(logFile, rotatedPath);
   return rotatedPath;
 }
@@ -4169,7 +4280,7 @@ function cleanupOldLogs(maxAgeDays = DEFAULT_LOG_RETENTION_DAYS) {
   for (const file of files) {
     if (!file.match(/^mihomo\.\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}\.log$/)) continue;
     try {
-      const filePath = path3.join(logsDir, file);
+      const filePath = path4.join(logsDir, file);
       const stat = fs5.statSync(filePath);
       if (now - stat.mtimeMs > maxAgeMs) {
         fs5.unlinkSync(filePath);
@@ -4200,7 +4311,7 @@ function listLogs() {
     const match = file.match(/^mihomo\.(\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2})\.log$/);
     if (!match) continue;
     try {
-      const filePath = path3.join(logsDir, file);
+      const filePath = path4.join(logsDir, file);
       const stat = fs5.statSync(filePath);
       result.archives.push({
         name: file,
@@ -4216,22 +4327,22 @@ function listLogs() {
   return result;
 }
 function isPathUnderDir(filePath, baseDir) {
-  const resolvedPath = path3.resolve(filePath);
-  const resolvedBase = path3.resolve(baseDir);
-  return resolvedPath === resolvedBase || resolvedPath.startsWith(resolvedBase + path3.sep);
+  const resolvedPath = path4.resolve(filePath);
+  const resolvedBase = path4.resolve(baseDir);
+  return resolvedPath === resolvedBase || resolvedPath.startsWith(resolvedBase + path4.sep);
 }
 function getLogPathByName(name) {
   const logsDir = DIRS.logs;
   let targetName = name;
   if (!name.endsWith(".log")) targetName = `mihomo.${name}.log`;
   if (!targetName.startsWith("mihomo.")) targetName = `mihomo.${targetName}`;
-  const filePath = path3.join(logsDir, targetName);
+  const filePath = path4.join(logsDir, targetName);
   if (fs5.existsSync(filePath) && isPathUnderDir(filePath, logsDir)) return filePath;
   if (fs5.existsSync(logsDir)) {
     const files = fs5.readdirSync(logsDir);
     for (const file of files) {
       if (file.includes(name)) {
-        const candidatePath = path3.join(logsDir, file);
+        const candidatePath = path4.join(logsDir, file);
         if (isPathUnderDir(candidatePath, logsDir)) return candidatePath;
       }
     }
@@ -4280,31 +4391,16 @@ function viewLogWithTail(logPath, options) {
 }
 
 // src/daemon.ts
-var LAUNCHCTL_TIMEOUT_MS = 1e4;
-function launchctl(args) {
-  const result = spawnSync4("launchctl", args, { encoding: "utf8", timeout: LAUNCHCTL_TIMEOUT_MS });
-  return {
-    status: result.status,
-    stdout: result.stdout || "",
-    stderr: result.stderr || ""
-  };
-}
-function getUid() {
-  const uid = process.getuid?.();
-  if (uid === void 0) {
-    throw new Error("\u65E0\u6CD5\u83B7\u53D6\u7528\u6237 UID\uFF0C\u4FDD\u6D3B\u529F\u80FD\u4EC5\u652F\u6301 macOS");
+var SERVICE_TARGET = `system/${LAUNCH_DAEMON_LABEL}`;
+var HOT_RELOAD_TIMEOUT_MS = 5e3;
+var DAEMON_BOOT_WAIT_MS = 500;
+var LOG_ROTATE_MAX_BYTES = 10 * 1024 * 1024;
+function logOversized() {
+  try {
+    return fs6.statSync(PATHS.logFile).size > LOG_ROTATE_MAX_BYTES;
+  } catch {
+    return false;
   }
-  return uid;
-}
-function guiDomain(uid) {
-  return `gui/${uid}`;
-}
-function serviceTarget(uid) {
-  return `gui/${uid}/${LAUNCH_AGENT_LABEL}`;
-}
-function launchctlError(action, result) {
-  const detail = (result.stderr || result.stdout || "").trim() || `\u9000\u51FA\u7801 ${result.status}`;
-  return new Error(`launchctl ${action} \u5931\u8D25: ${detail}`);
 }
 function escapeXml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
@@ -4317,7 +4413,7 @@ function buildPlist() {
 <plist version="1.0">
 <dict>
   <key>Label</key>
-  <string>${escapeXml(LAUNCH_AGENT_LABEL)}</string>
+  <string>${escapeXml(LAUNCH_DAEMON_LABEL)}</string>
   <key>ProgramArguments</key>
   <array>
 ${argsXml}
@@ -4336,25 +4432,42 @@ ${argsXml}
 </plist>
 `;
 }
+function runSudoScript(scriptBody, opts) {
+  if (!process.stdin.isTTY) {
+    throw new Error("\u5F53\u524D\u73AF\u5883\u65E0\u6CD5\u8F93\u5165\u7BA1\u7406\u5458\u5BC6\u7801\uFF08\u9700\u8981\u5728\u4EA4\u4E92\u5F0F\u7EC8\u7AEF\u8FD0\u884C sudo\uFF09");
+  }
+  ensureDirs();
+  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 });
+    if (result.error) throw result.error;
+    if (result.status !== 0) {
+      if (result.status === 1) {
+        throw new Error("\u5DF2\u53D6\u6D88\u6216\u5BC6\u7801\u9519\u8BEF");
+      }
+      if (result.status == null) {
+        throw new Error(`${opts.action}\u88AB\u4E2D\u65AD\uFF08sudo \u8FDB\u7A0B\u88AB\u4FE1\u53F7\u7EC8\u6B62\uFF09`);
+      }
+      const custom = opts.codeMessages?.[result.status];
+      throw new Error(custom || `${opts.action}\u5931\u8D25\uFF08\u9000\u51FA\u7801 ${result.status}\uFF09`);
+    }
+  } finally {
+    try {
+      fs6.unlinkSync(scriptPath);
+    } catch {
+    }
+  }
+}
 function isDaemonEnabled() {
-  return fs6.existsSync(PATHS.launchAgentPlist);
+  return fs6.existsSync(PATHS.launchDaemonPlist);
 }
 function getDaemonStatus() {
   if (!isDaemonEnabled()) {
     return { enabled: false, loaded: false, pid: null };
   }
-  const uid = process.getuid?.();
-  if (uid === void 0) {
-    const pids = getAllMihomoPids();
-    return { enabled: true, loaded: pids.length > 0, pid: pids[0] ?? null };
-  }
-  const result = launchctl(["print", serviceTarget(uid)]);
-  if (result.status !== 0) {
-    return { enabled: true, loaded: false, pid: null };
-  }
-  const pidMatch = result.stdout.match(/\bpid = (\d+)/);
-  const pid = pidMatch ? parseInt(pidMatch[1], 10) : null;
-  return { enabled: true, loaded: true, pid };
+  const rootPids = getMihomoPids().filter(isProcessRoot);
+  return { enabled: true, loaded: rootPids.length > 0, pid: rootPids[0] ?? null };
 }
 function isDaemonRunning(status) {
   return status.loaded && status.pid !== null;
@@ -4366,47 +4479,104 @@ function enableDaemon() {
   if (!fs6.existsSync(PATHS.configFile)) {
     throw new Error("\u672A\u627E\u5230\u8FD0\u884C\u65F6\u914D\u7F6E\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605");
   }
-  const uid = getUid();
-  launchctl(["bootout", serviceTarget(uid)]);
-  cleanupAll();
-  fs6.mkdirSync(path4.dirname(PATHS.launchAgentPlist), { recursive: true });
-  atomicWriteFileSync(PATHS.launchAgentPlist, buildPlist(), { mode: 384 });
-  const result = launchctl(["bootstrap", guiDomain(uid), PATHS.launchAgentPlist]);
-  if (result.status !== 0) {
-    launchctl(["bootout", serviceTarget(uid)]);
+  ensureDirs();
+  const stagePath = path5.join(DIRS.runtime, "daemon.plist.stage");
+  atomicWriteFileSync(stagePath, buildPlist(), { mode: 384 });
+  const target = shellQuote(SERVICE_TARGET);
+  const plistDest = shellQuote(PATHS.launchDaemonPlist);
+  const stage = shellQuote(stagePath);
+  const pattern = shellQuote(MAIN_INSTANCE_PATTERN);
+  const script = [
+    "#!/bin/bash",
+    `launchctl bootout ${target} 2>/dev/null || true`,
+    `pkill -9 -f ${pattern} 2>/dev/null || true`,
+    "sleep 0.2",
+    `install -m 644 -o root -g wheel ${stage} ${plistDest} || exit 2`,
+    `launchctl bootstrap system ${plistDest} || { launchctl bootout ${target} 2>/dev/null; rm -f ${plistDest}; exit 3; }`,
+    "exit 0",
+    ""
+  ].join("\n");
+  try {
+    runSudoScript(script, {
+      action: "\u542F\u7528\u4FDD\u6D3B",
+      file: "daemon-enable.sh",
+      codeMessages: {
+        2: "\u5B89\u88C5 plist \u5230 /Library/LaunchDaemons \u5931\u8D25",
+        3: "\u88C5\u8F7D\u4FDD\u6D3B\u670D\u52A1\u5931\u8D25\uFF08launchctl bootstrap\uFF09"
+      }
+    });
+  } finally {
     try {
-      fs6.unlinkSync(PATHS.launchAgentPlist);
+      fs6.unlinkSync(stagePath);
     } catch {
     }
-    throw launchctlError("bootstrap", result);
   }
 }
 function disableDaemon() {
-  const uid = process.getuid?.();
-  if (uid !== void 0) {
-    launchctl(["bootout", serviceTarget(uid)]);
+  if (!isDaemonEnabled()) return;
+  const target = shellQuote(SERVICE_TARGET);
+  const plistDest = shellQuote(PATHS.launchDaemonPlist);
+  const logFile = shellQuote(PATHS.logFile);
+  const dataDir = shellQuote(DIRS.data);
+  const script = [
+    "#!/bin/bash",
+    `launchctl bootout ${target} 2>/dev/null || true`,
+    `rm -f ${plistDest}`,
+    `chown "$SUDO_UID:$SUDO_GID" ${logFile} 2>/dev/null || true`,
+    `chown -R "$SUDO_UID:$SUDO_GID" ${dataDir} 2>/dev/null || true`,
+    "exit 0",
+    ""
+  ].join("\n");
+  runSudoScript(script, { action: "\u5173\u95ED\u4FDD\u6D3B", file: "daemon-disable.sh" });
+  const rootPids = getMihomoPids().filter(isProcessRoot);
+  if (rootPids.length > 0) {
+    console.log("");
+    console.log(`\u4ECD\u6709 root \u5185\u6838\u8FDB\u7A0B\u6B8B\u7559 (PID ${rootPids.join(", ")})`);
+    console.log("\u624B\u52A8\u6E05\u7406: sudo pkill -9 mihomo");
   }
+}
+async function tryHotReload() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), HOT_RELOAD_TIMEOUT_MS);
   try {
-    fs6.unlinkSync(PATHS.launchAgentPlist);
+    const res = await fetch(`${CONTROLLER_BASE_URL}/configs?force=true`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: "{}",
+      signal: controller.signal
+    });
+    return res.status === 204 || res.ok;
   } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
   }
 }
-function restartDaemon() {
-  const uid = getUid();
-  if (!fs6.existsSync(PATHS.launchAgentPlist)) {
+async function restartDaemon() {
+  if (!fs6.existsSync(PATHS.launchDaemonPlist)) {
     throw new Error("\u4FDD\u6D3B\u672A\u542F\u7528\uFF0C\u65E0\u6CD5\u91CD\u542F");
   }
-  if (launchctl(["print", serviceTarget(uid)]).status === 0) {
-    const result2 = launchctl(["kickstart", "-k", serviceTarget(uid)]);
-    if (result2.status !== 0) {
-      throw launchctlError("kickstart", result2);
-    }
-    return;
-  }
-  const result = launchctl(["bootstrap", guiDomain(uid), PATHS.launchAgentPlist]);
-  if (result.status !== 0) {
-    throw launchctlError("bootstrap", result);
-  }
+  if (!logOversized() && await tryHotReload()) return;
+  const target = shellQuote(SERVICE_TARGET);
+  const plistDest = shellQuote(PATHS.launchDaemonPlist);
+  const logFile = shellQuote(PATHS.logFile);
+  const archiveFile = shellQuote(path5.join(DIRS.logs, `mihomo.${formatLocalTimestamp()}.log`));
+  const script = [
+    "#!/bin/bash",
+    `if [ -f ${logFile} ] && [ "$(stat -f%z ${logFile} 2>/dev/null || echo 0)" -gt ${LOG_ROTATE_MAX_BYTES} ]; then`,
+    `  cp ${logFile} ${archiveFile} 2>/dev/null && : > ${logFile}`,
+    "fi",
+    `if launchctl kickstart -k ${target} 2>/dev/null; then exit 0; fi`,
+    `launchctl bootstrap system ${plistDest} || exit 3`,
+    "exit 0",
+    ""
+  ].join("\n");
+  runSudoScript(script, {
+    action: "\u91CD\u542F\u4FDD\u6D3B",
+    file: "daemon-restart.sh",
+    codeMessages: { 3: "\u91CD\u542F\u4FDD\u6D3B\u5931\u8D25\uFF08launchctl bootstrap\uFF09" }
+  });
+  cleanupOldLogs();
 }
 
 // src/subscription.ts
@@ -4419,7 +4589,6 @@ function getDefaultUpdateInterval(url) {
 function resolveUpdateInterval(url, cachedInterval) {
   return cachedInterval && cachedInterval > 0 ? cachedInterval : getDefaultUpdateInterval(url);
 }
-var YAML_DUMP_OPTS = { indent: 2, lineWidth: -1, schema: CORE_SCHEMA };
 var HTTP_CLIENT = createHttpClient({ timeout: 6e4 });
 function isMultiUrl(url) {
   return url.includes(",");
@@ -4443,7 +4612,7 @@ function saveSubscriptionConfig(subName, parsed) {
   normalizeProxyNamesBeforeSave(parsed);
   parsed.raw.proxies = parsed.proxies;
   parsed.raw["proxy-groups"] = parsed.proxyGroups;
-  saveSubscriptionRawConfig(subName, dump(parsed.raw, YAML_DUMP_OPTS));
+  saveSubscriptionRawConfig(subName, dumpYaml(parsed.raw));
 }
 function parseUserInfo(header) {
   if (!header) return null;
@@ -4610,7 +4779,7 @@ async function downloadMergedSubscription(urls, subName, signal) {
     }
   }
   base.proxies = baseProxies;
-  const mergedContent = dump(base, YAML_DUMP_OPTS);
+  const mergedContent = dumpYaml(base);
   saveSubscriptionRawConfig(subName, mergedContent);
   const meta = extractSubscriptionMeta(responses[0].response?.headers);
   saveSubscriptionMeta(subName, meta);
@@ -4706,8 +4875,7 @@ async function autoUpdateStaleSubscription(options = {}) {
   }
   return { total: staleSubs.length, updated: updatedCount, failed: staleSubs.length - updatedCount };
 }
-var API_BASE = `http://${BASE_CONFIG["external-controller"]}`;
-async function testProxyDelay(proxyName, timeout, testUrl, client, apiBase = API_BASE) {
+async function testProxyDelay(proxyName, timeout, testUrl, client, apiBase = CONTROLLER_BASE_URL) {
   const encodedName = encodeURIComponent(proxyName);
   const url = `${apiBase}/proxies/${encodedName}/delay?timeout=${timeout}&url=${encodeURIComponent(testUrl)}`;
   try {
@@ -4729,7 +4897,13 @@ async function testProxyDelay(proxyName, timeout, testUrl, client, apiBase = API
   }
 }
 async function testSubscriptionProxies(subName, options = {}) {
-  const { timeout = DEFAULT_TEST_TIMEOUT, concurrency = DEFAULT_TEST_CONCURRENCY, testUrl = DEFAULT_TEST_URL, apiBase = API_BASE, onResult } = options;
+  const {
+    timeout = DEFAULT_TEST_TIMEOUT,
+    concurrency = DEFAULT_TEST_CONCURRENCY,
+    testUrl = DEFAULT_TEST_URL,
+    apiBase = CONTROLLER_BASE_URL,
+    onResult
+  } = options;
   const { proxies } = options.parsed || loadSubscriptionConfig(subName);
   if (proxies.length === 0) {
     return { total: 0, alive: 0, dead: 0, results: [] };
@@ -4791,7 +4965,8 @@ function cleanDeadProxies(parsed, deadNames) {
       if (group.proxies.length < before) {
         updatedGroups++;
       }
-      if (group.proxies.length === 0) {
+      const hasOtherSource = group.use || group["include-all"] || group["include-all-proxies"];
+      if (group.proxies.length === 0 && !hasOtherSource) {
         removedGroupNames.add(group.name);
       }
     }
@@ -4807,9 +4982,7 @@ function cleanDeadProxies(parsed, deadNames) {
     if (Array.isArray(rules)) {
       parsed.raw.rules = rules.filter((rule) => {
         if (typeof rule !== "string") return true;
-        const parts = rule.split(",");
-        if (parts.length < 2) return true;
-        return !removedGroupNames.has(parts[parts.length - 1].trim());
+        return !removedGroupNames.has(getRuleTarget(rule));
       });
     }
   }
@@ -4904,6 +5077,8 @@ async function cmdDaemon(args) {
       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) {
@@ -4913,6 +5088,7 @@ async function cmdDaemon(args) {
     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();
     return;
   }
@@ -4923,6 +5099,7 @@ async function cmdDaemon(args) {
       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) {
@@ -5009,98 +5186,10 @@ function cmdDirectory(args) {
   console.log("");
 }
 
-// src/commands/help.ts
-function printShortHelp() {
-  console.log(`
-${colors.cyan(colors.bold(`mihomo-cli v${VERSION}`))}  (mihomo help \u67E5\u770B\u5B8C\u6574\u5E2E\u52A9)
-`);
-  console.log(
-    `\u5E38\u7528\u547D\u4EE4:
-  ${colors.bold("start")} [tun|mixed]    \u542F\u52A8/\u5207\u6362\u4EE3\u7406
-  ${colors.bold("sub")} [use|update]     \u8BA2\u9605\u7BA1\u7406
-  ${colors.bold("ow")} [on|off]          \u8986\u5199\u914D\u7F6E
-  ${colors.bold("ui")} [zash|dash|yacd]  \u6253\u5F00 Web UI
-`
-  );
-}
-function printHelp() {
-  console.log(
-    `
-${colors.cyan(colors.bold(`mihomo-cli v${VERSION}`))}
-
-\u547D\u4EE4\u522B\u540D: mihomo, mhm, mh
-
-\u7528\u6CD5:
-  mihomo <\u547D\u4EE4> [\u9009\u9879]
-
-${colors.cyan("\u63A7\u5236:")}
-  ${colors.bold("start")} [tun|mixed] [-s] [-u ms]     \u542F\u52A8/\u5207\u6362\u4EE3\u7406 (\u9ED8\u8BA4 mixed)
-        [-r N] [-t ms] [-j N]
-  ${colors.bold("stop")}                         \u505C\u6B62\u4EE3\u7406
-  ${colors.bold("status")}                       \u67E5\u770B\u72B6\u6001
-
-${colors.cyan("\u754C\u9762:")}
-  ${colors.bold("ui")} [zash|dash|yacd]          \u6253\u5F00 Web UI (\u9ED8\u8BA4 zash)
-  ${colors.bold("log")} [-o]                     \u5B9E\u65F6\u65E5\u5FD7\uFF08-o \u6253\u5F00\u6587\u4EF6\uFF09
-  ${colors.bold("logs")} [\u7F16\u53F7] [-n N] [-o]      \u65E5\u5FD7\u5217\u8868\uFF080=\u5F53\u524D\uFF0C1+=\u5F52\u6863\uFF09
-
-${colors.cyan("\u8BA2\u9605:")}
-  ${colors.bold("subscription")}                 \u5217\u51FA\u6240\u6709\u8BA2\u9605\uFF08\u522B\u540D sub\uFF09
-  ${colors.bold("subscription")} use <name>      \u5207\u6362\u5F53\u524D\u8BA2\u9605
-  ${colors.bold("subscription")} add <url> [name]  \u6DFB\u52A0\u8BA2\u9605
-  ${colors.bold("subscription")} update [name]   \u66F4\u65B0\u8BA2\u9605\uFF08\u65E0\u53C2\u66F4\u65B0\u6240\u6709\uFF09
-  ${colors.bold("subscription")} remove <name>   \u5220\u9664\u8BA2\u9605
-  ${colors.bold("subscription")} web [name]      \u6253\u5F00\u8BA2\u9605\u9875\u9762
-  ${colors.bold("subscription")} test [name]     \u6D4B\u8BD5\u8282\u70B9\u8FDE\u901A\u6027
-  ${colors.bold("subscription")} clean [name]    \u6D4B\u901F\u5E76\u6E05\u7406\u5931\u8D25\u8282\u70B9
-  ${colors.bold("test")} [-t ms] [-j N]           \u5FEB\u901F\u6D4B\u8BD5\u5F53\u524D\u8282\u70B9\u8FDE\u901A\u6027
-  ${colors.bold("clean")} [-t ms] [-j N] [-r N]   \u6E05\u7406\u5931\u8D25\u8282\u70B9\u5E76\u81EA\u52A8\u91CD\u542F
-
-${colors.cyan("\u914D\u7F6E:")}
-  ${colors.bold("overwrite")}                   \u67E5\u770B\u8986\u5199\u72B6\u6001\uFF08\u522B\u540D ow\uFF09
-  ${colors.bold("overwrite")} on|off            \u542F\u7528/\u7981\u7528\u8986\u5199\u914D\u7F6E
-  ${colors.bold("directory")}                   \u663E\u793A\u6570\u636E\u76EE\u5F55\u4F4D\u7F6E\uFF08\u522B\u540D dir\uFF09
-  ${colors.bold("directory")} open [target]     \u6253\u5F00\u76EE\u5F55: root|subs|logs|runtime|...
-
-${colors.cyan("\u7CFB\u7EDF:")}
-  ${colors.bold("kernel")} [--mirror [\u955C\u50CF]]         \u66F4\u65B0\u5185\u6838\uFF08\u9ED8\u8BA4\u76F4\u8FDE\uFF0C--mirror \u4F7F\u7528 v6\uFF09
-  ${colors.bold("daemon")} on|off               \u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u91CD\u542F\uFF08\u4EC5 Mixed\uFF09
-  ${colors.bold("daemon")} status               \u67E5\u770B\u4FDD\u6D3B\u72B6\u6001
-  ${colors.bold("update")}                       \u66F4\u65B0 mihomo-cli (npm install -g)
-  ${colors.bold("reset")} [\u76EE\u6807...] [--full]   \u91CD\u7F6E: \u7559\u7A7A\u4FDD\u7559\u8BBE\u7F6E/\u5185\u6838/\u8986\u5199, \u6307\u5B9A\u76EE\u6807\u5220\u5BF9\u5E94\u9879, --full \u5220\u5168\u90E8
-  ${colors.bold("help")}, -h                     \u663E\u793A\u5E2E\u52A9
-  ${colors.bold("version")}, -v                  \u663E\u793A\u7248\u672C
-
-${colors.cyan("\u793A\u4F8B:")}
-  mihomo start              # \u542F\u52A8/\u91CD\u542F Mixed \u6A21\u5F0F
-  mihomo start tun          # \u5207\u6362\u5230 TUN \u900F\u660E\u4EE3\u7406\u6A21\u5F0F
-  mihomo start -s           # \u8DF3\u8FC7\u81EA\u52A8\u66F4\u65B0\u8BA2\u9605
-  mihomo start -u 30000     # \u81EA\u52A8\u66F4\u65B0\u8D85\u65F6 30 \u79D2 (\u9ED8\u8BA4 10s)
-  mihomo daemon on          # \u5F00\u542F\u4FDD\u6D3B\uFF08\u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u91CD\u542F\uFF09
-  mihomo sub add <url>      # \u6DFB\u52A0\u8BA2\u9605 (sub \u662F subscription \u522B\u540D)
-  mihomo ui                 # \u6253\u5F00 Web UI
-
-${colors.cyan("\u6A21\u5F0F\u8BF4\u660E:")}
-  mixed  HTTP + SOCKS5 \u6DF7\u5408\u7AEF\u53E3 (\u9ED8\u8BA4)
-  tun    \u900F\u660E\u4EE3\u7406\uFF0C\u5168\u5C40\u81EA\u52A8\u8DEF\u7531\uFF0C\u9700\u8981 sudo
-
-${colors.cyan("\u6570\u636E\u76EE\u5F55:")}
-  \u73AF\u5883\u53D8\u91CF MIHOMO_CLI_DIR \u53EF\u81EA\u5B9A\u4E49\u4F4D\u7F6E
-  \u9ED8\u8BA4: ${USER_DATA_DIR}
-`
-  );
-}
-function printVersion() {
-  const kv = getKernelVersion() || "\u672A\u5B89\u88C5";
-  console.log(colors.cyan(colors.bold(`mihomo-cli v${VERSION}`)));
-  console.log(`${colors.gray("\u5185\u6838: ")}${kv}`);
-  console.log(`${colors.gray("\u6570\u636E\u76EE\u5F55: ")}${USER_DATA_DIR}`);
-}
-
 // src/kernel.ts
 import { spawnSync as spawnSync5 } from "child_process";
 import fs7 from "fs";
-import path5 from "path";
+import path6 from "path";
 
 // node_modules/compare-versions/lib/esm/utils.js
 var semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
@@ -5185,7 +5274,7 @@ function findMatchingAsset(assets, platform, arch) {
     const nameWithoutGz = a.name.slice(0, -3);
     const parts = nameWithoutGz.split("-");
     const lastPart = parts[parts.length - 1];
-    return /^v?\d+\.\d+\.\d+/.test(lastPart) && !nameWithoutGz.includes("-go");
+    return /^v?\d+\.\d+\.\d+/.test(lastPart) && !nameWithoutGz.includes("-go") && !nameWithoutGz.includes("-compatible");
   });
   return standardAsset || matchingAssets[0];
 }
@@ -5228,7 +5317,7 @@ function findBinaryInDir(dir, maxDepth = 4) {
   if (maxDepth <= 0) return null;
   const files = fs7.readdirSync(dir);
   for (const f of files) {
-    const fullPath = path5.join(dir, f);
+    const fullPath = path6.join(dir, f);
     const stat = fs7.statSync(fullPath);
     if (stat.isDirectory()) {
       const found = findBinaryInDir(fullPath, maxDepth - 1);
@@ -5255,7 +5344,7 @@ async function downloadKernel(progressCallback, mirror, releaseInfo) {
   \u5E73\u53F0: ${platform}, \u67B6\u6784: ${arch}${hint}`);
   }
   const downloadUrl = withMirror(asset.browser_download_url, mirror);
-  const tempPath = path5.join(DIRS.kernel, asset.name);
+  const tempPath = path6.join(DIRS.kernel, asset.name);
   const sizeMB = (asset.size / 1024 / 1024).toFixed(2);
   if (mirror && progressCallback) {
     progressCallback("\u63D0\u793A: \u7ECF\u7B2C\u4E09\u65B9\u955C\u50CF\u4E2D\u8F6C\u4E0B\u8F7D\uFF0C\u65E0\u6CD5\u9A8C\u8BC1\u6765\u6E90\u5B8C\u6574\u6027\uFF0C\u5EFA\u8BAE\u76F4\u8FDE\u6216\u81EA\u884C\u6821\u9A8C\u4EA7\u7269");
@@ -5289,8 +5378,8 @@ async function downloadKernel(progressCallback, mirror, releaseInfo) {
       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 = path5.basename(tempPath, ".gz");
-      const outputPath = path5.join(extractPath, baseName);
+      const baseName = path6.basename(tempPath, ".gz");
+      const outputPath = path6.join(extractPath, baseName);
       const gzipResult = spawnSync5("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}`);
@@ -5357,20 +5446,8 @@ async function cmdKernel(args) {
   if (effectiveMirror) {
     const mirrorDesc = mirrorInfo.type === "all" ? " (API\u548C\u4E0B\u8F7D\u5747\u4F7F\u7528\u955C\u50CF)" : " (\u4E0B\u8F7D\u65F6\u4F7F\u7528\u955C\u50CF)";
     console.log(`\u955C\u50CF: ${effectiveMirror}${mirrorDesc}`);
+    console.log("");
   }
-  console.log("\n\u63D0\u793A: \u5982\u679C\u4E0B\u8F7D\u901F\u5EA6\u8FC7\u6162\u6216\u76F4\u8FDE\u5931\u8D25\uFF0C\u53EF\u4F7F\u7528 --mirror \u53C2\u6570\u901A\u8FC7\u955C\u50CF\u4E0B\u8F7D");
-  console.log("\n\u7528\u6CD5:");
-  console.log("  mihomo kernel                    # \u76F4\u8FDE");
-  console.log("  mihomo kernel --mirror           # \u4E0B\u8F7D\u4F7F\u7528\u9ED8\u8BA4\u955C\u50CF (v6.gh-proxy.org)");
-  console.log("  mihomo kernel --mirror hk.gh-proxy.org  # \u4E0B\u8F7D\u4F7F\u7528\u6307\u5B9A\u955C\u50CF");
-  console.log("  mihomo kernel --mirror-all       # API\u8BF7\u6C42\u548C\u4E0B\u8F7D\u90FD\u4F7F\u7528\u9ED8\u8BA4\u955C\u50CF");
-  console.log("  mihomo kernel --mirror-all hk.gh-proxy.org  # API\u548C\u4E0B\u8F7D\u90FD\u4F7F\u7528\u6307\u5B9A\u955C\u50CF");
-  console.log("\n\u53EF\u7528\u955C\u50CF:");
-  for (const m of AVAILABLE_MIRRORS) {
-    const isCurrent = effectiveMirror && (effectiveMirror.includes(`//${m}/`) || effectiveMirror.includes(`//${m}:`) || effectiveMirror.endsWith(`//${m}`));
-    console.log(`  ${m}${isCurrent ? " (\u5F53\u524D)" : ""}`);
-  }
-  console.log("");
   console.log("\u68C0\u67E5\u5185\u6838\u66F4\u65B0...");
   try {
     const apiMirror = mirrorInfo.type === "all" ? effectiveMirror : null;
@@ -5397,6 +5474,13 @@ async function cmdKernel(args) {
         console.error(`\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(", ")}`);
+    }
     process.exit(1);
   }
 }
@@ -5484,18 +5568,43 @@ function cmdLogs(args) {
 }
 
 // src/commands/overwrite.ts
-import path7 from "path";
+import path8 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/commands/status.ts
 function printStatus() {
   const status = getStatus();
-  const daemon = getDaemonStatus();
+  const state = getRunningState();
   const info = getConfigInfo();
   const overwriteEnabled = isOverwriteEnabled();
   const overwriteFiles = listOverwriteFile().files;
   const activeSub = getActiveSubscription();
-  const running = daemon.enabled ? isDaemonRunning(daemon) : status.running;
-  const pid = daemon.enabled ? daemon.pid : status.pid;
+  const { running, pid, daemon: daemonManaged } = state;
   console.log("");
   let modeLabel = "";
   if (info && running) {
@@ -5506,7 +5615,7 @@ function printStatus() {
   console.log(`${colors.gray("\u5185\u6838: ")}${status.kernelVersion || "\u672A\u5B89\u88C5"}`);
   if (pid) {
     console.log(`${colors.gray("PID:  ")}${pid}`);
-    if (!daemon.enabled && status.processInfo) {
+    if (!daemonManaged && status.processInfo) {
       console.log(`${colors.gray("\u5185\u5B58: ")}${status.processInfo.memory}`);
     }
   }
@@ -5537,7 +5646,7 @@ function printStatus() {
   } else {
     console.log(`${colors.gray("\u8986\u5199: ")}${colors.yellow("\u5DF2\u7981\u7528")}`);
   }
-  if (daemon.enabled) {
+  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("");
@@ -5557,7 +5666,7 @@ async function cmdStop() {
     console.log("\u76F4\u63A5\u505C\u6B62\u4F1A\u88AB\u81EA\u52A8\u91CD\u65B0\u62C9\u8D77\uFF0C\u8BF7\u7528: mihomo daemon off");
     return;
   }
-  const pids = getAllMihomoPids();
+  const pids = getMihomoPids();
   if (pids.length === 0) {
     console.log(colors.yellow("\u4E0D\u5728\u8FD0\u884C"));
     return;
@@ -5570,7 +5679,7 @@ async function cmdStop() {
 // src/test-instance.ts
 import { spawn as spawn2 } from "child_process";
 import fs8 from "fs";
-import path6 from "path";
+import path7 from "path";
 
 // src/lifecycle.ts
 var cleanupFns = /* @__PURE__ */ new Set();
@@ -5591,15 +5700,15 @@ function runCleanup() {
 }
 
 // src/test-instance.ts
-var TEST_DIR = path6.join(USER_DATA_DIR, "test");
+var TEST_DIR = path7.join(USER_DATA_DIR, "test");
 var TEST_DIRS = {
-  data: path6.join(TEST_DIR, "data"),
-  runtime: path6.join(TEST_DIR, "runtime")
+  data: path7.join(TEST_DIR, "data"),
+  runtime: path7.join(TEST_DIR, "runtime")
 };
 var TEST_PATHS = {
-  configFile: path6.join(TEST_DIRS.runtime, "config.yaml"),
-  pidFile: path6.join(TEST_DIRS.runtime, "pid"),
-  logFile: path6.join(TEST_DIR, "test.log")
+  configFile: path7.join(TEST_DIRS.runtime, "config.yaml"),
+  pidFile: path7.join(TEST_DIRS.runtime, "pid"),
+  logFile: path7.join(TEST_DIR, "test.log")
 };
 var TEST_API = `http://${TEST_CONFIG["external-controller"]}`;
 function ensureTestDirs() {
@@ -5641,7 +5750,7 @@ function buildTestConfig(subName) {
     ],
     rules: ["MATCH,PROXY"]
   };
-  const content = dump(config, { indent: 2, lineWidth: -1, schema: CORE_SCHEMA });
+  const content = dumpYaml(config);
   fs8.writeFileSync(TEST_PATHS.configFile, content, { mode: 384 });
 }
 async function startTestInstance() {
@@ -5811,6 +5920,12 @@ function resolveTestTarget(args) {
   }
   return { target, timeout, concurrency };
 }
+function printRestartHintIfRunning() {
+  if (getRunningState().running) {
+    console.log(colors.yellow("\u63D0\u793A: \u8FD0\u884C\u4E2D\u7684\u5B9E\u4F8B\u4ECD\u4F7F\u7528\u65E7\u914D\u7F6E\uFF0C\u6267\u884C mihomo start \u4F7F\u66F4\u65B0\u751F\u6548"));
+    console.log("");
+  }
+}
 async function printSubscriptionList(options) {
   if (options?.autoUpdate !== false) {
     const updateResult = await autoUpdateStaleSubscription();
@@ -5934,6 +6049,7 @@ async function cmdSubscription(args) {
       }
       if (ok === 0) process.exit(1);
       console.log("");
+      printRestartHintIfRunning();
       await printSubscriptionList();
       return;
     }
@@ -5947,6 +6063,7 @@ async function cmdSubscription(args) {
     }
     console.log(`\u5DF2\u66F4\u65B0 (${formatProxySummary(result)})`);
     console.log("");
+    printRestartHintIfRunning();
     await printSubscriptionList();
     return;
   }
@@ -5971,9 +6088,8 @@ async function cmdSubscription(args) {
       await printSubscriptionList();
       return;
     }
-    const status = getStatus();
-    const configInfo = getConfigInfo();
-    const currentMode = isDaemonEnabled() ? "mixed" : configInfo?.tun ? "tun" : "mixed";
+    const currentMode = getRuntimeMode();
+    const restartNeeded = isRestartNeededOnChange();
     const success = setDefaultSubscription(target.name);
     if (success) {
       console.log(`\u5DF2\u5207\u6362\u5230 "${target.name}"`);
@@ -5981,7 +6097,7 @@ async function cmdSubscription(args) {
       console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u8BA2\u9605 "${name}"`);
       process.exit(1);
     }
-    if (status.running || isDaemonEnabled()) {
+    if (restartNeeded) {
       console.log("");
       await cmdStart(["start", currentMode]);
       return;
@@ -6075,8 +6191,7 @@ async function cmdSubscription(args) {
       console.log(colors.yellow("\u5B58\u6D3B\u8282\u70B9\u4E0D\u8DB3 1%\uFF0C\u8DF3\u8FC7\u6E05\u7406\u3002\u8BF7\u68C0\u67E5\u539F\u59CB\u8BA2\u9605\u662F\u5426\u6709\u6548"));
     } else if (result.removedProxies > 0) {
       console.log(`${colors.green("\u5DF2\u6E05\u7406")}: ${formatCleanSummary(result)}`);
-      const status = getStatus();
-      if (status.running) {
+      if (getRunningState().running) {
         console.log("");
         console.log("\u63D0\u793A: \u9700\u8981\u91CD\u542F mihomo \u4F7F\u66F4\u6539\u751F\u6548 (mihomo start)");
       }
@@ -6107,7 +6222,6 @@ async function cmdSubscription(args) {
 }
 
 // src/commands/start.ts
-var DAEMON_RESTART_WAIT_MS = 500;
 async function cmdStart(args) {
   if (!hasKernel()) {
     console.error('\u9519\u8BEF: \u672A\u627E\u5230\u5185\u6838\uFF0C\u8BF7\u8FD0\u884C "mihomo kernel"');
@@ -6133,15 +6247,6 @@ async function cmdStart(args) {
   if (!skipUpdate) {
     await autoUpdateStaleSubscription({ timeout: updateTimeout });
   }
-  async function launchOrRestart() {
-    if (daemonEnabled) {
-      restartDaemon();
-      await sleep(DAEMON_RESTART_WAIT_MS);
-      return getDaemonStatus().pid;
-    }
-    const result = await start(targetMode);
-    return result.pid;
-  }
   if (!daemonEnabled) {
     const status = getStatus();
     const hasProcess = status.running || status.allProcesses.length > 0;
@@ -6165,7 +6270,7 @@ async function cmdStart(args) {
   const modeLabel = targetMode === "tun" ? "TUN" : "Mixed";
   console.log([colors.cyan(modeLabel), sub.name, formatProxySummary(configInfo)].join(" \xB7 "));
   try {
-    const pid = await launchOrRestart();
+    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) {
@@ -6202,7 +6307,7 @@ async function cmdStart(args) {
       if (!daemonEnabled) handleStopResult(stop());
       try {
         configInfo = prepareConfigForStart(targetMode, sub.name);
-        const pid = await launchOrRestart();
+        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]}`);
@@ -6223,8 +6328,8 @@ function printOverwriteList() {
   if (info.files.length === 0) {
     console.log("\u6682\u65E0\u8986\u5199\u6587\u4EF6");
     console.log("");
-    console.log(`\u7528\u6CD5\u793A\u4F8B: \u521B\u5EFA\u6587\u4EF6 ${path7.join(info.dir, "overwrite.yaml")}`);
-    console.log(`         \u6216        ${path7.join(info.dir, "overwrite.dns.yaml")}`);
+    console.log(`\u7528\u6CD5\u793A\u4F8B: \u521B\u5EFA\u6587\u4EF6 ${path8.join(info.dir, "overwrite.yaml")}`);
+    console.log(`         \u6216        ${path8.join(info.dir, "overwrite.dns.yaml")}`);
     console.log("");
   } else {
     console.log(`${colors.cyan("\u8986\u5199\u6587\u4EF6")} (${info.files.length} \u4E2A\uFF0C\u6309\u987A\u5E8F\u52A0\u8F7D):`);
@@ -6244,9 +6349,8 @@ function printOverwriteList() {
 }
 async function cmdOverwrite(args) {
   const action = args?.[1];
-  const status = getStatus();
-  const configInfo = getConfigInfo();
-  const currentMode = isDaemonEnabled() ? "mixed" : configInfo?.tun ? "tun" : "mixed";
+  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");
@@ -6256,7 +6360,7 @@ async function cmdOverwrite(args) {
     }
     setOverwriteEnabled(true);
     console.log("\u5DF2\u542F\u7528\u8986\u5199\u914D\u7F6E");
-    if (status.running || isDaemonEnabled()) {
+    if (restartNeeded) {
       console.log("");
       await cmdStart(["start", currentMode]);
       return;
@@ -6274,7 +6378,7 @@ async function cmdOverwrite(args) {
     }
     setOverwriteEnabled(false);
     console.log("\u5DF2\u7981\u7528\u8986\u5199\u914D\u7F6E");
-    if (status.running || isDaemonEnabled()) {
+    if (restartNeeded) {
       console.log("");
       await cmdStart(["start", currentMode]);
       return;
@@ -6344,7 +6448,7 @@ var RESET_TARGETS = [
     paths: () => {
       const dir = USER_DATA_DIR;
       if (!fs9.existsSync(dir)) return [];
-      return fs9.readdirSync(dir).filter((f) => f === "overwrite.yaml" || /^overwrite\..+\.ya?ml$/.test(f)).map((f) => `${dir}/${f}`);
+      return fs9.readdirSync(dir).filter(isOverwriteFilename).map((f) => `${dir}/${f}`);
     },
     needsStop: false
   },
@@ -6352,8 +6456,9 @@ var RESET_TARGETS = [
     id: "daemon",
     aliases: ["daemon"],
     label: "\u4FDD\u6D3B",
-    // 删除全部交给 onAfter：disableDaemon 会先 bootout 卸载、再删 plist、再兜底清理进程，
-    // 顺序正确（先卸载再删文件）；此处返回空避免提前删掉 plist 破坏卸载。
+    // 卸载由确认后的 disablesDaemon 段统一处理（需 sudo，受取消保护）；
+    // 此处 paths 返回空（plist 在系统目录，用户态删不掉，且不应提前删破坏卸载），
+    // onAfter 因幂等守卫（plist 已删）成为 no-op，仅作单独 reset 未走前段时的兜底。
     paths: () => [],
     needsStop: false,
     onAfter: () => disableDaemon(),
@@ -6421,8 +6526,9 @@ async function cmdReset(args) {
   const needsStop = targets.some((t) => t.needsStop);
   const warnRunning = targets.some((t) => t.warnIfRunning);
   const kernelTargeted = targets.some((t) => t.id === "kernel");
-  const disablesDaemon = needsStop || kernelTargeted;
-  const pids = needsStop || warnRunning ? getAllMihomoPids() : [];
+  const daemonTargeted = targets.some((t) => t.id === "daemon");
+  const disablesDaemon = needsStop || kernelTargeted || daemonTargeted;
+  const pids = needsStop || warnRunning ? getMihomoPids() : [];
   if (warnRunning && pids.length > 0) {
     console.log(colors.yellow(`\u8B66\u544A: mihomo \u6B63\u5728\u8FD0\u884C (PID ${pids.join(", ")})\uFF0C\u5220\u9664\u5185\u6838\u540E\u5C06\u65E0\u6CD5\u91CD\u65B0\u542F\u52A8`));
   }
@@ -6435,13 +6541,18 @@ async function cmdReset(args) {
     return;
   }
   if (disablesDaemon && isDaemonEnabled()) {
-    disableDaemon();
+    try {
+      disableDaemon();
+    } catch (e) {
+      console.error(`${colors.red("\u4FDD\u6D3B\u5173\u95ED\u5DF2\u53D6\u6D88\uFF0C\u91CD\u7F6E\u4E2D\u6B62:")} ${e.message.split("\n")[0]}`);
+      return;
+    }
   }
-  if (needsStop && getAllMihomoPids().length > 0) {
+  if (needsStop && getMihomoPids().length > 0) {
     console.log("\u505C\u6B62\u8FDB\u7A0B...");
     cleanupAll();
     for (let i = 0; i < PROCESS_WAIT_ATTEMPTS; i++) {
-      if (getAllMihomoPids().length === 0) break;
+      if (getMihomoPids().length === 0) break;
       await new Promise((r) => setTimeout(r, PROCESS_WAIT_INTERVAL));
     }
   }
@@ -6466,16 +6577,10 @@ async function cmdReset(args) {
 
 // src/commands/test.ts
 function requireRunning() {
-  if (isDaemonEnabled()) {
-    if (!isDaemonRunning(getDaemonStatus())) {
-      console.error("\u9519\u8BEF: mihomo \u672A\u8FD0\u884C\uFF0C\u8BF7\u5148\u542F\u52A8 (mihomo daemon on)");
-      process.exit(1);
-    }
-    return;
-  }
-  const status = getStatus();
-  if (!status.running) {
-    console.error("\u9519\u8BEF: mihomo \u672A\u8FD0\u884C\uFF0C\u8BF7\u5148\u542F\u52A8 (mihomo start)");
+  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);
   }
 }
@@ -6532,21 +6637,17 @@ async function cmdClean(args) {
     console.log(`${colors.green("\u5DF2\u6E05\u7406")}: ${formatCleanSummary(result)}`);
     console.log("");
     console.log("\u91CD\u542F mihomo \u4F7F\u66F4\u6539\u751F\u6548...");
-    if (isDaemonEnabled()) {
-      const configInfo = prepareConfigForStart("mixed", activeSub.name);
-      try {
-        restartDaemon();
-      } catch (e) {
-        console.error(`${colors.red("\u91CD\u542F\u5931\u8D25:")} ${e.message.split("\n")[0]}`);
-        process.exit(1);
-      }
-      console.log(`${colors.green("\u5DF2\u91CD\u542F (\u4FDD\u6D3B)")} \xB7 ${formatProxySummary(configInfo)}`);
-    } else {
-      const currentMode = getConfigInfo()?.tun ? "tun" : "mixed";
-      handleStopResult(stop());
-      const configInfo = prepareConfigForStart(currentMode, activeSub.name);
-      const startResult = await start(currentMode);
-      console.log(`${colors.green("\u5DF2\u91CD\u542F")} (PID ${startResult.pid}) \xB7 ${formatProxySummary(configInfo)}`);
+    const mode = getRuntimeMode();
+    const daemonManaged = isDaemonEnabled();
+    try {
+      if (!daemonManaged) handleStopResult(stop());
+      const configInfo = prepareConfigForStart(mode, activeSub.name);
+      const pid = await launchOrRestart(mode);
+      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);
     }
   }
 }
@@ -6607,6 +6708,199 @@ async function cmdUpdate() {
   }
 }
 
+// src/commands/registry.ts
+var COMMANDS = [
+  // === 控制 ===
+  {
+    name: "start",
+    aliases: ["up"],
+    handler: cmdStart,
+    group: "control",
+    usage: ["start [tun|mixed] [-s] [-u ms]     \u542F\u52A8/\u5207\u6362\u4EE3\u7406 (\u9ED8\u8BA4 mixed)", "      [-r N] [-t ms] [-j N]"]
+  },
+  {
+    name: "tun",
+    aliases: [],
+    handler: cmdStart,
+    rewrite: (args) => ["start", "tun", ...args.slice(1)],
+    group: "control",
+    usage: []
+  },
+  {
+    name: "stop",
+    aliases: ["down"],
+    handler: cmdStop,
+    group: "control",
+    usage: ["stop                         \u505C\u6B62\u4EE3\u7406"]
+  },
+  {
+    name: "status",
+    aliases: [],
+    handler: printStatus,
+    group: "control",
+    usage: ["status                       \u67E5\u770B\u72B6\u6001"]
+  },
+  // === 界面 ===
+  {
+    name: "ui",
+    aliases: [],
+    handler: cmdUI,
+    group: "interface",
+    usage: ["ui [zash|dash|yacd]          \u6253\u5F00 Web UI (\u9ED8\u8BA4 zash)"]
+  },
+  {
+    name: "log",
+    aliases: [],
+    handler: cmdLog,
+    group: "interface",
+    usage: ["log [-o]                     \u5B9E\u65F6\u65E5\u5FD7\uFF08-o \u6253\u5F00\u6587\u4EF6\uFF09"]
+  },
+  {
+    name: "logs",
+    aliases: [],
+    handler: cmdLogs,
+    group: "interface",
+    usage: ["logs [\u7F16\u53F7] [-n N] [-o]      \u65E5\u5FD7\u5217\u8868\uFF080=\u5F53\u524D\uFF0C1+=\u5F52\u6863\uFF09"]
+  },
+  // === 订阅 ===
+  {
+    name: "subscription",
+    aliases: ["sub", "subscriptions"],
+    handler: cmdSubscription,
+    group: "subscription",
+    usage: [
+      "subscription                 \u5217\u51FA\u6240\u6709\u8BA2\u9605\uFF08\u522B\u540D sub\uFF09",
+      "subscription use <name>      \u5207\u6362\u5F53\u524D\u8BA2\u9605",
+      "subscription add <url> [name]  \u6DFB\u52A0\u8BA2\u9605",
+      "subscription update [name]   \u66F4\u65B0\u8BA2\u9605\uFF08\u65E0\u53C2\u66F4\u65B0\u6240\u6709\uFF09",
+      "subscription remove <name>   \u5220\u9664\u8BA2\u9605",
+      "subscription web [name]      \u6253\u5F00\u8BA2\u9605\u9875\u9762",
+      "subscription test [name]     \u6D4B\u8BD5\u8282\u70B9\u8FDE\u901A\u6027",
+      "subscription clean [name]    \u6D4B\u901F\u5E76\u6E05\u7406\u5931\u8D25\u8282\u70B9"
+    ]
+  },
+  {
+    name: "use",
+    aliases: [],
+    handler: cmdSubscription,
+    rewrite: (args) => ["sub", "use", ...args.slice(1)],
+    group: "subscription",
+    usage: []
+  },
+  {
+    name: "test",
+    aliases: [],
+    handler: cmdTest,
+    group: "subscription",
+    usage: ["test [-t ms] [-j N]           \u5FEB\u901F\u6D4B\u8BD5\u5F53\u524D\u8282\u70B9\u8FDE\u901A\u6027"]
+  },
+  {
+    name: "clean",
+    aliases: [],
+    handler: cmdClean,
+    group: "subscription",
+    usage: ["clean [-t ms] [-j N] [-r N]   \u6E05\u7406\u5931\u8D25\u8282\u70B9\u5E76\u81EA\u52A8\u91CD\u542F"]
+  },
+  // === 配置 ===
+  {
+    name: "overwrite",
+    aliases: ["ow"],
+    handler: cmdOverwrite,
+    group: "config",
+    usage: ["overwrite                   \u67E5\u770B\u8986\u5199\u72B6\u6001\uFF08\u522B\u540D ow\uFF09", "overwrite on|off            \u542F\u7528/\u7981\u7528\u8986\u5199\u914D\u7F6E"]
+  },
+  {
+    name: "on",
+    aliases: [],
+    handler: cmdOverwrite,
+    rewrite: () => ["ow", "on"],
+    group: "config",
+    usage: []
+  },
+  {
+    name: "off",
+    aliases: [],
+    handler: cmdOverwrite,
+    rewrite: () => ["ow", "off"],
+    group: "config",
+    usage: []
+  },
+  {
+    name: "directory",
+    aliases: ["dir", "dirs", "directories"],
+    handler: cmdDirectory,
+    group: "config",
+    usage: ["directory                   \u663E\u793A\u6570\u636E\u76EE\u5F55\u4F4D\u7F6E\uFF08\u522B\u540D dir\uFF09", "directory open [target]     \u6253\u5F00\u76EE\u5F55: root|subs|logs|runtime|..."]
+  },
+  {
+    name: "open",
+    aliases: [],
+    handler: cmdDirectory,
+    rewrite: (args) => ["dir", "open", ...args.slice(1)],
+    group: "config",
+    usage: []
+  },
+  // === 系统 ===
+  {
+    name: "kernel",
+    aliases: [],
+    handler: cmdKernel,
+    group: "system",
+    usage: ["kernel [--mirror [\u955C\u50CF]]         \u66F4\u65B0\u5185\u6838\uFF08\u9ED8\u8BA4\u76F4\u8FDE\uFF0C--mirror \u4F7F\u7528 v6\uFF09"]
+  },
+  {
+    name: "daemon",
+    aliases: [],
+    handler: cmdDaemon,
+    group: "system",
+    usage: ["daemon on|off               \u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u91CD\u542F\uFF08\u4EC5 Mixed\uFF0C\u9700\u7BA1\u7406\u5458\u5BC6\u7801\uFF09", "daemon status               \u67E5\u770B\u4FDD\u6D3B\u72B6\u6001"]
+  },
+  {
+    name: "update",
+    aliases: ["upd", "upgrade"],
+    handler: cmdUpdate,
+    group: "system",
+    usage: ["update                       \u66F4\u65B0 mihomo-cli (npm install -g)"]
+  },
+  {
+    name: "reset",
+    aliases: [],
+    handler: cmdReset,
+    group: "system",
+    usage: ["reset [\u76EE\u6807...] [--full]   \u91CD\u7F6E: \u7559\u7A7A\u4FDD\u7559\u8BBE\u7F6E/\u5185\u6838/\u8986\u5199, \u6307\u5B9A\u76EE\u6807\u5220\u5BF9\u5E94\u9879, --full \u5220\u5168\u90E8"]
+  },
+  // === meta(不在分组清单展示,help 末尾单列) ===
+  {
+    name: "help",
+    aliases: ["-h", "--help"],
+    handler: () => printHelp(COMMANDS),
+    group: "meta",
+    usage: ["help, -h                     \u663E\u793A\u5E2E\u52A9"]
+  },
+  {
+    name: "version",
+    aliases: ["-v", "--version"],
+    handler: printVersion,
+    group: "meta",
+    usage: ["version, -v                  \u663E\u793A\u7248\u672C"]
+  }
+];
+var COMMAND_INDEX = (() => {
+  const index = /* @__PURE__ */ new Map();
+  for (const cmd of COMMANDS) {
+    for (const token of [cmd.name, ...cmd.aliases]) {
+      if (index.has(token)) {
+        throw new Error(`\u547D\u4EE4\u6CE8\u518C\u8868\u5B58\u5728\u91CD\u590D token: "${token}"\uFF08${index.get(token)?.name} \u4E0E ${cmd.name}\uFF09`);
+      }
+      index.set(token, cmd);
+    }
+  }
+  return index;
+})();
+function findCommand(token) {
+  return COMMAND_INDEX.get(token);
+}
+
 // src/index.ts
 process.on("SIGINT", () => {
   console.log("\n\u6B63\u5728\u9000\u51FA...");
@@ -6623,12 +6917,14 @@ process.on("uncaughtException", (e) => {
   if (e.stack) {
     console.error(e.stack.split("\n").slice(1).join("\n"));
   }
+  runCleanup();
   process.exit(1);
 });
 process.on("unhandledRejection", (reason) => {
   const msg = reason instanceof Error ? reason.message : String(reason);
   console.error(`
 \u672A\u5904\u7406\u7684 Promise \u62D2\u7EDD: ${msg}`);
+  runCleanup();
   process.exit(1);
 });
 function clearProxyEnv() {
@@ -6648,94 +6944,18 @@ async function main() {
     printShortHelp();
     return;
   }
-  const cmd = args[0].toLowerCase();
-  if (["help", "-h", "--help"].includes(cmd)) {
-    printHelp();
-    return;
-  }
-  if (["version", "-v", "--version"].includes(cmd)) {
-    printVersion();
-    return;
-  }
-  switch (cmd) {
-    case "up":
-    case "start":
-      await cmdStart(args);
-      break;
-    case "tun":
-      await cmdStart(["start", "tun", ...args.slice(1)]);
-      break;
-    case "down":
-    case "stop":
-      await cmdStop();
-      break;
-    case "status":
-      printStatus();
-      break;
-    case "log":
-      cmdLog(args);
-      break;
-    case "logs":
-      cmdLogs(args);
-      break;
-    case "open":
-      cmdDirectory(["dir", "open", ...args.slice(1)]);
-      break;
-    case "ui":
-      cmdUI(args);
-      break;
-    case "kernel":
-      await cmdKernel(args);
-      break;
-    case "upd":
-    case "update":
-    case "upgrade":
-      await cmdUpdate();
-      break;
-    case "use":
-      await cmdSubscription(["sub", "use", ...args.slice(1)]);
-      break;
-    case "sub":
-    case "subscription":
-    case "subscriptions":
-      await cmdSubscription(args);
-      break;
-    case "dir":
-    case "dirs":
-    case "directory":
-    case "directories":
-      cmdDirectory(args);
-      break;
-    case "reset":
-      await cmdReset(args);
-      break;
-    case "daemon":
-      await cmdDaemon(args);
-      break;
-    case "on":
-      await cmdOverwrite(["ow", "on"]);
-      break;
-    case "off":
-      await cmdOverwrite(["ow", "off"]);
-      break;
-    case "ow":
-    case "overwrite":
-      await cmdOverwrite(args);
-      break;
-    case "test":
-      await cmdTest(args);
-      break;
-    case "clean":
-      await cmdClean(args);
-      break;
-    default:
-      console.error(`\u672A\u77E5\u547D\u4EE4: ${cmd}`);
-      console.error('\u4F7F\u7528 "mihomo help" \u67E5\u770B\u5E2E\u52A9');
-      process.exit(1);
+  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);
   }
+  await command.handler(command.rewrite ? command.rewrite(args) : args);
 }
 main().catch((e) => {
   console.error(`\u9519\u8BEF: ${e.message}`);
+  runCleanup();
   process.exit(1);
 });
 /*! Bundled license information: