tt-help-cli-ycl 1.4.140 → 1.4.142

package/package.json

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

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

@@ -0,0 +1,176 @@
+/**
+ * 客户端异常监控单测（2026-08-28）
+ *
+ * 验证：
+ *   - detectClientError 检测函数：reportCount > 8 且最近一次上报在 2 分钟内
+ *   - 按 hostname 过滤本机条目；hostname 为空的旧条目不参与关联
+ *   - 命中 → onAlert 收到本机全部条目（含未命中条目）；未命中 → 不回调
+ *   - removeErrors 逐条 DELETE 并计数
+ *
+ * 运行: node --test scripts/test-client-error-monitor.mjs
+ */
+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();
+
+function makeErr(overrides = {}) {
+  return {
+    userId: "u1",
+    hostname: HOST,
+    errorType: "consecutive_blocked",
+    reportCount: 10,
+    timestamp: Date.now() - 30_000,
+    ...overrides,
+  };
+}
+
+// ── 检测函数 ──
+
+test("D1 detectClientError：累计>8 且 2 分钟内 → 命中", () => {
+  assert.equal(
+    detectClientError(makeErr({ reportCount: 9 }), Date.now()),
+    true,
+  );
+});
+
+test("D2 detectClientError：reportCount=8 不命中（阈值是 >8）", () => {
+  assert.equal(
+    detectClientError(makeErr({ reportCount: 8 }), Date.now()),
+    false,
+  );
+});
+
+test("D3 detectClientError：最近上报超过 2 分钟 → 不命中", () => {
+  assert.equal(
+    detectClientError(
+      makeErr({ timestamp: Date.now() - 2 * 60_000 - 1 }),
+      Date.now(),
+    ),
+    false,
+  );
+});
+
+test("D4 detectClientError：缺 reportCount → 不命中", () => {
+  assert.equal(detectClientError({ timestamp: Date.now() }, Date.now()), false);
+});
+
+// ── 监控器 ──
+
+test("M1 按 hostname 过滤：他机条目不触发本机回调", async () => {
+  mock.method(globalThis, "fetch", async () => ({
+    ok: true,
+    json: async () => ({
+      clients: [makeErr({ hostname: "OTHER-MACHINE" })],
+    }),
+  }));
+  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, "他机异常不应回调");
+  assert.equal(hit, null, "无本机条目应返回 null");
+  mock.restoreAll();
+});
+
+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" });
+  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 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.deepEqual(
+    received.mine.map((e) => e.userId).sort(),
+    ["u-hit", "u-miss"],
+    "回调含命中与未命中的本机条目",
+  );
+  mock.restoreAll();
+});
+
+test("M3 hostname 为空的旧条目不参与本机关联", async () => {
+  mock.method(globalThis, "fetch", async () => ({
+    ok: true,
+    json: async () => ({ clients: [makeErr({ hostname: "" })] }),
+  }));
+  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(hit, null);
+  mock.restoreAll();
+});
+
+test("M4 removeErrors：逐条 DELETE 并计数", async () => {
+  const deleted = [];
+  mock.method(globalThis, "fetch", async (url, opts) => {
+    if (opts && opts.method === "DELETE") {
+      deleted.push(String(url));
+      return { ok: true };
+    }
+    return { ok: true, json: async () => ({ clients: [] }) };
+  });
+  const m = new ClientErrorMonitor({ serverUrl: "http://127.0.0.1:3000" });
+  const removed = await m.removeErrors([
+    { userId: "a" },
+    { userId: "b" },
+    { userId: "" },
+    null,
+  ]);
+  assert.equal(removed, 2, "有效 userId 各删一条");
+  assert.equal(deleted.length, 2, "共 2 次 DELETE");
+  assert.ok(
+    deleted.every((u) =>
+      ["a", "b"].some((id) => u.endsWith(`/api/client-error/${id}`)),
+    ),
+    "DELETE 路径正确",
+  );
+  mock.restoreAll();
+});
+
+test("M5 拉取失败静默：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 hit = await m._poll();
+  assert.equal(alerted, false);
+  assert.equal(hit, null);
+  mock.restoreAll();
+});

