mihomo-cli 2.10.0 → 3.0.0

package/dist/index.js

@@ -1,71 +1,5 @@
 #!/usr/bin/env node
 
-// src/paths.ts
-import fs from "fs";
-import os from "os";
-import path from "path";
-function getUserDataDir() {
-  if (process.env.MIHOMO_CLI_DIR) {
-    return process.env.MIHOMO_CLI_DIR;
-  }
-  return path.join(os.homedir(), ".mihomo-cli");
-}
-var USER_DATA_DIR = getUserDataDir();
-var DIRS = {
-  kernel: path.join(USER_DATA_DIR, "kernel"),
-  subscriptions: path.join(USER_DATA_DIR, "subscriptions"),
-  logs: path.join(USER_DATA_DIR, "logs"),
-  data: path.join(USER_DATA_DIR, "data"),
-  runtime: path.join(USER_DATA_DIR, "runtime")
-};
-var PATHS = {
-  mihomoBinary: path.join(DIRS.kernel, "mihomo"),
-  settingsFile: path.join(USER_DATA_DIR, "settings.json"),
-  subscriptionsCacheFile: path.join(DIRS.subscriptions, "cache.json"),
-  configFile: path.join(DIRS.runtime, "config.yaml"),
-  logFile: path.join(DIRS.logs, "mihomo.log"),
-  pidFile: path.join(DIRS.runtime, "pid"),
-  configStage1Subscription: path.join(DIRS.runtime, "1.subscription.yaml"),
-  configStage2Overwrite: path.join(DIRS.runtime, "2.overwrite.yaml"),
-  configStage3System: path.join(DIRS.runtime, "3.system.yaml")
-};
-var DIRECTORY_TARGETS = {
-  root: { path: null, label: "\u6839\u76EE\u5F55" },
-  subs: { path: DIRS.subscriptions, label: "\u8BA2\u9605\u76EE\u5F55" },
-  logs: { path: DIRS.logs, label: "\u65E5\u5FD7\u76EE\u5F55" },
-  data: { path: DIRS.data, label: "mihomo \u6570\u636E\u76EE\u5F55" },
-  runtime: { path: DIRS.runtime, label: "\u8FD0\u884C\u65F6\u76EE\u5F55" },
-  kernel: { path: DIRS.kernel, label: "\u5185\u6838\u76EE\u5F55" }
-};
-function ensureDirs() {
-  for (const dir of Object.values(DIRS)) {
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true, mode: 448 });
-    }
-  }
-}
-function atomicWriteFileSync(filePath, content, options) {
-  const tmp = `${filePath}.${process.pid}.tmp`;
-  try {
-    fs.writeFileSync(tmp, content, options);
-    fs.renameSync(tmp, filePath);
-  } catch (e) {
-    try {
-      fs.unlinkSync(tmp);
-    } catch {
-    }
-    throw e;
-  }
-}
-function rmrf(dir) {
-  fs.rmSync(dir, { recursive: true, force: true });
-}
-
-// src/process.ts
-import { spawn, spawnSync as spawnSync3 } from "child_process";
-import fs5 from "fs";
-import path3 from "path";
-
 // src/config.ts
 import { spawnSync } from "child_process";
 import fs4 from "fs";
@@ -2989,6 +2923,7 @@ var UI_URLS = {
   dash: "https://metacubex.github.io/metacubexd",
   yacd: "https://yacd.metacubex.one"
 };
+var LAUNCH_AGENT_LABEL = "com.mihomo-cli.daemon";
 var TUN_CONFIG = {
   tun: {
     enable: true,
@@ -3040,6 +2975,69 @@ var AUTO_CLEAN_THRESHOLD_GITHUB = 50;
 import fs3 from "fs";
 import path2 from "path";
 
+// src/paths.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+function getUserDataDir() {
+  if (process.env.MIHOMO_CLI_DIR) {
+    return process.env.MIHOMO_CLI_DIR;
+  }
+  return path.join(os.homedir(), ".mihomo-cli");
+}
+var USER_DATA_DIR = getUserDataDir();
+var DIRS = {
+  kernel: path.join(USER_DATA_DIR, "kernel"),
+  subscriptions: path.join(USER_DATA_DIR, "subscriptions"),
+  logs: path.join(USER_DATA_DIR, "logs"),
+  data: path.join(USER_DATA_DIR, "data"),
+  runtime: path.join(USER_DATA_DIR, "runtime")
+};
+var PATHS = {
+  mihomoBinary: path.join(DIRS.kernel, "mihomo"),
+  settingsFile: path.join(USER_DATA_DIR, "settings.json"),
+  subscriptionsCacheFile: path.join(DIRS.subscriptions, "cache.json"),
+  configFile: path.join(DIRS.runtime, "config.yaml"),
+  logFile: path.join(DIRS.logs, "mihomo.log"),
+  pidFile: path.join(DIRS.runtime, "pid"),
+  configStage1Subscription: path.join(DIRS.runtime, "1.subscription.yaml"),
+  configStage2Overwrite: path.join(DIRS.runtime, "2.overwrite.yaml"),
+  configStage3System: path.join(DIRS.runtime, "3.system.yaml"),
+  // launchd LaunchAgent plist 必须位于真实用户主目录，不受 MIHOMO_CLI_DIR 影响
+  launchAgentPlist: path.join(os.homedir(), "Library", "LaunchAgents", `${LAUNCH_AGENT_LABEL}.plist`)
+};
+var DIRECTORY_TARGETS = {
+  root: { path: null, label: "\u6839\u76EE\u5F55" },
+  subs: { path: DIRS.subscriptions, label: "\u8BA2\u9605\u76EE\u5F55" },
+  logs: { path: DIRS.logs, label: "\u65E5\u5FD7\u76EE\u5F55" },
+  data: { path: DIRS.data, label: "mihomo \u6570\u636E\u76EE\u5F55" },
+  runtime: { path: DIRS.runtime, label: "\u8FD0\u884C\u65F6\u76EE\u5F55" },
+  kernel: { path: DIRS.kernel, label: "\u5185\u6838\u76EE\u5F55" }
+};
+function ensureDirs() {
+  for (const dir of Object.values(DIRS)) {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true, mode: 448 });
+    }
+  }
+}
+function atomicWriteFileSync(filePath, content, options) {
+  const tmp = `${filePath}.${process.pid}.tmp`;
+  try {
+    fs.writeFileSync(tmp, content, options);
+    fs.renameSync(tmp, filePath);
+  } catch (e) {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {
+    }
+    throw e;
+  }
+}
+function rmrf(dir) {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
 // src/settings.ts
 import fs2 from "fs";
 var settingsCache = null;
@@ -3581,6 +3579,16 @@ function clearKernelVersionCache() {
   kernelVersionCached = false;
 }
 
+// src/daemon.ts
+import { spawnSync as spawnSync4 } from "child_process";
+import fs6 from "fs";
+import path4 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";
@@ -4271,1021 +4279,1234 @@ function viewLogWithTail(logPath, options) {
   });
 }
 
-// src/commands/directory.ts
-function cmdDirectory(args) {
-  const action = args?.[1];
-  if (action === "open") {
-    const target = args[2];
-    if (!target || target === "root") {
-      console.log("\u6B63\u5728\u6253\u5F00: \u6839\u76EE\u5F55");
-      const success = openUrl(USER_DATA_DIR);
-      if (!success) {
-        console.log(`\u8BF7\u624B\u52A8\u6253\u5F00: ${USER_DATA_DIR}`);
-      }
-      return;
-    }
-    const key = target.toLowerCase();
-    const targetInfo = Object.hasOwn(DIRECTORY_TARGETS, key) ? DIRECTORY_TARGETS[key] : void 0;
-    if (targetInfo) {
-      const targetPath = targetInfo.path || USER_DATA_DIR;
-      console.log(`\u6B63\u5728\u6253\u5F00: ${targetInfo.label}`);
-      const success = openUrl(targetPath);
-      if (!success) {
-        console.log(`\u8BF7\u624B\u52A8\u6253\u5F00: ${targetPath}`);
-      }
-      return;
+// 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");
+  }
+  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;");
+}
+function buildPlist() {
+  const programArguments = [PATHS.mihomoBinary, "-d", DIRS.data, "-f", PATHS.configFile];
+  const argsXml = programArguments.map((a) => `    <string>${escapeXml(a)}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${escapeXml(LAUNCH_AGENT_LABEL)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${argsXml}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(PATHS.logFile)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(PATHS.logFile)}</string>
+  <key>WorkingDirectory</key>
+  <string>/tmp</string>
+</dict>
+</plist>
+`;
+}
+function isDaemonEnabled() {
+  return fs6.existsSync(PATHS.launchAgentPlist);
+}
+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 };
+}
+function isDaemonRunning(status) {
+  return status.loaded && status.pid !== null;
+}
+function enableDaemon() {
+  if (!fs6.existsSync(PATHS.mihomoBinary)) {
+    throw new Error("\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");
+  }
+  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)]);
+    try {
+      fs6.unlinkSync(PATHS.launchAgentPlist);
+    } catch {
     }
-    console.error(`\u9519\u8BEF: \u672A\u77E5\u7684\u76EE\u5F55\u76EE\u6807 "${target}"`);
-    console.log("");
-    console.log("\u53EF\u7528\u76EE\u6807:");
-    console.log("  root (\u9ED8\u8BA4)   \u6839\u76EE\u5F55");
-    for (const [key2, val] of Object.entries(DIRECTORY_TARGETS)) {
-      if (key2 !== "root") {
-        console.log(`  ${key2.padEnd(14)}${val.label}`);
-      }
+    throw launchctlError("bootstrap", result);
+  }
+}
+function disableDaemon() {
+  const uid = process.getuid?.();
+  if (uid !== void 0) {
+    launchctl(["bootout", serviceTarget(uid)]);
+  }
+  try {
+    fs6.unlinkSync(PATHS.launchAgentPlist);
+  } catch {
+  }
+}
+function restartDaemon() {
+  const uid = getUid();
+  if (!fs6.existsSync(PATHS.launchAgentPlist)) {
+    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);
     }
-    console.log("");
-    process.exit(1);
+    return;
+  }
+  const result = launchctl(["bootstrap", guiDomain(uid), PATHS.launchAgentPlist]);
+  if (result.status !== 0) {
+    throw launchctlError("bootstrap", result);
   }
-  console.log("");
-  console.log("\u6570\u636E\u76EE\u5F55\u4F4D\u7F6E:");
-  console.log(`  \u6839\u76EE\u5F55: ${USER_DATA_DIR}`);
-  console.log(`  \u5168\u5C40\u8BBE\u7F6E: ${PATHS.settingsFile}`);
-  console.log(`  \u5185\u6838\u76EE\u5F55: ${DIRS.kernel}`);
-  console.log(`  \u5185\u6838\u6587\u4EF6: ${PATHS.mihomoBinary}`);
-  console.log(`  \u8BA2\u9605\u76EE\u5F55: ${DIRS.subscriptions}`);
-  console.log("    - cache.json (\u8BA2\u9605\u7F13\u5B58\uFF1A\u66F4\u65B0\u65F6\u95F4\u3001\u6D41\u91CF\u7B49)");
-  console.log("    - xxx.yaml (\u8BA2\u9605\u539F\u59CB\u914D\u7F6E)");
-  console.log(`  \u8FD0\u884C\u65F6\u76EE\u5F55: ${DIRS.runtime}`);
-  console.log("    - config.yaml (\u542F\u52A8\u65F6\u751F\u6210\uFF0Cstop \u81EA\u52A8\u6E05\u9664)");
-  console.log("    - pid (PID \u6587\u4EF6\uFF0Cstop \u81EA\u52A8\u6E05\u9664)");
-  console.log(`  \u65E5\u5FD7\u6587\u4EF6: ${PATHS.logFile}`);
-  console.log(`  mihomo \u6570\u636E: ${DIRS.data}`);
-  console.log("    - cache.db, Geo*.dat \u7B49 (mihomo \u81EA\u884C\u7BA1\u7406)");
-  console.log("");
-  console.log("\u6253\u5F00\u76EE\u5F55:");
-  console.log("  mihomo dir open                \u6253\u5F00\u6839\u76EE\u5F55");
-  console.log("  mihomo dir open subs           \u6253\u5F00\u8BA2\u9605\u76EE\u5F55");
-  console.log("  mihomo dir open logs           \u6253\u5F00\u65E5\u5FD7\u76EE\u5F55");
-  console.log("  mihomo dir open data           \u6253\u5F00 mihomo \u6570\u636E\u76EE\u5F55");
-  console.log("  mihomo dir open runtime        \u6253\u5F00\u8FD0\u884C\u65F6\u76EE\u5F55");
-  console.log("  mihomo dir open kernel         \u6253\u5F00\u5185\u6838\u76EE\u5F55");
-  console.log("");
-  console.log("\u73AF\u5883\u53D8\u91CF:");
-  console.log("  MIHOMO_CLI_DIR: \u81EA\u5B9A\u4E49\u6839\u76EE\u5F55\u4F4D\u7F6E");
-  console.log("");
 }
 
