mihomo-cli 3.8.0 → 3.8.1

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## [3.8.1] - 2026-09-01
+
+一轮全量代码审查的修复集：1 项新发现的高危数据丢失，以及上轮审查遗留的 9 项「仍待处理」。全部经实际复现确认，修复后回归验证。
+
+### 修复
+
+- **并发操作会静默丢数据（高危）** - `settings.json` 无跨进程锁，两个 CLI 进程各自读旧全量再写回，后写者把先写者的改动整块抹掉，**而先写者已经打印了「已添加」**。实测 6 个并发 `sub add` 丢 3 条；慢速 `sub add`（跨网络下载）期间执行 `tunnel add`，隧道被抹成 `null`——订阅与隧道同住一个文件，互不相干的命令互相摧毁。触发条件很日常：机场慢时 `sub add` 要跑十几秒，此间在另一个终端做点别的即可
+
+  修法是新增文件锁（`O_EXCL`）把整个「读-改-写」圈起来。仅「写前重读盘」不够——读与写之间仍有窗口，实测仍丢 3 条。持锁超过 10s 视为进程已崩溃并强夺，避免一次崩溃永久锁死后续所有命令
+
+- **内核下载来源未钉死（供应链）** - `--mirror-all` 下连 GitHub API 都走镜像，`browser_download_url` 完全由镜像说了算，而此前对非 github 的 URL 原样放行，镜像返回任意主机地址即可让 CLI 下载任意二进制；该产物随后 `chmod 755` 并在 TUN/daemon 下**以 root 运行**。现加下载 host 白名单 + 强制 https（校验在加镜像前缀之前），curl 补 `--proto '=https' --proto-redir '=https'`（实测 `-L` 会跟着 302 降级到明文 http 并落盘）与 `--max-filesize`，下载后比对 `asset.size`
+
+- **归档 symlink 成员可 chmod 任意文件** - 名为 `mihomo`、指向任意路径的符号链接，其条目名完全合法（不含 `..`、非绝对路径），能通过路径穿越守卫，随后被当成二进制 `chmod 755`——实测把 `chmod 600` 的文件改成了 755。现同时校验条目**类型**（拒符号/硬链接）并把遍历的 `statSync` 改为 `lstatSync`
+
+- **畸形流量响应头会抹掉已有用量数据** - `Subscription-Userinfo` 返回 `garbage` 这类无有效字段的头时，解析结果 `{}` 是 truthy，导致 upload/download/total/expire 四个字段被 `undefined` 覆盖。反直觉的是**没有响应头反而安全**（整块跳过）。另修 `expire=abc` 被塞 0 而显示成「永久有效」（垃圾值朝最误导的方向失败）、`total=1e999` 写成 `null`、负数原样入库使百分比失真
+
+- **时钟偏移导致订阅永不自动更新** - `updated_at` 落在未来（系统时间被改过、跨时区调时）时时间差恒为负，`needsAutoUpdate` 恒 false，订阅静默过期到失联
+
+- **`daemon off` 在 plist 被手动删除后是空操作** - 用户 `sudo rm` 掉 plist 后任务仍处装载状态，此前只看文件存在就直接返回，永不执行 `launchctl bootout`，于是 KeepAlive 继续把内核拉起——杀掉立刻重生，且 CLI 无任何途径卸载。现判据改为「plist 不在**且**无 root 内核在跑」
+
+- **`daemon on` 遗留 root 属主 pid 文件** - 使后续 `daemon off` → `start` 撞上残留检查而拒绝启动，这个死胡同完全由 CLI 自身的 on/off 循环造成
+
+- **热重载信任 9090 上的任意响应** - 该端口被其他服务占用且对 PUT 返回 2xx 时，CLI 打印「已重启 (保活)」而 daemon 内核仍跑旧配置，配置变更静默未生效。现先确认应答方确为 mihomo
+
+- **`tunnel up` 期间 Ctrl+C 泄漏 ssh 进程** - 等待转发建立最长 20 秒，其间中断会留下孤儿 ssh 进程和一份声称健康的运行态文件（实测持久残留、不自愈），随后 `tunnel up` 报「已在运行」而 `status` 报「假活」，自相矛盾。现在该窗口内注册一次性清理，启动成功后立即注销以保持「隧道活过 CLI 退出」的语义
+
+- **`__proto__` 作订阅名时缓存永远写不进** - 该名称通过校验，但在普通对象上赋值是设置原型而非自有属性，落盘为 `{}`，`updated_at` 永远缺失 → 每次 `start` 都重新下载该订阅
+
+- **配置校验的四个静默空洞** - 均无任何告警：proxy 与 proxy-group 同名（两者都留下，mihomo 因重复名拒绝加载）；`use` 引用不存在的 provider（从不校验，且使该组免于删除）；节点池为空 + `include-all` 的空组保留（实际无任何出口）；`proxies` 写成字符串时整体跳过校验、非法结构原样落盘
+
+- **`--mirror` 接受非法 scheme** - 此前用 `startsWith('http')` 判断，放行 `httpfoo://x` 与明文 `http://`，并把 `ftp://e.test` 拼成 `https://ftp://e.test/`。现改用 `URL` 解析 + https 白名单
+
+- **sudo 中间脚本的权限位不重放** - `writeFileSync` 的 `mode` 只在创建新文件时生效，前次崩溃残留的同名文件会保留旧权限（实测 0666 重写后仍是 0666），而该文件下一步就交给 sudo 执行。两处写后补显式 `chmodSync`
+
+### 测试
+
+- 单测 145 → 165：文件锁 6 项（含用真实子进程验证跨进程互斥、陈旧锁强夺、异常路径释放）、`parseUserInfo` 边界 8 项、配置校验空洞 6 项（含「正常配置不产生告警」的回归用例）
+
 ## [3.8.0] - 2026-09-01
 
 ### 新增