package/scripts/test-daemon-failover.mjs

@@ -5,6 +5,7 @@
  *   - 探针不健康 → 立即切换（无视冷却）
  *   - 探针健康（含壳页）→ 距上次切换 < 冷却期仅检查不切换
  *   - 探针健康 → 距上次切换 >= 冷却期 → 按业务级封禁轮换一次
+ *   - 强切（force=true）→ 探针健康且冷却期内仍强制轮换
  *   - 切换后（含手动/巡检/failover）更新 _lastSwitchAt 锚点，冷却期内不再切
  *   - 候选集为空 → 触发 delay 初测且不切换
  *
@@ -229,3 +230,15 @@ test("F9 disconnectMode=full：直接全断", async () => {
   assert.equal(state.idleCloses, 0, "full 模式不走优雅断连");
   assert.equal(state.closes, 1, "full 模式直接全断");
 });
+
+test("F10 强切（force）：冷却期内探针健康仍强制轮换", async () => {
+  resetState();
+  const { d, c } = makeCtx();
+  c._lastSwitchAt = Date.now(); // 刚切过，处于 10min 冷却期内
+  await d._handleFailover({ reason: "F10", force: true }, c);
+  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "force 应无视冷却直接轮换");
+  assert.ok(
+    c._lastSwitchAt && c._lastSwitchAt > Date.now() - 5000,
+    "强切后应更新锚点（给新节点观察期）",
+  );
+});

package/scripts/test-proxy-switch-restart.mjs

