mihomo-cli 2.10.0 → 3.2.0

package/dist/index.js

@@ -1,73 +1,7 @@
 #!/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 { spawnSync as spawnSync2 } from "child_process";
 import fs4 from "fs";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
@@ -2989,6 +2923,11 @@ var UI_URLS = {
   dash: "https://metacubex.github.io/metacubexd",
   yacd: "https://yacd.metacubex.one"
 };
+var LAUNCH_DAEMON_LABEL = process.env.MIHOMO_CLI_DAEMON_LABEL || "com.mihomo-cli.daemon";
+var CONTROLLER_PORT = 9090;
+var CONTROLLER_ADDR = `127.0.0.1:${CONTROLLER_PORT}`;
+var CONTROLLER_BASE_URL = `http://${CONTROLLER_ADDR}`;
+var TEST_CONTROLLER_ADDR = "127.0.0.1:29090";
 var TUN_CONFIG = {
   tun: {
     enable: true,
@@ -3002,14 +2941,14 @@ var TUN_CONFIG = {
 var TEST_CONFIG = {
   "mixed-port": 27890,
   "allow-lan": false,
-  "external-controller": "127.0.0.1:29090",
+  "external-controller": TEST_CONTROLLER_ADDR,
   "log-level": "error",
   "geodata-mode": true
 };
 var BASE_CONFIG = {
   "mixed-port": 7890,
   "allow-lan": false,
-  "external-controller": "127.0.0.1:9090",
+  "external-controller": CONTROLLER_ADDR,
   "unified-delay": true,
   "tcp-concurrent": true,
   "geo-auto-update": true,
@@ -3038,10 +2977,74 @@ var AUTO_CLEAN_THRESHOLD_GITHUB = 50;
 
 // src/overwrite.ts
 import fs3 from "fs";
-import path2 from "path";
+import path3 from "path";
+
+// src/paths.ts
+import fs from "fs";
+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 LaunchDaemon plist 位于系统级 /Library/LaunchDaemons/，root:wheel 拥有，与 homedir / MIHOMO_CLI_DIR 无关
+  launchDaemonPlist: path.join("/Library/LaunchDaemons", `${LAUNCH_DAEMON_LABEL}.plist`)
+};
+var DIRECTORY_TARGETS = {
+  root: { path: null, label: "\u6839\u76EE\u5F55" },
+  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";
+import path2 from "path";
 var settingsCache = null;
 function readSettings() {
   if (settingsCache !== null) return settingsCache;
@@ -3145,12 +3148,10 @@ function addSubscription(url, name = "default") {
   validateSubscriptionName(name);
   const settings = readSettings();
   const subs = [...settings.subscriptions || []];
-  const existingIndex = subs.findIndex((s) => s.name === name);
-  if (existingIndex >= 0) {
-    subs[existingIndex] = { name, url };
-  } else {
-    subs.push({ name, url });
+  if (subs.some((s) => s.name === name)) {
+    throw new Error(`\u8BA2\u9605 "${name}" \u5DF2\u5B58\u5728\uFF0C\u8BF7\u6362\u4E2A\u540D\u79F0\uFF08mihomo sub add <url> <\u540D\u79F0>\uFF09\uFF0C\u6216\u5148\u5220\u9664\uFF08mihomo sub remove ${name}\uFF09`);
   }
+  subs.push({ name, url });
   const updates = { subscriptions: subs };
   if (!settings.active_subscription && subs.length === 1) {
     updates.active_subscription = name;
@@ -3175,7 +3176,10 @@ function removeSubscription(name) {
     delete cache[name];
     writeSubscriptionCache(cache);
   }
-  fs2.rmSync(getSubscriptionRawConfigPath(name), { force: true });
+  try {
+    fs2.rmSync(getSubscriptionRawConfigPath(name), { force: true });
+  } catch {
+  }
   return switchedTo;
 }
 function setDefaultSubscription(name) {
@@ -3188,7 +3192,10 @@ function setDefaultSubscription(name) {
   return true;
 }
 function getSubscriptionRawConfigPath(subName) {
-  return `${DIRS.subscriptions}/${subName}.yaml`;
+  if (!SAFE_NAME_RE.test(subName)) {
+    throw new Error(`\u8BA2\u9605\u540D\u79F0\u65E0\u6548: "${subName}"`);
+  }
+  return path2.join(DIRS.subscriptions, `${subName}.yaml`);
 }
 function saveSubscriptionRawConfig(subName, content) {
   ensureDirs();
@@ -3286,17 +3293,20 @@ function isOverwriteEnabled() {
 function setOverwriteEnabled(enabled) {
   writeSettings({ overwrite_enabled: enabled });
 }
+function isOverwriteFilename(filename) {
+  return filename === "overwrite.yaml" || /^overwrite\..+\.ya?ml$/.test(filename);
+}
 function loadOverwriteFile() {
   const dir = USER_DATA_DIR;
   if (!fs3.existsSync(dir)) return [];
-  const files = fs3.readdirSync(dir).filter((f) => f === "overwrite.yaml" || /^overwrite\..+\.ya?ml$/.test(f)).sort((a, b) => {
+  const files = fs3.readdirSync(dir).filter(isOverwriteFilename).sort((a, b) => {
     if (a === "overwrite.yaml") return -1;
     if (b === "overwrite.yaml") return 1;
     return a.localeCompare(b);
   });
   const results = [];
   for (const file of files) {
-    const filePath = path2.join(dir, file);
+    const filePath = path3.join(dir, file);
     try {
       const content = fs3.readFileSync(filePath, "utf8");
       const parsed = load(content);
@@ -3333,57 +3343,267 @@ function listOverwriteFile() {
   };
 }
 
-// src/config.ts
-function parseYamlOrJson(content, errorMsg) {
-  if (!content?.trim()) {
-    throw new Error(`${errorMsg || "\u5185\u5BB9"}\u4E3A\u7A7A`);
+// src/utils.ts
+import { spawnSync } from "child_process";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var VERSION = pkg.version;
+var sleepBuf = new Int32Array(new SharedArrayBuffer(4));
+var NO_COLOR = process.env.NO_COLOR !== void 0 || !process.stdout.isTTY;
+function colorize(code, str) {
+  if (NO_COLOR) return String(str);
+  return `${code + String(str)}\x1B[0m`;
+}
+var colors = {
+  bold: (s) => colorize("\x1B[1m", s),
+  red: (s) => colorize("\x1B[31m", s),
+  green: (s) => colorize("\x1B[32m", s),
+  yellow: (s) => colorize("\x1B[33m", s),
+  cyan: (s) => colorize("\x1B[36m", s),
+  gray: (s) => colorize("\x1B[90m", s)
+};
+function sleepSync(ms) {
+  Atomics.wait(sleepBuf, 0, 0, ms);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function shellQuote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+var TimeoutError = class extends Error {
+  constructor() {
+    super("timeout");
+    this.name = "TimeoutError";
   }
+};
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new TimeoutError()), ms);
+    promise.then(
+      (v) => {
+        clearTimeout(timer);
+        resolve(v);
+      },
+      (e) => {
+        clearTimeout(timer);
+        reject(e);
+      }
+    );
+  });
+}
+function formatBytes(bytes) {
+  if (bytes === void 0 || bytes === null) return "\u672A\u77E5";
+  const num = Number(bytes);
+  if (!Number.isFinite(num) || num < 0) return "\u672A\u77E5";
+  if (num === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.min(Math.floor(Math.log(num) / Math.log(k)), sizes.length - 1);
+  return `${parseFloat((num / k ** i).toFixed(2))} ${sizes[i]}`;
+}
+function formatTimestamp(ts) {
+  if (ts === void 0 || ts === null) return "\u672A\u77E5";
   try {
-    const result = load(content);
-    if (result != null && typeof result === "object" && !Array.isArray(result)) return result;
+    return new Date(ts * 1e3).toLocaleString("zh-CN");
   } catch {
+    return "\u672A\u77E5";
   }
+}
+function formatLocalTimestamp(d = /* @__PURE__ */ new Date()) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}_${p(d.getHours())}-${p(d.getMinutes())}-${p(d.getSeconds())}`;
+}
+function formatDate(dateOrIso) {
+  if (dateOrIso === void 0 || dateOrIso === null) return "\u672A\u77E5";
   try {
-    return JSON.parse(content);
+    const d = dateOrIso instanceof Date ? dateOrIso : new Date(dateOrIso);
+    if (Number.isNaN(d.getTime())) return "\u672A\u77E5";
+    return d.toLocaleString("zh-CN");
   } catch {
-    throw new Error(`${errorMsg || "\u5185\u5BB9"}\u683C\u5F0F\u9519\u8BEF\uFF0C\u65E0\u6CD5\u89E3\u6790\u4E3A YAML \u6216 JSON`);
+    return "\u672A\u77E5";
   }
 }
-function collectOverwriteProxyNames(overwriteFiles) {
-  const names = [];
-  for (const file of overwriteFiles) {
-    for (const [key, value] of Object.entries(file.config)) {
-      if ((key === "+proxies" || key === "proxies+") && Array.isArray(value)) {
-        for (const proxy of value) {
-          if (proxy && typeof proxy === "object" && "name" in proxy) {
-            names.push(proxy.name);
-          }
-        }
-      }
-    }
-  }
-  return names;
+function hasFlag(args, short, long) {
+  return !!args && (args.includes(short) || args.includes(long));
 }
-function excludeOverwriteProxiesFromIncludeAll(config, overwriteFiles) {
-  const injectedNames = collectOverwriteProxyNames(overwriteFiles);
-  if (injectedNames.length === 0) return;
-  const groups = config["proxy-groups"];
-  if (!groups) return;
-  const excludePattern = injectedNames.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
-  for (const group of groups) {
-    if (!group["include-all"] && !group["include-all-proxies"]) continue;
-    const existing = group["exclude-filter"];
-    if (existing) {
-      group["exclude-filter"] = `${existing}|${excludePattern}`;
-    } else {
-      group["exclude-filter"] = excludePattern;
+function parseIntArg(args, short, long, defaultValue) {
+  if (!args) return defaultValue;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === short || args[i] === long) {
+      if (i + 1 < args.length) {
+        const val = parseInt(args[i + 1], 10);
+        return Number.isNaN(val) ? defaultValue : val;
+      }
     }
   }
+  return defaultValue;
 }
-var BUILTIN_PROXY_NAMES = /* @__PURE__ */ new Set(["DIRECT", "REJECT", "REJECT-DROP", "PASS", "COMPATIBLE"]);
-function deduplicateByName(items) {
-  const names = /* @__PURE__ */ new Set();
-  const duplicates = [];
+var VALUE_FLAGS = /* @__PURE__ */ new Set(["-t", "--timeout", "-j", "--concurrency", "-r", "--rounds", "-n", "--lines", "-u", "--update-timeout"]);
+function getNonFlagArg(args, startIdx, valueFlags = VALUE_FLAGS) {
+  if (!args) return null;
+  for (let i = startIdx; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith("-")) {
+      if (valueFlags.has(a)) i++;
+      continue;
+    }
+    return a;
+  }
+  return null;
+}
+function isProcessRunning(pid) {
+  if (!pid) return false;
+  try {
+    const result = spawnSync("ps", ["-p", String(pid), "-o", "pid="], { encoding: "utf8", timeout: 5e3 });
+    return (result.stdout || "").trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function isProcessRoot(pid) {
+  if (!pid) return false;
+  try {
+    const result = spawnSync("ps", ["-p", String(pid), "-o", "uid="], { encoding: "utf8", timeout: 5e3 });
+    return (result.stdout || "").trim() === "0";
+  } catch {
+    return false;
+  }
+}
+function createHttpClient(options = {}) {
+  const { timeout = 6e4 } = options;
+  return {
+    async get(url, config) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      const signal = config?.signal ? AbortSignal.any([controller.signal, config.signal]) : controller.signal;
+      try {
+        const response = await fetch(url, {
+          signal,
+          headers: { "User-Agent": `mihomo-cli/${VERSION}` }
+        });
+        if (!response.ok) {
+          const error = new Error(`HTTP ${response.status}`);
+          error.response = { status: response.status };
+          try {
+            error.response.data = await response.json();
+          } catch {
+          }
+          throw error;
+        }
+        const data = config?.responseType === "json" ? await response.json() : await response.text();
+        return { data, headers: response.headers, status: response.status };
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+function normalizeMirrorUrl(val) {
+  if (!val) return null;
+  if (val === "direct" || val === "no" || val === "none") return null;
+  let url = val;
+  if (!url.startsWith("http")) {
+    url = `https://${url}`;
+  }
+  if (!url.endsWith("/")) {
+    url += "/";
+  }
+  return url;
+}
+function parseMirrorArg(args) {
+  if (!args || args.length < 2) {
+    return { mirror: null, isOverride: false, type: "download" };
+  }
+  if (args.includes("--no-mirror") || args.includes("--direct")) {
+    return { mirror: null, isOverride: true, type: "download" };
+  }
+  const mirrorAllIdx = args.indexOf("--mirror-all");
+  if (mirrorAllIdx >= 0) {
+    const nextArg = args[mirrorAllIdx + 1];
+    if (!nextArg || nextArg.startsWith("-")) {
+      return { mirror: "https://v6.gh-proxy.org/", isOverride: true, type: "all" };
+    }
+    return { mirror: normalizeMirrorUrl(nextArg), isOverride: true, type: "all" };
+  }
+  const mirrorIdx = args.indexOf("--mirror");
+  if (mirrorIdx >= 0) {
+    const nextArg = args[mirrorIdx + 1];
+    if (!nextArg || nextArg.startsWith("-")) {
+      return { mirror: "https://v6.gh-proxy.org/", isOverride: true, type: "download" };
+    }
+    return { mirror: normalizeMirrorUrl(nextArg), isOverride: true, type: "download" };
+  }
+  return { mirror: null, isOverride: false, type: "download" };
+}
+function isProxyValid(proxy) {
+  if (!proxy.name || !proxy.server || !proxy.port) return false;
+  if (!proxy.type) return false;
+  if (proxy.type === "ss" && typeof proxy.cipher === "string" && proxy.cipher.startsWith("2022-blake3")) {
+    const pw = String(proxy.password || "");
+    if (!/^[A-Za-z0-9+/\-_]+=*$/.test(pw) || pw.length < 20) return false;
+  }
+  return true;
+}
+
+// src/config.ts
+function parseYamlOrJson(content, errorMsg) {
+  if (!content?.trim()) {
+    throw new Error(`${errorMsg || "\u5185\u5BB9"}\u4E3A\u7A7A`);
+  }
+  try {
+    const result = load(content);
+    if (result != null && typeof result === "object" && !Array.isArray(result)) return result;
+  } catch {
+  }
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error(`${errorMsg || "\u5185\u5BB9"}\u683C\u5F0F\u9519\u8BEF\uFF0C\u65E0\u6CD5\u89E3\u6790\u4E3A YAML \u6216 JSON`);
+  }
+}
+function dumpYaml(obj) {
+  return dump(obj, { indent: 2, lineWidth: -1, schema: CORE_SCHEMA });
+}
+function collectOverwriteProxyNames(overwriteFiles) {
+  const names = [];
+  for (const file of overwriteFiles) {
+    for (const [key, value] of Object.entries(file.config)) {
+      if ((key === "+proxies" || key === "proxies+") && Array.isArray(value)) {
+        for (const proxy of value) {
+          if (proxy && typeof proxy === "object" && "name" in proxy) {
+            names.push(proxy.name);
+          }
+        }
+      }
+    }
+  }
+  return names;
+}
+function excludeOverwriteProxiesFromIncludeAll(config, overwriteFiles) {
+  const injectedNames = collectOverwriteProxyNames(overwriteFiles);
+  if (injectedNames.length === 0) return;
+  const groups = config["proxy-groups"];
+  if (!groups) return;
+  const excludePattern = injectedNames.map((n) => escapeRegExp(n)).join("|");
+  for (const group of groups) {
+    if (!group["include-all"] && !group["include-all-proxies"]) continue;
+    const existing = group["exclude-filter"];
+    if (existing) {
+      group["exclude-filter"] = `${existing}|${excludePattern}`;
+    } else {
+      group["exclude-filter"] = excludePattern;
+    }
+  }
+}
+var BUILTIN_PROXY_NAMES = /* @__PURE__ */ new Set(["DIRECT", "REJECT", "REJECT-DROP", "PASS", "COMPATIBLE"]);
+function deduplicateByName(items) {
+  const names = /* @__PURE__ */ new Set();
+  const duplicates = [];
   const result = items.filter((item) => {
     if (names.has(item.name)) {
       duplicates.push(item.name);
@@ -3394,6 +3614,15 @@ function deduplicateByName(items) {
   });
   return { result, names, duplicates };
 }
+function getRuleTarget(rule) {
+  const parts = rule.split(",");
+  if (parts.length < 2) return "";
+  const last = parts[parts.length - 1].trim();
+  if (last.toLowerCase() === "no-resolve" && parts.length >= 3) {
+    return parts[parts.length - 2].trim();
+  }
+  return last;
+}
 function validateConfig(config) {
   const warnings = [];
   const proxies = config.proxies || [];
@@ -3438,9 +3667,7 @@ function validateConfig(config) {
   if (rules.length > 0) {
     const removedRules = [];
     config.rules = rules.filter((rule) => {
-      const parts = rule.split(",");
-      if (parts.length < 2) return true;
-      const target = parts[parts.length - 1].trim();
+      const target = getRuleTarget(rule);
       if (!target || validNames.has(target)) return true;
       removedRules.push(rule);
       return false;
@@ -3487,6 +3714,8 @@ function buildConfig(subRawContent, mode) {
     if (Object.keys(dns).length > 0) {
       systemConfig.dns = dns;
     }
+  } else {
+    delete withOverwrites.tun;
   }
   const merged = { ...withOverwrites, ...systemConfig };
   if (systemConfig.dns) {
@@ -3509,20 +3738,19 @@ function buildConfig(subRawContent, mode) {
 }
 function writeMihomoConfig(configObj) {
   ensureDirs();
-  const content = dump(configObj, { indent: 2, lineWidth: -1, schema: CORE_SCHEMA });
+  const content = dumpYaml(configObj);
   atomicWriteFileSync(PATHS.configFile, content, { mode: 384 });
 }
 function writeDebugConfig(buildResult) {
   ensureDirs();
-  const dumpOpts = { indent: 2, lineWidth: -1, schema: CORE_SCHEMA };
-  fs4.writeFileSync(PATHS.configStage1Subscription, dump(buildResult.subscriptionConfig, dumpOpts), { mode: 384 });
+  fs4.writeFileSync(PATHS.configStage1Subscription, dumpYaml(buildResult.subscriptionConfig), { mode: 384 });
   const overwriteMerged = {};
   for (const f of buildResult.overwriteFiles) {
     Object.assign(overwriteMerged, f.config);
   }
-  const overwriteContent = buildResult.overwriteFiles.length > 0 ? dump(overwriteMerged, dumpOpts) : "# overwrite \u5DF2\u7981\u7528\u6216\u65E0\u8986\u5199\u6587\u4EF6\n";
+  const overwriteContent = buildResult.overwriteFiles.length > 0 ? dumpYaml(overwriteMerged) : "# overwrite \u5DF2\u7981\u7528\u6216\u65E0\u8986\u5199\u6587\u4EF6\n";
   fs4.writeFileSync(PATHS.configStage2Overwrite, overwriteContent, { mode: 384 });
-  fs4.writeFileSync(PATHS.configStage3System, dump(buildResult.systemConfig, dumpOpts), { mode: 384 });
+  fs4.writeFileSync(PATHS.configStage3System, dumpYaml(buildResult.systemConfig), { mode: 384 });
 }
 function hasConfig() {
   return fs4.existsSync(PATHS.configFile);
@@ -3562,7 +3790,7 @@ function getKernelVersion() {
   }
   if (kernelVersionCached) return kernelVersionCache;
   try {
-    const result = spawnSync(PATHS.mihomoBinary, ["-v"], { encoding: "utf8", timeout: 5e3 });
+    const result = spawnSync2(PATHS.mihomoBinary, ["-v"], { encoding: "utf8", timeout: 5e3 });
     const output = `${result.stdout || ""}${result.stderr || ""}`.trim();
     if (output) {
       const match = output.match(/v?[\d]+\.[\d]+\.[\d]+/);
@@ -3581,219 +3809,102 @@ function clearKernelVersionCache() {
   kernelVersionCached = false;
 }
 
-// src/utils.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../package.json");
-var VERSION = pkg.version;
-var sleepBuf = new Int32Array(new SharedArrayBuffer(4));
-var NO_COLOR = process.env.NO_COLOR !== void 0 || !process.stdout.isTTY;
-function colorize(code, str) {
-  if (NO_COLOR) return String(str);
-  return `${code + String(str)}\x1B[0m`;
+// src/commands/help.ts
+function printShortHelp() {
+  console.log(`
+${colors.cyan(colors.bold(`mihomo-cli v${VERSION}`))}  (mihomo help \u67E5\u770B\u5B8C\u6574\u5E2E\u52A9)
+`);
+  console.log(
+    `\u5E38\u7528\u547D\u4EE4:
+  ${colors.bold("start")} [tun|mixed]    \u542F\u52A8/\u5207\u6362\u4EE3\u7406
+  ${colors.bold("sub")} [use|update]     \u8BA2\u9605\u7BA1\u7406
+  ${colors.bold("ow")} [on|off]          \u8986\u5199\u914D\u7F6E
+  ${colors.bold("ui")} [zash|dash|yacd]  \u6253\u5F00 Web UI
+`
+  );
 }
-var colors = {
-  bold: (s) => colorize("\x1B[1m", s),
-  red: (s) => colorize("\x1B[31m", s),
-  green: (s) => colorize("\x1B[32m", s),
-  yellow: (s) => colorize("\x1B[33m", s),
-  cyan: (s) => colorize("\x1B[36m", s),
-  gray: (s) => colorize("\x1B[90m", s)
-};
-function sleepSync(ms) {
-  Atomics.wait(sleepBuf, 0, 0, ms);
+var GROUP_TITLES = [
+  ["control", "\u63A7\u5236:"],
+  ["interface", "\u754C\u9762:"],
+  ["subscription", "\u8BA2\u9605:"],
+  ["config", "\u914D\u7F6E:"],
+  ["system", "\u7CFB\u7EDF:"]
+];
+function printHelp(commands) {
+  const lines = [`
+${colors.cyan(colors.bold(`mihomo-cli v${VERSION}`))}`, "", "\u547D\u4EE4\u522B\u540D: mihomo, mhm, mh", "", "\u7528\u6CD5:", "  mihomo <\u547D\u4EE4> [\u9009\u9879]"];
+  for (const [group, title] of GROUP_TITLES) {
+    const usageLines = commands.filter((c) => c.group === group).flatMap((c) => c.usage);
+    if (usageLines.length === 0) continue;
+    lines.push("", colors.cyan(title));
+    for (const u of usageLines) {
+      lines.push(u.startsWith(" ") ? `  ${u}` : `  ${boldFirstToken(u)}`);
+    }
+  }
+  const meta = commands.filter((c) => c.group === "meta").flatMap((c) => c.usage);
+  if (meta.length > 0) {
+    lines.push("", colors.cyan("\u5143:"));
+    for (const u of meta) lines.push(`  ${boldFirstToken(u)}`);
+  }
+  lines.push(
+    "",
+    `${colors.cyan("\u793A\u4F8B:")}`,
+    "  mihomo start              # \u542F\u52A8/\u91CD\u542F Mixed \u6A21\u5F0F",
+    "  mihomo start tun          # \u5207\u6362\u5230 TUN \u900F\u660E\u4EE3\u7406\u6A21\u5F0F",
+    "  mihomo start -s           # \u8DF3\u8FC7\u81EA\u52A8\u66F4\u65B0\u8BA2\u9605",
+    "  mihomo start -u 30000     # \u81EA\u52A8\u66F4\u65B0\u8D85\u65F6 30 \u79D2 (\u9ED8\u8BA4 10s)",
+    "  mihomo daemon on          # \u5F00\u542F\u4FDD\u6D3B\uFF08\u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u91CD\u542F\uFF09",
+    "  mihomo sub add <url>      # \u6DFB\u52A0\u8BA2\u9605 (sub \u662F subscription \u522B\u540D)",
+    "  mihomo ui                 # \u6253\u5F00 Web UI",
+    "",
+    `${colors.cyan("\u5FEB\u6377\u547D\u4EE4:")}`,
+    "  tun = start tun   use = sub use   on/off = ow on/off   open = dir open",
+    "  up = start   down = stop   upd/upgrade = update",
+    "",
+    `${colors.cyan("\u6A21\u5F0F\u8BF4\u660E:")}`,
+    "  mixed  HTTP + SOCKS5 \u6DF7\u5408\u7AEF\u53E3 (\u9ED8\u8BA4)",
+    "  tun    \u900F\u660E\u4EE3\u7406\uFF0C\u5168\u5C40\u81EA\u52A8\u8DEF\u7531\uFF0C\u9700\u8981 sudo",
+    "",
+    `${colors.cyan("\u6570\u636E\u76EE\u5F55:")}`,
+    "  \u73AF\u5883\u53D8\u91CF MIHOMO_CLI_DIR \u53EF\u81EA\u5B9A\u4E49\u4F4D\u7F6E",
+    `  \u9ED8\u8BA4: ${USER_DATA_DIR}`
+  );
+  console.log(lines.join("\n"));
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function boldFirstToken(usage) {
+  const spaceIdx = usage.indexOf(" ");
+  if (spaceIdx < 0) return colors.bold(usage);
+  return `${colors.bold(usage.slice(0, spaceIdx))}${usage.slice(spaceIdx)}`;
 }
-var TimeoutError = class extends Error {
-  constructor() {
-    super("timeout");
-    this.name = "TimeoutError";
-  }
-};
-function withTimeout(promise, ms) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new TimeoutError()), ms);
-    promise.then(
-      (v) => {
-        clearTimeout(timer);
-        resolve(v);
-      },
-      (e) => {
-        clearTimeout(timer);
-        reject(e);
-      }
-    );
-  });
+function 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 formatBytes(bytes) {
-  if (bytes === void 0 || bytes === null) return "\u672A\u77E5";
-  const num = Number(bytes);
-  if (!Number.isFinite(num) || num < 0) return "\u672A\u77E5";
-  if (num === 0) return "0 B";
-  const k = 1024;
-  const sizes = ["B", "KB", "MB", "GB", "TB"];
-  const i = Math.min(Math.floor(Math.log(num) / Math.log(k)), sizes.length - 1);
-  return `${parseFloat((num / k ** i).toFixed(2))} ${sizes[i]}`;
-}
-function formatTimestamp(ts) {
-  if (ts === void 0 || ts === null) return "\u672A\u77E5";
-  try {
-    return new Date(ts * 1e3).toLocaleString("zh-CN");
-  } catch {
-    return "\u672A\u77E5";
-  }
-}
-function formatDate(dateOrIso) {
-  if (dateOrIso === void 0 || dateOrIso === null) return "\u672A\u77E5";
-  try {
-    const d = dateOrIso instanceof Date ? dateOrIso : new Date(dateOrIso);
-    if (Number.isNaN(d.getTime())) return "\u672A\u77E5";
-    return d.toLocaleString("zh-CN");
-  } catch {
-    return "\u672A\u77E5";
-  }
-}
-function hasFlag(args, short, long) {
-  return !!args && (args.includes(short) || args.includes(long));
-}
-function parseIntArg(args, short, long, defaultValue) {
-  if (!args) return defaultValue;
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === short || args[i] === long) {
-      if (i + 1 < args.length) {
-        const val = parseInt(args[i + 1], 10);
-        return Number.isNaN(val) ? defaultValue : val;
-      }
-    }
-  }
-  return defaultValue;
-}
-var VALUE_FLAGS = /* @__PURE__ */ new Set(["-t", "--timeout", "-j", "--concurrency", "-r", "--rounds", "-n", "--lines", "-u", "--update-timeout"]);
-function getNonFlagArg(args, startIdx, valueFlags = VALUE_FLAGS) {
-  if (!args) return null;
-  for (let i = startIdx; i < args.length; i++) {
-    const a = args[i];
-    if (a.startsWith("-")) {
-      if (valueFlags.has(a)) i++;
-      continue;
-    }
-    return a;
-  }
-  return null;
-}
-function isProcessRunning(pid) {
-  if (!pid) return false;
-  try {
-    const result = spawnSync2("ps", ["-p", String(pid), "-o", "pid="], { encoding: "utf8", timeout: 5e3 });
-    return (result.stdout || "").trim().length > 0;
-  } catch {
-    return false;
-  }
-}
-function isProcessRoot(pid) {
-  if (!pid) return false;
-  try {
-    const result = spawnSync2("ps", ["-p", String(pid), "-o", "uid="], { encoding: "utf8", timeout: 5e3 });
-    return (result.stdout || "").trim() === "0";
-  } catch {
-    return false;
-  }
-}
-function createHttpClient(options = {}) {
-  const { timeout = 6e4 } = options;
-  return {
-    async get(url, config) {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), timeout);
-      const signal = config?.signal ? AbortSignal.any([controller.signal, config.signal]) : controller.signal;
-      try {
-        const response = await fetch(url, {
-          signal,
-          headers: { "User-Agent": `mihomo-cli/${VERSION}` }
-        });
-        if (!response.ok) {
-          const error = new Error(`HTTP ${response.status}`);
-          error.response = { status: response.status };
-          try {
-            error.response.data = await response.json();
-          } catch {
-          }
-          throw error;
-        }
-        const data = config?.responseType === "json" ? await response.json() : await response.text();
-        return { data, headers: response.headers, status: response.status };
-      } finally {
-        clearTimeout(timer);
-      }
-    }
-  };
-}
-function normalizeMirrorUrl(val) {
-  if (!val) return null;
-  if (val === "direct" || val === "no" || val === "none") return null;
-  let url = val;
-  if (!url.startsWith("http")) {
-    url = `https://${url}`;
-  }
-  if (!url.endsWith("/")) {
-    url += "/";
-  }
-  return url;
-}
-function parseMirrorArg(args) {
-  if (!args || args.length < 2) {
-    return { mirror: null, isOverride: false, type: "download" };
-  }
-  if (args.includes("--no-mirror") || args.includes("--direct")) {
-    return { mirror: null, isOverride: true, type: "download" };
-  }
-  const mirrorAllIdx = args.indexOf("--mirror-all");
-  if (mirrorAllIdx >= 0) {
-    const nextArg = args[mirrorAllIdx + 1];
-    if (!nextArg || nextArg.startsWith("-")) {
-      return { mirror: "https://v6.gh-proxy.org/", isOverride: true, type: "all" };
-    }
-    return { mirror: normalizeMirrorUrl(nextArg), isOverride: true, type: "all" };
-  }
-  const mirrorIdx = args.indexOf("--mirror");
-  if (mirrorIdx >= 0) {
-    const nextArg = args[mirrorIdx + 1];
-    if (!nextArg || nextArg.startsWith("-")) {
-      return { mirror: "https://v6.gh-proxy.org/", isOverride: true, type: "download" };
-    }
-    return { mirror: normalizeMirrorUrl(nextArg), isOverride: true, type: "download" };
-  }
-  return { mirror: null, isOverride: false, type: "download" };
-}
-function isProxyValid(proxy) {
-  if (!proxy.name || !proxy.server || !proxy.port) return false;
-  if (!proxy.type) return false;
-  if (proxy.type === "ss" && typeof proxy.cipher === "string" && proxy.cipher.startsWith("2022-blake3")) {
-    const pw = String(proxy.password || "");
-    if (!/^[A-Za-z0-9+/\-_]+=*$/.test(pw) || pw.length < 20) return false;
-  }
-  return true;
-}
-
-// src/process.ts
-var PROCESS_WAIT_ATTEMPTS = 50;
-var PROCESS_WAIT_INTERVAL = 100;
-var STARTUP_WAIT_MS = 800;
-var SUDO_TIMEOUT_MS = 6e4;
-var TUN_MODE_POST_WAIT_MS = 500;
-var BATCH_KILL_THRESHOLD = 3;
-var DEFAULT_LOG_RETENTION_DAYS = 7;
-function escapeForPgrep(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function clearRuntime() {
-  if (fs5.existsSync(DIRS.runtime)) {
-    rmrf(DIRS.runtime);
-  }
-  ensureDirs();
+
+// src/daemon.ts
+import { spawnSync as spawnSync4 } from "child_process";
+import fs6 from "fs";
+import path5 from "path";
+
+// src/process.ts
+import { spawn, spawnSync as spawnSync3 } from "child_process";
+import fs5 from "fs";
+import path4 from "path";
+var PROCESS_WAIT_ATTEMPTS = 50;
+var PROCESS_WAIT_INTERVAL = 100;
+var STARTUP_WAIT_MS = 800;
+var SUDO_TIMEOUT_MS = 6e4;
+var TUN_MODE_POST_WAIT_MS = 500;
+var BATCH_KILL_THRESHOLD = 3;
+var DEFAULT_LOG_RETENTION_DAYS = 7;
+var MAIN_INSTANCE_PATTERN = `${escapeRegExp(PATHS.mihomoBinary)}.*${escapeRegExp(PATHS.configFile)}`;
+function clearRuntime() {
+  if (fs5.existsSync(DIRS.runtime)) {
+    rmrf(DIRS.runtime);
+  }
+  ensureDirs();
 }
 function getPid() {
   if (!fs5.existsSync(PATHS.pidFile)) return null;
@@ -3808,10 +3919,9 @@ function isRunning() {
   const pid = getPid();
   return pid ? isProcessRunning(pid) : false;
 }
-function getAllMihomoPids() {
-  const binaryPath = PATHS.mihomoBinary;
+function getMihomoPids() {
   try {
-    const result = spawnSync3("pgrep", ["-f", escapeForPgrep(binaryPath)], { encoding: "utf8", timeout: 1e4 });
+    const result = spawnSync3("pgrep", ["-f", MAIN_INSTANCE_PATTERN], { encoding: "utf8", timeout: 1e4 });
     const output = (result.stdout || "").trim();
     if (!output) return [];
     return output.split("\n").filter(Boolean).map((p) => parseInt(p, 10)).filter((p) => Number.isInteger(p) && p > 0);
@@ -3829,7 +3939,7 @@ function isPidFileOwnedByRoot() {
   }
 }
 function checkStaleState() {
-  const allPids = getAllMihomoPids();
+  const allPids = getMihomoPids();
   const hasRootProcess = allPids.some((p) => isProcessRoot(p));
   const hasRootPidFile = isPidFileOwnedByRoot();
   return {
@@ -3880,7 +3990,7 @@ function killProcess(pid, needsSudo = false) {
   }
 }
 function killAllMihomo(forceSudo = false) {
-  const pattern = escapeForPgrep(PATHS.mihomoBinary);
+  const pattern = MAIN_INSTANCE_PATTERN;
   if (forceSudo) {
     try {
       spawnSync3("sudo", ["pkill", "-9", "-f", pattern], { stdio: "inherit", timeout: 15e3 });
@@ -3898,7 +4008,7 @@ function killAllMihomo(forceSudo = false) {
   }
 }
 function cleanupAll(forceSudo = false) {
-  const pids = getAllMihomoPids();
+  const pids = getMihomoPids();
   if (pids.length === 0) {
     clearPid();
     return { killed: 0, failed: 0, remaining: [] };
@@ -3929,26 +4039,26 @@ function cleanupAll(forceSudo = false) {
     }
   }
   for (let i = 0; i < PROCESS_WAIT_ATTEMPTS; i++) {
-    if (getAllMihomoPids().length === 0) break;
+    if (getMihomoPids().length === 0) break;
     sleepSync(PROCESS_WAIT_INTERVAL);
   }
   clearPid();
-  return { killed: killedCount, failed: failedPids.length, remaining: getAllMihomoPids() };
+  return { killed: killedCount, failed: failedPids.length, remaining: getMihomoPids() };
 }
 function createTunLaunchScript() {
-  const binary = PATHS.mihomoBinary;
-  const configFile = PATHS.configFile;
-  const logFile = PATHS.logFile;
-  const pidFile = PATHS.pidFile;
-  const dataDir = DIRS.data;
-  const killPattern = escapeForPgrep(binary);
+  const binary = shellQuote(PATHS.mihomoBinary);
+  const configFile = shellQuote(PATHS.configFile);
+  const logFile = shellQuote(PATHS.logFile);
+  const pidFile = shellQuote(PATHS.pidFile);
+  const dataDir = shellQuote(DIRS.data);
+  const killPattern = shellQuote(MAIN_INSTANCE_PATTERN);
   const scriptContent = `#!/bin/bash
-BINARY="${binary}"
-CONFIG_FILE="${configFile}"
-LOG_FILE="${logFile}"
-PID_FILE="${pidFile}"
-DATA_DIR="${dataDir}"
-KILL_PATTERN='${killPattern}'
+BINARY=${binary}
+CONFIG_FILE=${configFile}
+LOG_FILE=${logFile}
+PID_FILE=${pidFile}
+DATA_DIR=${dataDir}
+KILL_PATTERN=${killPattern}
 
 # \u7EC8\u6B62\u65E7\u8FDB\u7A0B
 pkill -9 -f "\${KILL_PATTERN}" 2>/dev/null || true
@@ -3979,7 +4089,7 @@ echo "--- \u65E5\u5FD7 ---"
 tail -25 "\${LOG_FILE}" 2>/dev/null
 exit 1
 `;
-  const scriptPath = path3.join(DIRS.runtime, "launch-tun.sh");
+  const scriptPath = path4.join(DIRS.runtime, "launch-tun.sh");
   fs5.writeFileSync(scriptPath, scriptContent, { mode: 448 });
   return scriptPath;
 }
@@ -4001,7 +4111,7 @@ function getProcessInfo(pid) {
 function getStatus() {
   const running = isRunning();
   const pid = getPid();
-  const allPids = getAllMihomoPids();
+  const allPids = getMihomoPids();
   return {
     running,
     pid: running ? pid : null,
@@ -4051,6 +4161,16 @@ async function startMixedMode(staleState) {
   const configFile = PATHS.configFile;
   const logFile = PATHS.logFile;
   const args = ["-d", DIRS.data, "-f", configFile];
+  if (fs5.existsSync(logFile)) {
+    try {
+      fs5.accessSync(logFile, fs5.constants.W_OK);
+    } catch {
+      try {
+        fs5.unlinkSync(logFile);
+      } catch {
+      }
+    }
+  }
   const logFd = fs5.openSync(logFile, "a");
   const child = spawn(PATHS.mihomoBinary, args, {
     detached: true,
@@ -4113,14 +4233,14 @@ async function startTunMode(staleState) {
   return { success: true, pid: finalPid, mode: "tun" };
 }
 function stop(forceSudo = false) {
-  const allPids = getAllMihomoPids();
+  const allPids = getMihomoPids();
   if (allPids.length === 0) {
     clearPid();
     clearRuntime();
     return { success: true, notRunning: true };
   }
   const result = cleanupAll(forceSudo);
-  const remaining = getAllMihomoPids();
+  const remaining = getMihomoPids();
   if (remaining.length > 0) {
     console.log("");
     console.log("\u4ECD\u6709\u8FDB\u7A0B\u6B8B\u7559\uFF0C\u9700\u8981\u624B\u52A8\u6E05\u7406:");
@@ -4144,9 +4264,8 @@ function rotateLog() {
   if (!fs5.existsSync(logFile)) return null;
   const stat = fs5.statSync(logFile);
   if (stat.size === 0) return null;
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/T/, "_").replace(/:/g, "-").replace(/\..+/, "");
-  const rotatedName = `mihomo.${timestamp}.log`;
-  const rotatedPath = path3.join(DIRS.logs, rotatedName);
+  const rotatedName = `mihomo.${formatLocalTimestamp()}.log`;
+  const rotatedPath = path4.join(DIRS.logs, rotatedName);
   fs5.renameSync(logFile, rotatedPath);
   return rotatedPath;
 }
@@ -4161,7 +4280,7 @@ function cleanupOldLogs(maxAgeDays = DEFAULT_LOG_RETENTION_DAYS) {
   for (const file of files) {
     if (!file.match(/^mihomo\.\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}\.log$/)) continue;
     try {
-      const filePath = path3.join(logsDir, file);
+      const filePath = path4.join(logsDir, file);
       const stat = fs5.statSync(filePath);
       if (now - stat.mtimeMs > maxAgeMs) {
         fs5.unlinkSync(filePath);
@@ -4192,7 +4311,7 @@ function listLogs() {
     const match = file.match(/^mihomo\.(\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2})\.log$/);
     if (!match) continue;
     try {
-      const filePath = path3.join(logsDir, file);
+      const filePath = path4.join(logsDir, file);
       const stat = fs5.statSync(filePath);
       result.archives.push({
         name: file,
@@ -4208,22 +4327,22 @@ function listLogs() {
   return result;
 }
 function isPathUnderDir(filePath, baseDir) {
-  const resolvedPath = path3.resolve(filePath);
-  const resolvedBase = path3.resolve(baseDir);
-  return resolvedPath === resolvedBase || resolvedPath.startsWith(resolvedBase + path3.sep);
+  const resolvedPath = path4.resolve(filePath);
+  const resolvedBase = path4.resolve(baseDir);
+  return resolvedPath === resolvedBase || resolvedPath.startsWith(resolvedBase + path4.sep);
 }
 function getLogPathByName(name) {
   const logsDir = DIRS.logs;
   let targetName = name;
   if (!name.endsWith(".log")) targetName = `mihomo.${name}.log`;
   if (!targetName.startsWith("mihomo.")) targetName = `mihomo.${targetName}`;
-  const filePath = path3.join(logsDir, targetName);
+  const filePath = path4.join(logsDir, targetName);
   if (fs5.existsSync(filePath) && isPathUnderDir(filePath, logsDir)) return filePath;
   if (fs5.existsSync(logsDir)) {
     const files = fs5.readdirSync(logsDir);
     for (const file of files) {
       if (file.includes(name)) {
-        const candidatePath = path3.join(logsDir, file);
+        const candidatePath = path4.join(logsDir, file);
         if (isPathUnderDir(candidatePath, logsDir)) return candidatePath;
       }
     }
@@ -4271,1021 +4390,1232 @@ 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}`);
+// src/daemon.ts
+var SERVICE_TARGET = `system/${LAUNCH_DAEMON_LABEL}`;
+var HOT_RELOAD_TIMEOUT_MS = 5e3;
+var DAEMON_BOOT_WAIT_MS = 500;
+var LOG_ROTATE_MAX_BYTES = 10 * 1024 * 1024;
+function logOversized() {
+  try {
+    return fs6.statSync(PATHS.logFile).size > LOG_ROTATE_MAX_BYTES;
+  } catch {
+    return false;
+  }
+}
+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_DAEMON_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 runSudoScript(scriptBody, opts) {
+  if (!process.stdin.isTTY) {
+    throw new Error("\u5F53\u524D\u73AF\u5883\u65E0\u6CD5\u8F93\u5165\u7BA1\u7406\u5458\u5BC6\u7801\uFF08\u9700\u8981\u5728\u4EA4\u4E92\u5F0F\u7EC8\u7AEF\u8FD0\u884C sudo\uFF09");
+  }
+  ensureDirs();
+  const scriptPath = path5.join(DIRS.runtime, opts.file);
+  fs6.writeFileSync(scriptPath, scriptBody, { mode: 448 });
+  try {
+    const result = spawnSync4("sudo", [scriptPath], { stdio: "inherit", timeout: SUDO_TIMEOUT_MS });
+    if (result.error) throw result.error;
+    if (result.status !== 0) {
+      if (result.status === 1) {
+        throw new Error("\u5DF2\u53D6\u6D88\u6216\u5BC6\u7801\u9519\u8BEF");
       }
-      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}`);
+      if (result.status == null) {
+        throw new Error(`${opts.action}\u88AB\u4E2D\u65AD\uFF08sudo \u8FDB\u7A0B\u88AB\u4FE1\u53F7\u7EC8\u6B62\uFF09`);
       }
-      return;
+      const custom = opts.codeMessages?.[result.status];
+      throw new Error(custom || `${opts.action}\u5931\u8D25\uFF08\u9000\u51FA\u7801 ${result.status}\uFF09`);
     }
-    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}`);
+  } finally {
+    try {
+      fs6.unlinkSync(scriptPath);
+    } catch {
+    }
+  }
+}
+function isDaemonEnabled() {
+  return fs6.existsSync(PATHS.launchDaemonPlist);
+}
+function getDaemonStatus() {
+  if (!isDaemonEnabled()) {
+    return { enabled: false, loaded: false, pid: null };
+  }
+  const rootPids = getMihomoPids().filter(isProcessRoot);
+  return { enabled: true, loaded: rootPids.length > 0, pid: rootPids[0] ?? null };
+}
+function isDaemonRunning(status) {
+  return status.loaded && status.pid !== null;
+}
+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");
+  }
+  ensureDirs();
+  const stagePath = path5.join(DIRS.runtime, "daemon.plist.stage");
+  atomicWriteFileSync(stagePath, buildPlist(), { mode: 384 });
+  const target = shellQuote(SERVICE_TARGET);
+  const plistDest = shellQuote(PATHS.launchDaemonPlist);
+  const stage = shellQuote(stagePath);
+  const pattern = shellQuote(MAIN_INSTANCE_PATTERN);
+  const script = [
+    "#!/bin/bash",
+    `launchctl bootout ${target} 2>/dev/null || true`,
+    `pkill -9 -f ${pattern} 2>/dev/null || true`,
+    "sleep 0.2",
+    `install -m 644 -o root -g wheel ${stage} ${plistDest} || exit 2`,
+    `launchctl bootstrap system ${plistDest} || { launchctl bootout ${target} 2>/dev/null; rm -f ${plistDest}; exit 3; }`,
+    "exit 0",
+    ""
+  ].join("\n");
+  try {
+    runSudoScript(script, {
+      action: "\u542F\u7528\u4FDD\u6D3B",
+      file: "daemon-enable.sh",
+      codeMessages: {
+        2: "\u5B89\u88C5 plist \u5230 /Library/LaunchDaemons \u5931\u8D25",
+        3: "\u88C5\u8F7D\u4FDD\u6D3B\u670D\u52A1\u5931\u8D25\uFF08launchctl bootstrap\uFF09"
       }
+    });
+  } finally {
+    try {
+      fs6.unlinkSync(stagePath);
+    } catch {
     }
+  }
+}
+function disableDaemon() {
+  if (!isDaemonEnabled()) return;
+  const target = shellQuote(SERVICE_TARGET);
+  const plistDest = shellQuote(PATHS.launchDaemonPlist);
+  const logFile = shellQuote(PATHS.logFile);
+  const dataDir = shellQuote(DIRS.data);
+  const script = [
+    "#!/bin/bash",
+    `launchctl bootout ${target} 2>/dev/null || true`,
+    `rm -f ${plistDest}`,
+    `chown "$SUDO_UID:$SUDO_GID" ${logFile} 2>/dev/null || true`,
+    `chown -R "$SUDO_UID:$SUDO_GID" ${dataDir} 2>/dev/null || true`,
+    "exit 0",
+    ""
+  ].join("\n");
+  runSudoScript(script, { action: "\u5173\u95ED\u4FDD\u6D3B", file: "daemon-disable.sh" });
+  const rootPids = getMihomoPids().filter(isProcessRoot);
+  if (rootPids.length > 0) {
     console.log("");
-    process.exit(1);
+    console.log(`\u4ECD\u6709 root \u5185\u6838\u8FDB\u7A0B\u6B8B\u7559 (PID ${rootPids.join(", ")})`);
+    console.log("\u624B\u52A8\u6E05\u7406: sudo pkill -9 mihomo");
   }
-  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
-`
-  );
+async function tryHotReload() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), HOT_RELOAD_TIMEOUT_MS);
+  try {
+    const res = await fetch(`${CONTROLLER_BASE_URL}/configs?force=true`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: "{}",
+      signal: controller.signal
+    });
+    return res.status === 204 || res.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function restartDaemon() {
+  if (!fs6.existsSync(PATHS.launchDaemonPlist)) {
+    throw new Error("\u4FDD\u6D3B\u672A\u542F\u7528\uFF0C\u65E0\u6CD5\u91CD\u542F");
+  }
+  if (!logOversized() && await tryHotReload()) return;
+  const target = shellQuote(SERVICE_TARGET);
+  const plistDest = shellQuote(PATHS.launchDaemonPlist);
+  const logFile = shellQuote(PATHS.logFile);
+  const archiveFile = shellQuote(path5.join(DIRS.logs, `mihomo.${formatLocalTimestamp()}.log`));
+  const script = [
+    "#!/bin/bash",
+    `if [ -f ${logFile} ] && [ "$(stat -f%z ${logFile} 2>/dev/null || echo 0)" -gt ${LOG_ROTATE_MAX_BYTES} ]; then`,
+    `  cp ${logFile} ${archiveFile} 2>/dev/null && : > ${logFile}`,
+    "fi",
+    `if launchctl kickstart -k ${target} 2>/dev/null; then exit 0; fi`,
+    `launchctl bootstrap system ${plistDest} || exit 3`,
+    "exit 0",
+    ""
+  ].join("\n");
+  runSudoScript(script, {
+    action: "\u91CD\u542F\u4FDD\u6D3B",
+    file: "daemon-restart.sh",
+    codeMessages: { 3: "\u91CD\u542F\u4FDD\u6D3B\u5931\u8D25\uFF08launchctl bootstrap\uFF09" }
+  });
+  cleanupOldLogs();
 }
-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}
-`
-  );
+// src/subscription.ts
+function isGithubUrl(url) {
+  return /github\.com|raw\.githubusercontent\.com/i.test(url);
 }
-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 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, dumpYaml(parsed.raw));
+}
+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}`);
+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 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)`);
-  }
-  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 = dumpYaml(base);
+  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;
+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]})`);
   }
-  viewLogWithTail(logPath, { follow: true, lines: 50 });
 }
-function cmdLogs(args) {
-  const targetName = getNonFlagArg(args, 1);
-  const lines = parseIntArg(args, "-n", "--lines", 100);
-  const openInViewer = hasFlag(args, "-o", "--open");
-  if (targetName) {
-    let logPath;
-    if (targetName === "current" || targetName === "0") {
-      logPath = getLogPath();
-    } else {
-      const parsedIdx = parseInt(targetName, 10);
-      if (!Number.isNaN(parsedIdx) && parsedIdx > 0 && String(parsedIdx) === targetName) {
-        const archiveLogs = listLogs();
-        const archive = archiveLogs.archives[parsedIdx - 1];
-        if (!archive) {
-          console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u65E5\u5FD7 "${targetName}"`);
-          console.log('\u4F7F\u7528 "mihomo logs" \u67E5\u770B\u53EF\u7528\u65E5\u5FD7\u5217\u8868');
-          process.exit(1);
-        }
-        logPath = archive.path;
-      } else {
-        logPath = getLogPathByName(targetName);
-      }
-    }
-    if (!logPath) {
-      console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u65E5\u5FD7 "${targetName}"`);
-      console.log('\u4F7F\u7528 "mihomo logs" \u67E5\u770B\u53EF\u7528\u65E5\u5FD7\u5217\u8868');
-      process.exit(1);
-    }
-    if (openInViewer) {
-      openLogFile(logPath);
-      return;
-    }
-    viewLogWithTail(logPath, { follow: false, lines });
-    return;
+async function autoUpdateStaleSubscription(options = {}) {
+  const allSubs = getSubscriptionsWithCache();
+  const staleSubs = allSubs.filter(needsAutoUpdate);
+  if (staleSubs.length === 0) {
+    return { total: 0, updated: 0, failed: 0 };
   }
-  const logs = listLogs();
-  const all = [];
-  if (logs.current) all.push(logs.current);
-  all.push(...logs.archives);
-  if (all.length === 0) {
-    console.log("\u6682\u65E0\u65E5\u5FD7");
-    return;
+  if (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...`);
   }
-  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`);
+  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 };
     }
-    console.log("");
+    throw e;
   }
-  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);
-}
-function loadSubscriptionConfig(subName) {
-  const rawContent = readSubscriptionRawConfig(subName);
-  if (!rawContent) {
-    throw new Error(`\u672A\u627E\u5230\u8BA2\u9605\u914D\u7F6E "${subName}"`);
+  let updatedCount = 0;
+  for (const r of results) {
+    if (r.success) updatedCount++;
+    printUpdateResult(r);
   }
-  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));
+  return { total: staleSubs.length, updated: updatedCount, failed: staleSubs.length - updatedCount };
 }
-function parseUserInfo(header) {
-  if (!header) return null;
-  const info = {};
-  const parts = header.split(";").map((p) => p.trim());
-  for (const part of parts) {
-    const [key, val] = part.split("=").map((s) => s.trim());
-    if (key && val !== void 0) {
-      const numVal = parseFloat(val);
-      info[key] = Number.isNaN(numVal) ? 0 : numVal;
+async function testProxyDelay(proxyName, timeout, testUrl, client, apiBase = CONTROLLER_BASE_URL) {
+  const encodedName = encodeURIComponent(proxyName);
+  const url = `${apiBase}/proxies/${encodedName}/delay?timeout=${timeout}&url=${encodeURIComponent(testUrl)}`;
+  try {
+    const response = await client.get(url);
+    const data = JSON.parse(response.data);
+    if (data.delay && data.delay > 0) {
+      return { name: proxyName, delay: data.delay };
+    }
+    return { name: proxyName, delay: null, error: data.message || "no delay" };
+  } catch (e) {
+    const err = e;
+    let errorMsg = "timeout";
+    if (err.response?.data?.message) {
+      errorMsg = String(err.response.data.message);
+    } else if (err.message) {
+      errorMsg = err.message;
     }
+    return { name: proxyName, delay: null, error: errorMsg };
   }
-  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 {
-    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 testSubscriptionProxies(subName, options = {}) {
+  const {
+    timeout = DEFAULT_TEST_TIMEOUT,
+    concurrency = DEFAULT_TEST_CONCURRENCY,
+    testUrl = DEFAULT_TEST_URL,
+    apiBase = CONTROLLER_BASE_URL,
+    onResult
+  } = options;
+  const { proxies } = options.parsed || loadSubscriptionConfig(subName);
+  if (proxies.length === 0) {
+    return { total: 0, alive: 0, dead: 0, results: [] };
   }
-  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(", ");
-}
-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 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++;
+    }
   }
-  return subs[0];
+  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 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);
+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);
     }
   }
-  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);
+  if (renameMap.size === 0) return 0;
+  for (const proxy of proxies) {
+    const newName = renameMap.get(proxy.name);
+    if (newName) proxy.name = newName;
   }
-  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);
+  for (const group of proxyGroups) {
+    if (Array.isArray(group.proxies)) {
+      group.proxies = group.proxies.map((name) => renameMap.get(name) || name);
+    }
+  }
+  return renameMap.size;
 }
-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})`;
+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++;
+      }
+      const hasOtherSource = group.use || group["include-all"] || group["include-all-proxies"];
+      if (group.proxies.length === 0 && !hasOtherSource) {
+        removedGroupNames.add(group.name);
+      }
     }
-    errorMsg += `
-  URL: ${maskedUrl}`;
-    throw new Error(errorMsg);
   }
-  const content = response.data;
-  if (!content?.trim()) {
-    throw new Error("\u8BA2\u9605\u5185\u5BB9\u4E3A\u7A7A");
+  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;
+        return !removedGroupNames.has(getRuleTarget(rule));
+      });
+    }
   }
-  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
-  };
+  return { removedProxies, updatedGroups, removedGroups: removedGroupNames.size };
 }
-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 };
+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;
       }
-    })
-  );
-  for (const r of responses) {
-    if (r.error) {
-      const maskedUrl = maskUrl(r.url);
-      throw new Error(`\u5408\u5E76\u8BA2\u9605\u7B2C ${r.index + 1} \u4E2A URL \u83B7\u53D6\u5931\u8D25: ${r.error.message}
-  URL: ${maskedUrl}`);
     }
   }
-  const parsed = responses.map((r, i) => {
-    const content = r.response?.data;
-    if (!content?.trim()) throw new Error(`\u5408\u5E76\u8BA2\u9605\u7B2C ${i + 1} \u4E2A URL \u5185\u5BB9\u4E3A\u7A7A`);
-    return parseYamlOrJson(content, `\u5408\u5E76\u8BA2\u9605\u7B2C ${i + 1} \u4E2A`);
-  });
-  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);
+  if (!skipped && removedProxies > 0) {
+    saveSubscriptionConfig(subName, parsed);
+  }
+  return { summary, removedProxies, updatedGroups, removedGroups, skipped };
+}
+
+// src/commands/daemon.ts
+function printDaemonStatus() {
+  const status = getDaemonStatus();
+  const stateText = status.enabled ? colors.green("\u5DF2\u542F\u7528") : colors.yellow("\u5DF2\u7981\u7528");
+  console.log(`${colors.gray("\u4FDD\u6D3B: ")}${stateText}`);
+  if (status.enabled) {
+    const runText = isDaemonRunning(status) ? colors.green(`\u8FD0\u884C\u4E2D (PID ${status.pid})`) : colors.yellow("\u672A\u8FD0\u884C");
+    console.log(`${colors.gray("\u5185\u6838: ")}${runText}`);
+  }
+  console.log("");
+  if (status.enabled) {
+    console.log("\u5173\u95ED\u4FDD\u6D3B: mihomo daemon off");
+  } else {
+    console.log("\u5F00\u542F\u4FDD\u6D3B: mihomo daemon on");
+    console.log(colors.gray("  \u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u81EA\u52A8\u91CD\u542F\uFF08\u4EC5 Mixed \u6A21\u5F0F\uFF09"));
+  }
+  console.log("");
+}
+async function cmdDaemon(args) {
+  const action = args?.[1];
+  if (action === "on" || action === "enable") {
+    if (!hasKernel()) {
+      console.error('\u9519\u8BEF: \u672A\u627E\u5230\u5185\u6838\uFF0C\u8BF7\u8FD0\u884C "mihomo kernel"');
+      process.exit(1);
+    }
+    const sub = getActiveSubscription();
+    if (!sub) {
+      console.error("\u9519\u8BEF: \u6CA1\u6709\u8BA2\u9605\uFF0C\u8BF7\u5148\u6DFB\u52A0\u8BA2\u9605");
+      process.exit(1);
+    }
+    let configInfo;
+    try {
+      configInfo = prepareConfigForStart("mixed", sub.name);
+    } catch (e) {
+      console.error(`${colors.red("\u914D\u7F6E\u9519\u8BEF:")} ${e.message}`);
+      process.exit(1);
+    }
+    console.log(colors.gray("\u5C06\u8BF7\u6C42\u7BA1\u7406\u5458\u6743\u9650\u4EE5\u5B89\u88C5\u7CFB\u7EDF\u7EA7\u4FDD\u6D3B\u670D\u52A1\uFF08LaunchDaemon\uFF09"));
+    console.log(colors.gray("\u7CFB\u7EDF\u7EA7\u4FDD\u6D3B\u9700\u8981 root\uFF0C\u4EE5\u89E3\u51B3\u5C40\u57DF\u7F51\u8BBF\u95EE\u53D7\u9650\u95EE\u9898"));
+    try {
+      enableDaemon();
+    } catch (e) {
+      console.error(`${colors.red("\u542F\u7528\u4FDD\u6D3B\u5931\u8D25:")} ${e.message}`);
+      process.exit(1);
+    }
+    console.log(`${colors.green("\u5DF2\u542F\u7528\u4FDD\u6D3B")} \xB7 ${sub.name} \xB7 ${formatProxySummary(configInfo)}`);
+    console.log(colors.gray("\u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u81EA\u52A8\u91CD\u542F\uFF0C\u4EE3\u7406\u5C06\u5728\u540E\u53F0\u5E38\u9A7B"));
+    console.log("");
+    await sleep(DAEMON_BOOT_WAIT_MS);
+    printDaemonStatus();
+    return;
+  }
+  if (action === "off" || action === "disable") {
+    if (!isDaemonEnabled()) {
+      console.log("\u4FDD\u6D3B\u5DF2\u662F\u5173\u95ED\u72B6\u6001");
+      console.log("");
+      printDaemonStatus();
+      return;
+    }
+    console.log(colors.gray("\u5C06\u8BF7\u6C42\u7BA1\u7406\u5458\u6743\u9650\u4EE5\u79FB\u9664\u7CFB\u7EDF\u7EA7\u4FDD\u6D3B\u670D\u52A1"));
+    try {
+      disableDaemon();
+    } catch (e) {
+      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);
+  }
+  console.log("");
+  printDaemonStatus();
+}
+
+// src/commands/directory.ts
+function cmdDirectory(args) {
+  const action = args?.[1];
+  if (action === "open") {
+    const target = args[2];
+    if (!target || target === "root") {
+      console.log("\u6B63\u5728\u6253\u5F00: \u6839\u76EE\u5F55");
+      const success = openUrl(USER_DATA_DIR);
+      if (!success) {
+        console.log(`\u8BF7\u624B\u52A8\u6253\u5F00: ${USER_DATA_DIR}`);
       }
+      return;
+    }
+    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);
+  }
+  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/kernel.ts
+import { spawnSync as spawnSync5 } from "child_process";
+import fs7 from "fs";
+import path6 from "path";
+
+// node_modules/compare-versions/lib/esm/utils.js
+var semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+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_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") && !nameWithoutGz.includes("-compatible");
+  });
+  return standardAsset || matchingAssets[0];
+}
+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 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;
     }
   }
-  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
+    current: currentDisplay,
+    latest: latestVersion,
+    needsUpdate,
+    assets: latest.assets,
+    release: latest
   };
 }
-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`);
+function findBinaryInDir(dir, maxDepth = 4) {
+  if (maxDepth <= 0) return null;
+  const files = fs7.readdirSync(dir);
+  for (const f of files) {
+    const fullPath = path6.join(dir, f);
+    const stat = fs7.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;
+  }
+  return null;
+}
+async function downloadKernel(progressCallback, mirror, releaseInfo) {
+  ensureDirs();
+  const latest = releaseInfo || await getLatestRelease(GITHUB_REPO, mirror);
+  const arch = getArch();
+  const platform = process.platform;
+  const asset = findMatchingAsset(latest.assets, platform, arch);
+  if (!asset) {
+    const available = latest.assets.map((a) => a.name).join(", ");
+    let hint = "";
+    if (available) hint = `
+  \u53EF\u7528\u7248\u672C: ${available}`;
+    throw new Error(`\u672A\u627E\u5230\u5339\u914D\u7684\u5185\u6838\u6587\u4EF6
+  \u5E73\u53F0: ${platform}, \u67B6\u6784: ${arch}${hint}`);
   }
-  const 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 downloadUrl = withMirror(asset.browser_download_url, mirror);
+  const tempPath = path6.join(DIRS.kernel, asset.name);
+  const sizeMB = (asset.size / 1024 / 1024).toFixed(2);
+  if (mirror && progressCallback) {
+    progressCallback("\u63D0\u793A: \u7ECF\u7B2C\u4E09\u65B9\u955C\u50CF\u4E2D\u8F6C\u4E0B\u8F7D\uFF0C\u65E0\u6CD5\u9A8C\u8BC1\u6765\u6E90\u5B8C\u6574\u6027\uFF0C\u5EFA\u8BAE\u76F4\u8FDE\u6216\u81EA\u884C\u6821\u9A8C\u4EA7\u7269");
+  }
+  if (progressCallback) {
+    progressCallback(`\u4E0B\u8F7D\u5185\u6838: ${asset.name} (${sizeMB} MB)`);
+  }
+  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 {
     }
-    console.log("");
+    throw new Error(`\u4E0B\u8F7D\u5931\u8D25 (curl \u9000\u51FA\u7801 ${curlResult.status})`);
   }
-  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) {
+  if (!fs7.existsSync(tempPath)) {
+    throw new Error("\u4E0B\u8F7D\u5931\u8D25: \u6587\u4EF6\u672A\u751F\u6210");
+  }
+  if (progressCallback) {
+    progressCallback("\u89E3\u538B\u5185\u6838...");
+  }
+  const extractPath = DIRS.kernel;
+  let extractedBinary = null;
   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);
+    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 = path6.basename(tempPath, ".gz");
+      const outputPath = path6.join(extractPath, baseName);
+      const gzipResult = spawnSync5("gzip", ["-dc", tempPath], { maxBuffer: 256 * 1024 * 1024, timeout: 6e4 });
+      if (gzipResult.error) throw gzipResult.error;
+      if (gzipResult.status !== 0) throw new Error(`gzip \u9000\u51FA\u7801 ${gzipResult.status}`);
+      fs7.writeFileSync(outputPath, gzipResult.stdout, { mode: 493 });
+      extractedBinary = outputPath;
     }
-    return { name: sub.name, success: true, proxies: info.proxies, proxyGroups: info.proxyGroups };
   } catch (e) {
-    return { name: sub.name, success: false, error: e.message };
+    try {
+      fs7.unlinkSync(tempPath);
+    } catch {
+    }
+    throw new Error(`\u89E3\u538B\u5931\u8D25: ${e.message}`);
   }
-}
-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]})`);
+  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");
   }
-}
-async function autoUpdateStaleSubscription(options = {}) {
-  const allSubs = getSubscriptionsWithCache();
-  const staleSubs = allSubs.filter(needsAutoUpdate);
-  if (staleSubs.length === 0) {
-    return { total: 0, updated: 0, failed: 0 };
+  const targetPath = PATHS.mihomoBinary;
+  if (foundBinary !== targetPath) {
+    if (fs7.existsSync(targetPath)) {
+      fs7.chmodSync(targetPath, 493);
+      try {
+        fs7.unlinkSync(targetPath);
+      } catch {
+      }
+    }
+    fs7.renameSync(foundBinary, targetPath);
   }
-  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...`);
+  fs7.chmodSync(targetPath, 493);
+  if (progressCallback) {
+    progressCallback("\u6821\u9A8C\u5185\u6838...");
   }
-  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 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 {
     }
-    throw e;
+    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)"}`);
   }
-  let updatedCount = 0;
-  for (const r of results) {
-    if (r.success) updatedCount++;
-    printUpdateResult(r);
+  try {
+    fs7.unlinkSync(tempPath);
+  } catch {
   }
-  return { total: staleSubs.length, updated: updatedCount, failed: staleSubs.length - updatedCount };
+  clearKernelVersionCache();
+  return { version: latest.tag_name, path: targetPath };
 }
-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)}`;
+
+// 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}`);
+    console.log("");
+  }
+  console.log("\u68C0\u67E5\u5185\u6838\u66F4\u65B0...");
   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 };
+    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 { name: proxyName, delay: null, error: data.message || "no delay" };
   } catch (e) {
+    console.error(`
+\u66F4\u65B0\u5931\u8D25: ${e.message}`);
     const err = e;
-    let errorMsg = "timeout";
-    if (err.response?.data?.message) {
-      errorMsg = String(err.response.data.message);
-    } else if (err.message) {
-      errorMsg = err.message;
+    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}`);
+      }
     }
-    return { name: proxyName, delay: null, error: errorMsg };
+    if (!effectiveMirror) {
+      console.error("");
+      console.error("\u63D0\u793A: \u76F4\u8FDE\u5931\u8D25\u6216\u4E0B\u8F7D\u8FC7\u6162\u65F6\u53EF\u4F7F\u7528\u955C\u50CF:");
+      console.error("  mihomo kernel --mirror [\u955C\u50CF]     # \u4E0B\u8F7D\u8D70\u955C\u50CF\uFF08\u9ED8\u8BA4 v6.gh-proxy.org\uFF09");
+      console.error("  mihomo kernel --mirror-all [\u955C\u50CF] # API \u548C\u4E0B\u8F7D\u90FD\u8D70\u955C\u50CF");
+      console.error(`  \u53EF\u7528\u955C\u50CF: ${AVAILABLE_MIRRORS.join(", ")}`);
+    }
+    process.exit(1);
   }
 }
-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 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++;
-    }
+
+// src/commands/log.ts
+function cmdLog(args) {
+  const logPath = getLogPath();
+  if (hasFlag(args, "-o", "--open")) {
+    openLogFile(logPath);
+    return;
   }
-  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 };
+  viewLogWithTail(logPath, { follow: true, lines: 50 });
 }
-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);
+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 {
-      usedNames.add(proxy.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);
+      }
+    }
+    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 (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);
+    if (openInViewer) {
+      openLogFile(logPath);
+      return;
     }
+    viewLogWithTail(logPath, { follow: false, lines });
+    return;
   }
-  return renameMap.size;
-}
-function cleanDeadProxies(parsed, deadNames) {
-  const { proxies, proxyGroups } = parsed;
-  const originalCount = proxies.length;
-  parsed.proxies = proxies.filter((p) => !deadNames.has(p.name));
-  const removedProxies = originalCount - parsed.proxies.length;
-  let updatedGroups = 0;
-  const removedGroupNames = /* @__PURE__ */ new Set();
-  for (const group of proxyGroups) {
-    if (Array.isArray(group.proxies)) {
-      const before = group.proxies.length;
-      group.proxies = group.proxies.filter((name) => !deadNames.has(name));
-      if (group.proxies.length < before) {
-        updatedGroups++;
-      }
-      if (group.proxies.length === 0) {
-        removedGroupNames.add(group.name);
-      }
-    }
+  const logs = listLogs();
+  const all = [];
+  if (logs.current) all.push(logs.current);
+  all.push(...logs.archives);
+  if (all.length === 0) {
+    console.log("\u6682\u65E0\u65E5\u5FD7");
+    return;
   }
-  if (removedGroupNames.size > 0) {
-    parsed.proxyGroups = proxyGroups.filter((g) => !removedGroupNames.has(g.name));
-    for (const group of parsed.proxyGroups) {
-      if (Array.isArray(group.proxies)) {
-        group.proxies = group.proxies.filter((name) => !removedGroupNames.has(name));
-      }
+  console.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 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());
-      });
+    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("");
   }
-  return { removedProxies, updatedGroups, removedGroups: removedGroupNames.size };
+  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("");
 }
-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;
-      }
-    }
+
+// src/commands/overwrite.ts
+import path8 from "path";
+
+// src/runtime.ts
+function getRuntimeMode() {
+  if (isDaemonEnabled()) return "mixed";
+  return getConfigInfo()?.tun ? "tun" : "mixed";
+}
+function getRunningState() {
+  if (isDaemonEnabled()) {
+    const daemon = getDaemonStatus();
+    return { running: isDaemonRunning(daemon), pid: daemon.pid, daemon: true };
   }
-  if (!skipped && removedProxies > 0) {
-    saveSubscriptionConfig(subName, parsed);
+  const status = getStatus();
+  return { running: status.running, pid: status.pid, daemon: false };
+}
+function isRestartNeededOnChange() {
+  return isDaemonEnabled() || getStatus().running;
+}
+async function launchOrRestart(mode) {
+  if (isDaemonEnabled()) {
+    await restartDaemon();
+    await sleep(DAEMON_BOOT_WAIT_MS);
+    return getDaemonStatus().pid;
   }
-  return { summary, removedProxies, updatedGroups, removedGroups, skipped };
+  const result = await start(mode);
+  return result.pid;
 }
 
 // src/commands/status.ts
 function printStatus() {
   const status = getStatus();
+  const state = getRunningState();
   const info = getConfigInfo();
   const overwriteEnabled = isOverwriteEnabled();
   const overwriteFiles = listOverwriteFile().files;
   const activeSub = getActiveSubscription();
+  const { running, pid, daemon: daemonManaged } = state;
   console.log("");
   let modeLabel = "";
-  if (info && 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 (!daemonManaged && status.processInfo) {
       console.log(`${colors.gray("\u5185\u5B58: ")}${status.processInfo.memory}`);
     }
   }
@@ -5316,6 +5646,9 @@ function printStatus() {
   } else {
     console.log(`${colors.gray("\u8986\u5199: ")}${colors.yellow("\u5DF2\u7981\u7528")}`);
   }
+  if (isDaemonEnabled()) {
+    console.log(`${colors.gray("\u4FDD\u6D3B: ")}${colors.green("\u5DF2\u542F\u7528")} ${colors.gray("(\u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u91CD\u542F)")}`);
+  }
   console.log("");
 }
 
@@ -5328,7 +5661,12 @@ function handleStopResult(result) {
   }
 }
 async function cmdStop() {
-  const pids = getAllMihomoPids();
+  if (isDaemonEnabled()) {
+    console.log(colors.yellow("\u4FDD\u6D3B\u5DF2\u542F\u7528\uFF0C\u4EE3\u7406\u7531 launchd \u6258\u7BA1"));
+    console.log("\u76F4\u63A5\u505C\u6B62\u4F1A\u88AB\u81EA\u52A8\u91CD\u65B0\u62C9\u8D77\uFF0C\u8BF7\u7528: mihomo daemon off");
+    return;
+  }
+  const pids = getMihomoPids();
   if (pids.length === 0) {
     console.log(colors.yellow("\u4E0D\u5728\u8FD0\u884C"));
     return;
@@ -5340,8 +5678,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 path7 from "path";
 
 // src/lifecycle.ts
 var cleanupFns = /* @__PURE__ */ new Set();
@@ -5362,20 +5700,20 @@ function runCleanup() {
 }
 
 // src/test-instance.ts
-var TEST_DIR = path5.join(USER_DATA_DIR, "test");
+var TEST_DIR = path7.join(USER_DATA_DIR, "test");
 var TEST_DIRS = {
-  data: path5.join(TEST_DIR, "data"),
-  runtime: path5.join(TEST_DIR, "runtime")
+  data: path7.join(TEST_DIR, "data"),
+  runtime: path7.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: path7.join(TEST_DIRS.runtime, "config.yaml"),
+  pidFile: path7.join(TEST_DIRS.runtime, "pid"),
+  logFile: path7.join(TEST_DIR, "test.log")
 };
 var TEST_API = `http://${TEST_CONFIG["external-controller"]}`;
 function ensureTestDirs() {
   for (const dir of Object.values(TEST_DIRS)) {
-    fs7.mkdirSync(dir, { recursive: true, mode: 448 });
+    fs8.mkdirSync(dir, { recursive: true, mode: 448 });
   }
 }
 function cleanupTestDir() {
@@ -5412,22 +5750,22 @@ 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 });
+  const content = dumpYaml(config);
+  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 +5781,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 +5794,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 +5806,7 @@ function stopTestInstance() {
     }
   }
   try {
-    fs7.unlinkSync(TEST_PATHS.pidFile);
+    fs8.unlinkSync(TEST_PATHS.pidFile);
   } catch {
   }
 }
