tt-help-cli-ycl 1.4.164 → 1.4.166

package/src/clash/runtime.js

@@ -15,7 +15,7 @@
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, statSync, readdirSync, copyFileSync, openSync, renameSync, lstatSync, symlinkSync } from "fs";
 import net from "net";
-import { homedir, platform, arch } from "os";
+import { homedir, platform, arch, tmpdir } from "os";
 import { join, dirname } from "path";
 import { spawn, spawnSync, execSync } from "child_process";
 import { gunzipSync } from "zlib";
@@ -681,6 +681,13 @@ export async function stopRuntimeInstance(index = 1, { log = () => {} } = {}) {
       } catch {}
     }
   }
+  if (killed) {
+    // 回收成功 → 一并清理通道健康文件，避免幽灵通道残留
+    //（daemon _rediscover 后不再巡检该实例，文件永远不会被覆盖，看门狗页面会多出幽灵订阅）
+    try {
+      rmSync(join(tmpdir(), `clash-health-${spec.mixedPort}.json`), { force: true });
+    } catch {}
+  }
   return killed;
 }
 

package/src/cli/tag.js

@@ -7,6 +7,7 @@ import {
   formatMemoryWithBrowser,
 } from "../lib/browser-memory.js";
 import { reportClientErrorAndFailover } from "../lib/client-error-report.js";
+import { getWatchdogClientId } from "../lib/api-client.js";
 import { fetchTagData, enrichVideosWithLocation } from "../lib/tag-fetcher.js";
 import { killEdgeProcesses, ensureBrowserReady } from "../lib/browser/cdp.js";
 import { getOrCreatePage } from "../lib/browser/page.js";
@@ -1324,6 +1325,7 @@ export async function handleScoreAll(parsed) {
                 stage: "tag-scoring",
                 errorStack: "",
                 hostname: os.hostname(),
+                clientId: getWatchdogClientId(), // 看门狗按 clientId 关联本机异常
               }),
             });
           } catch {}

package/src/lib/api-client.js

@@ -1,5 +1,9 @@
 import crypto from "node:crypto";
 import os from "os";
+import { getWatchdogClientId } from "../watchdog/reporter.js";
+
+// 供业务侧（client-error-report / tag / webserver 等）统一从本模块取机器标识
+export { getWatchdogClientId };
 
 const MAX_RETRY_WAIT = 5 * 60 * 1000;
 