@@ -0,0 +1,198 @@
+/**
+ * 代理切换 → watchdog 强制重启命令 链路测试（2026-08-28，先打通路版本）
+ *
+ * 验证：
+ *   T1  daemon _markSwitchTime 递增 restartSeq（首次为 1，连续递增）
+ *   T2  daemon _writeHealth 把 restartSeq 带进 health 文件
+ *   T3  daemon 未切换时 restartSeq 保持 0
+ *   T4  ProcessManager.restartAll 先停后起（真实子进程，pid 变化、数量恢复）
+ *   T5  restartAll 跳过 stopped / 无 child 的命令
+ *   T6  无运行命令时 restartAll 返回 {restarted:0}
+ *   T7  Agent._checkProxySwitch 首次读取仅建基线不触发
+ *   T8  health.restartSeq 变大 → 触发强制重启（真实子进程 pid 变化）
+ *   T9  health.restartSeq 变小（daemon 重启归零）→ 不触发
+ *   T10 通道重启：主文件 seq 不变时不触发
+ *
+ * 运行: node --test scripts/test-proxy-switch-restart.mjs
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { writeFileSync, rmSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+const HEALTH_FILE = join(tmpdir(), "clash-health.json");
+
+/** 清理并写 health 文件（模拟 daemon 写入） */
+function writeHealthFile(extra) {
+  writeFileSync(
+    HEALTH_FILE,
+    JSON.stringify(
+      {
+        node: "🇺🇸 美国01",
+        healthy: true,
+        lastCheck: new Date().toISOString(),
+        ...extra,
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+/** 生成一个常驻假命令（测试业务进程） */
+function fakeCmd(id) {
+  return {
+    id,
+    name: id,
+    command: process.execPath,
+    args: ["-e", "setInterval(()=>{},1000)"],
+    enabled: true,
+  };
+}
+
+function cleanup() {
+  try {
+    rmSync(HEALTH_FILE, { force: true });
+  } catch {}
+}
+
+test("T1-T3: daemon 切换信号（_markSwitchTime 递增 + _writeHealth 带出）", async () => {
+  const { ClashDaemon } = await import("../src/clash/daemon.js");
+  const ipc = await import("../src/clash/ipc.js");
+  cleanup();
+  try {
+    const d = new ClashDaemon({ dryRun: true });
+    const c = { proxyPort: 0 };
+
+    // T3: 未切换 → restartSeq = 0
+    d._writeHealth(c, { node: "A", healthy: true });
+    let h = ipc.readHealth(0);
+    assert.equal(h.restartSeq, 0, "未切换时 restartSeq 应为 0");
+
+    // T1: 首次切换 → 1
+    d._markSwitchTime(c);
+    assert.equal(c._restartSeq, 1, "首次切换 restartSeq 应为 1");
+    d._markSwitchTime(c);
+    assert.equal(c._restartSeq, 2, "连续切换 restartSeq 递增");
+
+    // T2: _writeHealth 带出 restartSeq
+    d._writeHealth(c, { node: "B", healthy: true, lastSwitch: "A → B" });
+    h = ipc.readHealth(0);
+    assert.equal(h.restartSeq, 2, "health 文件应携带 restartSeq=2");
+    assert.equal(h.lastSwitch, "A → B");
+  } finally {
+    cleanup();
+  }
+});
+
+test("T4-T6: ProcessManager.restartAll 先停后起", async () => {
+  const { ProcessManager } = await import("../src/watchdog/process-manager.js");
+  const pm = new ProcessManager();
+  try {
+    // T6: 空集
+    const empty = await pm.restartAll("测试");
+    assert.deepEqual(empty, { restarted: 0 }, "无运行命令应返回 0");
+
+    pm.startCommand(fakeCmd("proc-a"));
+    await new Promise((r) => setTimeout(r, 500));
+    assert.equal(pm.runningCount, 1);
+    const oldPid = pm.processes.get("proc-a").child.pid;
+
+    // T4: 先停后起，pid 变化、数量恢复
+    const r = await pm.restartAll("代理切换(测试)");
+    assert.equal(r.restarted, 1, "应重启 1 个命令");
+    assert.equal(pm.runningCount, 1, "重启后数量恢复");
+    const newPid = pm.processes.get("proc-a").child.pid;
+    assert.notEqual(newPid, oldPid, "重启后应是新进程（pid 不同）");
+
+    // T5: stopped 的命令不参与重启
+    pm.startCommand(fakeCmd("proc-b"));
+    await new Promise((r) => setTimeout(r, 500));
+    pm.stopCommand("proc-b");
+    const r2 = await pm.restartAll("二次重启");
+    assert.equal(r2.restarted, 1, "只重启 running 的 1 个，stopped 的不算");
+    assert.equal(pm.runningCount, 1);
+    assert.ok(!pm.processes.has("proc-b"), "proc-b 保持停止状态");
+  } finally {
+    pm.stopAll();
+  }
+});
+
+test("T7-T13: Agent._checkProxySwitch 感知切换（默认禁用，开启后才重启）", async () => {
+  const { WatchdogAgent } = await import("../src/watchdog/agent.js");
+  cleanup();
+  const agent = new WatchdogAgent({
+    serverUrl: "http://127.0.0.1:9",
+    clientId: "test-switch",
+    intervalMs: 60000,
+    spawnDaemon: false,
+  });
+  try {
+    // 准备一个运行中的假业务命令
+    agent.processManager.startCommand(fakeCmd("proc-c"));
+    await new Promise((r) => setTimeout(r, 500));
+    const pid0 = agent.processManager.processes.get("proc-c").child.pid;
+
+    // T7: 首次读取建基线，不触发
+    writeHealthFile({ restartSeq: 0, lastSwitch: "初始化" });
+    await agent._checkProxySwitch();
+    assert.equal(
+      agent.processManager.processes.get("proc-c").child.pid,
+      pid0,
+      "首次读取仅建基线，不应重启",
+    );
+
+    // T10: seq 不变不触发
+    writeHealthFile({ restartSeq: 0, lastSwitch: "初始化" });
+    await agent._checkProxySwitch();
+    assert.equal(
+      agent.processManager.processes.get("proc-c").child.pid,
+      pid0,
+      "seq 不变不应重启",
+    );
+
+    // T11: 默认禁用时 seq 变大 → 不触发（但基线已跟随更新）
+    writeHealthFile({ restartSeq: 1, lastSwitch: "禁用期间切换: A → B" });
+    await agent._checkProxySwitch();
+    assert.equal(
+      agent.processManager.processes.get("proc-c").child.pid,
+      pid0,
+      "默认禁用时检测到切换也不应重启",
+    );
+
+    // T12: 开启开关后，seq 仍为 1（无新切换）→ 不补触发历史切换
+    agent._applySwitchRestartConfig({ enabled: true });
+    await agent._checkProxySwitch();
+    assert.equal(
+      agent.processManager.processes.get("proc-c").child.pid,
+      pid0,
+      "开启开关后不应补触发开启前的历史切换",
+    );
+
+    // T8: 开启后 seq 1→2 → 触发强制重启
+    writeHealthFile({ restartSeq: 2, lastSwitch: "开启后切换: B → C" });
+    await agent._checkProxySwitch();
+    const pid1 = agent.processManager.processes.get("proc-c").child.pid;
+    assert.notEqual(pid1, pid0, "开启后检测到切换应强制重启（pid 变化）");
+    assert.equal(agent.processManager.runningCount, 1, "重启后数量恢复");
+
+    // T9: seq 变小（daemon 重启归零）→ 不触发
+    writeHealthFile({ restartSeq: 0, lastSwitch: "daemon 重启" });
+    await agent._checkProxySwitch();
+    assert.equal(
+      agent.processManager.processes.get("proc-c").child.pid,
+      pid1,
+      "seq 变小（daemon 重启归零）不应触发",
+    );
+
+    // T13: 归零后再次真实切换（0 → 1）应重新触发
+    writeHealthFile({ restartSeq: 1, lastSwitch: "再次切换: C → D" });
+    await agent._checkProxySwitch();
+    const pid2 = agent.processManager.processes.get("proc-c").child.pid;
+    assert.notEqual(pid2, pid1, "归零后再次切换应重新触发");
+  } finally {
+    await agent.stop();
+    cleanup();
+  }
+});

package/src/clash/daemon.js

@@ -104,7 +104,11 @@ export class ClashDaemon {
 
   /** 记录最近一次实际切换节点的时间（failover/巡检/手动切换共用锚点，冷却期判断依据） */
   _markSwitchTime(c) {
-    if (c) c._lastSwitchAt = Date.now();
+    if (!c) return;
+    c._lastSwitchAt = Date.now();
+    // 切换通知序号：每次实际切换 +1，watchdog 感知变化后强制重启全部命令
+    // （先打通路：发现切了就重启；冷却/开关等控制后续再加）
+    c._restartSeq = (c._restartSeq || 0) + 1;
   }
 
   /**
@@ -191,7 +195,12 @@ export class ClashDaemon {
 
   /** 写通道健康状态（每端口一份；主控制端额外写默认文件兼容 watchdog） */
   _writeHealth(c, state) {
-    const payload = { ...state, meta: this._buildMeta(c) };
+    const payload = {
+      ...state,
+      // 切换通知序号（每次实际切换 +1，watchdog 比较变化感知切换）
+      restartSeq: (c && c._restartSeq) || 0,
+      meta: this._buildMeta(c),
+    };
     ipc.writeHealth(payload, c.proxyPort || 0);
     if (c === this._primary && c.proxyPort) ipc.writeHealth(payload, 0);
   }
@@ -667,21 +676,28 @@ export class ClashDaemon {
     try {
       const reason = (cmd && cmd.reason) || "看门狗主动故障切换";
       const now = Date.now();
+      // 强切（force=true，看门狗客户端异常监控触发）：无视冷却期直接轮换；
+      // 切换成功后仍更新 _lastSwitchAt 锚点，给新节点干净观察期
+      const force = !!(cmd && cmd.force);
 
       // 第 1 级：先检查当前节点（壳页 = 链路正常，按健康对待，与巡检口径一致）
       const h = checker.checkNodeHealth();
       const probeOk = !!h && (h.healthy || this._isShellPage(h));
       if (probeOk) {
-        // 探针健康：受冷却期约束（锚点 = 最近一次实际切换节点的时间 _lastSwitchAt）
-        const gap = now - (c._lastSwitchAt || 0);
-        if (gap < this.failoverCooldownMs) {
-          this._log(
-            `🔄 [${c.proxyPort}] 探针健康，距上次切换 ${Math.round(gap / 1000)}s（<${this.failoverCooldownMs / 60000}min 冷却），仅检查不切换 [${reason}]`,
-          );
-          return;
+        if (!force) {
+          // 探针健康：受冷却期约束（锚点 = 最近一次实际切换节点的时间 _lastSwitchAt）
+          const gap = now - (c._lastSwitchAt || 0);
+          if (gap < this.failoverCooldownMs) {
+            this._log(
+              `🔄 [${c.proxyPort}] 探针健康，距上次切换 ${Math.round(gap / 1000)}s（<${this.failoverCooldownMs / 60000}min 冷却），仅检查不切换 [${reason}]`,
+            );
+            return;
+          }
         }
         this._log(
-          `🔄 [${c.proxyPort}] 探针健康但业务持续报错，距上次切换已过冷却期，按业务级封禁轮换 [${reason}]`,
+          force
+            ? `🔄 [${c.proxyPort}] 强切指令（无视冷却），按业务级封禁轮换 [${reason}]`
+            : `🔄 [${c.proxyPort}] 探针健康但业务持续报错，距上次切换已过冷却期，按业务级封禁轮换 [${reason}]`,
         );
       } else {
         this._log(

package/src/cli/tag.js

@@ -2,6 +2,7 @@ import { writeFileSync } from "fs";
 import { randomUUID } from "crypto";
 import http from "http";
 import readline from "readline";
+import os from "os";
 import {
   getBrowserMemory,
   formatMemoryWithBrowser,
@@ -1058,11 +1059,12 @@ export async function handleScoreAll(parsed) {
   let retrySameTag = false; // 是否重试同一个 tag
   let tag403Attempts = 0; // 当前 tag 已发生 403 的次数
   let bannedCount = 0; // 连续判定“被封”的次数（成功 tag 清零）
-  // 按判封次数递增的重试预算：第 1 次判封前重试 30、第 2 次 40、第 3 次及以后 50
-  const BAN_RETRY_BUDGETS = [
-    parseInt(process.env.TAG_SCOREALL_403_RETRY_1 || "30", 10) || 30,
-    parseInt(process.env.TAG_SCOREALL_403_RETRY_2 || "40", 10) || 40,
-    parseInt(process.env.TAG_SCOREALL_403_RETRY_3 || "50", 10) || 50,
+  // 403 渐退重试间隔（秒）：30/40/50s 各重试一次，仍 403 才判定“被封”一次。
+  // 与 api-interceptor 被封重试（30/40/50s 共 3 次）保持一致
+  const BAN_RETRY_WAITS = [
+    (parseInt(process.env.TAG_SCOREALL_403_RETRY_1 || "30", 10) || 30) * 1000,
+    (parseInt(process.env.TAG_SCOREALL_403_RETRY_2 || "40", 10) || 40) * 1000,
+    (parseInt(process.env.TAG_SCOREALL_403_RETRY_3 || "50", 10) || 50) * 1000,
   ];
 
   // 生成客户端 ID，用于服务端追踪
@@ -1439,26 +1441,32 @@ export async function handleScoreAll(parsed) {
           e.message &&
           (e.message.includes("验证码") || e.message.includes("captcha"));
 
-        // ── 403：重试同一 tag，预算按判封次数递增 ──
+        // ── 403：渐退等待 30/40/50s 各重试一次，仍 403 判定“被封” ──
+        // 首次被封重启浏览器（同端口换新会话），后续仍 403 只清 tab
         if (is403) {
+          const retryIndex = tag403Attempts;
           tag403Attempts++;
-          const budget =
-            BAN_RETRY_BUDGETS[
-              Math.min(bannedCount, BAN_RETRY_BUDGETS.length - 1)
-            ];
-          if (tag403Attempts <= budget) {
+          if (retryIndex < BAN_RETRY_WAITS.length) {
+            const waitMs = BAN_RETRY_WAITS[retryIndex];
             retrySameTag = true;
-            log(
-              `  🚫 HTTP 403 (${tag403Attempts}/${budget}) — 重试同一 tag #${currentTag} ...`,
-            );
-            await recyclePage();
-            await randomDelay(2000, 5000);
+            if (retryIndex === 0) {
+              log(
+                `  🚫 HTTP 403，判定被封，重启浏览器后 ${waitMs / 1000}s 第 ${tag403Attempts}/${BAN_RETRY_WAITS.length} 次重试 #${currentTag} ...`,
+              );
+              await recycleCdpSession(`首次被封`, { switchPort: false });
+            } else {
+              log(
+                `  🚫 HTTP 403，判定被封，${waitMs / 1000}s 后第 ${tag403Attempts}/${BAN_RETRY_WAITS.length} 次重试 #${currentTag} ...`,
+              );
+              await recyclePage();
+            }
+            await new Promise((r) => setTimeout(r, waitMs));
             continue;
           }
           // 重试耗尽：判定“被封”
           bannedCount++;
           log(
-            `  🚫 重试 ${tag403Attempts} 次仍 403，判定账号被封（连续判封 ${bannedCount} 次）`,
+            `  🚫 30/40/50s 重试 ${BAN_RETRY_WAITS.length} 次仍 403，判定账号被封（连续判封 ${bannedCount} 次）`,
           );
           if (bannedCount >= 2) {
             log(`  ⚠️ 连续两次判封 → 汇报服务端 + 触发 daemon fallback`);
@@ -1511,6 +1519,7 @@ export async function handleScoreAll(parsed) {
                 errorMessage: e.message,
                 stage: "tag-scoring",
                 errorStack: "",
+                hostname: os.hostname(),
               }),
             });
           } catch {}

package/src/lib/api-client.js

@@ -1,4 +1,5 @@
 import crypto from "node:crypto";
+import os from "os";
 
 const MAX_RETRY_WAIT = 5 * 60 * 1000;
 
@@ -68,13 +69,18 @@ export function createApiClient(opts = {}) {
     return withRetry(
       `POST ${url}`,
       async () => {
+        const headers = buildHeaders(
+          { "Content-Type": "application/json" },
+          clientId,
+          meta,
+        );
+        // error-report 自动带上本机 hostname，供看门狗按机器关联异常
+        if (/\/api\/error-report(\?|$)/.test(String(url))) {
+          headers["X-Client-Hostname"] = os.hostname();
+        }
         const res = await fetch(url, {
           method: "POST",
-          headers: buildHeaders(
-            { "Content-Type": "application/json" },
-            clientId,
-            meta,
-          ),
+          headers,
           body: JSON.stringify(body),
           signal: AbortSignal.timeout(30000),
         });

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

@@ -3,6 +3,8 @@
  * 供 tag / comments 等业务命令复用，避免重复实现。
  */
 
+import os from "os";
+
 /**
  * 触发 Clash daemon 的故障切换（换出口节点），与 watchdog 的 failover 一致。
  * 复用 ../clash/ipc.js 现成的 writeCommand 接口，不改动 daemon/ipc 模块。
@@ -47,6 +49,7 @@ export async function reportClientErrorAndFailover({
       errorMessage: message,
       stage,
       errorStack: "",
+      hostname: os.hostname(), // 机器标识：看门狗按 hostname 关联本机异常
     });
   } catch {}
   await triggerClashFailover(message, log);

package/src/watch/data-store.js

@@ -2477,10 +2477,12 @@ export function createStore(filePath, options = {}) {
     username,
     stage,
     errorStack,
+    hostname,
   ) {
     const existing = clientErrors.get(userId);
     if (existing) {
       existing.timestamp = Date.now();
+      if (hostname) existing.hostname = hostname;
       if (errorType === "captcha") {
         existing.captchaCount = (existing.captchaCount || 0) + 1;
         if (!existing.captchaStage) existing.captchaStage = stage || "";
@@ -2498,6 +2500,7 @@ export function createStore(filePath, options = {}) {
     } else {
       clientErrors.set(userId, {
         userId,
+        hostname: hostname || "",
         errorType,
         errorMessage: errorMessage || "",
         errorStack: errorStack || "",