@@ -5582,6 +5920,12 @@ function resolveTestTarget(args) {
   }
   return { target, timeout, concurrency };
 }
+function printRestartHintIfRunning() {
+  if (getRunningState().running) {
+    console.log(colors.yellow("\u63D0\u793A: \u8FD0\u884C\u4E2D\u7684\u5B9E\u4F8B\u4ECD\u4F7F\u7528\u65E7\u914D\u7F6E\uFF0C\u6267\u884C mihomo start \u4F7F\u66F4\u65B0\u751F\u6548"));
+    console.log("");
+  }
+}
 async function printSubscriptionList(options) {
   if (options?.autoUpdate !== false) {
     const updateResult = await autoUpdateStaleSubscription();
@@ -5705,6 +6049,7 @@ async function cmdSubscription(args) {
       }
       if (ok === 0) process.exit(1);
       console.log("");
+      printRestartHintIfRunning();
       await printSubscriptionList();
       return;
     }
@@ -5718,6 +6063,7 @@ async function cmdSubscription(args) {
     }
     console.log(`\u5DF2\u66F4\u65B0 (${formatProxySummary(result)})`);
     console.log("");
+    printRestartHintIfRunning();
     await printSubscriptionList();
     return;
   }
@@ -5742,9 +6088,8 @@ async function cmdSubscription(args) {
       await printSubscriptionList();
       return;
     }