@@ -82,11 +86,23 @@ export function createApiClient(opts = {}) {
         //   - header 放净化后的 ASCII 值（仅保证请求能发出）
         //   - 原始 hostname 塞进 body（JSON 为 UTF-8，无 ByteString 限制），
         //     服务端 body.hostname 优先，看门狗仍能按原始主机名关联本机异常
+        // 另：克隆机群 hostname 全部相同（如 F-2~F-10 均为 WIN-AADJ1HTCCAQ），
+        // hostname 已不能唯一标识机器 → 同时携带 watchdog clientId（每台唯一，
+        // watchdog 启动时写入 ~/.tt-help.json 的 watchdogClientId 字段），
+        // 看门狗按 clientId 关联本机异常，hostname 仅作展示。
         if (/\/api\/error-report(\?|$)/.test(String(url))) {
           headers["X-Client-Hostname"] = os
             .hostname()
             .replace(/[^\x20-\x7e]/g, "_");
           body = { ...body, hostname: os.hostname() };
+          const wdClientId = getWatchdogClientId();
+          if (wdClientId) {
+            headers["X-Watchdog-Client-Id"] = wdClientId.replace(
+              /[^\x20-\x7e]/g,
+              "_",
+            );
+            body = { ...body, clientId: wdClientId };
+          }
         }
         const res = await fetch(url, {
           method: "POST",

package/src/lib/browser/cdp.js

@@ -222,6 +222,92 @@ function killEdgeProcesses(targetDir, port) {
   });
 }
 
+/**
+ * 查找"残留" Edge 主进程：命令行包含指定 user-data-dir、但不带
+ * --remote-debugging-port（Edge 自动更新/崩溃自恢复、上次强杀残留等，
+ * 占着 profile 却没监听 CDP 端口）。
+ * 排除带 --type= 的子进程：渲染进程等子进程同样带 user-data-dir 却没有
+ * CDP 参数，误杀会打断同 profile 的健康实例。
+ *
+ * 这类实例必须先杀掉再启动：否则新 msedge 会因 Chromium ProcessSingleton
+ * 把命令行转发给旧实例，变成"旧实例开一个 about:blank 新 tab"，CDP 端口
+ * 永远起不来 → 等待超时 → watchdog 自动重启 → 每轮再开一个 tab。
+ *
+ * killEdgeProcesses 在 Windows 上按监听端口找 PID，对这类实例无效，
+ * 故单独按命令行匹配精确清理。
+ *
+ * @param {string} targetDir - user-data-dir 路径
+ * @returns {string[]|null} PID 列表；无法枚举进程命令行（PowerShell/WMI 不可用）时返回 null
+ */
+function findStaleEdgePids(targetDir) {
+  const platform = os.platform();
+  try {
+    let out;
+    if (platform === "win32") {
+      // PowerShell 为主（wmic 已从新版 Win11 移除；项目其他模块同样依赖 PowerShell）
+      out = decodeWinOutput(
+        execSync(
+          'powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.Name -eq \'msedge.exe\' } | ForEach-Object { Write-Output ($_.ProcessId.ToString() + \'|\' + $_.CommandLine) }"',
+          { encoding: "buffer", timeout: 10000, windowsHide: true },
+        ),
+      );
+    } else {
+      out = execSync("ps -eo pid,args", {
+        encoding: "utf-8",
+        timeout: 10000,
+      });
+    }
+    const dirLower = targetDir.toLowerCase();
+    const pids = [];
+    for (const line of out.split(/\r?\n/)) {
+      const lower = line.toLowerCase();
+      if (!lower.includes(dirLower)) continue; // 只匹配本 profile
+      // 边界保护：避免 _p9222 误匹配 _p92221 这类前缀目录
+      const idx = lower.indexOf(dirLower);
+      const next = lower[idx + dirLower.length];
+      if (next && /[a-z0-9_]/.test(next)) continue;
+      if (lower.includes("remote-debugging-port")) continue; // 健康 CDP 实例，不动
+      if (lower.includes("--type=")) continue; // 子进程，误杀会打断健康实例
+      // 提取 PID：win 格式 "PID|命令行"，unix 格式 "  PID 命令行"
+      const m = line.match(/^\s*(\d+)(?:\||\s)/);
+      if (m && !pids.includes(m[1])) pids.push(m[1]);
+    }
+    return pids;
+  } catch (e) {
+    console.error(`[findStaleEdgePids] 枚举 Edge 进程失败: ${e.message}`);
+    return null;
+  }
+}
+
+/**
+ * 强杀指定 PID 的 Edge 进程树（Windows 用 taskkill /T 保级联，其余平台 kill -9）。
+ * @param {string[]} pids
+ * @returns {Promise<void>}
+ */
+function killEdgeStale(pids) {
+  const platform = os.platform();
+  if (platform === "win32") {
+    const killCmds = pids.map((pid) => `taskkill /F /T /PID ${pid}`).join(" & ");
+    try {
+      const out = execSync(`(${killCmds})`, {
+        encoding: "buffer",
+        timeout: 15000,
+        windowsHide: true,
+      });
+      const lines = decodeWinOutput(out).split(/\r?\n/).filter(Boolean);
+      console.error(
+        `[killEdgeStale] taskkill 结果: ${lines.join(" | ") || "(无输出)"}`,
+      );
+    } catch (e) {
+      console.error(`[killEdgeStale] taskkill 失败: ${e.message}`);
+    }
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    exec(`kill -9 ${pids.join(" ")} 2>/dev/null; true`, () => resolve());
+  });
+}
+
 function launchEdgeWithCDP(port, userDataDir, proxyServer) {
   return new Promise((resolve, reject) => {
     const platform = os.platform();
@@ -319,10 +405,27 @@ export async function ensureBrowserReady(options = {}) {
         console.error(`CDP 端口 ${port} 未就绪，正在启动 Edge 浏览器...`);
       }
     }
+    // 残留实例清理：占着该 user-data-dir 却没开 CDP 的旧 Edge 必须先杀掉，
+    // 否则 launch 会被 ProcessSingleton 转发成"旧实例开新 tab"，CDP 永远起不来。
+    const stalePids = findStaleEdgePids(userDataDir);
+    if (stalePids === null) {
+      console.error("[浏览器] 无法枚举 Edge 进程命令行，跳过残留实例检测");
+    } else if (stalePids.length > 0) {
+      console.error(
+        `[浏览器] 检测到占用 ${path.basename(userDataDir)} 但未开 CDP 的残留 Edge 实例 (PID: ${stalePids.join(", ")})，正在清理...`,
+      );
+      await killEdgeStale(stalePids);
+      await new Promise((r) => setTimeout(r, 3000));
+    }
+
     await launchEdgeWithCDP(port, userDataDir, proxyServer);
 
     console.error("等待浏览器启动...");
-    const launched = await waitForCDP(port);
+    // Windows 冷启动（杀软扫描/更新后首次启动）可能超过 30s，放宽到 60s
+    const launched = await waitForCDP(
+      port,
+      os.platform() === "win32" ? 60000 : 30000,
+    );
     if (!launched) {
       throw new Error(
         `等待 CDP 端口 ${port} 超时。请确认 Edge 浏览器已安装，\n` +

package/src/lib/client-error-report.js

@@ -4,6 +4,7 @@
  */
 
 import os from "os";
+import { getWatchdogClientId } from "./api-client.js";
 
 /**
  * 触发 Clash daemon 的故障切换（换出口节点），与 watchdog 的 failover 一致。
@@ -49,7 +50,9 @@ export async function reportClientErrorAndFailover({
       errorMessage: message,
       stage,
       errorStack: "",
-      hostname: os.hostname(), // 机器标识：看门狗按 hostname 关联本机异常
+      hostname: os.hostname(), // 机器标识（展示用；克隆机群 hostname 重复）
+      // 看门狗按 clientId 关联本机异常（每台唯一，克隆机 hostname 重复不可用）
+      clientId: getWatchdogClientId(),
     });
   } catch {}
   await triggerClashFailover(message, log);

package/src/watch/data-store.js

@@ -2563,11 +2563,15 @@ export function createStore(filePath, options = {}) {
     stage,
     errorStack,
     hostname,
+    clientId,
   ) {
     const existing = clientErrors.get(userId);
     if (existing) {
       existing.timestamp = Date.now();
       if (hostname) existing.hostname = hostname;
+      // clientId（机器唯一标识，如 F-9@HOST）随上报刷新；克隆机群 hostname 重复，
+      // 看门狗只认 clientId 关联本机条目
+      if (clientId) existing.clientId = clientId;
       if (errorType === "captcha") {
         existing.captchaCount = (existing.captchaCount || 0) + 1;
         if (!existing.captchaStage) existing.captchaStage = stage || "";
@@ -2586,6 +2590,7 @@ export function createStore(filePath, options = {}) {
       clientErrors.set(userId, {
         userId,
         hostname: hostname || "",
+        clientId: clientId || "", // 机器唯一标识；空 = 旧版客户端上报，不参与看门狗触发
         errorType,
         errorMessage: errorMessage || "",
         errorStack: errorStack || "",

package/src/watch/db-schema.js

@@ -173,7 +173,6 @@ export function initDb(filePath) {
     product_review_count: "INTEGER",
     product_sold_count: "INTEGER",
     product_name: "TEXT",
-    product_skus: "TEXT",
     user_create_time: "INTEGER",
     recent_ec_videos: "TEXT",
   });
@@ -210,7 +209,6 @@ export function initDb(filePath) {
     product_review_count: "INTEGER",
     product_sold_count: "INTEGER",
     product_name: "TEXT",
-    product_skus: "TEXT",
     user_create_time: "INTEGER",
     recent_ec_videos: "TEXT",
   });
@@ -248,7 +246,6 @@ export function initDb(filePath) {
     product_review_count: "INTEGER",
     product_sold_count: "INTEGER",
     product_name: "TEXT",
-    product_skus: "TEXT",
     user_create_time: "INTEGER",
     recent_ec_videos: "TEXT",
   });
@@ -451,13 +448,17 @@ export function initDb(filePath) {
 
   // ===== task_queue 索引（claimNextJob 逐级短路查询 + 监控列表） =====
   // idx_tq_claim_fast：claim 分支查询主索引（2026-09-17 实战验证：分支 7s→1ms）。
-  // 普通复合索引，不依赖部分索引的 WHERE 表达式文本匹配（旧 4 个部分索引因
+  // idx_tq_claim_fallback：兜底分支索引（2026-09-28 实战验证：NOT IN 多国分支 4.2s→16ms）。
+  //   配置外国家（OTHER）的池子可达十几万行，NOT IN 多国无法用 loc 前导列 seek，
+  //   此索引跳过 loc、直接按 (status, follower_count) 排序 seek 第一行。
+  // 均为普通复合索引，不依赖部分索引的 WHERE 表达式文本匹配（旧 4 个部分索引因
   // pinned=0 与 COALESCE(pinned,0)=0 文本不一致、首国分支 OR 空串，从未被命中，已废弃清理）。
   const tqIndexes = [
     `CREATE INDEX IF NOT EXISTS idx_tq_status ON task_queue(status)`,
     `CREATE INDEX IF NOT EXISTS idx_tq_claimed_by_status ON task_queue(claimed_by, status, claimed_at)`,
     `CREATE INDEX IF NOT EXISTS idx_tq_status_claimed_at ON task_queue(status, claimed_at)`,
     `CREATE INDEX IF NOT EXISTS idx_tq_claim_fast ON task_queue(status, UPPER(COALESCE(guessed_location,'')), follower_count DESC, created_at ASC, unique_id ASC)`,
+    `CREATE INDEX IF NOT EXISTS idx_tq_claim_fallback ON task_queue(status, follower_count DESC, created_at ASC, unique_id ASC)`,
     // 监控页面用户列表查询加速
     `CREATE INDEX IF NOT EXISTS idx_tq_list_pending ON task_queue(pinned, processed_at, follower_count, unique_id) WHERE status = 'pending'`,
     `CREATE INDEX IF NOT EXISTS idx_tq_list_processing ON task_queue(pinned, processed_at, follower_count, unique_id) WHERE status = 'processing'`,

package/src/watch/public/app.js

@@ -5316,6 +5316,8 @@ function renderProxySection(c, userId) {
     }
     var html = renderSubsOverview(c, userId, builtin, channels);
     for (var j = 0; j < external.length; j++) {
+      // 幽灵外部通道（>2min 未更新的残留健康文件）不渲染
+      if (external[j].stale) continue;
       // 外部通道的订阅配置入口：仅当没有总览区时显示（配置入口全局收敛为一个）
       html += renderExternalChannel(external[j], userId, !html);
     }
@@ -5391,6 +5393,8 @@ function renderSubsOverview(c, userId, builtinChannels, allChannels) {
   }
   var count = configured.length;
   for (var p in byPort) {
+    // 幽灵通道（实例已回收但健康文件残留，>2min 未更新）不得撑大订阅数
+    if (byPort[p] && byPort[p].stale) continue;
     var n = parseInt(p, 10) - _SUBS_BASE_PROXY_PORT + 1;
     if (n > count) count = n;
   }

package/src/watch/server.js

@@ -2047,6 +2047,7 @@ export function startWatchServer(
             body.stage || "",
             body.errorStack || "",
             body.hostname || req.headers["x-client-hostname"] || "",
+            body.clientId || req.headers["x-watchdog-client-id"] || "",
           );
           sendJSON(res, 200, { ok: true });
         } else {

package/src/watchdog/agent.js

@@ -13,6 +13,7 @@ import {
   getLocalIP,
   getClashHealth,
   getClashHealthChannels,
+  setWatchdogClientId,
 } from "./reporter.js";
 import { ProcessManager } from "./process-manager.js";
 import {
@@ -27,7 +28,10 @@ import { join, dirname } from "path";
 import { homedir, tmpdir, hostname as osHostname } from "os";
 import { fileURLToPath } from "url";
 import { pushSelfLog, getSelfLogs } from "./self-log-buffer.js";
-import { ClientErrorMonitor } from "./client-error-monitor.js";
+import {
+  ClientErrorMonitor,
+  DETECT_CAPTCHA_COUNT_THRESHOLD,
+} from "./client-error-monitor.js";
 import { takeoverEnvironment } from "./env-init.js";
 
 // ── 看门狗自身日志入环（供后台页面按需拉取，经 report-logs 回传落盘） ──
@@ -340,6 +344,14 @@ export class WatchdogAgent {
       `[watchdog] 升级: ${isGlobalInstall() ? "已启用" : "跳过（源码模式）"}`,
     );
 
+    // 把 clientId 写入 ~/.tt-help.json：业务进程上报异常时携带，看门狗按
+    // clientId（每台唯一）关联本机条目；克隆机群 hostname 重复不可用
+    if (!setWatchdogClientId(this.clientId)) {
+      console.error(
+        `[watchdog] ⚠️ clientId 写入 ~/.tt-help.json 失败，客户端异常监控将无法关联本机条目`,
+      );
+    }
+
     // 注册信号处理
     this._setupSignalHandlers();
 
@@ -350,7 +362,11 @@ export class WatchdogAgent {
         spawnDaemon: this.spawnDaemon,
         selfPid: process.pid,
       });
-      if (takeover.agents.length || takeover.daemons.length || takeover.orphans.length) {
+      if (
+        takeover.agents.length ||
+        takeover.daemons.length ||
+        takeover.orphans.length
+      ) {
         console.error(
           `[watchdog] 环境初始化: 接管旧 agent ${takeover.agents.length} 个、旧 daemon ${takeover.daemons.length} 个、孤儿命令 ${takeover.orphans.length} 个`,
         );
@@ -719,7 +735,8 @@ export class WatchdogAgent {
 
   /**
    * 启动客户端异常监控：定时拉取 watch 服务端异常列表，
-   * 命中本机条目（reportCount > 8 且最近 2 分钟内）→ 强切代理 + 删除全部本机条目。
+   * 命中本机条目（reportCount > 8 或 captchaCount ≥ 3，且最近 2 分钟内）
+   * → 强切代理 + 删除命中条目（防下一轮轮询重复强切）。
    */
   _startClientErrorMonitor() {
     const cfg = getClientConfig();
@@ -732,18 +749,27 @@ export class WatchdogAgent {
     }
     this.clientErrorMonitor = new ClientErrorMonitor({
       serverUrl: server,
-      hostname: osHostname(),
+      hostname: osHostname(), // 仅展示；关联用 clientId
+      clientId: this.clientId, // 唯一机器标识，克隆机 hostname 重复不可用
       intervalMs: 60_000,
-      onAlert: async (mine) => {
-        const ids = mine.map((e) => e.userId).join(",");
-        console.error(
-          `[watchdog] 客户端异常监控命中 ${mine.length} 条本机异常 (${ids})，强制切换代理并清理`,
+      onAlert: async (mine, hit) => {
+        const ids = hit.map((e) => e.userId).join(",");
+        // 验证码计数与业务错误累计共用监控通道，强切原因区分便于排障
+        const hasCaptcha = hit.some(
+          (e) =>
+            typeof e.captchaCount === "number" &&
+            e.captchaCount >= DETECT_CAPTCHA_COUNT_THRESHOLD,
         );
-        await this._forceFailover("client-errors");
-        const removed = await this.clientErrorMonitor.removeErrors(mine);
         console.error(
-          `[watchdog] 已清理本机异常条目 ${removed}/${mine.length}`,
+          `[watchdog] 客户端异常监控命中 ${hit.length} 条本机异常 (${ids})${hasCaptcha ? " [含验证码]" : ""}，强制切换代理并清理`,
+        );
+        await this._forceFailover(
+          hasCaptcha ? "client-captcha" : "client-errors",
         );
+        // 仅清理命中条目：命中条目留存会持续满足阈值 → 下轮轮询重复强切；
+        // 未命中的本机条目（计数未达标）保留继续累计
+        const removed = await this.clientErrorMonitor.removeErrors(hit);
+        console.error(`[watchdog] 已清理命中异常条目 ${removed}/${hit.length}`);
       },
     });
     this.clientErrorMonitor.start();
@@ -844,7 +870,10 @@ export class WatchdogAgent {
         applyClientConfig(data.clientConfig);
       }
       // 服务端下发的代理订阅配置（变化才转发给 daemon 热应用；daemon 侧幂等）
-      if (data.proxySettings && Array.isArray(data.proxySettings.subscriptions)) {
+      if (
+        data.proxySettings &&
+        Array.isArray(data.proxySettings.subscriptions)
+      ) {
         const sig = JSON.stringify(data.proxySettings.subscriptions);
         if (sig !== this._proxySubsSig) {
           this._proxySubsSig = sig;

package/src/watchdog/client-error-monitor.js

@@ -3,30 +3,55 @@
  *
  * 职责：
  *   1. 定时拉取 watch 服务端 /api/client-errors
- *   2. 按 hostname 过滤出本机条目（异常条目由业务进程上报时携带 hostname）
+ *   2. 按 clientId 过滤出本机条目（异常条目由业务进程上报时携带 watchdog clientId）
  *   3. 逐条过独立检测函数，命中 → onAlert(本机全部条目, 命中条目)
  *   4. 提供 removeErrors 删除接口（处理完成后的清理）
  *
- * 检测函数第一版：reportCount > 8 且最近一次上报在 2 分钟内。
+ * 检测函数（两条命中路径，满足任一即命中）：
+ *   A. reportCount > 8（非验证码业务错误累计）且最近一次上报在 2 分钟内
+ *   B. captchaCount ≥ 3（webserver 验证码上报，服务端 10 分钟过期窗口内累计）
+ *
+ * ⚠️ 本机关联必须用 clientId（如 F-9@WIN-AADJ1HTCCAQ，每台唯一）：克隆机群
+ * hostname 全部相同，按 hostname 关联会把兄弟机器的条目当自己的 → 误删条目 +
+ * 误强切（2026-09-28 F-9 条目被 F-10/F-6 抢删事故）。旧条目无 clientId 不参与
+ * 触发（宁漏不误：漏切由业务自带 failover + daemon 冷却兑底）。
  */
 
 import os from "os";
 
-/** 检测阈值：累计上报次数 > 8 */
+/** 检测阈值：非验证码错误累计上报次数 > 8 */
 export const DETECT_REPORT_COUNT_THRESHOLD = 8;
+/** 检测阈值：验证码次数 ≥ 3（10 分钟过期窗口内 3 次独立验证码事件） */
+export const DETECT_CAPTCHA_COUNT_THRESHOLD = 3;
 /** 检测窗口：最近一次上报距今 < 2 分钟 */
 export const DETECT_FRESH_MS = 2 * 60 * 1000;
 
 /**
- * 独立检测函数（第一版）
+ * 独立检测函数
  * @param {object} err - /api/client-errors 返回的单条异常
  * @param {number} [now] - 当前时间戳（测试注入用）
  * @returns {boolean}
  */
 export function detectClientError(err, now = Date.now()) {
-  if (!err || typeof err.reportCount !== "number") return false;
+  if (!err || typeof err.timestamp !== "number") return false;
   const fresh = now - err.timestamp < DETECT_FRESH_MS;
-  return err.reportCount > DETECT_REPORT_COUNT_THRESHOLD && fresh;
+  if (!fresh) return false;
+  // 路径 A：非验证码业务错误累计
+  if (
+    typeof err.reportCount === "number" &&
+    err.reportCount > DETECT_REPORT_COUNT_THRESHOLD
+  ) {
+    return true;
+  }
+  // 路径 B：验证码计数达标（每次验证码上报都刷新 timestamp，达标时必然新鲜，
+  // freshness 主要防陈旧累计延迟触发）
+  if (
+    typeof err.captchaCount === "number" &&
+    err.captchaCount >= DETECT_CAPTCHA_COUNT_THRESHOLD
+  ) {
+    return true;
+  }
+  return false;
 }
 
 /**
@@ -36,14 +61,24 @@ export class ClientErrorMonitor {
   /**
    * @param {object} opts
    * @param {string} opts.serverUrl - watch 服务端地址（~/.tt-help.json 的 server）
-   * @param {string} [opts.hostname] - 本机 hostname（默认 os.hostname()）
+   * @param {string} opts.clientId - 本机 watchdog clientId（唯一机器标识，必传；
+   *   未传则不匹配任何条目，客户端异常监控不生效）
+   * @param {string} [opts.hostname] - 本机 hostname（仅日志展示用，不再参与关联）
    * @param {number} [opts.intervalMs] - 拉取周期，默认 60s
    * @param {(err: object, now: number) => boolean} [opts.detect] - 检测函数，默认 detectClientError
-   * @param {(mine: Array, hit: Array) => Promise|void} [opts.onAlert] - 命中回调
+   * @param {(err: object, now: number) => boolean} [opts.onAlert] - 命中回调
    */
-  constructor({ serverUrl, hostname, intervalMs = 60_000, detect, onAlert }) {
+  constructor({
+    serverUrl,
+    hostname,
+    clientId,
+    intervalMs = 60_000,
+    detect,
+    onAlert,
+  }) {
     this.serverUrl = serverUrl ? String(serverUrl).replace(/\/+$/, "") : "";
-    this.hostname = hostname || os.hostname();
+    this.hostname = hostname || os.hostname(); // 仅展示用
+    this.clientId = clientId || ""; // 本机关联唯一依据
     this.intervalMs = intervalMs;
     this.detect = detect || detectClientError;
     this.onAlert = onAlert || null;
@@ -85,10 +120,11 @@ export class ClientErrorMonitor {
       if (!resp.ok) return null;
       const data = await resp.json();
       const clients = Array.isArray(data.clients) ? data.clients : [];
-      // hostname 为空的旧条目（升级前上报）不参与本机关联
-      const mine = clients.filter(
-        (c) => c.hostname && c.hostname === this.hostname,
-      );
+      // 严格 clientId 匹配：克隆机群 hostname 重复，绝不用 hostname 关联；
+      // 未配置 clientId（异常）或条目无 clientId（旧版客户端上报）均不匹配
+      const mine = this.clientId
+        ? clients.filter((c) => c.clientId && c.clientId === this.clientId)
+        : [];
       if (mine.length === 0) return null;
       const now = Date.now();
       const hit = mine.filter((c) => this.detect(c, now));

package/src/watchdog/reporter.js

@@ -4,7 +4,7 @@
  */
 
 import os from "os";
-import { existsSync, readFileSync, readdirSync } from "fs";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "fs";
 import { join } from "path";
 import { homedir, tmpdir } from "os";
 
@@ -12,6 +12,47 @@ const homeDir = homedir() || process.env.HOME || process.env.USERPROFILE || "";
 const CONFIG_PATH = join(homeDir, ".tt-help.json");
 const CLASH_HEALTH_FILE = join(tmpdir(), "clash-health.json");
 
+/**
+ * 写入本机 watchdog clientId 到 ~/.tt-help.json（业务进程上报异常时读取携带）
+ *
+ * 背景：克隆机群 hostname 全部相同（如 F-2~F-10 均为 WIN-AADJ1HTCCAQ），
+ * 看门狗按 hostname 关联「本机异常」会把兄弟机器的条目当自己的 → 互删条目、
+ * 误强切。clientId（如 F-9@WIN-AADJ1HTCCAQ）每台唯一，取代 hostname 做关联。
+ * @param {string} id - watchdog clientId（--client-id 参数值）
+ * @returns {boolean} 是否写入成功（失败不阻断启动，仅影响异常关联精度）
+ */
+export function setWatchdogClientId(id) {
+  if (!id) return false;
+  try {
+    let cfg = {};
+    if (existsSync(CONFIG_PATH)) {
+      cfg = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    }
+    if (cfg.watchdogClientId === id) return true; // 已一致，免写
+    cfg.watchdogClientId = id;
+    writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 读取本机 watchdog clientId（业务进程上报异常时携带；watchdog 未启动过/未写入时返回 ""）
+ * @returns {string}
+ */
+export function getWatchdogClientId() {
+  try {
+    if (existsSync(CONFIG_PATH)) {
+      const cfg = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+      return cfg.watchdogClientId || "";
+    }
+  } catch {
+    // 配置不可读
+  }
+  return "";
+}
+
 /**
  * 获取系统信息
  */