-// src/commands/help.ts
-function printShortHelp() {
-  console.log(`
-${colors.cyan(colors.bold(`mihomo-cli v${VERSION}`))}  (mihomo help \u67E5\u770B\u5B8C\u6574\u5E2E\u52A9)
-`);
-  console.log(
-    `\u5E38\u7528\u547D\u4EE4:
-  ${colors.bold("start")} [tun|mixed]    \u542F\u52A8/\u5207\u6362\u4EE3\u7406
-  ${colors.bold("sub")} [use|update]     \u8BA2\u9605\u7BA1\u7406
-  ${colors.bold("ow")} [on|off]          \u8986\u5199\u914D\u7F6E
-  ${colors.bold("ui")} [zash|dash|yacd]  \u6253\u5F00 Web UI
-`
-  );
+// src/subscription.ts
+function isGithubUrl(url) {
+  return /github\.com|raw\.githubusercontent\.com/i.test(url);
 }
-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("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 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}`);
+function getDefaultUpdateInterval(url) {
+  return isGithubUrl(url) ? DEFAULT_UPDATE_INTERVAL_HOURS_GITHUB : DEFAULT_UPDATE_INTERVAL_HOURS;
 }
-
-// src/kernel.ts
-import { spawnSync as spawnSync4 } from "child_process";
-import fs6 from "fs";
-import path4 from "path";
-
-// node_modules/compare-versions/lib/esm/utils.js
-var semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
-var validateAndParse = (version) => {
-  if (typeof version !== "string") {
-    throw new TypeError("Invalid argument expected string");
-  }
-  const match = version.match(semver);
-  if (!match) {
-    throw new Error(`Invalid argument not valid semver ('${version}' received)`);
-  }
-  match.shift();
-  return match;
-};
-var isWildcard = (s) => s === "*" || s === "x" || s === "X";
-var tryParse = (v) => {
-  const n = parseInt(v, 10);
-  return isNaN(n) ? v : n;
-};
-var forceType = (a, b) => typeof a !== typeof b ? [String(a), String(b)] : [a, b];
-var compareStrings = (a, b) => {
-  if (isWildcard(a) || isWildcard(b))
-    return 0;
-  const [ap, bp] = forceType(tryParse(a), tryParse(b));
-  if (ap > bp)
-    return 1;
-  if (ap < bp)
-    return -1;
-  return 0;
-};
-var compareSegments = (a, b) => {
-  for (let i = 0; i < Math.max(a.length, b.length); i++) {
-    const r = compareStrings(a[i] || "0", b[i] || "0");
-    if (r !== 0)
-      return r;
-  }
-  return 0;
-};
-
-// node_modules/compare-versions/lib/esm/compareVersions.js
-var compareVersions = (v1, v2) => {
-  const n1 = validateAndParse(v1);
-  const n2 = validateAndParse(v2);
-  const p1 = n1.pop();
-  const p2 = n2.pop();
-  const r = compareSegments(n1, n2);
-  if (r !== 0)
-    return r;
-  if (p1 && p2) {
-    return compareSegments(p1.split("."), p2.split("."));
-  } else if (p1 || p2) {
-    return p1 ? -1 : 1;
-  }
-  return 0;
-};
-
-// src/kernel.ts
-var GITHUB_REPO = "MetaCubeX/mihomo";
-var KERNEL_HTTP_TIMEOUT = 12e4;
-var KERNEL_DOWNLOAD_TIMEOUT = 18e4;
-var HTTP_CLIENT = createHttpClient({ timeout: KERNEL_HTTP_TIMEOUT });
-function withMirror(url, mirror) {
-  if (mirror && (url.startsWith("https://github.com/") || url.startsWith("https://api.github.com/"))) {
-    return mirror + url;
-  }
-  return url;
+function resolveUpdateInterval(url, cachedInterval) {
+  return cachedInterval && cachedInterval > 0 ? cachedInterval : getDefaultUpdateInterval(url);
 }
-function getArch() {
-  const arch = process.arch;
-  if (arch === "arm64") return "arm64";
-  if (arch === "x64") return "amd64";
-  return arch;
+var YAML_DUMP_OPTS = { indent: 2, lineWidth: -1, schema: CORE_SCHEMA };
+var HTTP_CLIENT = createHttpClient({ timeout: 6e4 });
+function isMultiUrl(url) {
+  return url.includes(",");
 }
-function findMatchingAsset(assets, platform, arch) {
-  const prefix = `mihomo-${platform}-${arch}`;
-  const matchingAssets = assets.filter(
-    (a) => a.name.startsWith(prefix) && a.name.endsWith(".gz") || a.name.startsWith(`${prefix}-`) && a.name.endsWith(".gz")
-  );
-  if (matchingAssets.length === 0) return null;
-  if (matchingAssets.length === 1) return matchingAssets[0];
-  const standardAsset = matchingAssets.find((a) => {
-    const nameWithoutGz = a.name.slice(0, -3);
-    const parts = nameWithoutGz.split("-");
-    const lastPart = parts[parts.length - 1];
-    return /^v?\d+\.\d+\.\d+/.test(lastPart) && !nameWithoutGz.includes("-go");
-  });
-  return standardAsset || matchingAssets[0];
+function splitUrls(url) {
+  return url.split(",").map((u) => u.trim()).filter(Boolean);
 }
-async function getLatestRelease(repo, mirror) {
-  const url = withMirror(`https://api.github.com/repos/${repo}/releases`, mirror);
-  const response = await HTTP_CLIENT.get(url, { responseType: "json" });
-  const releases = response.data;
-  if (!Array.isArray(releases) || releases.length === 0) {
-    throw new Error("\u65E0\u6CD5\u83B7\u53D6\u7248\u672C\u4FE1\u606F");
+function loadSubscriptionConfig(subName) {
+  const rawContent = readSubscriptionRawConfig(subName);
+  if (!rawContent) {
+    throw new Error(`\u672A\u627E\u5230\u8BA2\u9605\u914D\u7F6E "${subName}"`);
   }
-  const stableReleases = releases.filter(
-    (r) => !r.prerelease && !r.tag_name.toLowerCase().includes("alpha") && !r.tag_name.toLowerCase().includes("beta") && !r.tag_name.toLowerCase().includes("prerelease")
-  );
-  return stableReleases.length > 0 ? stableReleases[0] : releases[0];
+  const raw = parseYamlOrJson(rawContent, "\u8BA2\u9605\u5185\u5BB9");
+  return {
+    raw,
+    proxies: raw.proxies || [],
+    proxyGroups: raw["proxy-groups"] || []
+  };
 }
-async function checkUpdate(mirror) {
-  const currentVersion = getKernelVersion();
-  const latest = await getLatestRelease(GITHUB_REPO, mirror);
-  const latestVersion = latest.tag_name;
-  let needsUpdate = false;
-  const currentDisplay = currentVersion || "\u672A\u5B89\u88C5";
-  if (!currentVersion) {
-    needsUpdate = true;
-  } else {
-    try {
-      needsUpdate = compareVersions(latestVersion.replace(/^v/, ""), currentVersion.replace(/^v/, "")) > 0;
-    } catch {
-      needsUpdate = latestVersion !== currentVersion;
+function saveSubscriptionConfig(subName, parsed) {
+  normalizeProxyNamesBeforeSave(parsed);
+  parsed.raw.proxies = parsed.proxies;
+  parsed.raw["proxy-groups"] = parsed.proxyGroups;
+  saveSubscriptionRawConfig(subName, dump(parsed.raw, YAML_DUMP_OPTS));
+}
+function parseUserInfo(header) {
+  if (!header) return null;
+  const info = {};
+  const parts = header.split(";").map((p) => p.trim());
+  for (const part of parts) {
+    const [key, val] = part.split("=").map((s) => s.trim());
+    if (key && val !== void 0) {
+      const numVal = parseFloat(val);
+      info[key] = Number.isNaN(numVal) ? 0 : numVal;
     }
   }
+  return info;
+}
+function parsePositiveInterval(header) {
+  if (!header) return null;
+  const n = parseInt(header, 10);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+function parseUsernameFromContentDisposition(header) {
+  if (!header) return null;
+  const match = header.match(/filename\s*=\s*["']?([^"';\s]+)["']?/i);
+  if (!match) return null;
+  const filename = match[1];
+  const parts = filename.split("/");
+  return parts[parts.length - 1] || null;
+}
+function extractSubscriptionMeta(headers) {
   return {
-    current: currentDisplay,
-    latest: latestVersion,
-    needsUpdate,
-    assets: latest.assets,
-    release: latest
+    userInfo: parseUserInfo(headers?.get("subscription-userinfo") ?? null),
+    updateInterval: parsePositiveInterval(headers?.get("profile-update-interval")),
+    webPageUrl: headers?.get("profile-web-page-url") || null,
+    username: parseUsernameFromContentDisposition(headers?.get("content-disposition") ?? null)
   };
 }
-function findBinaryInDir(dir, maxDepth = 4) {
-  if (maxDepth <= 0) return null;
-  const files = fs6.readdirSync(dir);
-  for (const f of files) {
-    const fullPath = path4.join(dir, f);
-    const stat = fs6.statSync(fullPath);
-    if (stat.isDirectory()) {
-      const found = findBinaryInDir(fullPath, maxDepth - 1);
-      if (found) return found;
-      continue;
-    }
-    if (f === "mihomo") return fullPath;
-    if (f.includes("mihomo") && !f.endsWith(".gz")) return fullPath;
+function saveSubscriptionMeta(subName, meta) {
+  const cacheData = { updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+  if (meta.userInfo) {
+    cacheData.upload = meta.userInfo.upload;
+    cacheData.download = meta.userInfo.download;
+    cacheData.total = meta.userInfo.total;
+    cacheData.expire = meta.userInfo.expire;
   }
-  return null;
+  if (meta.updateInterval) cacheData.update_interval = meta.updateInterval;
+  if (meta.webPageUrl) cacheData.web_page_url = meta.webPageUrl;
+  if (meta.username) cacheData.username = meta.username;
+  saveSubscriptionCache(subName, cacheData);
 }
-async function downloadKernel(progressCallback, mirror, releaseInfo) {
-  ensureDirs();
-  const latest = releaseInfo || await getLatestRelease(GITHUB_REPO, mirror);
-  const arch = getArch();
-  const platform = process.platform;
-  const asset = findMatchingAsset(latest.assets, platform, arch);
-  if (!asset) {
-    const available = latest.assets.map((a) => a.name).join(", ");
-    let hint = "";
-    if (available) hint = `
-  \u53EF\u7528\u7248\u672C: ${available}`;
-    throw new Error(`\u672A\u627E\u5230\u5339\u914D\u7684\u5185\u6838\u6587\u4EF6
-  \u5E73\u53F0: ${platform}, \u67B6\u6784: ${arch}${hint}`);
-  }
-  const downloadUrl = withMirror(asset.browser_download_url, mirror);
-  const tempPath = path4.join(DIRS.kernel, asset.name);
-  const sizeMB = (asset.size / 1024 / 1024).toFixed(2);
-  if (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");
-  }
-  if (progressCallback) {
-    progressCallback(`\u4E0B\u8F7D\u5185\u6838: ${asset.name} (${sizeMB} MB)`);
+function formatProxySummary(info) {
+  const parts = [];
+  if (info.proxyGroups && info.proxyGroups > 0) parts.push(`${info.proxyGroups} \u7EC4`);
+  parts.push(`${info.proxies || 0} \u8282\u70B9`);
+  return parts.join(", ");
+}
+function getActiveSubscription() {
+  const subs = getSubscriptions();
+  if (subs.length === 0) return null;
+  const settings = readSettings();
+  const activeName = settings.active_subscription;
+  if (activeName) {
+    const found = subs.find((s) => s.name === activeName);
+    if (found) return found;
   }
-  const curlResult = spawnSync4(
-    "curl",
-    ["-L", "--progress-bar", "--connect-timeout", "30", "--max-time", String(Math.floor(KERNEL_DOWNLOAD_TIMEOUT / 1e3)), "-o", tempPath, downloadUrl],
-    { stdio: "inherit" }
-  );
-  if (curlResult.status !== 0) {
-    try {
-      fs6.unlinkSync(tempPath);
-    } catch {
+  return subs[0];
+}
+function findSubscriptionFuzzy(subs, pattern) {
+  const lowerPattern = pattern.toLowerCase();
+  const exact = [];
+  const prefix = [];
+  const includes = [];
+  for (const s of subs) {
+    const name = s.name.toLowerCase();
+    if (name === lowerPattern) {
+      exact.push(s);
+    } else if (name.startsWith(lowerPattern)) {
+      prefix.push(s);
+    } else if (name.includes(lowerPattern)) {
+      includes.push(s);
     }
-    throw new Error(`\u4E0B\u8F7D\u5931\u8D25 (curl \u9000\u51FA\u7801 ${curlResult.status})`);
-  }
-  if (!fs6.existsSync(tempPath)) {
-    throw new Error("\u4E0B\u8F7D\u5931\u8D25: \u6587\u4EF6\u672A\u751F\u6210");
   }
-  if (progressCallback) {
-    progressCallback("\u89E3\u538B\u5185\u6838...");
+  if (exact.length > 0) return exact;
+  if (prefix.length > 0) return prefix;
+  return includes;
+}
+function pickSingleSubscription(subs, pattern) {
+  if (subs.length === 0) {
+    console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u5339\u914D "${pattern}" \u7684\u8BA2\u9605`);
+    process.exit(1);
   }
-  const extractPath = DIRS.kernel;
-  let extractedBinary = null;
+  if (subs.length === 1) return subs[0];
+  console.error("\u9519\u8BEF: \u5339\u914D\u5230\u591A\u4E2A\u8BA2\u9605\uFF0C\u8BF7\u66F4\u7CBE\u786E\u6307\u5B9A");
+  console.log("\n\u5339\u914D\u7684\u8BA2\u9605:");
+  for (const s of subs) console.log(`  ${s.name}`);
+  process.exit(1);
+}
+async function downloadSubscription(url, subName = "default", signal) {
+  let response;
   try {
-    if (tempPath.endsWith(".tar.gz") || tempPath.endsWith(".tgz")) {
-      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 = path4.basename(tempPath, ".gz");
-      const outputPath = path4.join(extractPath, baseName);
-      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}`);
-      fs6.writeFileSync(outputPath, gzipResult.stdout, { mode: 493 });
-      extractedBinary = outputPath;
-    }
+    response = await HTTP_CLIENT.get(url, { responseType: "text", signal });
   } catch (e) {
-    try {
-      fs6.unlinkSync(tempPath);
-    } catch {
+    const maskedUrl = maskUrl(url);
+    let errorMsg = `\u83B7\u53D6\u8BA2\u9605\u5931\u8D25: ${e.message}`;
+    const err = e;
+    if (err.response) {
+      errorMsg += ` (HTTP ${err.response.status})`;
     }
-    throw new Error(`\u89E3\u538B\u5931\u8D25: ${e.message}`);
+    errorMsg += `
+  URL: ${maskedUrl}`;
+    throw new Error(errorMsg);
   }
-  const foundBinary = extractedBinary || findBinaryInDir(extractPath);
-  if (!foundBinary) {
-    try {
-      fs6.unlinkSync(tempPath);
-    } catch {
-    }
-    throw new Error("\u89E3\u538B\u540E\u672A\u627E\u5230\u53EF\u6267\u884C\u6587\u4EF6");
+  const content = response.data;
+  if (!content?.trim()) {
+    throw new Error("\u8BA2\u9605\u5185\u5BB9\u4E3A\u7A7A");
   }
-  const targetPath = PATHS.mihomoBinary;
-  if (foundBinary !== targetPath) {
-    if (fs6.existsSync(targetPath)) {
-      fs6.chmodSync(targetPath, 493);
+  const parsed = parseYamlOrJson(content, "\u8BA2\u9605\u5185\u5BB9");
+  if (!parsed) throw new Error("\u8BA2\u9605\u5185\u5BB9\u4E3A\u7A7A");
+  saveSubscriptionRawConfig(subName, content);
+  const meta = extractSubscriptionMeta(response.headers);
+  saveSubscriptionMeta(subName, meta);
+  const proxies = parsed.proxies;
+  const proxyGroups = parsed["proxy-groups"];
+  return {
+    proxies: proxies ? proxies.length : 0,
+    proxyGroups: proxyGroups ? proxyGroups.length : 0,
+    userInfo: meta.userInfo,
+    updateInterval: meta.updateInterval,
+    webPageUrl: meta.webPageUrl,
+    username: meta.username
+  };
+}
+async function downloadMergedSubscription(urls, subName, signal) {
+  const responses = await Promise.all(
+    urls.map(async (url, index) => {
       try {
-        fs6.unlinkSync(targetPath);
-      } catch {
+        const response = await HTTP_CLIENT.get(url, { responseType: "text", signal });
+        return { url, index, response, error: null };
+      } catch (e) {
+        return { url, index, response: null, error: e };
       }
+    })
+  );
+  for (const r of responses) {
+    if (r.error) {
+      const maskedUrl = maskUrl(r.url);
+      throw new Error(`\u5408\u5E76\u8BA2\u9605\u7B2C ${r.index + 1} \u4E2A URL \u83B7\u53D6\u5931\u8D25: ${r.error.message}
+  URL: ${maskedUrl}`);
     }
-    fs6.renameSync(foundBinary, targetPath);
   }
-  fs6.chmodSync(targetPath, 493);
-  if (progressCallback) {
-    progressCallback("\u6821\u9A8C\u5185\u6838...");
-  }
-  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 {
-      fs6.unlinkSync(targetPath);
-    } catch {
-    }
-    try {
-      fs6.unlinkSync(tempPath);
-    } catch {
+  const parsed = responses.map((r, i) => {
+    const content = r.response?.data;
+    if (!content?.trim()) throw new Error(`\u5408\u5E76\u8BA2\u9605\u7B2C ${i + 1} \u4E2A URL \u5185\u5BB9\u4E3A\u7A7A`);
+    return parseYamlOrJson(content, `\u5408\u5E76\u8BA2\u9605\u7B2C ${i + 1} \u4E2A`);
+  });
+  const base = parsed[0];
+  const baseProxies = base.proxies || [];
+  const seenNames = new Set(baseProxies.map((p) => p.name));
+  for (let i = 1; i < parsed.length; i++) {
+    const extraProxies = parsed[i].proxies || [];
+    for (const proxy of extraProxies) {
+      if (!seenNames.has(proxy.name)) {
+        baseProxies.push(proxy);
+        seenNames.add(proxy.name);
+      }
     }
-    throw new Error(`\u5185\u6838\u81EA\u68C0\u5931\u8D25\uFF08\u53EF\u80FD\u4E0B\u8F7D\u635F\u574F\u6216\u67B6\u6784\u4E0D\u5339\u914D\uFF09\uFF0C\u5DF2\u5220\u9664
-  \u9000\u51FA\u7801: ${check.status}
-  \u8F93\u51FA: ${checkOutput || "(\u7A7A)"}`);
   }
-  try {
-    fs6.unlinkSync(tempPath);
-  } catch {
-  }
-  clearKernelVersionCache();
-  return { version: latest.tag_name, path: targetPath };
+  base.proxies = baseProxies;
+  const mergedContent = dump(base, YAML_DUMP_OPTS);
+  saveSubscriptionRawConfig(subName, mergedContent);
+  const meta = extractSubscriptionMeta(responses[0].response?.headers);
+  saveSubscriptionMeta(subName, meta);
+  const proxyGroups = base["proxy-groups"];
+  return {
+    proxies: baseProxies.length,
+    proxyGroups: proxyGroups ? proxyGroups.length : 0,
+    userInfo: meta.userInfo,
+    updateInterval: meta.updateInterval,
+    webPageUrl: meta.webPageUrl,
+    username: meta.username
+  };
 }
-
-// src/commands/kernel.ts
-async function cmdKernel(args) {
-  const mirrorInfo = parseMirrorArg(args);
-  const effectiveMirror = mirrorInfo.mirror;
-  if (effectiveMirror) {
-    const mirrorDesc = mirrorInfo.type === "all" ? " (API\u548C\u4E0B\u8F7D\u5747\u4F7F\u7528\u955C\u50CF)" : " (\u4E0B\u8F7D\u65F6\u4F7F\u7528\u955C\u50CF)";
-    console.log(`\u955C\u50CF: ${effectiveMirror}${mirrorDesc}`);
+function 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`);
   }
-  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)" : ""}`);
+  const buildResult = buildConfig(rawContent, mode);
+  if (buildResult.warnings.length > 0) {
+    for (const warning of buildResult.warnings) {
+      console.log(`${colors.yellow("\u81EA\u52A8\u4FEE\u590D:")} ${warning}`);
+    }
+    console.log("");
   }
-  console.log("");
-  console.log("\u68C0\u67E5\u5185\u6838\u66F4\u65B0...");
+  writeMihomoConfig(buildResult.config);
+  writeDebugConfig(buildResult);
+  const proxies = buildResult.config.proxies;
+  const proxyGroups = buildResult.config["proxy-groups"];
+  return {
+    proxies: proxies ? proxies.length : 0,
+    proxyGroups: proxyGroups ? proxyGroups.length : 0
+  };
+}
+function needsAutoUpdate(sub) {
+  if (!sub.updated_at) return true;
+  const lastUpdate = new Date(sub.updated_at).getTime();
+  if (Number.isNaN(lastUpdate)) return true;
+  const intervalHours = resolveUpdateInterval(sub.url, sub.update_interval);
+  const intervalMs = intervalHours * 60 * 60 * 1e3;
+  return Date.now() - lastUpdate > intervalMs;
+}
+async function tryUpdateOne(sub, signal) {
   try {
-    const apiMirror = mirrorInfo.type === "all" ? effectiveMirror : null;
-    const info = await checkUpdate(apiMirror);
-    console.log(`\u5F53\u524D: ${info.current}`);
-    console.log(`\u6700\u65B0: ${info.latest}`);
-    if (!info.needsUpdate) {
-      console.log("\u5DF2\u662F\u6700\u65B0\u7248\u672C");
+    let info;
+    if (isMultiUrl(sub.url)) {
+      info = await downloadMergedSubscription(splitUrls(sub.url), sub.name, signal);
     } else {
-      console.log("\n\u6B63\u5728\u4E0B\u8F7D...");
-      const result = await downloadKernel((msg) => console.log(msg), mirrorInfo.mirror, info.release);
-      console.log(`
-\u5DF2\u66F4\u65B0\u5230 ${result.version}`);
+      info = await downloadSubscription(sub.url, sub.name, signal);
     }
+    return { name: sub.name, success: true, proxies: info.proxies, proxyGroups: info.proxyGroups };
   } catch (e) {
-    console.error(`
-\u66F4\u65B0\u5931\u8D25: ${e.message}`);
-    const err = e;
-    if (err.response?.data) {
-      if (err.response.data.message) {
-        console.error(`\u539F\u56E0: ${err.response.data.message}`);
-      }
-      if (err.response.data.documentation_url) {
-        console.error(`\u6587\u6863: ${err.response.data.documentation_url}`);
-      }
-    }
-    process.exit(1);
+    return { name: sub.name, success: false, error: e.message };
   }
 }
-
-// src/commands/log.ts
-function cmdLog(args) {
-  const logPath = getLogPath();
-  if (hasFlag(args, "-o", "--open")) {
-    openLogFile(logPath);
-    return;
-  }
-  viewLogWithTail(logPath, { follow: true, lines: 50 });
+function printUpdateResult(r) {
+  if (r.success) {
+    console.log(`${colors.green("\u2713")} ${r.name}: ${colors.green("\u5DF2\u66F4\u65B0")} (${formatProxySummary(r)})`);
+  } else {
+    console.log(`${colors.red("\u2717")} ${r.name}: ${colors.red("\u5931\u8D25")} (${(r.error || "").split("\n")[0]})`);
+  }
 }
-function cmdLogs(args) {
-  const targetName = getNonFlagArg(args, 1);
-  const lines = parseIntArg(args, "-n", "--lines", 100);
-  const openInViewer = hasFlag(args, "-o", "--open");
-  if (targetName) {
-    let logPath;
-    if (targetName === "current" || targetName === "0") {
-      logPath = getLogPath();
-    } else {
-      const parsedIdx = parseInt(targetName, 10);
-      if (!Number.isNaN(parsedIdx) && parsedIdx > 0 && String(parsedIdx) === targetName) {
-        const archiveLogs = listLogs();
-        const archive = archiveLogs.archives[parsedIdx - 1];
-        if (!archive) {
-          console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u65E5\u5FD7 "${targetName}"`);
-          console.log('\u4F7F\u7528 "mihomo logs" \u67E5\u770B\u53EF\u7528\u65E5\u5FD7\u5217\u8868');
-          process.exit(1);
-        }
-        logPath = archive.path;
-      } else {
-        logPath = getLogPathByName(targetName);
-      }
+async function autoUpdateStaleSubscription(options = {}) {
+  const allSubs = getSubscriptionsWithCache();
+  const staleSubs = allSubs.filter(needsAutoUpdate);
+  if (staleSubs.length === 0) {
+    return { total: 0, updated: 0, failed: 0 };
+  }
+  if (staleSubs.length === 1) {
+    const sub = staleSubs[0];
+    const interval = resolveUpdateInterval(sub.url, sub.update_interval);
+    console.log(`\u8BA2\u9605 "${sub.name}" \u8D85\u8FC7 ${interval} \u5C0F\u65F6\u672A\u66F4\u65B0\uFF0C\u6B63\u5728\u66F4\u65B0...`);
+  } else {
+    console.log(`\u68C0\u67E5\u5230 ${staleSubs.length} \u4E2A\u8BA2\u9605\u9700\u8981\u66F4\u65B0\uFF0C\u6B63\u5728\u5E76\u884C\u66F4\u65B0...`);
+  }
+  const timeoutMs = options.timeout ?? DEFAULT_AUTO_UPDATE_TIMEOUT;
+  const controller = new AbortController();
+  let results;
+  try {
+    results = await withTimeout(Promise.all(staleSubs.map((sub) => tryUpdateOne(sub, controller.signal))), timeoutMs);
+  } catch (e) {
+    if (e instanceof TimeoutError) {
+      controller.abort();
+      console.log(colors.yellow(`\u81EA\u52A8\u66F4\u65B0\u8D85\u65F6 (${timeoutMs / 1e3}s)\uFF0C\u8DF3\u8FC7\u66F4\u65B0\uFF0C\u4F7F\u7528\u7F13\u5B58\u914D\u7F6E`));
+      return { total: staleSubs.length, updated: 0, failed: staleSubs.length };
     }
-    if (!logPath) {
-      console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u65E5\u5FD7 "${targetName}"`);
-      console.log('\u4F7F\u7528 "mihomo logs" \u67E5\u770B\u53EF\u7528\u65E5\u5FD7\u5217\u8868');
-      process.exit(1);
+    throw e;
+  }
+  let updatedCount = 0;
+  for (const r of results) {
+    if (r.success) updatedCount++;
+    printUpdateResult(r);
+  }
+  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) {
+  const encodedName = encodeURIComponent(proxyName);
+  const url = `${apiBase}/proxies/${encodedName}/delay?timeout=${timeout}&url=${encodeURIComponent(testUrl)}`;
+  try {
+    const response = await client.get(url);
+    const data = JSON.parse(response.data);
+    if (data.delay && data.delay > 0) {
+      return { name: proxyName, delay: data.delay };
     }
-    if (openInViewer) {
-      openLogFile(logPath);
-      return;
+    return { name: proxyName, delay: null, error: data.message || "no delay" };
+  } catch (e) {
+    const err = e;
+    let errorMsg = "timeout";
+    if (err.response?.data?.message) {
+      errorMsg = String(err.response.data.message);
+    } else if (err.message) {
+      errorMsg = err.message;
     }
-    viewLogWithTail(logPath, { follow: false, lines });
-    return;
+    return { name: proxyName, delay: null, error: errorMsg };
   }
-  const logs = listLogs();
-  const all = [];
-  if (logs.current) all.push(logs.current);
-  all.push(...logs.archives);
-  if (all.length === 0) {
-    console.log("\u6682\u65E0\u65E5\u5FD7");
-    return;
+}
+async function testSubscriptionProxies(subName, options = {}) {
+  const { timeout = DEFAULT_TEST_TIMEOUT, concurrency = DEFAULT_TEST_CONCURRENCY, testUrl = DEFAULT_TEST_URL, apiBase = API_BASE, onResult } = options;
+  const { proxies } = options.parsed || loadSubscriptionConfig(subName);
+  if (proxies.length === 0) {
+    return { total: 0, alive: 0, dead: 0, results: [] };
   }
-  console.log("");
-  console.log("\u65E5\u5FD7\u5217\u8868:");
-  console.log("");
-  let archiveCounter = 0;
-  for (const log of all) {
-    let num;
-    if (log.isCurrent) {
-      num = " 0";
+  const client = createHttpClient({ timeout: timeout + 3e3 });
+  const results = new Array(proxies.length);
+  let completedCount = 0;
+  let nextIndex = 0;
+  async function runNext() {
+    while (nextIndex < proxies.length) {
+      const idx = nextIndex++;
+      const result = await testProxyDelay(proxies[idx].name, timeout, testUrl, client, apiBase);
+      results[idx] = result;
+      onResult?.(result, completedCount, proxies.length);
+      completedCount++;
+    }
+  }
+  const workers = Array.from({ length: Math.min(concurrency, proxies.length) }, () => runNext());
+  await Promise.all(workers);
+  const alive = results.filter((r) => r.delay !== null).length;
+  return { total: results.length, alive, dead: results.length - alive, results };
+}
+function normalizeProxyNamesBeforeSave(parsed) {
+  const { proxies, proxyGroups } = parsed;
+  const renameMap = /* @__PURE__ */ new Map();
+  const usedNames = /* @__PURE__ */ new Set();
+  for (const proxy of proxies) {
+    const shortened = proxy.name.replace(/_github\.com\/[^_]+/, "");
+    if (shortened !== proxy.name && !usedNames.has(shortened)) {
+      renameMap.set(proxy.name, shortened);
+      usedNames.add(shortened);
     } else {
-      archiveCounter++;
-      num = archiveCounter < 10 ? ` ${archiveCounter}` : `${archiveCounter}`;
+      usedNames.add(proxy.name);
     }
-    const time = formatDate(log.mtime);
-    const size = formatBytes(log.size);
-    const name = log.isCurrent ? "mihomo.log (\u5F53\u524D\u8FD0\u884C\u4E2D)" : log.name;
-    console.log(` ${num}. ${name}`);
-    console.log(`    \u65F6\u95F4: ${time}  \u5927\u5C0F: ${size}`);
-    if (!log.isCurrent) {
-      console.log(`    \u67E5\u770B: mihomo logs ${archiveCounter}  \u6216  mihomo logs ${archiveCounter} -o`);
+  }
+  if (renameMap.size === 0) return 0;
+  for (const proxy of proxies) {
+    const newName = renameMap.get(proxy.name);
+    if (newName) proxy.name = newName;
+  }
+  for (const group of proxyGroups) {
+    if (Array.isArray(group.proxies)) {
+      group.proxies = group.proxies.map((name) => renameMap.get(name) || name);
     }
-    console.log("");
   }
-  console.log("\u7528\u6CD5:");
-  console.log("  mihomo logs 0          # \u67E5\u770B\u5F53\u524D\u65E5\u5FD7 (\u6700\u540E 100 \u884C)");
-  console.log("  mihomo logs 1          # \u67E5\u770B\u7B2C 1 \u4E2A\u5F52\u6863\u65E5\u5FD7\uFF08\u6700\u65B0\uFF09");
-  console.log("  mihomo logs 1 -n 200   # \u67E5\u770B 200 \u884C");
-  console.log("  mihomo logs 1 -o       # \u7528\u7CFB\u7EDF\u9ED8\u8BA4\u7A0B\u5E8F\u6253\u5F00");
-  console.log("");
-}
-
-// src/commands/overwrite.ts
-import path6 from "path";
-
-// src/subscription.ts
-function isGithubUrl(url) {
-  return /github\.com|raw\.githubusercontent\.com/i.test(url);
-}
-function getDefaultUpdateInterval(url) {
-  return isGithubUrl(url) ? DEFAULT_UPDATE_INTERVAL_HOURS_GITHUB : DEFAULT_UPDATE_INTERVAL_HOURS;
-}
-function resolveUpdateInterval(url, cachedInterval) {
-  return cachedInterval && cachedInterval > 0 ? cachedInterval : getDefaultUpdateInterval(url);
-}
-var YAML_DUMP_OPTS = { indent: 2, lineWidth: -1, schema: CORE_SCHEMA };
-var HTTP_CLIENT2 = createHttpClient({ timeout: 6e4 });
-function isMultiUrl(url) {
-  return url.includes(",");
-}
-function splitUrls(url) {
-  return url.split(",").map((u) => u.trim()).filter(Boolean);
+  return renameMap.size;
 }
-function loadSubscriptionConfig(subName) {
-  const rawContent = readSubscriptionRawConfig(subName);
-  if (!rawContent) {
-    throw new Error(`\u672A\u627E\u5230\u8BA2\u9605\u914D\u7F6E "${subName}"`);
+function cleanDeadProxies(parsed, deadNames) {
+  const { proxies, proxyGroups } = parsed;
+  const originalCount = proxies.length;
+  parsed.proxies = proxies.filter((p) => !deadNames.has(p.name));
+  const removedProxies = originalCount - parsed.proxies.length;
+  let updatedGroups = 0;
+  const removedGroupNames = /* @__PURE__ */ new Set();
+  for (const group of proxyGroups) {
+    if (Array.isArray(group.proxies)) {
+      const before = group.proxies.length;
+      group.proxies = group.proxies.filter((name) => !deadNames.has(name));
+      if (group.proxies.length < before) {
+        updatedGroups++;
+      }
+      if (group.proxies.length === 0) {
+        removedGroupNames.add(group.name);
+      }
+    }
   }
-  const raw = parseYamlOrJson(rawContent, "\u8BA2\u9605\u5185\u5BB9");
-  return {
-    raw,
-    proxies: raw.proxies || [],
-    proxyGroups: raw["proxy-groups"] || []
-  };
-}
-function saveSubscriptionConfig(subName, parsed) {
-  normalizeProxyNamesBeforeSave(parsed);
-  parsed.raw.proxies = parsed.proxies;
-  parsed.raw["proxy-groups"] = parsed.proxyGroups;
-  saveSubscriptionRawConfig(subName, dump(parsed.raw, YAML_DUMP_OPTS));
-}
-function parseUserInfo(header) {
-  if (!header) return null;
-  const info = {};
-  const parts = header.split(";").map((p) => p.trim());
-  for (const part of parts) {
-    const [key, val] = part.split("=").map((s) => s.trim());
-    if (key && val !== void 0) {
-      const numVal = parseFloat(val);
-      info[key] = Number.isNaN(numVal) ? 0 : numVal;
+  if (removedGroupNames.size > 0) {
+    parsed.proxyGroups = proxyGroups.filter((g) => !removedGroupNames.has(g.name));
+    for (const group of parsed.proxyGroups) {
+      if (Array.isArray(group.proxies)) {
+        group.proxies = group.proxies.filter((name) => !removedGroupNames.has(name));
+      }
+    }
+    const rules = parsed.raw.rules;
+    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 info;
-}
-function parsePositiveInterval(header) {
-  if (!header) return null;
-  const n = parseInt(header, 10);
-  return Number.isFinite(n) && n > 0 ? n : null;
+  return { removedProxies, updatedGroups, removedGroups: removedGroupNames.size };
 }
-function parseUsernameFromContentDisposition(header) {
-  if (!header) return null;
-  const match = header.match(/filename\s*=\s*["']?([^"';\s]+)["']?/i);
-  if (!match) return null;
-  const filename = match[1];
-  const parts = filename.split("/");
-  return parts[parts.length - 1] || null;
-}
-function extractSubscriptionMeta(headers) {
-  return {
-    userInfo: parseUserInfo(headers?.get("subscription-userinfo") ?? null),
-    updateInterval: parsePositiveInterval(headers?.get("profile-update-interval")),
-    webPageUrl: headers?.get("profile-web-page-url") || null,
-    username: parseUsernameFromContentDisposition(headers?.get("content-disposition") ?? null)
-  };
-}
-function saveSubscriptionMeta(subName, meta) {
-  const cacheData = { updated_at: (/* @__PURE__ */ new Date()).toISOString() };
-  if (meta.userInfo) {
-    cacheData.upload = meta.userInfo.upload;
-    cacheData.download = meta.userInfo.download;
-    cacheData.total = meta.userInfo.total;
-    cacheData.expire = meta.userInfo.expire;
+async function autoCleanSubscription(subName, options = {}) {
+  const parsed = loadSubscriptionConfig(subName);
+  const { onResult, onRetryRound, rounds = DEFAULT_CLEAN_ROUNDS, ...testOptions } = options;
+  const wrapOnResult = (round) => onResult ? (r, i, t) => onResult(r, i, t, round) : void 0;
+  const summary = await testSubscriptionProxies(subName, {
+    ...testOptions,
+    parsed,
+    onResult: wrapOnResult(1)
+  });
+  let removedProxies = 0;
+  let updatedGroups = 0;
+  let removedGroups = 0;
+  let skipped = false;
+  if (summary.dead > 0) {
+    if (summary.alive === 0 || summary.alive / summary.total < 0.01) {
+      skipped = true;
+    } else {
+      const deadNames = new Set(summary.results.filter((r) => r.delay === null).map((r) => r.name));
+      const deadProxies = parsed.proxies.filter((p) => deadNames.has(p.name));
+      for (let retry = 0; retry < rounds - 1; retry++) {
+        const round = retry + 2;
+        const retryTargets = deadProxies.filter((p) => deadNames.has(p.name));
+        if (retryTargets.length === 0) break;
+        onRetryRound?.(round, retryTargets.length);
+        const retryParsed = { raw: {}, proxies: retryTargets, proxyGroups: [] };
+        const retrySummary = await testSubscriptionProxies(subName, {
+          ...testOptions,
+          parsed: retryParsed,
+          onResult: wrapOnResult(round)
+        });
+        for (const r of retrySummary.results) {
+          if (r.delay !== null) {
+            deadNames.delete(r.name);
+          }
+        }
+      }
+      summary.dead = deadNames.size;
+      summary.alive = summary.total - summary.dead;
+      if (deadNames.size > 0) {
+        const cleanResult = cleanDeadProxies(parsed, deadNames);
+        removedProxies = cleanResult.removedProxies;
+        updatedGroups = cleanResult.updatedGroups;
+        removedGroups = cleanResult.removedGroups;
+      }
+    }
   }
-  if (meta.updateInterval) cacheData.update_interval = meta.updateInterval;
-  if (meta.webPageUrl) cacheData.web_page_url = meta.webPageUrl;
-  if (meta.username) cacheData.username = meta.username;
-  saveSubscriptionCache(subName, cacheData);
-}
-function formatProxySummary(info) {
-  const parts = [];
-  if (info.proxyGroups && info.proxyGroups > 0) parts.push(`${info.proxyGroups} \u7EC4`);
-  parts.push(`${info.proxies || 0} \u8282\u70B9`);
-  return parts.join(", ");
+  if (!skipped && removedProxies > 0) {
+    saveSubscriptionConfig(subName, parsed);
+  }
+  return { summary, removedProxies, updatedGroups, removedGroups, skipped };
 }
-function getActiveSubscription() {
-  const subs = getSubscriptions();
-  if (subs.length === 0) return null;
-  const settings = readSettings();
-  const activeName = settings.active_subscription;
-  if (activeName) {
-    const found = subs.find((s) => s.name === activeName);
-    if (found) return found;
+
+// src/commands/daemon.ts
+function printDaemonStatus() {
+  const status = getDaemonStatus();
+  const stateText = status.enabled ? colors.green("\u5DF2\u542F\u7528") : colors.yellow("\u5DF2\u7981\u7528");
+  console.log(`${colors.gray("\u4FDD\u6D3B: ")}${stateText}`);
+  if (status.enabled) {
+    const runText = isDaemonRunning(status) ? colors.green(`\u8FD0\u884C\u4E2D (PID ${status.pid})`) : colors.yellow("\u672A\u8FD0\u884C");
+    console.log(`${colors.gray("\u5185\u6838: ")}${runText}`);
   }
-  return subs[0];
+  console.log("");
+  if (status.enabled) {
+    console.log("\u5173\u95ED\u4FDD\u6D3B: mihomo daemon off");
+  } else {
+    console.log("\u5F00\u542F\u4FDD\u6D3B: mihomo daemon on");
+    console.log(colors.gray("  \u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u81EA\u52A8\u91CD\u542F\uFF08\u4EC5 Mixed \u6A21\u5F0F\uFF09"));
+  }
+  console.log("");
 }
-function findSubscriptionFuzzy(subs, pattern) {
-  const lowerPattern = pattern.toLowerCase();
-  const exact = [];
-  const prefix = [];
-  const includes = [];
-  for (const s of subs) {
-    const name = s.name.toLowerCase();
-    if (name === lowerPattern) {
-      exact.push(s);
-    } else if (name.startsWith(lowerPattern)) {
-      prefix.push(s);
-    } else if (name.includes(lowerPattern)) {
-      includes.push(s);
+async function cmdDaemon(args) {
+  const action = args?.[1];
+  if (action === "on" || action === "enable") {
+    if (!hasKernel()) {
+      console.error('\u9519\u8BEF: \u672A\u627E\u5230\u5185\u6838\uFF0C\u8BF7\u8FD0\u884C "mihomo kernel"');
+      process.exit(1);
     }
+    const sub = getActiveSubscription();
+    if (!sub) {
+      console.error("\u9519\u8BEF: \u6CA1\u6709\u8BA2\u9605\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605");
+      process.exit(1);
+    }
+    let configInfo;
+    try {
+      configInfo = prepareConfigForStart("mixed", sub.name);
+    } catch (e) {
+      console.error(`${colors.red("\u914D\u7F6E\u9519\u8BEF:")} ${e.message}`);
+      process.exit(1);
+    }
+    try {
+      enableDaemon();
+    } catch (e) {
+      console.error(`${colors.red("\u542F\u7528\u4FDD\u6D3B\u5931\u8D25:")} ${e.message}`);
+      process.exit(1);
+    }
+    console.log(`${colors.green("\u5DF2\u542F\u7528\u4FDD\u6D3B")} \xB7 ${sub.name} \xB7 ${formatProxySummary(configInfo)}`);
+    console.log(colors.gray("\u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u81EA\u52A8\u91CD\u542F\uFF0C\u4EE3\u7406\u5C06\u5728\u540E\u53F0\u5E38\u9A7B"));
+    console.log("");
+    printDaemonStatus();
+    return;
   }
-  if (exact.length > 0) return exact;
-  if (prefix.length > 0) return prefix;
-  return includes;
-}
-function pickSingleSubscription(subs, pattern) {
-  if (subs.length === 0) {
-    console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u5339\u914D "${pattern}" \u7684\u8BA2\u9605`);
+  if (action === "off" || action === "disable") {
+    if (!isDaemonEnabled()) {
+      console.log("\u4FDD\u6D3B\u5DF2\u662F\u5173\u95ED\u72B6\u6001");
+      console.log("");
+      printDaemonStatus();
+      return;
+    }
+    try {
+      disableDaemon();
+    } catch (e) {
+      console.error(`${colors.red("\u5173\u95ED\u4FDD\u6D3B\u5931\u8D25:")} ${e.message}`);
+      process.exit(1);
+    }
+    console.log(`${colors.green("\u5DF2\u5173\u95ED\u4FDD\u6D3B")}\uFF0C\u4EE3\u7406\u5DF2\u505C\u6B62`);
+    console.log(colors.gray("\u91CD\u65B0\u542F\u7528: mihomo daemon on"));
+    console.log("");
+    return;
+  }
+  if (action !== void 0 && action !== "status") {
+    console.error(`\u9519\u8BEF: \u672A\u77E5\u7684 daemon \u5B50\u547D\u4EE4: ${action}`);
+    console.log("");
+    console.log("\u53EF\u7528\u5B50\u547D\u4EE4: on, off, status");
     process.exit(1);
   }
-  if (subs.length === 1) return subs[0];
-  console.error("\u9519\u8BEF: \u5339\u914D\u5230\u591A\u4E2A\u8BA2\u9605\uFF0C\u8BF7\u66F4\u7CBE\u786E\u6307\u5B9A");
-  console.log("\n\u5339\u914D\u7684\u8BA2\u9605:");
-  for (const s of subs) console.log(`  ${s.name}`);
-  process.exit(1);
+  console.log("");
+  printDaemonStatus();
 }
-async function downloadSubscription(url, subName = "default", signal) {
-  let response;
-  try {
-    response = await HTTP_CLIENT2.get(url, { responseType: "text", signal });
-  } catch (e) {
-    const maskedUrl = maskUrl(url);
-    let errorMsg = `\u83B7\u53D6\u8BA2\u9605\u5931\u8D25: ${e.message}`;
-    const err = e;
-    if (err.response) {
-      errorMsg += ` (HTTP ${err.response.status})`;
+
+// src/commands/directory.ts
+function cmdDirectory(args) {
+  const action = args?.[1];
+  if (action === "open") {
+    const target = args[2];
+    if (!target || target === "root") {
+      console.log("\u6B63\u5728\u6253\u5F00: \u6839\u76EE\u5F55");
+      const success = openUrl(USER_DATA_DIR);
+      if (!success) {
+        console.log(`\u8BF7\u624B\u52A8\u6253\u5F00: ${USER_DATA_DIR}`);
+      }
+      return;
     }
-    errorMsg += `
-  URL: ${maskedUrl}`;
-    throw new Error(errorMsg);
-  }
-  const content = response.data;
-  if (!content?.trim()) {
-    throw new Error("\u8BA2\u9605\u5185\u5BB9\u4E3A\u7A7A");
+    const key = target.toLowerCase();
+    const targetInfo = Object.hasOwn(DIRECTORY_TARGETS, key) ? DIRECTORY_TARGETS[key] : void 0;
+    if (targetInfo) {
+      const targetPath = targetInfo.path || USER_DATA_DIR;
+      console.log(`\u6B63\u5728\u6253\u5F00: ${targetInfo.label}`);
+      const success = openUrl(targetPath);
+      if (!success) {
+        console.log(`\u8BF7\u624B\u52A8\u6253\u5F00: ${targetPath}`);
+      }
+      return;
+    }
+    console.error(`\u9519\u8BEF: \u672A\u77E5\u7684\u76EE\u5F55\u76EE\u6807 "${target}"`);
+    console.log("");
+    console.log("\u53EF\u7528\u76EE\u6807:");
+    console.log("  root (\u9ED8\u8BA4)   \u6839\u76EE\u5F55");
+    for (const [key2, val] of Object.entries(DIRECTORY_TARGETS)) {
+      if (key2 !== "root") {
+        console.log(`  ${key2.padEnd(14)}${val.label}`);
+      }
+    }
+    console.log("");
+    process.exit(1);
   }
-  const parsed = parseYamlOrJson(content, "\u8BA2\u9605\u5185\u5BB9");
-  if (!parsed) throw new Error("\u8BA2\u9605\u5185\u5BB9\u4E3A\u7A7A");
-  saveSubscriptionRawConfig(subName, content);
-  const meta = extractSubscriptionMeta(response.headers);
-  saveSubscriptionMeta(subName, meta);
-  const proxies = parsed.proxies;
-  const proxyGroups = parsed["proxy-groups"];
-  return {
-    proxies: proxies ? proxies.length : 0,
-    proxyGroups: proxyGroups ? proxyGroups.length : 0,
-    userInfo: meta.userInfo,
-    updateInterval: meta.updateInterval,
-    webPageUrl: meta.webPageUrl,
-    username: meta.username
-  };
+  console.log("");
+  console.log("\u6570\u636E\u76EE\u5F55\u4F4D\u7F6E:");
+  console.log(`  \u6839\u76EE\u5F55: ${USER_DATA_DIR}`);
+  console.log(`  \u5168\u5C40\u8BBE\u7F6E: ${PATHS.settingsFile}`);
+  console.log(`  \u5185\u6838\u76EE\u5F55: ${DIRS.kernel}`);
+  console.log(`  \u5185\u6838\u6587\u4EF6: ${PATHS.mihomoBinary}`);
+  console.log(`  \u8BA2\u9605\u76EE\u5F55: ${DIRS.subscriptions}`);
+  console.log("    - cache.json (\u8BA2\u9605\u7F13\u5B58\uFF1A\u66F4\u65B0\u65F6\u95F4\u3001\u6D41\u91CF\u7B49)");
+  console.log("    - xxx.yaml (\u8BA2\u9605\u539F\u59CB\u914D\u7F6E)");
+  console.log(`  \u8FD0\u884C\u65F6\u76EE\u5F55: ${DIRS.runtime}`);
+  console.log("    - config.yaml (\u542F\u52A8\u65F6\u751F\u6210\uFF0Cstop \u81EA\u52A8\u6E05\u9664)");
+  console.log("    - pid (PID \u6587\u4EF6\uFF0Cstop \u81EA\u52A8\u6E05\u9664)");
+  console.log(`  \u65E5\u5FD7\u6587\u4EF6: ${PATHS.logFile}`);
+  console.log(`  mihomo \u6570\u636E: ${DIRS.data}`);
+  console.log("    - cache.db, Geo*.dat \u7B49 (mihomo \u81EA\u884C\u7BA1\u7406)");
+  console.log("");
+  console.log("\u6253\u5F00\u76EE\u5F55:");
+  console.log("  mihomo dir open                \u6253\u5F00\u6839\u76EE\u5F55");
+  console.log("  mihomo dir open subs           \u6253\u5F00\u8BA2\u9605\u76EE\u5F55");
+  console.log("  mihomo dir open logs           \u6253\u5F00\u65E5\u5FD7\u76EE\u5F55");
+  console.log("  mihomo dir open data           \u6253\u5F00 mihomo \u6570\u636E\u76EE\u5F55");
+  console.log("  mihomo dir open runtime        \u6253\u5F00\u8FD0\u884C\u65F6\u76EE\u5F55");
+  console.log("  mihomo dir open kernel         \u6253\u5F00\u5185\u6838\u76EE\u5F55");
+  console.log("");
+  console.log("\u73AF\u5883\u53D8\u91CF:");
+  console.log("  MIHOMO_CLI_DIR: \u81EA\u5B9A\u4E49\u6839\u76EE\u5F55\u4F4D\u7F6E");
+  console.log("");
 }
-async function downloadMergedSubscription(urls, subName, signal) {
-  const responses = await Promise.all(
-    urls.map(async (url, index) => {
-      try {
-        const response = await HTTP_CLIENT2.get(url, { responseType: "text", signal });
-        return { url, index, response, error: null };
-      } catch (e) {
-        return { url, index, response: null, error: e };
-      }
-    })
+
+// 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
+`
   );
-  for (const r of responses) {
-    if (r.error) {
-      const maskedUrl = maskUrl(r.url);
-      throw new Error(`\u5408\u5E76\u8BA2\u9605\u7B2C ${r.index + 1} \u4E2A URL \u83B7\u53D6\u5931\u8D25: ${r.error.message}
-  URL: ${maskedUrl}`);
-    }
+}
+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";
+
+// node_modules/compare-versions/lib/esm/utils.js
+var semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+var validateAndParse = (version) => {
+  if (typeof version !== "string") {
+    throw new TypeError("Invalid argument expected string");
   }
-  const parsed = responses.map((r, i) => {
-    const content = r.response?.data;
-    if (!content?.trim()) throw new Error(`\u5408\u5E76\u8BA2\u9605\u7B2C ${i + 1} \u4E2A URL \u5185\u5BB9\u4E3A\u7A7A`);
-    return parseYamlOrJson(content, `\u5408\u5E76\u8BA2\u9605\u7B2C ${i + 1} \u4E2A`);
+  const match = version.match(semver);
+  if (!match) {
+    throw new Error(`Invalid argument not valid semver ('${version}' received)`);
+  }
+  match.shift();
+  return match;
+};
+var isWildcard = (s) => s === "*" || s === "x" || s === "X";
+var tryParse = (v) => {
+  const n = parseInt(v, 10);
+  return isNaN(n) ? v : n;
+};
+var forceType = (a, b) => typeof a !== typeof b ? [String(a), String(b)] : [a, b];
+var compareStrings = (a, b) => {
+  if (isWildcard(a) || isWildcard(b))
+    return 0;
+  const [ap, bp] = forceType(tryParse(a), tryParse(b));
+  if (ap > bp)
+    return 1;
+  if (ap < bp)
+    return -1;
+  return 0;
+};
+var compareSegments = (a, b) => {
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const r = compareStrings(a[i] || "0", b[i] || "0");
+    if (r !== 0)
+      return r;
+  }
+  return 0;
+};
+
+// node_modules/compare-versions/lib/esm/compareVersions.js
+var compareVersions = (v1, v2) => {
+  const n1 = validateAndParse(v1);
+  const n2 = validateAndParse(v2);
+  const p1 = n1.pop();
+  const p2 = n2.pop();
+  const r = compareSegments(n1, n2);
+  if (r !== 0)
+    return r;
+  if (p1 && p2) {
+    return compareSegments(p1.split("."), p2.split("."));
+  } else if (p1 || p2) {
+    return p1 ? -1 : 1;
+  }
+  return 0;
+};
+
+// src/kernel.ts
+var GITHUB_REPO = "MetaCubeX/mihomo";
+var KERNEL_HTTP_TIMEOUT = 12e4;
+var KERNEL_DOWNLOAD_TIMEOUT = 18e4;
+var HTTP_CLIENT2 = createHttpClient({ timeout: KERNEL_HTTP_TIMEOUT });
+function withMirror(url, mirror) {
+  if (mirror && (url.startsWith("https://github.com/") || url.startsWith("https://api.github.com/"))) {
+    return mirror + url;
+  }
+  return url;
+}
+function getArch() {
+  const arch = process.arch;
+  if (arch === "arm64") return "arm64";
+  if (arch === "x64") return "amd64";
+  return arch;
+}
+function findMatchingAsset(assets, platform, arch) {
+  const prefix = `mihomo-${platform}-${arch}`;
+  const matchingAssets = assets.filter(
+    (a) => a.name.startsWith(prefix) && a.name.endsWith(".gz") || a.name.startsWith(`${prefix}-`) && a.name.endsWith(".gz")
+  );
+  if (matchingAssets.length === 0) return null;
+  if (matchingAssets.length === 1) return matchingAssets[0];
+  const standardAsset = matchingAssets.find((a) => {
+    const nameWithoutGz = a.name.slice(0, -3);
+    const parts = nameWithoutGz.split("-");
+    const lastPart = parts[parts.length - 1];
+    return /^v?\d+\.\d+\.\d+/.test(lastPart) && !nameWithoutGz.includes("-go");
   });
-  const base = parsed[0];
-  const baseProxies = base.proxies || [];
-  const seenNames = new Set(baseProxies.map((p) => p.name));
-  for (let i = 1; i < parsed.length; i++) {
-    const extraProxies = parsed[i].proxies || [];
-    for (const proxy of extraProxies) {
-      if (!seenNames.has(proxy.name)) {
-        baseProxies.push(proxy);
-        seenNames.add(proxy.name);
-      }
-    }
-  }
-  base.proxies = baseProxies;
-  const mergedContent = dump(base, YAML_DUMP_OPTS);
-  saveSubscriptionRawConfig(subName, mergedContent);
-  const meta = extractSubscriptionMeta(responses[0].response?.headers);
-  saveSubscriptionMeta(subName, meta);
-  const proxyGroups = base["proxy-groups"];
-  return {
-    proxies: baseProxies.length,
-    proxyGroups: proxyGroups ? proxyGroups.length : 0,
-    userInfo: meta.userInfo,
-    updateInterval: meta.updateInterval,
-    webPageUrl: meta.webPageUrl,
-    username: meta.username
-  };
+  return standardAsset || matchingAssets[0];
 }
-function prepareConfigForStart(mode, subName = "default") {
-  const rawContent = readSubscriptionRawConfig(subName);
-  if (!rawContent) {
-    throw new Error(`\u672A\u627E\u5230\u8BA2\u9605\u914D\u7F6E "${subName}"\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605`);
+async function getLatestRelease(repo, mirror) {
+  const url = withMirror(`https://api.github.com/repos/${repo}/releases`, mirror);
+  const response = await HTTP_CLIENT2.get(url, { responseType: "json" });
+  const releases = response.data;
+  if (!Array.isArray(releases) || releases.length === 0) {
+    throw new Error("\u65E0\u6CD5\u83B7\u53D6\u7248\u672C\u4FE1\u606F");
   }
-  const buildResult = buildConfig(rawContent, mode);
-  if (buildResult.warnings.length > 0) {
-    for (const warning of buildResult.warnings) {
-      console.log(`${colors.yellow("\u81EA\u52A8\u4FEE\u590D:")} ${warning}`);
+  const stableReleases = releases.filter(
+    (r) => !r.prerelease && !r.tag_name.toLowerCase().includes("alpha") && !r.tag_name.toLowerCase().includes("beta") && !r.tag_name.toLowerCase().includes("prerelease")
+  );
+  return stableReleases.length > 0 ? stableReleases[0] : releases[0];
+}
+async function checkUpdate(mirror) {
+  const currentVersion = getKernelVersion();
+  const latest = await getLatestRelease(GITHUB_REPO, mirror);
+  const latestVersion = latest.tag_name;
+  let needsUpdate = false;
+  const currentDisplay = currentVersion || "\u672A\u5B89\u88C5";
+  if (!currentVersion) {
+    needsUpdate = true;
+  } else {
+    try {
+      needsUpdate = compareVersions(latestVersion.replace(/^v/, ""), currentVersion.replace(/^v/, "")) > 0;
+    } catch {
+      needsUpdate = latestVersion !== currentVersion;
     }
-    console.log("");
   }
-  writeMihomoConfig(buildResult.config);
-  writeDebugConfig(buildResult);
-  const proxies = buildResult.config.proxies;
-  const proxyGroups = buildResult.config["proxy-groups"];
   return {
-    proxies: proxies ? proxies.length : 0,
-    proxyGroups: proxyGroups ? proxyGroups.length : 0
+    current: currentDisplay,
+    latest: latestVersion,
+    needsUpdate,
+    assets: latest.assets,
+    release: latest
   };
 }
-function needsAutoUpdate(sub) {
-  if (!sub.updated_at) return true;
-  const lastUpdate = new Date(sub.updated_at).getTime();
-  if (Number.isNaN(lastUpdate)) return true;
-  const intervalHours = resolveUpdateInterval(sub.url, sub.update_interval);
-  const intervalMs = intervalHours * 60 * 60 * 1e3;
-  return Date.now() - lastUpdate > intervalMs;
-}
-async function tryUpdateOne(sub, signal) {
-  try {
-    let info;
-    if (isMultiUrl(sub.url)) {
-      info = await downloadMergedSubscription(splitUrls(sub.url), sub.name, signal);
-    } else {
-      info = await downloadSubscription(sub.url, sub.name, signal);
+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 stat = fs7.statSync(fullPath);
+    if (stat.isDirectory()) {
+      const found = findBinaryInDir(fullPath, maxDepth - 1);
+      if (found) return found;
+      continue;
     }
-    return { name: sub.name, success: true, proxies: info.proxies, proxyGroups: info.proxyGroups };
-  } catch (e) {
-    return { name: sub.name, success: false, error: e.message };
+    if (f === "mihomo") return fullPath;
+    if (f.includes("mihomo") && !f.endsWith(".gz")) return fullPath;
   }
+  return null;
 }
-function printUpdateResult(r) {
-  if (r.success) {
-    console.log(`${colors.green("\u2713")} ${r.name}: ${colors.green("\u5DF2\u66F4\u65B0")} (${formatProxySummary(r)})`);
-  } else {
-    console.log(`${colors.red("\u2717")} ${r.name}: ${colors.red("\u5931\u8D25")} (${(r.error || "").split("\n")[0]})`);
+async function downloadKernel(progressCallback, mirror, releaseInfo) {
+  ensureDirs();
+  const latest = releaseInfo || await getLatestRelease(GITHUB_REPO, mirror);
+  const arch = getArch();
+  const platform = process.platform;
+  const asset = findMatchingAsset(latest.assets, platform, arch);
+  if (!asset) {
+    const available = latest.assets.map((a) => a.name).join(", ");
+    let hint = "";
+    if (available) hint = `
+  \u53EF\u7528\u7248\u672C: ${available}`;
+    throw new Error(`\u672A\u627E\u5230\u5339\u914D\u7684\u5185\u6838\u6587\u4EF6
+  \u5E73\u53F0: ${platform}, \u67B6\u6784: ${arch}${hint}`);
   }
-}
-async function autoUpdateStaleSubscription(options = {}) {
-  const allSubs = getSubscriptionsWithCache();
-  const staleSubs = allSubs.filter(needsAutoUpdate);
-  if (staleSubs.length === 0) {
-    return { total: 0, updated: 0, failed: 0 };
+  const downloadUrl = withMirror(asset.browser_download_url, mirror);
+  const tempPath = path5.join(DIRS.kernel, asset.name);
+  const sizeMB = (asset.size / 1024 / 1024).toFixed(2);
+  if (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");
   }
-  if (staleSubs.length === 1) {
-    const sub = staleSubs[0];
-    const interval = resolveUpdateInterval(sub.url, sub.update_interval);
-    console.log(`\u8BA2\u9605 "${sub.name}" \u8D85\u8FC7 ${interval} \u5C0F\u65F6\u672A\u66F4\u65B0\uFF0C\u6B63\u5728\u66F4\u65B0...`);
-  } else {
-    console.log(`\u68C0\u67E5\u5230 ${staleSubs.length} \u4E2A\u8BA2\u9605\u9700\u8981\u66F4\u65B0\uFF0C\u6B63\u5728\u5E76\u884C\u66F4\u65B0...`);
+  if (progressCallback) {
+    progressCallback(`\u4E0B\u8F7D\u5185\u6838: ${asset.name} (${sizeMB} MB)`);
   }
-  const timeoutMs = options.timeout ?? DEFAULT_AUTO_UPDATE_TIMEOUT;
-  const controller = new AbortController();
-  let results;
-  try {
-    results = await withTimeout(Promise.all(staleSubs.map((sub) => tryUpdateOne(sub, controller.signal))), timeoutMs);
-  } catch (e) {
-    if (e instanceof TimeoutError) {
-      controller.abort();
-      console.log(colors.yellow(`\u81EA\u52A8\u66F4\u65B0\u8D85\u65F6 (${timeoutMs / 1e3}s)\uFF0C\u8DF3\u8FC7\u66F4\u65B0\uFF0C\u4F7F\u7528\u7F13\u5B58\u914D\u7F6E`));
-      return { total: staleSubs.length, updated: 0, failed: staleSubs.length };
+  const curlResult = spawnSync5(
+    "curl",
+    ["-L", "--progress-bar", "--connect-timeout", "30", "--max-time", String(Math.floor(KERNEL_DOWNLOAD_TIMEOUT / 1e3)), "-o", tempPath, downloadUrl],
+    { stdio: "inherit" }
+  );
+  if (curlResult.status !== 0) {
+    try {
+      fs7.unlinkSync(tempPath);
+    } catch {
     }
-    throw e;
+    throw new Error(`\u4E0B\u8F7D\u5931\u8D25 (curl \u9000\u51FA\u7801 ${curlResult.status})`);
   }
-  let updatedCount = 0;
-  for (const r of results) {
-    if (r.success) updatedCount++;
-    printUpdateResult(r);
+  if (!fs7.existsSync(tempPath)) {
+    throw new Error("\u4E0B\u8F7D\u5931\u8D25: \u6587\u4EF6\u672A\u751F\u6210");
   }
-  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) {
-  const encodedName = encodeURIComponent(proxyName);
-  const url = `${apiBase}/proxies/${encodedName}/delay?timeout=${timeout}&url=${encodeURIComponent(testUrl)}`;
+  if (progressCallback) {
+    progressCallback("\u89E3\u538B\u5185\u6838...");
+  }
+  const extractPath = DIRS.kernel;
+  let extractedBinary = null;
   try {
-    const response = await client.get(url);
-    const data = JSON.parse(response.data);
-    if (data.delay && data.delay > 0) {
-      return { name: proxyName, delay: data.delay };
+    if (tempPath.endsWith(".tar.gz") || tempPath.endsWith(".tgz")) {
+      const tarResult = spawnSync5("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 = path5.basename(tempPath, ".gz");
+      const outputPath = path5.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}`);
+      fs7.writeFileSync(outputPath, gzipResult.stdout, { mode: 493 });
+      extractedBinary = outputPath;
     }
-    return { name: proxyName, delay: null, error: data.message || "no delay" };
   } catch (e) {
-    const err = e;
-    let errorMsg = "timeout";
-    if (err.response?.data?.message) {
-      errorMsg = String(err.response.data.message);
-    } else if (err.message) {
-      errorMsg = err.message;
+    try {
+      fs7.unlinkSync(tempPath);
+    } catch {
     }
-    return { name: proxyName, delay: null, error: errorMsg };
+    throw new Error(`\u89E3\u538B\u5931\u8D25: ${e.message}`);
   }
-}
-async function testSubscriptionProxies(subName, options = {}) {
-  const { timeout = DEFAULT_TEST_TIMEOUT, concurrency = DEFAULT_TEST_CONCURRENCY, testUrl = DEFAULT_TEST_URL, apiBase = API_BASE, onResult } = options;
-  const { proxies } = options.parsed || loadSubscriptionConfig(subName);
-  if (proxies.length === 0) {
-    return { total: 0, alive: 0, dead: 0, results: [] };
+  const foundBinary = extractedBinary || findBinaryInDir(extractPath);
+  if (!foundBinary) {
+    try {
+      fs7.unlinkSync(tempPath);
+    } catch {
+    }
+    throw new Error("\u89E3\u538B\u540E\u672A\u627E\u5230\u53EF\u6267\u884C\u6587\u4EF6");
   }
-  const client = createHttpClient({ timeout: timeout + 3e3 });
-  const results = new Array(proxies.length);
-  let completedCount = 0;
-  let nextIndex = 0;
-  async function runNext() {
-    while (nextIndex < proxies.length) {
-      const idx = nextIndex++;
-      const result = await testProxyDelay(proxies[idx].name, timeout, testUrl, client, apiBase);
-      results[idx] = result;
-      onResult?.(result, completedCount, proxies.length);
-      completedCount++;
+  const targetPath = PATHS.mihomoBinary;
+  if (foundBinary !== targetPath) {
+    if (fs7.existsSync(targetPath)) {
+      fs7.chmodSync(targetPath, 493);
+      try {
+        fs7.unlinkSync(targetPath);
+      } catch {
+      }
     }
+    fs7.renameSync(foundBinary, targetPath);
   }
-  const workers = Array.from({ length: Math.min(concurrency, proxies.length) }, () => runNext());
-  await Promise.all(workers);
-  const alive = results.filter((r) => r.delay !== null).length;
-  return { total: results.length, alive, dead: results.length - alive, results };
-}
-function normalizeProxyNamesBeforeSave(parsed) {
-  const { proxies, proxyGroups } = parsed;
-  const renameMap = /* @__PURE__ */ new Map();
-  const usedNames = /* @__PURE__ */ new Set();
-  for (const proxy of proxies) {
-    const shortened = proxy.name.replace(/_github\.com\/[^_]+/, "");
-    if (shortened !== proxy.name && !usedNames.has(shortened)) {
-      renameMap.set(proxy.name, shortened);
-      usedNames.add(shortened);
-    } else {
-      usedNames.add(proxy.name);
+  fs7.chmodSync(targetPath, 493);
+  if (progressCallback) {
+    progressCallback("\u6821\u9A8C\u5185\u6838...");
+  }
+  const check = spawnSync5(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 {
+      fs7.unlinkSync(targetPath);
+    } catch {
     }
+    try {
+      fs7.unlinkSync(tempPath);
+    } catch {
+    }
+    throw new Error(`\u5185\u6838\u81EA\u68C0\u5931\u8D25\uFF08\u53EF\u80FD\u4E0B\u8F7D\u635F\u574F\u6216\u67B6\u6784\u4E0D\u5339\u914D\uFF09\uFF0C\u5DF2\u5220\u9664
+  \u9000\u51FA\u7801: ${check.status}
+  \u8F93\u51FA: ${checkOutput || "(\u7A7A)"}`);
+  }
+  try {
+    fs7.unlinkSync(tempPath);
+  } catch {
+  }
+  clearKernelVersionCache();
+  return { version: latest.tag_name, path: targetPath };
+}
+
+// src/commands/kernel.ts
+async function cmdKernel(args) {
+  const mirrorInfo = parseMirrorArg(args);
+  const effectiveMirror = mirrorInfo.mirror;
+  if (effectiveMirror) {
+    const mirrorDesc = mirrorInfo.type === "all" ? " (API\u548C\u4E0B\u8F7D\u5747\u4F7F\u7528\u955C\u50CF)" : " (\u4E0B\u8F7D\u65F6\u4F7F\u7528\u955C\u50CF)";
+    console.log(`\u955C\u50CF: ${effectiveMirror}${mirrorDesc}`);
   }
-  if (renameMap.size === 0) return 0;
-  for (const proxy of proxies) {
-    const newName = renameMap.get(proxy.name);
-    if (newName) proxy.name = newName;
+  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)" : ""}`);
   }
-  for (const group of proxyGroups) {
-    if (Array.isArray(group.proxies)) {
-      group.proxies = group.proxies.map((name) => renameMap.get(name) || name);
+  console.log("");
+  console.log("\u68C0\u67E5\u5185\u6838\u66F4\u65B0...");
+  try {
+    const apiMirror = mirrorInfo.type === "all" ? effectiveMirror : null;
+    const info = await checkUpdate(apiMirror);
+    console.log(`\u5F53\u524D: ${info.current}`);
+    console.log(`\u6700\u65B0: ${info.latest}`);
+    if (!info.needsUpdate) {
+      console.log("\u5DF2\u662F\u6700\u65B0\u7248\u672C");
+    } else {
+      console.log("\n\u6B63\u5728\u4E0B\u8F7D...");
+      const result = await downloadKernel((msg) => console.log(msg), mirrorInfo.mirror, info.release);
+      console.log(`
+\u5DF2\u66F4\u65B0\u5230 ${result.version}`);
     }
-  }
-  return renameMap.size;
-}
-function cleanDeadProxies(parsed, deadNames) {
-  const { proxies, proxyGroups } = parsed;
-  const originalCount = proxies.length;
-  parsed.proxies = proxies.filter((p) => !deadNames.has(p.name));
-  const removedProxies = originalCount - parsed.proxies.length;
-  let updatedGroups = 0;
-  const removedGroupNames = /* @__PURE__ */ new Set();
-  for (const group of proxyGroups) {
-    if (Array.isArray(group.proxies)) {
-      const before = group.proxies.length;
-      group.proxies = group.proxies.filter((name) => !deadNames.has(name));
-      if (group.proxies.length < before) {
-        updatedGroups++;
+  } catch (e) {
+    console.error(`
+\u66F4\u65B0\u5931\u8D25: ${e.message}`);
+    const err = e;
+    if (err.response?.data) {
+      if (err.response.data.message) {
+        console.error(`\u539F\u56E0: ${err.response.data.message}`);
       }
-      if (group.proxies.length === 0) {
-        removedGroupNames.add(group.name);
+      if (err.response.data.documentation_url) {
+        console.error(`\u6587\u6863: ${err.response.data.documentation_url}`);
       }
     }
+    process.exit(1);
   }
-  if (removedGroupNames.size > 0) {
-    parsed.proxyGroups = proxyGroups.filter((g) => !removedGroupNames.has(g.name));
-    for (const group of parsed.proxyGroups) {
-      if (Array.isArray(group.proxies)) {
-        group.proxies = group.proxies.filter((name) => !removedGroupNames.has(name));
-      }
-    }
-    const rules = parsed.raw.rules;
-    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());
-      });
-    }
+}
+
+// src/commands/log.ts
+function cmdLog(args) {
+  const logPath = getLogPath();
+  if (hasFlag(args, "-o", "--open")) {
+    openLogFile(logPath);
+    return;
   }
-  return { removedProxies, updatedGroups, removedGroups: removedGroupNames.size };
+  viewLogWithTail(logPath, { follow: true, lines: 50 });
 }
-async function autoCleanSubscription(subName, options = {}) {
-  const parsed = loadSubscriptionConfig(subName);
-  const { onResult, onRetryRound, rounds = DEFAULT_CLEAN_ROUNDS, ...testOptions } = options;
-  const wrapOnResult = (round) => onResult ? (r, i, t) => onResult(r, i, t, round) : void 0;
-  const summary = await testSubscriptionProxies(subName, {
-    ...testOptions,
-    parsed,
-    onResult: wrapOnResult(1)
-  });
-  let removedProxies = 0;
-  let updatedGroups = 0;
-  let removedGroups = 0;
-  let skipped = false;
-  if (summary.dead > 0) {
-    if (summary.alive === 0 || summary.alive / summary.total < 0.01) {
-      skipped = true;
+function cmdLogs(args) {
+  const targetName = getNonFlagArg(args, 1);
+  const lines = parseIntArg(args, "-n", "--lines", 100);
+  const openInViewer = hasFlag(args, "-o", "--open");
+  if (targetName) {
+    let logPath;
+    if (targetName === "current" || targetName === "0") {
+      logPath = getLogPath();
     } else {
-      const deadNames = new Set(summary.results.filter((r) => r.delay === null).map((r) => r.name));
-      const deadProxies = parsed.proxies.filter((p) => deadNames.has(p.name));
-      for (let retry = 0; retry < rounds - 1; retry++) {
-        const round = retry + 2;
-        const retryTargets = deadProxies.filter((p) => deadNames.has(p.name));
-        if (retryTargets.length === 0) break;
-        onRetryRound?.(round, retryTargets.length);
-        const retryParsed = { raw: {}, proxies: retryTargets, proxyGroups: [] };
-        const retrySummary = await testSubscriptionProxies(subName, {
-          ...testOptions,
-          parsed: retryParsed,
-          onResult: wrapOnResult(round)
-        });
-        for (const r of retrySummary.results) {
-          if (r.delay !== null) {
-            deadNames.delete(r.name);
-          }
+      const parsedIdx = parseInt(targetName, 10);
+      if (!Number.isNaN(parsedIdx) && parsedIdx > 0 && String(parsedIdx) === targetName) {
+        const archiveLogs = listLogs();
+        const archive = archiveLogs.archives[parsedIdx - 1];
+        if (!archive) {
+          console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u65E5\u5FD7 "${targetName}"`);
+          console.log('\u4F7F\u7528 "mihomo logs" \u67E5\u770B\u53EF\u7528\u65E5\u5FD7\u5217\u8868');
+          process.exit(1);
         }
+        logPath = archive.path;
+      } else {
+        logPath = getLogPathByName(targetName);
       }
-      summary.dead = deadNames.size;
-      summary.alive = summary.total - summary.dead;
-      if (deadNames.size > 0) {
-        const cleanResult = cleanDeadProxies(parsed, deadNames);
-        removedProxies = cleanResult.removedProxies;
-        updatedGroups = cleanResult.updatedGroups;
-        removedGroups = cleanResult.removedGroups;
-      }
     }
+    if (!logPath) {
+      console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u65E5\u5FD7 "${targetName}"`);
+      console.log('\u4F7F\u7528 "mihomo logs" \u67E5\u770B\u53EF\u7528\u65E5\u5FD7\u5217\u8868');
+      process.exit(1);
+    }
+    if (openInViewer) {
+      openLogFile(logPath);
+      return;
+    }
+    viewLogWithTail(logPath, { follow: false, lines });
+    return;
   }
-  if (!skipped && removedProxies > 0) {
-    saveSubscriptionConfig(subName, parsed);
+  const logs = listLogs();
+  const all = [];
+  if (logs.current) all.push(logs.current);
+  all.push(...logs.archives);
+  if (all.length === 0) {
+    console.log("\u6682\u65E0\u65E5\u5FD7");
+    return;
   }
-  return { summary, removedProxies, updatedGroups, removedGroups, skipped };
+  console.log("");
+  console.log("\u65E5\u5FD7\u5217\u8868:");
+  console.log("");
+  let archiveCounter = 0;
+  for (const log of all) {
+    let num;
+    if (log.isCurrent) {
+      num = " 0";
+    } else {
+      archiveCounter++;
+      num = archiveCounter < 10 ? ` ${archiveCounter}` : `${archiveCounter}`;
+    }
+    const time = formatDate(log.mtime);
+    const size = formatBytes(log.size);
+    const name = log.isCurrent ? "mihomo.log (\u5F53\u524D\u8FD0\u884C\u4E2D)" : log.name;
+    console.log(` ${num}. ${name}`);
+    console.log(`    \u65F6\u95F4: ${time}  \u5927\u5C0F: ${size}`);
+    if (!log.isCurrent) {
+      console.log(`    \u67E5\u770B: mihomo logs ${archiveCounter}  \u6216  mihomo logs ${archiveCounter} -o`);
+    }
+    console.log("");
+  }
+  console.log("\u7528\u6CD5:");
+  console.log("  mihomo logs 0          # \u67E5\u770B\u5F53\u524D\u65E5\u5FD7 (\u6700\u540E 100 \u884C)");
+  console.log("  mihomo logs 1          # \u67E5\u770B\u7B2C 1 \u4E2A\u5F52\u6863\u65E5\u5FD7\uFF08\u6700\u65B0\uFF09");
+  console.log("  mihomo logs 1 -n 200   # \u67E5\u770B 200 \u884C");
+  console.log("  mihomo logs 1 -o       # \u7528\u7CFB\u7EDF\u9ED8\u8BA4\u7A0B\u5E8F\u6253\u5F00");
+  console.log("");
 }
 
+// src/commands/overwrite.ts
+import path7 from "path";
+
 // src/commands/status.ts
 function printStatus() {
   const status = getStatus();
+  const daemon = getDaemonStatus();
   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;
   console.log("");
   let modeLabel = "";
-  if (info && status.running) {
+  if (info && running) {
     modeLabel = colors.cyan(info.tun ? " (TUN)" : " (Mixed)");
   }
-  const statusText = status.running ? colors.green("\u25CF \u8FD0\u884C\u4E2D") : colors.yellow("\u4E0D\u5728\u8FD0\u884C");
+  const statusText = running ? colors.green("\u25CF \u8FD0\u884C\u4E2D") : colors.yellow("\u4E0D\u5728\u8FD0\u884C");
   console.log(`${colors.gray("\u72B6\u6001: ")}${statusText}${modeLabel}`);
   console.log(`${colors.gray("\u5185\u6838: ")}${status.kernelVersion || "\u672A\u5B89\u88C5"}`);
-  if (status.pid) {
-    console.log(`${colors.gray("PID:  ")}${status.pid}`);
-    if (status.processInfo) {
+  if (pid) {
+    console.log(`${colors.gray("PID:  ")}${pid}`);
+    if (!daemon.enabled && status.processInfo) {
       console.log(`${colors.gray("\u5185\u5B58: ")}${status.processInfo.memory}`);
     }
   }
@@ -5316,6 +5537,9 @@ function printStatus() {
   } else {
     console.log(`${colors.gray("\u8986\u5199: ")}${colors.yellow("\u5DF2\u7981\u7528")}`);
   }
+  if (daemon.enabled) {
+    console.log(`${colors.gray("\u4FDD\u6D3B: ")}${colors.green("\u5DF2\u542F\u7528")} ${colors.gray("(\u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u91CD\u542F)")}`);
+  }
   console.log("");
 }
 
@@ -5328,6 +5552,11 @@ function handleStopResult(result) {
   }
 }
 async function cmdStop() {
+  if (isDaemonEnabled()) {
+    console.log(colors.yellow("\u4FDD\u6D3B\u5DF2\u542F\u7528\uFF0C\u4EE3\u7406\u7531 launchd \u6258\u7BA1"));
+    console.log("\u76F4\u63A5\u505C\u6B62\u4F1A\u88AB\u81EA\u52A8\u91CD\u65B0\u62C9\u8D77\uFF0C\u8BF7\u7528: mihomo daemon off");
+    return;
+  }
   const pids = getAllMihomoPids();
   if (pids.length === 0) {
     console.log(colors.yellow("\u4E0D\u5728\u8FD0\u884C"));
@@ -5340,8 +5569,8 @@ async function cmdStop() {
 
 // src/test-instance.ts
 import { spawn as spawn2 } from "child_process";
-import fs7 from "fs";
-import path5 from "path";
+import fs8 from "fs";
+import path6 from "path";
 
 // src/lifecycle.ts
 var cleanupFns = /* @__PURE__ */ new Set();
@@ -5362,20 +5591,20 @@ function runCleanup() {
 }
 
 // src/test-instance.ts
-var TEST_DIR = path5.join(USER_DATA_DIR, "test");
+var TEST_DIR = path6.join(USER_DATA_DIR, "test");
 var TEST_DIRS = {
-  data: path5.join(TEST_DIR, "data"),
-  runtime: path5.join(TEST_DIR, "runtime")
+  data: path6.join(TEST_DIR, "data"),
+  runtime: path6.join(TEST_DIR, "runtime")
 };
 var TEST_PATHS = {
-  configFile: path5.join(TEST_DIRS.runtime, "config.yaml"),
-  pidFile: path5.join(TEST_DIRS.runtime, "pid"),
-  logFile: path5.join(TEST_DIR, "test.log")
+  configFile: path6.join(TEST_DIRS.runtime, "config.yaml"),
+  pidFile: path6.join(TEST_DIRS.runtime, "pid"),
+  logFile: path6.join(TEST_DIR, "test.log")
 };
 var TEST_API = `http://${TEST_CONFIG["external-controller"]}`;
 function ensureTestDirs() {
   for (const dir of Object.values(TEST_DIRS)) {
-    fs7.mkdirSync(dir, { recursive: true, mode: 448 });
+    fs8.mkdirSync(dir, { recursive: true, mode: 448 });
   }
 }
 function cleanupTestDir() {
@@ -5413,21 +5642,21 @@ function buildTestConfig(subName) {
     rules: ["MATCH,PROXY"]
   };
   const content = dump(config, { indent: 2, lineWidth: -1, schema: CORE_SCHEMA });
-  fs7.writeFileSync(TEST_PATHS.configFile, content, { mode: 384 });
+  fs8.writeFileSync(TEST_PATHS.configFile, content, { mode: 384 });
 }
 async function startTestInstance() {
   const binary = PATHS.mihomoBinary;
-  if (!fs7.existsSync(binary)) throw new Error("\u672A\u627E\u5230 mihomo \u5185\u6838");
+  if (!fs8.existsSync(binary)) throw new Error("\u672A\u627E\u5230 mihomo \u5185\u6838");
   stopTestInstance();
-  const logFd = fs7.openSync(TEST_PATHS.logFile, "a");
+  const logFd = fs8.openSync(TEST_PATHS.logFile, "a");
   const child = spawn2(binary, ["-d", TEST_DIRS.data, "-f", TEST_PATHS.configFile], {
     detached: true,
     stdio: ["ignore", logFd, logFd]
   });
-  fs7.closeSync(logFd);
+  fs8.closeSync(logFd);
   child.unref();
   const pid = child.pid;
-  fs7.writeFileSync(TEST_PATHS.pidFile, pid.toString(), { mode: 384 });
+  fs8.writeFileSync(TEST_PATHS.pidFile, pid.toString(), { mode: 384 });
   const client = createHttpClient({ timeout: 2e3 });
   let ready = false;
   for (let i = 0; i < 60; i++) {
@@ -5443,7 +5672,7 @@ async function startTestInstance() {
   if (!isProcessRunning(pid)) {
     let errorDetail = "";
     try {
-      errorDetail = fs7.readFileSync(TEST_PATHS.logFile, "utf8").slice(-1e3);
+      errorDetail = fs8.readFileSync(TEST_PATHS.logFile, "utf8").slice(-1e3);
     } catch {
     }
     throw new Error(`\u6D4B\u8BD5\u5B9E\u4F8B\u542F\u52A8\u5931\u8D25${errorDetail ? `
@@ -5456,7 +5685,7 @@ ${errorDetail}` : ""}`);
 function stopTestInstance() {
   let pid;
   try {
-    pid = parseInt(fs7.readFileSync(TEST_PATHS.pidFile, "utf8").trim(), 10);
+    pid = parseInt(fs8.readFileSync(TEST_PATHS.pidFile, "utf8").trim(), 10);
   } catch {
     return;
   }
@@ -5468,7 +5697,7 @@ function stopTestInstance() {
     }
   }
   try {
-    fs7.unlinkSync(TEST_PATHS.pidFile);
+    fs8.unlinkSync(TEST_PATHS.pidFile);
   } catch {
   }
 }
@@ -5744,7 +5973,7 @@ async function cmdSubscription(args) {
     }
     const status = getStatus();
     const configInfo = getConfigInfo();
-    const currentMode = configInfo?.tun ? "tun" : "mixed";
+    const currentMode = isDaemonEnabled() ? "mixed" : configInfo?.tun ? "tun" : "mixed";
     const success = setDefaultSubscription(target.name);
     if (success) {
       console.log(`\u5DF2\u5207\u6362\u5230 "${target.name}"`);
@@ -5752,7 +5981,7 @@ async function cmdSubscription(args) {
       console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u8BA2\u9605 "${name}"`);
       process.exit(1);
     }
-    if (status.running) {
+    if (status.running || isDaemonEnabled()) {
       console.log("");
       await cmdStart(["start", currentMode]);
       return;
@@ -5878,12 +6107,19 @@ 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"');
     process.exit(1);
   }
   const targetMode = args[1] === "tun" ? "tun" : "mixed";
+  const daemonEnabled = isDaemonEnabled();
+  if (targetMode === "tun" && daemonEnabled) {
+    console.error(`${colors.red("\u9519\u8BEF:")} \u4FDD\u6D3B\u5DF2\u542F\u7528\uFF08\u4EC5\u652F\u6301 Mixed \u6A21\u5F0F\uFF09\uFF0C\u65E0\u6CD5\u542F\u52A8 TUN`);
+    console.error("\u8BF7\u5148\u5173\u95ED\u4FDD\u6D3B: mihomo daemon off");
+    process.exit(1);
+  }
   const rounds = parseIntArg(args, "-r", "--rounds", DEFAULT_CLEAN_ROUNDS);
   const timeout = parseIntArg(args, "-t", "--timeout", DEFAULT_TEST_TIMEOUT);
   const concurrency = parseIntArg(args, "-j", "--concurrency", DEFAULT_TEST_CONCURRENCY);
@@ -5897,16 +6133,27 @@ async function cmdStart(args) {
   if (!skipUpdate) {
     await autoUpdateStaleSubscription({ timeout: updateTimeout });
   }
-  const status = getStatus();
-  const hasProcess = status.running || status.allProcesses.length > 0;
-  if (hasProcess) {
-    const count = status.allProcesses.length > 0 ? status.allProcesses.length : 1;
-    console.log(`\u505C\u6B62 ${count} \u4E2A\u8FDB\u7A0B...`);
+  async function launchOrRestart() {
+    if (daemonEnabled) {
+      restartDaemon();
+      await sleep(DAEMON_RESTART_WAIT_MS);
+      return getDaemonStatus().pid;
+    }
+    const result = await start(targetMode);
+    return result.pid;
   }
-  handleStopResult(stop());
-  if (hasProcess) {
-    console.log(`${colors.green("\u5DF2\u505C\u6B62\u8FDB\u7A0B")}
+  if (!daemonEnabled) {
+    const status = getStatus();
+    const hasProcess = status.running || status.allProcesses.length > 0;
+    if (hasProcess) {
+      const count = status.allProcesses.length > 0 ? status.allProcesses.length : 1;
+      console.log(`\u505C\u6B62 ${count} \u4E2A\u8FDB\u7A0B...`);
+    }
+    handleStopResult(stop());
+    if (hasProcess) {
+      console.log(`${colors.green("\u5DF2\u505C\u6B62\u8FDB\u7A0B")}
 `);
+    }
   }
   let configInfo;
   try {
@@ -5918,8 +6165,9 @@ async function cmdStart(args) {
   const modeLabel = targetMode === "tun" ? "TUN" : "Mixed";
   console.log([colors.cyan(modeLabel), sub.name, formatProxySummary(configInfo)].join(" \xB7 "));
   try {
-    const result = await start(targetMode);
-    console.log(`${colors.green("\u5DF2\u542F\u52A8")} (PID ${result.pid})`);
+    const pid = await launchOrRestart();
+    const label = daemonEnabled ? "\u5DF2\u542F\u52A8 (\u4FDD\u6D3B)" : "\u5DF2\u542F\u52A8";
+    console.log(`${colors.green(label)}${pid ? ` (PID ${pid})` : ""}`);
   } catch (e) {
     const msg = e.message;
     const lines = msg.split("\n");
@@ -5951,11 +6199,11 @@ async function cmdStart(args) {
       console.log(`${colors.green("\u5DF2\u6E05\u7406")}: ${formatCleanSummary(cleanResult)}`);
       console.log("");
       console.log("\u91CD\u65B0\u52A0\u8F7D\u914D\u7F6E...");
-      handleStopResult(stop());
+      if (!daemonEnabled) handleStopResult(stop());
       try {
         configInfo = prepareConfigForStart(targetMode, sub.name);
-        const result = await start(targetMode);
-        console.log(`${colors.green("\u5DF2\u91CD\u542F")} (PID ${result.pid}) \xB7 ${formatProxySummary(configInfo)}`);
+        const pid = await launchOrRestart();
+        console.log(`${colors.green("\u5DF2\u91CD\u542F")}${pid ? ` (PID ${pid})` : ""} \xB7 ${formatProxySummary(configInfo)}`);
       } catch (e) {
         console.error(`${colors.red("\u91CD\u542F\u5931\u8D25:")} ${e.message.split("\n")[0]}`);
         process.exit(1);
@@ -5975,8 +6223,8 @@ function printOverwriteList() {
   if (info.files.length === 0) {
     console.log("\u6682\u65E0\u8986\u5199\u6587\u4EF6");
     console.log("");
-    console.log(`\u7528\u6CD5\u793A\u4F8B: \u521B\u5EFA\u6587\u4EF6 ${path6.join(info.dir, "overwrite.yaml")}`);
-    console.log(`         \u6216        ${path6.join(info.dir, "overwrite.dns.yaml")}`);
+    console.log(`\u7528\u6CD5\u793A\u4F8B: \u521B\u5EFA\u6587\u4EF6 ${path7.join(info.dir, "overwrite.yaml")}`);
+    console.log(`         \u6216        ${path7.join(info.dir, "overwrite.dns.yaml")}`);
     console.log("");
   } else {
     console.log(`${colors.cyan("\u8986\u5199\u6587\u4EF6")} (${info.files.length} \u4E2A\uFF0C\u6309\u987A\u5E8F\u52A0\u8F7D):`);
@@ -5998,7 +6246,7 @@ async function cmdOverwrite(args) {
   const action = args?.[1];
   const status = getStatus();
   const configInfo = getConfigInfo();
-  const currentMode = configInfo?.tun ? "tun" : "mixed";
+  const currentMode = isDaemonEnabled() ? "mixed" : configInfo?.tun ? "tun" : "mixed";
   if (action === "on" || action === "enable") {
     if (isOverwriteEnabled()) {
       console.log("\u8986\u5199\u914D\u7F6E\u5DF2\u662F\u542F\u7528\u72B6\u6001");
@@ -6008,7 +6256,7 @@ async function cmdOverwrite(args) {
     }
     setOverwriteEnabled(true);
     console.log("\u5DF2\u542F\u7528\u8986\u5199\u914D\u7F6E");
-    if (status.running) {
+    if (status.running || isDaemonEnabled()) {
       console.log("");
       await cmdStart(["start", currentMode]);
       return;
@@ -6026,7 +6274,7 @@ async function cmdOverwrite(args) {
     }
     setOverwriteEnabled(false);
     console.log("\u5DF2\u7981\u7528\u8986\u5199\u914D\u7F6E");
-    if (status.running) {
+    if (status.running || isDaemonEnabled()) {
       console.log("");
       await cmdStart(["start", currentMode]);
       return;
@@ -6040,7 +6288,7 @@ async function cmdOverwrite(args) {
 }
 
 // src/commands/reset.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import readline from "readline";
 var RESET_TARGETS = [
   {
@@ -6095,10 +6343,22 @@ var RESET_TARGETS = [
     label: "\u8986\u5199",
     paths: () => {
       const dir = USER_DATA_DIR;
-      if (!fs8.existsSync(dir)) return [];
-      return fs8.readdirSync(dir).filter((f) => f === "overwrite.yaml" || /^overwrite\..+\.ya?ml$/.test(f)).map((f) => `${dir}/${f}`);
+      if (!fs9.existsSync(dir)) return [];
+      return fs9.readdirSync(dir).filter((f) => f === "overwrite.yaml" || /^overwrite\..+\.ya?ml$/.test(f)).map((f) => `${dir}/${f}`);
     },
     needsStop: false
+  },
+  {
+    id: "daemon",
+    aliases: ["daemon"],
+    label: "\u4FDD\u6D3B",
+    // 删除全部交给 onAfter：disableDaemon 会先 bootout 卸载、再删 plist、再兜底清理进程，
+    // 顺序正确（先卸载再删文件）；此处返回空避免提前删掉 plist 破坏卸载。
+    paths: () => [],
+    needsStop: false,
+    onAfter: () => disableDaemon(),
+    checkEmpty: () => !isDaemonEnabled(),
+    emptyMsg: "\u4FDD\u6D3B\u672A\u542F\u7528\uFF0C\u65E0\u9700\u5220\u9664"
   }
 ];
 function resolveResetTargets(names) {
@@ -6148,7 +6408,7 @@ async function cmdReset(args) {
     }
     targets = matched;
   } else {
-    targets = RESET_TARGETS.filter((t) => !["settings", "kernel", "overwrites"].includes(t.id));
+    targets = RESET_TARGETS.filter((t) => !["settings", "kernel", "overwrites", "daemon"].includes(t.id));
   }
   for (const t of targets) {
     if (t.checkEmpty?.()) {
@@ -6160,25 +6420,34 @@ 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() : [];
-  if (needsStop && pids.length > 0) {
-    console.log(`\u505C\u6B62 ${pids.length} \u4E2A\u8FDB\u7A0B...`);
-    cleanupAll();
-    for (let i = 0; i < PROCESS_WAIT_ATTEMPTS; i++) {
-      if (getAllMihomoPids().length === 0) break;
-      await new Promise((r) => setTimeout(r, PROCESS_WAIT_INTERVAL));
-    }
-  } else if (warnRunning && pids.length > 0) {
+  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`));
   }
+  if (disablesDaemon && isDaemonEnabled()) {
+    console.log(colors.yellow("\u4FDD\u6D3B\u5DF2\u542F\u7528\uFF0C\u91CD\u7F6E\u5C06\u4E00\u5E76\u5173\u95ED\u4FDD\u6D3B\uFF08\u79FB\u9664\u5F00\u673A\u81EA\u542F\uFF09"));
+  }
   console.log(`\u5C06\u5220\u9664: ${targets.map((t) => t.label).join("\u3001")}`);
   if (!skipConfirm && !await confirmPrompt("\u786E\u8BA4?")) {
     console.log("\u5DF2\u53D6\u6D88");
     return;
   }
+  if (disablesDaemon && isDaemonEnabled()) {
+    disableDaemon();
+  }
+  if (needsStop && getAllMihomoPids().length > 0) {
+    console.log("\u505C\u6B62\u8FDB\u7A0B...");
+    cleanupAll();
+    for (let i = 0; i < PROCESS_WAIT_ATTEMPTS; i++) {
+      if (getAllMihomoPids().length === 0) break;
+      await new Promise((r) => setTimeout(r, PROCESS_WAIT_INTERVAL));
+    }
+  }
   for (const t of targets) {
     for (const p of t.paths()) {
-      if (fs8.existsSync(p)) {
+      if (fs9.existsSync(p)) {
         try {
           rmrf(p);
         } catch (e) {
@@ -6197,6 +6466,13 @@ 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)");
@@ -6256,11 +6532,22 @@ 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...");
-    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)}`);
+    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)}`);
+    }
   }
 }
 
@@ -6422,6 +6709,9 @@ async function main() {
     case "reset":
       await cmdReset(args);
       break;
+    case "daemon":
+      await cmdDaemon(args);
+      break;
     case "on":
       await cmdOverwrite(["ow", "on"]);
       break;