-    const status = getStatus();
-    const configInfo = getConfigInfo();
-    const currentMode = configInfo?.tun ? "tun" : "mixed";
+    const currentMode = getRuntimeMode();
+    const restartNeeded = isRestartNeededOnChange();
     const success = setDefaultSubscription(target.name);
     if (success) {
       console.log(`\u5DF2\u5207\u6362\u5230 "${target.name}"`);
@@ -5752,7 +6097,7 @@ async function cmdSubscription(args) {
       console.error(`\u9519\u8BEF: \u672A\u627E\u5230\u8BA2\u9605 "${name}"`);
       process.exit(1);
     }
-    if (status.running) {
+    if (restartNeeded) {
       console.log("");
       await cmdStart(["start", currentMode]);
       return;
@@ -5846,8 +6191,7 @@ async function cmdSubscription(args) {
       console.log(colors.yellow("\u5B58\u6D3B\u8282\u70B9\u4E0D\u8DB3 1%\uFF0C\u8DF3\u8FC7\u6E05\u7406\u3002\u8BF7\u68C0\u67E5\u539F\u59CB\u8BA2\u9605\u662F\u5426\u6709\u6548"));
     } else if (result.removedProxies > 0) {
       console.log(`${colors.green("\u5DF2\u6E05\u7406")}: ${formatCleanSummary(result)}`);
-      const status = getStatus();
-      if (status.running) {
+      if (getRunningState().running) {
         console.log("");
         console.log("\u63D0\u793A: \u9700\u8981\u91CD\u542F mihomo \u4F7F\u66F4\u6539\u751F\u6548 (mihomo start)");
       }
@@ -5884,6 +6228,12 @@ async function cmdStart(args) {
     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 +6247,18 @@ 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...`);
-  }
-  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 +6270,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(targetMode);
+    const label = daemonEnabled ? "\u5DF2\u542F\u52A8 (\u4FDD\u6D3B)" : "\u5DF2\u542F\u52A8";
+    console.log(`${colors.green(label)}${pid ? ` (PID ${pid})` : ""}`);
   } catch (e) {
     const msg = e.message;
     const lines = msg.split("\n");
@@ -5951,11 +6304,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(targetMode);
+        console.log(`${colors.green("\u5DF2\u91CD\u542F")}${pid ? ` (PID ${pid})` : ""} \xB7 ${formatProxySummary(configInfo)}`);
       } catch (e) {
         console.error(`${colors.red("\u91CD\u542F\u5931\u8D25:")} ${e.message.split("\n")[0]}`);
         process.exit(1);
@@ -5975,8 +6328,8 @@ function printOverwriteList() {
   if (info.files.length === 0) {
     console.log("\u6682\u65E0\u8986\u5199\u6587\u4EF6");
     console.log("");
-    console.log(`\u7528\u6CD5\u793A\u4F8B: \u521B\u5EFA\u6587\u4EF6 ${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 ${path8.join(info.dir, "overwrite.yaml")}`);
+    console.log(`         \u6216        ${path8.join(info.dir, "overwrite.dns.yaml")}`);
     console.log("");
   } else {
     console.log(`${colors.cyan("\u8986\u5199\u6587\u4EF6")} (${info.files.length} \u4E2A\uFF0C\u6309\u987A\u5E8F\u52A0\u8F7D):`);
@@ -5996,9 +6349,8 @@ function printOverwriteList() {
 }
 async function cmdOverwrite(args) {
   const action = args?.[1];
-  const status = getStatus();
-  const configInfo = getConfigInfo();
-  const currentMode = configInfo?.tun ? "tun" : "mixed";
+  const currentMode = getRuntimeMode();
+  const restartNeeded = isRestartNeededOnChange();
   if (action === "on" || action === "enable") {
     if (isOverwriteEnabled()) {
       console.log("\u8986\u5199\u914D\u7F6E\u5DF2\u662F\u542F\u7528\u72B6\u6001");
@@ -6008,7 +6360,7 @@ async function cmdOverwrite(args) {
     }
     setOverwriteEnabled(true);
     console.log("\u5DF2\u542F\u7528\u8986\u5199\u914D\u7F6E");
-    if (status.running) {
+    if (restartNeeded) {
       console.log("");
       await cmdStart(["start", currentMode]);
       return;
@@ -6026,7 +6378,7 @@ async function cmdOverwrite(args) {
     }
     setOverwriteEnabled(false);
     console.log("\u5DF2\u7981\u7528\u8986\u5199\u914D\u7F6E");
-    if (status.running) {
+    if (restartNeeded) {
       console.log("");
       await cmdStart(["start", currentMode]);
       return;
@@ -6040,7 +6392,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 +6447,23 @@ 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(isOverwriteFilename).map((f) => `${dir}/${f}`);
     },
     needsStop: false
+  },
+  {
+    id: "daemon",
+    aliases: ["daemon"],
+    label: "\u4FDD\u6D3B",
+    // 卸载由确认后的 disablesDaemon 段统一处理（需 sudo，受取消保护）；
+    // 此处 paths 返回空（plist 在系统目录，用户态删不掉，且不应提前删破坏卸载），
+    // onAfter 因幂等守卫（plist 已删）成为 no-op，仅作单独 reset 未走前段时的兜底。
+    paths: () => [],
+    needsStop: false,
+    onAfter: () => disableDaemon(),
+    checkEmpty: () => !isDaemonEnabled(),
+    emptyMsg: "\u4FDD\u6D3B\u672A\u542F\u7528\uFF0C\u65E0\u9700\u5220\u9664"
   }
 ];
 function resolveResetTargets(names) {
@@ -6148,7 +6513,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 +6525,40 @@ async function cmdReset(args) {
   }
   const needsStop = targets.some((t) => t.needsStop);
   const warnRunning = targets.some((t) => t.warnIfRunning);
-  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) {
+  const kernelTargeted = targets.some((t) => t.id === "kernel");
+  const daemonTargeted = targets.some((t) => t.id === "daemon");
+  const disablesDaemon = needsStop || kernelTargeted || daemonTargeted;
+  const pids = needsStop || warnRunning ? getMihomoPids() : [];
+  if (warnRunning && pids.length > 0) {
     console.log(colors.yellow(`\u8B66\u544A: mihomo \u6B63\u5728\u8FD0\u884C (PID ${pids.join(", ")})\uFF0C\u5220\u9664\u5185\u6838\u540E\u5C06\u65E0\u6CD5\u91CD\u65B0\u542F\u52A8`));
   }
+  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()) {
+    try {
+      disableDaemon();
+    } catch (e) {
+      console.error(`${colors.red("\u4FDD\u6D3B\u5173\u95ED\u5DF2\u53D6\u6D88\uFF0C\u91CD\u7F6E\u4E2D\u6B62:")} ${e.message.split("\n")[0]}`);
+      return;
+    }
+  }
+  if (needsStop && getMihomoPids().length > 0) {
+    console.log("\u505C\u6B62\u8FDB\u7A0B...");
+    cleanupAll();
+    for (let i = 0; i < PROCESS_WAIT_ATTEMPTS; i++) {
+      if (getMihomoPids().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,9 +6577,10 @@ async function cmdReset(args) {
 
 // src/commands/test.ts
 function requireRunning() {
-  const status = getStatus();
-  if (!status.running) {
-    console.error("\u9519\u8BEF: mihomo \u672A\u8FD0\u884C\uFF0C\u8BF7\u5148\u542F\u52A8 (mihomo start)");
+  const state = getRunningState();
+  if (!state.running) {
+    const hint = state.daemon ? "mihomo daemon on" : "mihomo start";
+    console.error(`\u9519\u8BEF: mihomo \u672A\u8FD0\u884C\uFF0C\u8BF7\u5148\u542F\u52A8 (${hint})`);
     process.exit(1);
   }
 }
@@ -6256,11 +6637,18 @@ 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)}`);
+    const mode = getRuntimeMode();
+    const daemonManaged = isDaemonEnabled();
+    try {
+      if (!daemonManaged) handleStopResult(stop());
+      const configInfo = prepareConfigForStart(mode, activeSub.name);
+      const pid = await launchOrRestart(mode);
+      const label = daemonManaged ? "\u5DF2\u91CD\u542F (\u4FDD\u6D3B)" : "\u5DF2\u91CD\u542F";
+      console.log(`${colors.green(label)}${pid ? ` (PID ${pid})` : ""} \xB7 ${formatProxySummary(configInfo)}`);
+    } catch (e) {
+      console.error(`${colors.red("\u91CD\u542F\u5931\u8D25:")} ${e.message.split("\n")[0]}`);
+      process.exit(1);
+    }
   }
 }
 
@@ -6320,6 +6708,199 @@ async function cmdUpdate() {
   }
 }
 
+// src/commands/registry.ts
+var COMMANDS = [
+  // === 控制 ===
+  {
+    name: "start",
+    aliases: ["up"],
+    handler: cmdStart,
+    group: "control",
+    usage: ["start [tun|mixed] [-s] [-u ms]     \u542F\u52A8/\u5207\u6362\u4EE3\u7406 (\u9ED8\u8BA4 mixed)", "      [-r N] [-t ms] [-j N]"]
+  },
+  {
+    name: "tun",
+    aliases: [],
+    handler: cmdStart,
+    rewrite: (args) => ["start", "tun", ...args.slice(1)],
+    group: "control",
+    usage: []
+  },
+  {
+    name: "stop",
+    aliases: ["down"],
+    handler: cmdStop,
+    group: "control",
+    usage: ["stop                         \u505C\u6B62\u4EE3\u7406"]
+  },
+  {
+    name: "status",
+    aliases: [],
+    handler: printStatus,
+    group: "control",
+    usage: ["status                       \u67E5\u770B\u72B6\u6001"]
+  },
+  // === 界面 ===
+  {
+    name: "ui",
+    aliases: [],
+    handler: cmdUI,
+    group: "interface",
+    usage: ["ui [zash|dash|yacd]          \u6253\u5F00 Web UI (\u9ED8\u8BA4 zash)"]
+  },
+  {
+    name: "log",
+    aliases: [],
+    handler: cmdLog,
+    group: "interface",
+    usage: ["log [-o]                     \u5B9E\u65F6\u65E5\u5FD7\uFF08-o \u6253\u5F00\u6587\u4EF6\uFF09"]
+  },
+  {
+    name: "logs",
+    aliases: [],
+    handler: cmdLogs,
+    group: "interface",
+    usage: ["logs [\u7F16\u53F7] [-n N] [-o]      \u65E5\u5FD7\u5217\u8868\uFF080=\u5F53\u524D\uFF0C1+=\u5F52\u6863\uFF09"]
+  },
+  // === 订阅 ===
+  {
+    name: "subscription",
+    aliases: ["sub", "subscriptions"],
+    handler: cmdSubscription,
+    group: "subscription",
+    usage: [
+      "subscription                 \u5217\u51FA\u6240\u6709\u8BA2\u9605\uFF08\u522B\u540D sub\uFF09",
+      "subscription use <name>      \u5207\u6362\u5F53\u524D\u8BA2\u9605",
+      "subscription add <url> [name]  \u6DFB\u52A0\u8BA2\u9605",
+      "subscription update [name]   \u66F4\u65B0\u8BA2\u9605\uFF08\u65E0\u53C2\u66F4\u65B0\u6240\u6709\uFF09",
+      "subscription remove <name>   \u5220\u9664\u8BA2\u9605",
+      "subscription web [name]      \u6253\u5F00\u8BA2\u9605\u9875\u9762",
+      "subscription test [name]     \u6D4B\u8BD5\u8282\u70B9\u8FDE\u901A\u6027",
+      "subscription clean [name]    \u6D4B\u901F\u5E76\u6E05\u7406\u5931\u8D25\u8282\u70B9"
+    ]
+  },
+  {
+    name: "use",
+    aliases: [],
+    handler: cmdSubscription,
+    rewrite: (args) => ["sub", "use", ...args.slice(1)],
+    group: "subscription",
+    usage: []
+  },
+  {
+    name: "test",
+    aliases: [],
+    handler: cmdTest,
+    group: "subscription",
+    usage: ["test [-t ms] [-j N]           \u5FEB\u901F\u6D4B\u8BD5\u5F53\u524D\u8282\u70B9\u8FDE\u901A\u6027"]
+  },
+  {
+    name: "clean",
+    aliases: [],
+    handler: cmdClean,
+    group: "subscription",
+    usage: ["clean [-t ms] [-j N] [-r N]   \u6E05\u7406\u5931\u8D25\u8282\u70B9\u5E76\u81EA\u52A8\u91CD\u542F"]
+  },
+  // === 配置 ===
+  {
+    name: "overwrite",
+    aliases: ["ow"],
+    handler: cmdOverwrite,
+    group: "config",
+    usage: ["overwrite                   \u67E5\u770B\u8986\u5199\u72B6\u6001\uFF08\u522B\u540D ow\uFF09", "overwrite on|off            \u542F\u7528/\u7981\u7528\u8986\u5199\u914D\u7F6E"]
+  },
+  {
+    name: "on",
+    aliases: [],
+    handler: cmdOverwrite,
+    rewrite: () => ["ow", "on"],
+    group: "config",
+    usage: []
+  },
+  {
+    name: "off",
+    aliases: [],
+    handler: cmdOverwrite,
+    rewrite: () => ["ow", "off"],
+    group: "config",
+    usage: []
+  },
+  {
+    name: "directory",
+    aliases: ["dir", "dirs", "directories"],
+    handler: cmdDirectory,
+    group: "config",
+    usage: ["directory                   \u663E\u793A\u6570\u636E\u76EE\u5F55\u4F4D\u7F6E\uFF08\u522B\u540D dir\uFF09", "directory open [target]     \u6253\u5F00\u76EE\u5F55: root|subs|logs|runtime|..."]
+  },
+  {
+    name: "open",
+    aliases: [],
+    handler: cmdDirectory,
+    rewrite: (args) => ["dir", "open", ...args.slice(1)],
+    group: "config",
+    usage: []
+  },
+  // === 系统 ===
+  {
+    name: "kernel",
+    aliases: [],
+    handler: cmdKernel,
+    group: "system",
+    usage: ["kernel [--mirror [\u955C\u50CF]]         \u66F4\u65B0\u5185\u6838\uFF08\u9ED8\u8BA4\u76F4\u8FDE\uFF0C--mirror \u4F7F\u7528 v6\uFF09"]
+  },
+  {
+    name: "daemon",
+    aliases: [],
+    handler: cmdDaemon,
+    group: "system",
+    usage: ["daemon on|off               \u5F00\u673A\u81EA\u542F + \u5D29\u6E83\u91CD\u542F\uFF08\u4EC5 Mixed\uFF0C\u9700\u7BA1\u7406\u5458\u5BC6\u7801\uFF09", "daemon status               \u67E5\u770B\u4FDD\u6D3B\u72B6\u6001"]
+  },
+  {
+    name: "update",
+    aliases: ["upd", "upgrade"],
+    handler: cmdUpdate,
+    group: "system",
+    usage: ["update                       \u66F4\u65B0 mihomo-cli (npm install -g)"]
+  },
+  {
+    name: "reset",
+    aliases: [],
+    handler: cmdReset,
+    group: "system",
+    usage: ["reset [\u76EE\u6807...] [--full]   \u91CD\u7F6E: \u7559\u7A7A\u4FDD\u7559\u8BBE\u7F6E/\u5185\u6838/\u8986\u5199, \u6307\u5B9A\u76EE\u6807\u5220\u5BF9\u5E94\u9879, --full \u5220\u5168\u90E8"]
+  },
+  // === meta(不在分组清单展示,help 末尾单列) ===
+  {
+    name: "help",
+    aliases: ["-h", "--help"],
+    handler: () => printHelp(COMMANDS),
+    group: "meta",
+    usage: ["help, -h                     \u663E\u793A\u5E2E\u52A9"]
+  },
+  {
+    name: "version",
+    aliases: ["-v", "--version"],
+    handler: printVersion,
+    group: "meta",
+    usage: ["version, -v                  \u663E\u793A\u7248\u672C"]
+  }
+];
+var COMMAND_INDEX = (() => {
+  const index = /* @__PURE__ */ new Map();
+  for (const cmd of COMMANDS) {
+    for (const token of [cmd.name, ...cmd.aliases]) {
+      if (index.has(token)) {
+        throw new Error(`\u547D\u4EE4\u6CE8\u518C\u8868\u5B58\u5728\u91CD\u590D token: "${token}"\uFF08${index.get(token)?.name} \u4E0E ${cmd.name}\uFF09`);
+      }
+      index.set(token, cmd);
+    }
+  }
+  return index;
+})();
+function findCommand(token) {
+  return COMMAND_INDEX.get(token);
+}
+
 // src/index.ts
 process.on("SIGINT", () => {
   console.log("\n\u6B63\u5728\u9000\u51FA...");
@@ -6336,12 +6917,14 @@ process.on("uncaughtException", (e) => {
   if (e.stack) {
     console.error(e.stack.split("\n").slice(1).join("\n"));
   }
+  runCleanup();
   process.exit(1);
 });
 process.on("unhandledRejection", (reason) => {
   const msg = reason instanceof Error ? reason.message : String(reason);
   console.error(`
 \u672A\u5904\u7406\u7684 Promise \u62D2\u7EDD: ${msg}`);
+  runCleanup();
   process.exit(1);
 });
 function clearProxyEnv() {
@@ -6361,91 +6944,18 @@ async function main() {
     printShortHelp();
     return;
   }
-  const cmd = args[0].toLowerCase();
-  if (["help", "-h", "--help"].includes(cmd)) {
-    printHelp();
-    return;
-  }
-  if (["version", "-v", "--version"].includes(cmd)) {
-    printVersion();
-    return;
-  }
-  switch (cmd) {
-    case "up":
-    case "start":
-      await cmdStart(args);
-      break;
-    case "tun":
-      await cmdStart(["start", "tun", ...args.slice(1)]);
-      break;
-    case "down":
-    case "stop":
-      await cmdStop();
-      break;
-    case "status":
-      printStatus();
-      break;
-    case "log":
-      cmdLog(args);
-      break;
-    case "logs":
-      cmdLogs(args);
-      break;
-    case "open":
-      cmdDirectory(["dir", "open", ...args.slice(1)]);
-      break;
-    case "ui":
-      cmdUI(args);
-      break;
-    case "kernel":
-      await cmdKernel(args);
-      break;
-    case "upd":
-    case "update":
-    case "upgrade":
-      await cmdUpdate();
-      break;
-    case "use":
-      await cmdSubscription(["sub", "use", ...args.slice(1)]);
-      break;
-    case "sub":
-    case "subscription":
-    case "subscriptions":
-      await cmdSubscription(args);
-      break;
-    case "dir":
-    case "dirs":
-    case "directory":
-    case "directories":
-      cmdDirectory(args);
-      break;
-    case "reset":
-      await cmdReset(args);
-      break;
-    case "on":
-      await cmdOverwrite(["ow", "on"]);
-      break;
-    case "off":
-      await cmdOverwrite(["ow", "off"]);
-      break;
-    case "ow":
-    case "overwrite":
-      await cmdOverwrite(args);
-      break;
-    case "test":
-      await cmdTest(args);
-      break;
-    case "clean":
-      await cmdClean(args);
-      break;
-    default:
-      console.error(`\u672A\u77E5\u547D\u4EE4: ${cmd}`);
-      console.error('\u4F7F\u7528 "mihomo help" \u67E5\u770B\u5E2E\u52A9');
-      process.exit(1);
+  const token = args[0].toLowerCase();
+  const command = findCommand(token);
+  if (!command) {
+    console.error(`\u672A\u77E5\u547D\u4EE4: ${token}`);
+    console.error('\u4F7F\u7528 "mihomo help" \u67E5\u770B\u5E2E\u52A9');
+    process.exit(1);
   }
+  await command.handler(command.rewrite ? command.rewrite(args) : args);
 }
 main().catch((e) => {
   console.error(`\u9519\u8BEF: ${e.message}`);
+  runCleanup();
   process.exit(1);
 });
 /*! Bundled license information: