tt-help-cli-ycl 1.4.165 → 1.4.166

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tt-help-cli-ycl",
-  "version": "1.4.165",
+  "version": "1.4.166",
   "description": "TikTok user & video data scraper - extract ttSeller, verified, locationCreated from HTML source",
   "type": "module",
   "bin": {

package/scripts/add-claim-fallback-index.mjs

@@ -0,0 +1,25 @@
+// 一次性运维脚本：为 task_queue 建 claim 兜底分支加速索引（幂等）
+import { createRequire } from "module";
+const require = createRequire("D:/tiktok/tiktok-cli/package.json");
+const Database = require("better-sqlite3");
+
+const db = new Database("D:/tiktok/data/result.db");
+db.pragma("busy_timeout = 30000");
+const t0 = Date.now();
+db.exec(
+  "CREATE INDEX IF NOT EXISTS idx_tq_claim_fallback ON task_queue(status, follower_count DESC, created_at ASC, unique_id ASC)",
+);
+console.log(`index created in ${Date.now() - t0}ms`);
+
+// 验证兜底分支走新索引
+const SQL = `SELECT * FROM task_queue WHERE status='pending' AND pinned=0 AND tt_seller=1 AND verified=0 AND UPPER(COALESCE(guessed_location,'')) NOT IN ('PL','NL','BE','DE','FR','IT','IE','ES','CZ','GR','HU','PT','AT','TH','US') AND (status_code IS NULL OR status_code=0 OR status_code=209002) ORDER BY follower_count DESC, created_at ASC, unique_id ASC LIMIT 1`;
+const plan = db
+  .prepare(`EXPLAIN QUERY PLAN ${SQL}`)
+  .all()
+  .map((r) => r.detail)
+  .join(" | ");
+console.log("plan:", plan);
+const t1 = Date.now();
+db.prepare(SQL).get();
+console.log(`fallback branch query: ${Date.now() - t1}ms`);
+db.close();

package/scripts/add-claim-index.mjs

@@ -19,10 +19,8 @@ const plan = db
   .join(" | ");
 console.log("plan:", plan);
 const t1 = Date.now();
-db
-  .prepare(
-    `SELECT * FROM task_queue WHERE status='pending' AND pinned=0 AND tt_seller=1 AND verified=0 AND UPPER(COALESCE(guessed_location,'')) IN ('PL') AND (status_code IS NULL OR status_code=0 OR status_code=209002) ORDER BY follower_count DESC, created_at ASC, unique_id ASC LIMIT 1`,
-  )
-  .get();
+db.prepare(
+  `SELECT * FROM task_queue WHERE status='pending' AND pinned=0 AND tt_seller=1 AND verified=0 AND UPPER(COALESCE(guessed_location,'')) IN ('PL') AND (status_code IS NULL OR status_code=0 OR status_code=209002) ORDER BY follower_count DESC, created_at ASC, unique_id ASC LIMIT 1`,
+).get();
 console.log(`branch query: ${Date.now() - t1}ms`);
 db.close();

package/scripts/test-client-error-monitor.mjs

@@ -1,11 +1,13 @@
 /**
- * 客户端异常监控单测（2026-08-28，2026-09-28 增补验证码路径）
+ * 客户端异常监控单测（2026-08-28，2026-09-28 增补验证码路径，
+ * 2026-09-29 改为 clientId 本机关联 —— 克隆机 hostname 撞名修复）
  *
  * 验证：
  *   - detectClientError 检测函数：
  *     A. reportCount > 8 且最近一次上报在 2 分钟内
  *     B. captchaCount ≥ 3（webserver 验证码上报，10 分钟过期窗口内累计）
- *   - 按 hostname 过滤本机条目；hostname 为空的旧条目不参与关联
+ *   - 按 clientId 过滤本机条目（每台唯一）；hostname 撞名的兄弟机条目、
+ *     无 clientId 的旧条目均不参与关联
  *   - 命中 → onAlert 收到本机全部条目与命中列表；未命中 → 不回调
  *   - removeErrors 逐条 DELETE 并计数
  *
@@ -13,18 +15,21 @@
  */
 import { test, mock } from "node:test";
 import assert from "node:assert/strict";
-import os from "os";
 import {
   detectClientError,
   ClientErrorMonitor,
 } from "../src/watchdog/client-error-monitor.js";
 
-const HOST = os.hostname();
+// 模拟克隆机群：hostname 全部相同（事故现场），clientId 每台唯一
+const CLONED_HOST = "WIN-AADJ1HTCCAQ";
+const CLIENT_ID = `F-9@${CLONED_HOST}`;
+const BROTHER_CLIENT_ID = `F-10@${CLONED_HOST}`;
 
 function makeErr(overrides = {}) {
   return {
     userId: "u1",
-    hostname: HOST,
+    hostname: CLONED_HOST,
+    clientId: CLIENT_ID,
     errorType: "consecutive_blocked",
     reportCount: 10,
     timestamp: Date.now() - 30_000,
@@ -32,6 +37,22 @@ function makeErr(overrides = {}) {
   };
 }
 
+function makeMonitor(opts = {}) {
+  let received = null;
+  let alerted = false;
+  const m = new ClientErrorMonitor({
+    serverUrl: "http://127.0.0.1:3000",
+    hostname: CLONED_HOST, // 仅展示用；关联只认 clientId
+    clientId: CLIENT_ID,
+    onAlert: async (mine, hit) => {
+      alerted = true;
+      received = { mine, hit };
+    },
+    ...opts,
+  });
+  return { m, isAlerted: () => alerted, getReceived: () => received };
+}
+
 // ── 检测函数 ──
 
 test("D1 detectClientError：累计>8 且 2 分钟内 → 命中", () => {
@@ -66,20 +87,14 @@ test("D4 detectClientError：缺 reportCount → 不命中", () => {
 
 test("C1 detectClientError：captchaCount=3 → 命中", () => {
   assert.equal(
-    detectClientError(
-      makeErr({ reportCount: 0, captchaCount: 3 }),
-      Date.now(),
-    ),
+    detectClientError(makeErr({ reportCount: 0, captchaCount: 3 }), Date.now()),
     true,
   );
 });
 
 test("C2 detectClientError：captchaCount=2 不命中（阈值是 ≥3）", () => {
   assert.equal(
-    detectClientError(
-      makeErr({ reportCount: 0, captchaCount: 2 }),
-      Date.now(),
-    ),
+    detectClientError(makeErr({ reportCount: 0, captchaCount: 2 }), Date.now()),
     false,
   );
 });
@@ -100,10 +115,7 @@ test("C3 detectClientError：captchaCount=3 但最近上报超 2 分钟 → 不
 
 test("C4 detectClientError：reportCount 未达标 + captchaCount 达标 → 命中", () => {
   assert.equal(
-    detectClientError(
-      makeErr({ reportCount: 1, captchaCount: 5 }),
-      Date.now(),
-    ),
+    detectClientError(makeErr({ reportCount: 1, captchaCount: 5 }), Date.now()),
     true,
   );
 });
@@ -119,41 +131,35 @@ test("C5 监控器：验证码条目命中 → onAlert 收到命中列表", asyn
     ok: true,
     json: async () => ({ clients: [captchaHit, businessMiss] }),
   }));
-  let received = null;
-  const m = new ClientErrorMonitor({
-    serverUrl: "http://127.0.0.1:3000",
-    hostname: HOST,
-    onAlert: async (mine, hit) => {
-      received = { mine, hit };
-    },
-  });
+  const { m, getReceived } = makeMonitor();
   const hit = await m._poll();
   assert.equal(hit.length, 1, "仅验证码条目命中");
   assert.equal(hit[0].userId, "webserver-host");
-  assert.equal(received.hit.length, 1);
-  assert.equal(received.mine.length, 2, "回调同时携带本机未命中条目");
+  assert.equal(getReceived().hit.length, 1);
+  assert.equal(getReceived().mine.length, 2, "回调同时携带本机未命中条目");
   mock.restoreAll();
 });
 
-// ── 监控器 ──
+// ── 监控器：本机关联（clientId） ──
 
-test("M1 按 hostname 过滤：他机条目不触发本机回调", async () => {
+test("M1 按 clientId 过滤：撞名兄弟机条目不触发本机回调", async () => {
+  // 克隆机事故回归：F-10 与 F-9 hostname 完全相同，仅 clientId 不同
   mock.method(globalThis, "fetch", async () => ({
     ok: true,
     json: async () => ({
-      clients: [makeErr({ hostname: "OTHER-MACHINE" })],
+      clients: [
+        makeErr({
+          userId: "F-10-8222-1",
+          clientId: BROTHER_CLIENT_ID,
+          captchaCount: 3,
+          reportCount: 0,
+        }),
+      ],
     }),
   }));
-  let alerted = false;
-  const m = new ClientErrorMonitor({
-    serverUrl: "http://127.0.0.1:3000",
-    hostname: HOST,
-    onAlert: async () => {
-      alerted = true;
-    },
-  });
+  const { m, isAlerted } = makeMonitor();
   const hit = await m._poll();
-  assert.equal(alerted, false, "他机异常不应回调");
+  assert.equal(isAlerted(), false, "兄弟机异常不应触发本机回调/强切");
   assert.equal(hit, null, "无本机条目应返回 null");
   mock.restoreAll();
 });
@@ -161,51 +167,62 @@ test("M1 按 hostname 过滤：他机条目不触发本机回调", async () => {
 test("M2 命中：onAlert 收到本机全部条目（含未命中条目）", async () => {
   const mineHit = makeErr({ userId: "u-hit", reportCount: 10 });
   const mineMiss = makeErr({ userId: "u-miss", reportCount: 2 });
-  const other = makeErr({ userId: "u-other", hostname: "OTHER-MACHINE" });
+  const other = makeErr({
+    userId: "u-other",
+    clientId: BROTHER_CLIENT_ID, // hostname 相同，clientId 不同
+  });
   mock.method(globalThis, "fetch", async () => ({
     ok: true,
     json: async () => ({ clients: [mineHit, mineMiss, other] }),
   }));
-  let received = null;
-  const m = new ClientErrorMonitor({
-    serverUrl: "http://127.0.0.1:3000",
-    hostname: HOST,
-    onAlert: async (mine, hit) => {
-      received = { mine, hit };
-    },
-  });
+  const { m, getReceived } = makeMonitor();
   const hit = await m._poll();
   assert.equal(hit.length, 1, "命中 1 条");
   assert.equal(hit[0].userId, "u-hit");
-  assert.equal(received.mine.length, 2, "回调收到本机全部 2 条");
+  assert.equal(getReceived().mine.length, 2, "回调收到本机全部 2 条");
   assert.deepEqual(
-    received.mine.map((e) => e.userId).sort(),
+    getReceived()
+      .mine.map((e) => e.userId)
+      .sort(),
     ["u-hit", "u-miss"],
     "回调含命中与未命中的本机条目",
   );
   mock.restoreAll();
 });
 
-test("M3 hostname 为空的旧条目不参与本机关联", async () => {
+test("M3 无 clientId 的旧条目不参与本机关联（宁漏不误）", async () => {
   mock.method(globalThis, "fetch", async () => ({
     ok: true,
-    json: async () => ({ clients: [makeErr({ hostname: "" })] }),
+    json: async () => ({
+      clients: [makeErr({ clientId: "", reportCount: 99 })],
+    }),
+  }));
+  const { m, isAlerted } = makeMonitor();
+  const hit = await m._poll();
+  assert.equal(isAlerted(), false, "旧版上报条目不应触发强切");
+  assert.equal(hit, null);
+  mock.restoreAll();
+});
+
+test("M4 未配置 clientId 的监控器：不匹配任何条目", async () => {
+  mock.method(globalThis, "fetch", async () => ({
+    ok: true,
+    json: async () => ({ clients: [makeErr({ reportCount: 99 })] }),
   }));
   let alerted = false;
   const m = new ClientErrorMonitor({
     serverUrl: "http://127.0.0.1:3000",
-    hostname: HOST,
     onAlert: async () => {
       alerted = true;
     },
   });
   const hit = await m._poll();
-  assert.equal(alerted, false, "空 hostname 旧条目不应回调");
+  assert.equal(alerted, false, "clientId 未配置时监控不生效");
   assert.equal(hit, null);
   mock.restoreAll();
 });
 
-test("M4 removeErrors：逐条 DELETE 并计数", async () => {
+test("M5 removeErrors：逐条 DELETE 并计数", async () => {
   const deleted = [];
   mock.method(globalThis, "fetch", async (url, opts) => {
     if (opts && opts.method === "DELETE") {
@@ -232,20 +249,13 @@ test("M4 removeErrors：逐条 DELETE 并计数", async () => {
   mock.restoreAll();
 });
 
-test("M5 拉取失败静默：fetch 抛错不回调不崩溃", async () => {
+test("M6 拉取失败静默：fetch 抛错不回调不崩溃", async () => {
   mock.method(globalThis, "fetch", async () => {
     throw new Error("ECONNREFUSED");
   });
-  let alerted = false;
-  const m = new ClientErrorMonitor({
-    serverUrl: "http://127.0.0.1:3000",
-    hostname: HOST,
-    onAlert: async () => {
-      alerted = true;
-    },
-  });
+  const { m, isAlerted } = makeMonitor();
   const hit = await m._poll();
-  assert.equal(alerted, false);
+  assert.equal(isAlerted(), false);
   assert.equal(hit, null);
   mock.restoreAll();
 });

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/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/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 {
@@ -343,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();
 
@@ -353,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} 个`,
         );
@@ -736,7 +749,8 @@ export class WatchdogAgent {
     }
     this.clientErrorMonitor = new ClientErrorMonitor({
       serverUrl: server,
-      hostname: osHostname(),
+      hostname: osHostname(), // 仅展示；关联用 clientId
+      clientId: this.clientId, // 唯一机器标识，克隆机 hostname 重复不可用
       intervalMs: 60_000,
       onAlert: async (mine, hit) => {
         const ids = hit.map((e) => e.userId).join(",");
@@ -856,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,13 +3,18 @@
  *
  * 职责：
  *   1. 定时拉取 watch 服务端 /api/client-errors
- *   2. 按 hostname 过滤出本机条目（异常条目由业务进程上报时携带 hostname）
+ *   2. 按 clientId 过滤出本机条目（异常条目由业务进程上报时携带 watchdog clientId）
  *   3. 逐条过独立检测函数，命中 → onAlert(本机全部条目, 命中条目)
  *   4. 提供 removeErrors 删除接口（处理完成后的清理）
  *
  * 检测函数（两条命中路径，满足任一即命中）：
  *   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";
@@ -56,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;
@@ -105,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 "";
+}
+
 /**
  * 获取系统信息
  */

package/src/webserver/server.mjs

@@ -3,6 +3,7 @@ import os from "os";
 import { TikTokScraper } from "../lib/tiktok-scraper.mjs";
 import { getProductInfo } from "../lib/shop-scraper.mjs";
 import { userId as configUserId } from "../lib/constants.js";
+import { getWatchdogClientId } from "../lib/api-client.js";
 import { killListeningOnPort } from "../lib/port.js";
 import {
   getCurrentNode,
@@ -378,9 +379,7 @@ export async function switchClashNode(reason) {
   const current = await getCurrentNode(CLASH_GROUP_NAME).catch(() => "?");
   const nodes = await listGroupNodes(CLASH_GROUP_NAME);
   // 过滤机场信息节点（剩余流量/套餐到期等，非真实出口）
-  const candidates = nodes.filter(
-    (n) => n !== current && isUsableProxyNode(n),
-  );
+  const candidates = nodes.filter((n) => n !== current && isUsableProxyNode(n));
   if (!candidates.length) {
     throw new Error(
       `切节点失败：组 ${CLASH_GROUP_NAME} 无候选节点 (当前 ${current})`,
@@ -808,6 +807,7 @@ async function notifyCaptchaToWatch(url, maxRetries = 3) {
           stage: "product_info",
           errorStack: url,
           hostname: os.hostname(),
+          clientId: getWatchdogClientId(), // 看门狗按 clientId 关联本机异常
         }),
       });
       console.error("[webserver] Captcha alert sent to watch server");