package/dist/index.js

@@ -3233,6 +3233,55 @@ function atomicWriteFileSync(filePath, content, options) {
 function rmrf(dir) {
   fs.rmSync(dir, { recursive: true, force: true });
 }
+var LOCK_STALE_MS = 1e4;
+var LOCK_RETRY_MS = 20;
+function withFileLock(filePath, fn) {
+  const lockPath = `${filePath}.lock`;
+  const deadline = Date.now() + LOCK_STALE_MS;
+  let fd = null;
+  while (fd === null) {
+    try {
+      fd = fs.openSync(lockPath, "wx");
+    } catch (e) {
+      if (e.code !== "EEXIST") throw e;
+      let stale = false;
+      try {
+        stale = Date.now() - fs.statSync(lockPath).mtimeMs > LOCK_STALE_MS;
+      } catch {
+      }
+      if (stale) {
+        try {
+          fs.rmSync(lockPath, { force: true });
+        } catch {
+        }
+        continue;
+      }
+      if (Date.now() > deadline) {
+        try {
+          fs.rmSync(lockPath, { force: true });
+        } catch {
+        }
+        continue;
+      }
+      sleepSyncMs(LOCK_RETRY_MS);
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    try {
+      fs.closeSync(fd);
+    } catch {
+    }
+    try {
+      fs.rmSync(lockPath, { force: true });
+    } catch {
+    }
+  }
+}
+function sleepSyncMs(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
 
 // src/settings.ts
 import fs2 from "fs";
@@ -3269,6 +3318,10 @@ function recoverCorruptedSettings() {
 }
 function writeSettings(settings) {
   ensureDirs();
+  return withFileLock(PATHS.settingsFile, () => writeSettingsUnlocked(settings));
+}
+function writeSettingsUnlocked(settings) {
+  settingsCache = null;
   const existing = readSettings();
   const merged = { ...existing, ...settings };
   for (const key of Object.keys(settings)) {
@@ -3278,6 +3331,14 @@ function writeSettings(settings) {
   settingsCache = merged;
   return settingsCache;
 }
+function updateSettings(mutate) {
+  ensureDirs();
+  return withFileLock(PATHS.settingsFile, () => {
+    settingsCache = null;
+    const current = readSettings();
+    return writeSettingsUnlocked(mutate(current));
+  });
+}
 function invalidateSettingsCache() {
   settingsCache = null;
 }
@@ -3323,10 +3384,13 @@ function maskUrl(url) {
 }
 function readSubscriptionCache() {
   ensureDirs();
+  const empty = () => /* @__PURE__ */ Object.create(null);
   if (fs2.existsSync(PATHS.subscriptionsCacheFile)) {
     try {
       const content = fs2.readFileSync(PATHS.subscriptionsCacheFile, "utf8");
-      return JSON.parse(content);
+      const parsed = JSON.parse(content);
+      if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return empty();
+      return Object.assign(empty(), parsed);
     } catch {
       try {
         fs2.copyFileSync(PATHS.subscriptionsCacheFile, `${PATHS.subscriptionsCacheFile}.bak`);
@@ -3334,10 +3398,10 @@ function readSubscriptionCache() {
       } catch {
         console.warn("\u8B66\u544A: \u8BA2\u9605\u7F13\u5B58\u683C\u5F0F\u635F\u574F\uFF0C\u5DF2\u5FFD\u7565");
       }
-      return {};
+      return empty();
     }
   }
-  return {};
+  return empty();
 }
 function writeSubscriptionCache(cache) {
   ensureDirs();
@@ -3375,31 +3439,41 @@ function validateSubscriptionName(name) {
 }
 function addSubscription(url, name = "default") {
   validateSubscriptionName(name);
-  const settings = readSettings();
-  const subs = [...getSubscriptions()];
-  if (subs.some((s) => s.name === name)) {
+  let duplicate = false;
+  updateSettings((settings) => {
+    const subs = [...getSubscriptions()];
+    if (subs.some((s) => s.name === name)) {
+      duplicate = true;
+      return {};
+    }
+    subs.push({ name, url });
+    const updates = { subscriptions: subs };
+    if (!settings.active_subscription && subs.length === 1) {
+      updates.active_subscription = name;
+    }
+    return updates;
+  });
+  if (duplicate) {
     throw new CliError(`\u8BA2\u9605 "${name}" \u5DF2\u5B58\u5728\uFF0C\u8BF7\u6362\u4E2A\u540D\u79F0\uFF08mihomo sub add <url> <\u540D\u79F0>\uFF09\uFF0C\u6216\u5148\u5220\u9664\uFF08mihomo sub remove ${name}\uFF09`);
   }
-  subs.push({ name, url });
-  const updates = { subscriptions: subs };
-  if (!settings.active_subscription && subs.length === 1) {
-    updates.active_subscription = name;
-  }
-  writeSettings(updates);
 }
 function removeSubscription(name) {
-  const settings = readSettings();
-  const subs = [...getSubscriptions()];
-  const idx = subs.findIndex((s) => s.name === name);
-  if (idx < 0) return null;
-  subs.splice(idx, 1);
-  const updates = { subscriptions: subs };
   let switchedTo = null;
-  if (settings.active_subscription === name) {
-    switchedTo = subs.length > 0 ? subs[0].name : null;
-    updates.active_subscription = switchedTo ?? void 0;
-  }
-  writeSettings(updates);
+  let found = false;
+  updateSettings((settings) => {
+    const subs = [...getSubscriptions()];
+    const idx = subs.findIndex((s) => s.name === name);
+    if (idx < 0) return {};
+    found = true;
+    subs.splice(idx, 1);
+    const updates = { subscriptions: subs };
+    if (settings.active_subscription === name) {
+      switchedTo = subs.length > 0 ? subs[0].name : null;
+      updates.active_subscription = switchedTo ?? void 0;
+    }
+    return updates;
+  });
+  if (!found) return null;
   const cache = readSubscriptionCache();
   if (cache[name]) {
     delete cache[name];
@@ -3859,14 +3933,24 @@ function suggestSimilar(input, candidates) {
 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}`;
+  const withScheme = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(val) ? val : `https://${val}`;
+  let parsed;
+  try {
+    parsed = new URL(withScheme);
+  } catch {
+    throw new CliError(`\u955C\u50CF\u5730\u5740\u65E0\u6548: "${val}"`, {
+      label: "\u53C2\u6570\u9519\u8BEF",
+      hint: ["\u683C\u5F0F\u5982: --mirror https://gh-proxy.org/ \u6216 --mirror gh-proxy.org", "\u4E0D\u4F7F\u7528\u955C\u50CF: --no-mirror"]
+    });
   }
-  if (!url.endsWith("/")) {
-    url += "/";
+  if (parsed.protocol !== "https:") {
+    throw new CliError(`\u955C\u50CF\u5730\u5740\u5FC5\u987B\u4F7F\u7528 https: "${val}"`, {
+      label: "\u53C2\u6570\u9519\u8BEF",
+      hint: ["\u955C\u50CF\u4F1A\u4E2D\u8F6C\u5185\u6838\u4E8C\u8FDB\u5236\uFF0C\u8BE5\u4EA7\u7269\u968F\u540E\u4EE5 root \u8FD0\u884C\uFF0C\u4E0D\u5141\u8BB8\u660E\u6587\u4F20\u8F93\u3002"]
+    });
   }
-  return url;
+  const url = parsed.toString();
+  return url.endsWith("/") ? url : `${url}/`;
 }
 function parseMirrorArg(args) {
   if (!args || args.length < 2) {
@@ -4045,6 +4129,14 @@ function validateConfig(config) {
     warnings.push(`\u79FB\u9664\u4E86 ${groupDedup.duplicates.length} \u4E2A\u91CD\u540D\u5206\u7EC4: ${groupDedup.duplicates.map((n) => `"${n}"`).join(", ")}`);
   }
   const validNames = /* @__PURE__ */ new Set([...BUILTIN_PROXY_NAMES, ...proxyDedup.names, ...groupDedup.names]);
+  for (const name of groupDedup.names) {
+    if (proxyDedup.names.has(name)) {
+      warnings.push(`\u540D\u79F0\u51B2\u7A81: "${name}" \u540C\u65F6\u662F\u8282\u70B9\u548C\u5206\u7EC4\u540D\uFF0Cmihomo \u4F1A\u62D2\u7EDD\u52A0\u8F7D\uFF08\u8BF7\u91CD\u547D\u540D\u5176\u4E00\uFF09`);
+    }
+  }
+  const providerNames = new Set(
+    config["proxy-providers"] && typeof config["proxy-providers"] === "object" && !Array.isArray(config["proxy-providers"]) ? Object.keys(config["proxy-providers"]) : []
+  );
   const activeGroups = groupDedup.result;
   const removedGroups = /* @__PURE__ */ new Set();
   let changed = true;
@@ -4052,12 +4144,32 @@ function validateConfig(config) {
     changed = false;
     for (const group of activeGroups) {
       if (removedGroups.has(group.name)) continue;
+      if (group.proxies !== void 0 && !Array.isArray(group.proxies)) {
+        if (typeof group.proxies === "string") {
+          warnings.push(`proxy-group "${group.name}": proxies \u5E94\u4E3A\u5217\u8868\uFF0C\u5DF2\u6309\u5355\u5143\u7D20\u5904\u7406\uFF08"${group.proxies}"\uFF09`);
+          group.proxies = [group.proxies];
+        } else {
+          warnings.push(`proxy-group "${group.name}": proxies \u4E0D\u662F\u5217\u8868\uFF0C\u5DF2\u5FFD\u7565\u8BE5\u5B57\u6BB5`);
+          group.proxies = [];
+        }
+      }
       if (!Array.isArray(group.proxies)) continue;
+      if (Array.isArray(group.use)) {
+        const ghosts = group.use.filter((u) => typeof u === "string" && !providerNames.has(u));
+        if (ghosts.length > 0) {
+          group.use = group.use.filter((u) => providerNames.has(u));
+          warnings.push(`proxy-group "${group.name}": \u79FB\u9664\u4E86\u4E0D\u5B58\u5728\u7684 provider \u5F15\u7528 ${ghosts.map((n) => `"${n}"`).join(", ")}`);
+        }
+      }
       const invalid = group.proxies.filter((name) => !validNames.has(name));
-      if (invalid.length === 0) continue;
-      group.proxies = group.proxies.filter((name) => validNames.has(name));
-      warnings.push(`proxy-group "${group.name}": \u79FB\u9664\u4E86\u4E0D\u5B58\u5728\u7684\u5F15\u7528 ${invalid.map((n) => `"${n}"`).join(", ")}`);
-      const hasOtherSource = group.use || group["include-all"] || group["include-all-proxies"];
+      if (invalid.length > 0) {
+        group.proxies = group.proxies.filter((name) => validNames.has(name));
+        warnings.push(`proxy-group "${group.name}": \u79FB\u9664\u4E86\u4E0D\u5B58\u5728\u7684\u5F15\u7528 ${invalid.map((n) => `"${n}"`).join(", ")}`);
+      }
+      const hasUse = Array.isArray(group.use) ? group.use.length > 0 : Boolean(group.use);
+      const includesAll = Boolean(group["include-all"] || group["include-all-proxies"]);
+      const includeAllUsable = includesAll && proxyDedup.result.length > 0;
+      const hasOtherSource = hasUse || includeAllUsable;
       if (group.proxies.length === 0 && !hasOtherSource) {
         removedGroups.add(group.name);
         validNames.delete(group.name);
@@ -4551,6 +4663,7 @@ exit 2
 `;
   const scriptPath = path4.join(DIRS.runtime, "launch-tun.sh");
   fs5.writeFileSync(scriptPath, scriptContent, { mode: 448 });
+  fs5.chmodSync(scriptPath, 448);
   return scriptPath;
 }
 function getProcessInfo(pid) {
@@ -4920,6 +5033,7 @@ function runSudoScript(scriptBody, opts) {
   ensureDirs();
   const scriptPath = path5.join(DIRS.runtime, opts.file);
   fs6.writeFileSync(scriptPath, scriptBody, { mode: 448 });
+  fs6.chmodSync(scriptPath, 448);
   try {
     const result = spawnSync3("sudo", [scriptPath], { stdio: "inherit", timeout: SUDO_TIMEOUT_MS });
     if (result.error) throw result.error;
@@ -4968,10 +5082,15 @@ function enableDaemon() {
   const plistDest = shellQuote(PATHS.launchDaemonPlist);
   const stage = shellQuote(stagePath);
   const pattern = shellQuote(MAIN_INSTANCE_PATTERN);
+  const pidFile = shellQuote(PATHS.pidFile);
   const script = [
     "#!/bin/bash",
     `launchctl bootout ${target} 2>/dev/null || true`,
     `pkill -9 -f ${pattern} 2>/dev/null || true`,
+    // 一并清掉 pid 文件：`start tun` 留下的是 **root 属主**的 pid 文件，普通用户删不掉。
+    // 不删会让后续 `daemon off` → `start` 撞上 hasRootResidue() 的拒绝启动，
+    // 而这个死胡同完全由 CLI 自身的 on/off 循环造成
+    `rm -f ${pidFile}`,
     "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; }`,
@@ -4996,7 +5115,13 @@ function enableDaemon() {
 }
 function disableDaemon() {
   assertDaemonLabelSafe();
-  if (!isDaemonEnabled()) return;
+  const plistExists = isDaemonEnabled();
+  const rootKernelRunning = getMihomoPids().some(isProcessRoot);
+  if (!plistExists && !rootKernelRunning) return;
+  if (!plistExists) {
+    console.log("\u672A\u627E\u5230 plist\uFF0C\u4F46\u68C0\u6D4B\u5230 root \u5185\u6838\u5728\u8FD0\u884C\uFF08\u53EF\u80FD plist \u88AB\u624B\u52A8\u5220\u9664\u800C\u4EFB\u52A1\u4ECD\u88C5\u8F7D\uFF09");
+    console.log("\u5C06\u6267\u884C launchctl bootout \u5378\u8F7D\u6B8B\u7559\u4EFB\u52A1");
+  }
   const target = shellQuote(SERVICE_TARGET);
   const plistDest = shellQuote(PATHS.launchDaemonPlist);
   const logFile = shellQuote(PATHS.logFile);
@@ -5019,12 +5144,17 @@ function disableDaemon() {
   }
 }
 async function tryHotReload() {
+  if (!isDaemonRunning(getDaemonStatus())) return false;
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), HOT_RELOAD_TIMEOUT_MS);
   const secret = readSettings().controller_secret;
   const headers = { "Content-Type": "application/json" };
   if (secret) headers.Authorization = `Bearer ${secret}`;
   try {
+    const probe = await fetch(`${CONTROLLER_BASE_URL}/version`, { headers, signal: controller.signal });
+    if (!probe.ok) return false;
+    const info = await probe.json();
+    if (typeof info?.version !== "string") return false;
     const res = await fetch(`${CONTROLLER_BASE_URL}/configs?force=true`, {
       method: "PUT",
       headers,
@@ -5181,15 +5311,18 @@ function saveSubscriptionConfig(subName, parsed) {
 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;
+  let hasAny = false;
+  for (const part of header.split(";")) {
+    const [rawKey, rawVal] = part.split("=");
+    const key = rawKey?.trim();
+    const val = rawVal?.trim();
+    if (!key || val === void 0 || val === "") continue;
+    const numVal = Number(val);
+    if (!Number.isFinite(numVal) || numVal < 0) continue;
+    info[key] = numVal;
+    hasAny = true;
+  }
+  return hasAny ? info : null;
 }
 function parsePositiveInterval(header) {
   if (!header) return null;
@@ -5215,10 +5348,11 @@ function extractSubscriptionMeta(headers) {
 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;
+    const { upload, download, total, expire } = meta.userInfo;
+    if (upload !== void 0) cacheData.upload = upload;
+    if (download !== void 0) cacheData.download = download;
+    if (total !== void 0) cacheData.total = total;
+    if (expire !== void 0) cacheData.expire = expire;
   }
   if (meta.updateInterval) cacheData.update_interval = meta.updateInterval;
   if (meta.webPageUrl) cacheData.web_page_url = meta.webPageUrl;
@@ -5422,6 +5556,7 @@ function needsAutoUpdate(sub) {
   if (!sub.updated_at) return true;
   const lastUpdate = new Date(sub.updated_at).getTime();
   if (Number.isNaN(lastUpdate)) return true;
+  if (lastUpdate > Date.now()) return true;
   const intervalHours = resolveUpdateInterval(sub.url, sub.update_interval);
   const intervalMs = intervalHours * 60 * 60 * 1e3;
   return Date.now() - lastUpdate > intervalMs;
@@ -5847,19 +5982,31 @@ function addTunnel(config) {
   validateTunnelName(config.name);
   validateTunnelHost(config.host);
   validateTunnelPort(config.port);
-  const tunnels = [...getTunnels()];
-  if (tunnels.some((t) => t.name === config.name)) {
+  let duplicate = false;
+  updateSettings(() => {
+    const tunnels = [...getTunnels()];
+    if (tunnels.some((t) => t.name === config.name)) {
+      duplicate = true;
+      return {};
+    }
+    tunnels.push(config);
+    return { tunnels };
+  });
+  if (duplicate) {
     throw new CliError(`\u96A7\u9053 "${config.name}" \u5DF2\u5B58\u5728\uFF0C\u8BF7\u6362\u4E2A\u540D\u79F0\uFF0C\u6216\u5148\u5220\u9664\uFF08mihomo tunnel rm ${config.name}\uFF09`);
   }
-  tunnels.push(config);
-  writeSettings({ tunnels });
 }
 function removeTunnel(name) {
-  const tunnels = [...getTunnels()];
-  const idx = tunnels.findIndex((t) => t.name === name);
-  if (idx < 0) return false;
-  tunnels.splice(idx, 1);
-  writeSettings({ tunnels });
+  let found = false;
+  updateSettings(() => {
+    const tunnels = [...getTunnels()];
+    const idx = tunnels.findIndex((t) => t.name === name);
+    if (idx < 0) return {};
+    found = true;
+    tunnels.splice(idx, 1);
+    return { tunnels };
+  });
+  if (!found) return false;
   clearTunnelRuntime(name);
   return true;
 }
@@ -5997,12 +6144,24 @@ async function startTunnel(name, options) {
     started_at: (/* @__PURE__ */ new Date()).toISOString(),
     port: config.port
   });
-  for (let i = 0; i < START_WAIT_ATTEMPTS; i++) {
-    if (!isProcessRunning(pid)) break;
-    if (await isPortListening(config.port)) {
-      return { alreadyRunning: false, pid };
+  const unregisterCleanup = registerCleanup(() => {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
     }
-    await new Promise((resolve) => setTimeout(resolve, START_WAIT_INTERVAL));
+    clearTunnelRuntime(name);
+  });
+  try {
+    for (let i = 0; i < START_WAIT_ATTEMPTS; i++) {
+      if (!isProcessRunning(pid)) break;
+      if (await isPortListening(config.port)) {
+        unregisterCleanup();
+        return { alreadyRunning: false, pid };
+      }
+      await new Promise((resolve) => setTimeout(resolve, START_WAIT_INTERVAL));
+    }
+  } finally {
+    unregisterCleanup();
   }
   clearTunnelRuntime(name);
   if (isProcessRunning(pid)) {
@@ -6453,7 +6612,8 @@ async function daemonOn() {
   printDaemonStatus();
 }
 function daemonOff() {
-  if (!isDaemonEnabled()) {
+  const residualRootKernel = getMihomoPids().some(isProcessRoot);
+  if (!isDaemonEnabled() && !residualRootKernel) {
     console.log("\u4FDD\u6D3B\u5DF2\u662F\u5173\u95ED\u72B6\u6001");
     console.log("");
     printDaemonStatus();
@@ -6645,6 +6805,23 @@ function withMirror(url, mirror) {
   }
   return url;
 }
+var ALLOWED_ASSET_HOSTS = /* @__PURE__ */ new Set(["github.com", "api.github.com", "objects.githubusercontent.com", "release-assets.githubusercontent.com"]);
+function assertTrustedAssetUrl(rawUrl) {
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    throw new Error(`\u5185\u6838\u4E0B\u8F7D\u5730\u5740\u65E0\u6CD5\u89E3\u6790: ${rawUrl}`);
+  }
+  if (parsed.protocol !== "https:") {
+    throw new Error(`\u5185\u6838\u4E0B\u8F7D\u5730\u5740\u5FC5\u987B\u662F https: ${rawUrl}`);
+  }
+  const host = parsed.hostname.toLowerCase();
+  if (!ALLOWED_ASSET_HOSTS.has(host)) {
+    throw new Error(`\u5185\u6838\u4E0B\u8F7D\u5730\u5740\u7684\u4E3B\u673A\u4E0D\u5728\u767D\u540D\u5355\u5185: ${host}
+  \u4EC5\u5141\u8BB8: ${[...ALLOWED_ASSET_HOSTS].join(", ")}`);
+  }
+}
 function getArch() {
   const arch = process.arch;
   if (arch === "arm64") return "arm64";
@@ -6706,12 +6883,13 @@ function findBinaryInDir(dir, maxDepth = 4) {
   const files = fs8.readdirSync(dir);
   for (const f of files) {
     const fullPath = path7.join(dir, f);
-    const stat = fs8.statSync(fullPath);
+    const stat = fs8.lstatSync(fullPath);
     if (stat.isDirectory()) {
       const found = findBinaryInDir(fullPath, maxDepth - 1);
       if (found) return found;
       continue;
     }
+    if (!stat.isFile()) continue;
     if (f === "mihomo") return fullPath;
     if (f.includes("mihomo") && !f.endsWith(".gz")) return fullPath;
   }
@@ -6731,6 +6909,7 @@ async function downloadKernel(progressCallback, mirror, releaseInfo) {
     throw new Error(`\u672A\u627E\u5230\u5339\u914D\u7684\u5185\u6838\u6587\u4EF6
   \u5E73\u53F0: ${platform}, \u67B6\u6784: ${arch}${hint}`);
   }
+  assertTrustedAssetUrl(asset.browser_download_url);
   const downloadUrl = withMirror(asset.browser_download_url, mirror);
   const tempPath = path7.join(DIRS.kernel, path7.basename(asset.name));
   const sizeMB = (asset.size / 1024 / 1024).toFixed(2);
@@ -6740,9 +6919,26 @@ async function downloadKernel(progressCallback, mirror, releaseInfo) {
   if (progressCallback) {
     progressCallback(`\u4E0B\u8F7D\u5185\u6838: ${asset.name} (${sizeMB} MB)`);
   }
+  const maxBytes = Number.isFinite(asset.size) && asset.size > 0 ? Math.floor(asset.size * 2 + 1024 * 1024) : 512 * 1024 * 1024;
   const curlResult = spawnSync4(
     "curl",
-    ["-L", "--progress-bar", "--connect-timeout", "30", "--max-time", String(Math.floor(KERNEL_DOWNLOAD_TIMEOUT / 1e3)), "-o", tempPath, downloadUrl],
+    [
+      "-L",
+      "--proto",
+      "=https",
+      "--proto-redir",
+      "=https",
+      "--max-filesize",
+      String(maxBytes),
+      "--progress-bar",
+      "--connect-timeout",
+      "30",
+      "--max-time",
+      String(Math.floor(KERNEL_DOWNLOAD_TIMEOUT / 1e3)),
+      "-o",
+      tempPath,
+      downloadUrl
+    ],
     { stdio: "inherit" }
   );
   if (curlResult.error) {
@@ -6761,6 +6957,19 @@ async function downloadKernel(progressCallback, mirror, releaseInfo) {
   if (!fs8.existsSync(tempPath)) {
     throw new Error("\u4E0B\u8F7D\u5931\u8D25: \u6587\u4EF6\u672A\u751F\u6210");
   }
+  if (Number.isFinite(asset.size) && asset.size > 0) {
+    const actual = fs8.statSync(tempPath).size;
+    if (actual !== asset.size) {
+      try {
+        fs8.unlinkSync(tempPath);
+      } catch {
+      }
+      throw new Error(
+        `\u4E0B\u8F7D\u7684\u6587\u4EF6\u5927\u5C0F\u4E0E release \u5143\u6570\u636E\u4E0D\u7B26\uFF08\u671F\u671B ${asset.size} \u5B57\u8282\uFF0C\u5B9E\u9645 ${actual} \u5B57\u8282\uFF09
+  \u53EF\u80FD\u662F\u4E0B\u8F7D\u88AB\u622A\u65AD\u6216\u5185\u5BB9\u88AB\u66FF\u6362\uFF0C\u8BF7\u91CD\u8BD5\u6216\u6539\u7528 --no-mirror \u76F4\u8FDE`
+      );
+    }
+  }
   if (progressCallback) {
     progressCallback("\u89E3\u538B\u5185\u6838...");
   }
@@ -6771,13 +6980,24 @@ async function downloadKernel(progressCallback, mirror, releaseInfo) {
       const listResult = spawnSync4("tar", ["-tzf", tempPath], { encoding: "utf8", timeout: 6e4 });
       if (listResult.error) throw listResult.error;
       if (listResult.status !== 0) throw new Error(`tar \u5217\u8868\u9000\u51FA\u7801 ${listResult.status}`);
-      const entries = (listResult.stdout || "").split("\n").filter(Boolean);
-      for (const entry of entries) {
+      for (const entry of (listResult.stdout || "").split("\n").filter(Boolean)) {
         if (entry.startsWith("/") || entry.split("/").includes("..")) {
           throw new Error(`\u5F52\u6863\u542B\u975E\u6CD5\u8DEF\u5F84\u6761\u76EE: ${entry}`);
         }
       }
-      const tarResult = spawnSync4("tar", ["-xzf", tempPath, "-C", extractPath], { stdio: ["ignore", "ignore", "inherit"], timeout: 6e4 });
+      const typeResult = spawnSync4("tar", ["-tvzf", tempPath], { encoding: "utf8", timeout: 6e4 });
+      if (typeResult.error) throw typeResult.error;
+      if (typeResult.status !== 0) throw new Error(`tar \u5217\u8868\u9000\u51FA\u7801 ${typeResult.status}`);
+      for (const line of (typeResult.stdout || "").split("\n").filter(Boolean)) {
+        const typeChar = line[0];
+        if (typeChar !== "-" && typeChar !== "d") {
+          throw new Error(`\u5F52\u6863\u542B\u975E\u666E\u901A\u6587\u4EF6\u6761\u76EE\uFF08\u7C7B\u578B "${typeChar}"\uFF09: ${line}`);
+        }
+      }
+      const tarResult = spawnSync4("tar", ["--no-same-owner", "-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")) {

package/package.json

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