tt-help-cli-ycl 1.4.139 → 1.4.142

package/scripts/test-webserver-error-classify.mjs

@@ -0,0 +1,379 @@
+// 回归测试：webserver 错误分类（IP 风控 → CDN 自愈，重启竞态 → 不计连续错误）
+// 运行：node scripts/test-webserver-error-classify.mjs
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { spawn } from "node:child_process";
+import {
+  TikTokScraper,
+  classifyGotoError,
+} from "../src/lib/tiktok-scraper.mjs";
+import {
+  classifyError,
+  switchClashNode,
+  settleCooldownWindow,
+} from "../src/webserver/server.mjs";
+import { CDNBlockedError, TikTokStatusError } from "../src/lib/parse-ssr.mjs";
+import { configure, resetConfig } from "../src/clash/api.js";
+import { parseNetstatListeningPids } from "../src/lib/browser/cdp.js";
+import { findListeningPids, killListeningOnPort } from "../src/lib/port.js";
+
+let passed = 0;
+let failed = 0;
+const checks = [];
+function check(name, fn) {
+  checks.push({ name, fn });
+}
+
+async function runAll() {
+  for (const { name, fn } of checks) {
+    try {
+      await fn();
+      passed++;
+      console.error(`PASS ${name}`);
+    } catch (e) {
+      failed++;
+      console.error(`FAIL ${name}: ${e.message}`);
+    }
+  }
+  console.error(`\n结果: ${passed} 通过, ${failed} 失败`);
+  process.exitCode = failed > 0 ? 1 : 0;
+}
+
+// ---- classifyGotoError ----
+check("goto 非2xx + status=403 → CDNBlockedError 带状态码", () => {
+  const err = classifyGotoError(
+    "page.goto: net::ERR_HTTP_RESPONSE_CODE_FAILURE at view-source:https://www.tiktok.com/@x/video/1",
+    403,
+  );
+  assert.ok(err instanceof CDNBlockedError);
+  assert.equal(err.name, "CDNBlockedError");
+  assert.match(err.message, /status=403/);
+});
+
+check("goto 非2xx + status=429 → CDNBlockedError", () => {
+  const err = classifyGotoError(
+    "page.goto: net::ERR_HTTP_RESPONSE_CODE_FAILURE at view-source:https://x",
+    429,
+  );
+  assert.ok(err instanceof CDNBlockedError);
+  assert.match(err.message, /status=429/);
+});
+
+check("goto 非2xx + status=null → CDNBlockedError 标 unknown", () => {
+  const err = classifyGotoError(
+    "page.goto: net::ERR_HTTP_RESPONSE_CODE_FAILURE at view-source:https://x",
+    null,
+  );
+  assert.ok(err instanceof CDNBlockedError);
+  assert.match(err.message, /status=unknown/);
+});
+
+check("goto 非2xx + status=404 → TikTokStatusError（业务结果）", () => {
+  const err = classifyGotoError(
+    "page.goto: net::ERR_HTTP_RESPONSE_CODE_FAILURE at view-source:https://www.tiktok.com/@x/video/9",
+    404,
+  );
+  assert.ok(err instanceof TikTokStatusError);
+  assert.equal(err.statusCode, 404);
+});
+
+check("goto ERR_ABORTED → null（原样冒泡）", () => {
+  assert.equal(
+    classifyGotoError(
+      "page.goto: net::ERR_ABORTED at view-source:https://x",
+      null,
+    ),
+    null,
+  );
+});
+
+check("goto frame detached → null（原样冒泡）", () => {
+  assert.equal(
+    classifyGotoError("page.goto: net::ERR_ABORTED; maybe frame was detached?"),
+    null,
+  );
+});
+
+check("goto 非字符串 → null", () => {
+  assert.equal(classifyGotoError(undefined), null);
+  assert.equal(classifyGotoError(null), null);
+});
+
+// ---- classifyError ----
+check("CDNBlockedError → cdn/503/retryable/不计连续错误", () => {
+  const c = classifyError(new CDNBlockedError("CDN限流"));
+  assert.deepEqual(c, {
+    kind: "cdn",
+    status: 503,
+    retryable: true,
+    countConsecutive: false,
+  });
+});
+
+check("goto 包装的 CDNBlockedError → cdn", () => {
+  const err = classifyGotoError(
+    "page.goto: net::ERR_HTTP_RESPONSE_CODE_FAILURE at view-source:https://www.tiktok.com/@x/video/2",
+    403,
+  );
+  const c = classifyError(err);
+  assert.equal(c.kind, "cdn");
+  assert.equal(c.status, 503);
+});
+
+check("TikTokStatusError(404) → business/200/不计连续错误", () => {
+  const c = classifyError(new TikTokStatusError(404, "TikTok HTTP 404"));
+  assert.deepEqual(c, {
+    kind: "business",
+    status: 200,
+    retryable: false,
+    countConsecutive: false,
+    statusCode: 404,
+  });
+});
+
+check("Server is shutting down → shutdown/503/不计", () => {
+  const c = classifyError(new Error("Server is shutting down"));
+  assert.deepEqual(c, {
+    kind: "shutdown",
+    status: 503,
+    retryable: true,
+    countConsecutive: false,
+  });
+});
+
+check("Timeout → timeout/504/计", () => {
+  const c = classifyError(new Error("page.goto: Timeout 15000ms exceeded"));
+  assert.deepEqual(c, {
+    kind: "timeout",
+    status: 504,
+    retryable: true,
+    countConsecutive: true,
+  });
+});
+
+check("重启竞态产物 → browser/503/不计", () => {
+  const cases = [
+    "browserContext.newPage: Target page, context or browser has been closed",
+    "page.goto: net::ERR_ABORTED at view-source:https://www.tiktok.com/@x/video/3",
+    "page.goto: net::ERR_ABORTED; maybe frame was detached?",
+    "Cannot read properties of null (reading 'newPage')",
+    "Execution context was destroyed, most likely because of a navigation.",
+    "Protocol error (Page.navigate): Target closed.",
+  ];
+  for (const msg of cases) {
+    const c = classifyError(new Error(msg));
+    assert.equal(c.kind, "browser", msg);
+    assert.equal(c.status, 503, msg);
+    assert.equal(c.retryable, true, msg);
+    assert.equal(c.countConsecutive, false, msg);
+  }
+});
+
+check("未知错误 → unknown/500/计", () => {
+  const c = classifyError(new Error("some random parse failure"));
+  assert.deepEqual(c, {
+    kind: "unknown",
+    status: 500,
+    retryable: false,
+    countConsecutive: true,
+  });
+});
+
+// ---- TikTokScraper 关闭标记（重启竞态防护）----
+check("closing=true 时 _ensurePage 抛 Server is shutting down", async () => {
+  const s = new TikTokScraper({ poolSize: 1 });
+  s.closing = true;
+  await assert.rejects(() => s._ensurePage({}), /Server is shutting down/);
+});
+
+check("context=null 时 _ensurePage 抛 Server is shutting down", async () => {
+  const s = new TikTokScraper({ poolSize: 1 });
+  s.closing = false;
+  s.context = null;
+  await assert.rejects(() => s._ensurePage({}), /Server is shutting down/);
+});
+
+// ---- switchClashNode（mock Clash API，不碰真实 9097）----
+/** 起一个 mock Clash 控制端，返回处理函数闭包里的状态 */
+function startMockClash(handler) {
+  return new Promise((resolve) => {
+    const server = createServer((req, res) => {
+      const url = new URL(req.url, "http://127.0.0.1");
+      let body = "";
+      req.on("data", (c) => (body += c));
+      req.on("end", () => {
+        const reply = (status, data) => {
+          res.statusCode = status;
+          if (data === undefined) {
+            res.end();
+            return;
+          }
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify(data));
+        };
+        handler(req, url, body ? JSON.parse(body) : null, reply);
+      });
+    });
+    server.listen(0, "127.0.0.1", () => resolve(server));
+  });
+}
+
+check("switchClashNode：选第一个 delay 通过的候选并切换", async () => {
+  let switchedTo = null;
+  const server = await startMockClash((req, url, body, reply) => {
+    if (req.method === "GET" && url.pathname === "/proxies/GLOBAL") {
+      reply(200, { now: "A", all: ["A", "B", "C"] });
+    } else if (req.method === "GET" && url.pathname.endsWith("/delay")) {
+      reply(200, { delay: 120, timeout: false });
+    } else if (req.method === "PUT" && url.pathname === "/proxies/GLOBAL") {
+      switchedTo = body.name;
+      reply(204);
+    } else {
+      reply(404, {});
+    }
+  });
+  const port = server.address().port;
+  configure({ port });
+  try {
+    const picked = await switchClashNode("测试切节点");
+    assert.equal(picked, "B"); // 跳过当前节点 A，选第一个探测通过的 B
+    assert.equal(switchedTo, "B");
+  } finally {
+    resetConfig();
+    await new Promise((r) => server.close(r));
+  }
+});
+
+check("switchClashNode：候选均探测不通 → 抛错", async () => {
+  const server = await startMockClash((req, url, body, reply) => {
+    if (req.method === "GET" && url.pathname === "/proxies/GLOBAL") {
+      reply(200, { now: "A", all: ["A", "B"] });
+    } else if (req.method === "GET" && url.pathname.endsWith("/delay")) {
+      reply(200, { delay: -1, timeout: true });
+    } else {
+      reply(404, {});
+    }
+  });
+  configure({ port: server.address().port });
+  try {
+    await assert.rejects(() => switchClashNode("测试"), /候选均探测不通/);
+  } finally {
+    resetConfig();
+    await new Promise((r) => server.close(r));
+  }
+});
+
+check("switchClashNode：无候选节点（组内只有当前节点）→ 抛错", async () => {
+  const server = await startMockClash((req, url, body, reply) => {
+    if (req.method === "GET" && url.pathname === "/proxies/GLOBAL") {
+      reply(200, { now: "A", all: ["A"] });
+    } else {
+      reply(404, {});
+    }
+  });
+  configure({ port: server.address().port });
+  try {
+    await assert.rejects(() => switchClashNode("测试"), /无候选节点/);
+  } finally {
+    resetConfig();
+    await new Promise((r) => server.close(r));
+  }
+});
+
+// ---- 端口占用清理 ----
+check("parseNetstatListeningPids：精确端口匹配（3000 不误匹配 30001）", () => {
+  const out = [
+    "  TCP    0.0.0.0:3000       0.0.0.0:0              LISTENING       1234",
+    "  TCP    0.0.0.0:30001      0.0.0.0:0              LISTENING       5678",
+    "  TCP    127.0.0.1:3000     0.0.0.0:0              LISTENING       1234",
+    "  TCP    [::]:3000          [::]:0                 LISTENING       4321",
+  ].join("\r\n");
+  assert.deepEqual(parseNetstatListeningPids(out, 3000), ["1234", "4321"]);
+});
+
+check("killListeningOnPort：杀掉占用端口的子进程并可重新监听", async () => {
+  // 先占一个随机端口拿到端口号，再释放
+  const holder = createServer();
+  await new Promise((r) => holder.listen(0, "127.0.0.1", r));
+  const port = holder.address().port;
+  await new Promise((r) => holder.close(r));
+
+  // spawn 独立子进程占住该端口
+  const child = spawn(
+    process.execPath,
+    [
+      "-e",
+      `require("http").createServer((q,s)=>s.end("ok")).listen(${port},"127.0.0.1");setInterval(()=>{},1000);`,
+    ],
+    { stdio: "ignore" },
+  );
+  await new Promise((r) => setTimeout(r, 800)); // 等子进程监听
+
+  // 确认端口确实被占用
+  const before = findListeningPids(port);
+  assert.ok(
+    before.includes(String(child.pid)),
+    `预期子进程 ${child.pid} 在监听 ${port}，实际: ${before.join(",")}`,
+  );
+
+  // 先注册 exit 监听（kill 后进程瞬间退出，后注册会丢失事件）
+  const exitedPromise = new Promise((resolve) => {
+    const t = setTimeout(() => resolve(false), 3000);
+    child.once("exit", () => {
+      clearTimeout(t);
+      resolve(true);
+    });
+  });
+
+  await killListeningOnPort(port);
+
+  const exited = await exitedPromise;
+  assert.equal(exited, true, "子进程应被杀死");
+
+  // 端口应可重新监听
+  const s2 = createServer();
+  await new Promise((r) => s2.listen(port, "127.0.0.1", r));
+  await new Promise((r) => s2.close(r));
+});
+
+// ---- 5 分钟窗口结算（只数限流窗口，成功请求不参与）----
+const WINDOW = 5 * 60 * 1000;
+check("settleCooldownWindow：无窗口 → 不结算原样返回", () => {
+  assert.deepEqual(settleCooldownWindow(0, 0, 1000, WINDOW, 2), {
+    shouldSwitch: false,
+    count: 0,
+    windowStartAt: 0,
+  });
+});
+check("settleCooldownWindow：窗口内 → 不结算原样返回", () => {
+  assert.deepEqual(
+    settleCooldownWindow(1, 1000, 1000 + WINDOW - 1, WINDOW, 2),
+    {
+      shouldSwitch: false,
+      count: 1,
+      windowStartAt: 1000,
+    },
+  );
+});
+check("settleCooldownWindow：超 5 分钟且限流窗口 ≥2 → 切换并重新计数", () => {
+  assert.deepEqual(
+    settleCooldownWindow(2, 1000, 1000 + WINDOW + 1, WINDOW, 2),
+    {
+      shouldSwitch: true,
+      count: 0,
+      windowStartAt: 0,
+    },
+  );
+});
+check("settleCooldownWindow：超 5 分钟但限流窗口 <2 → 重新计算不切换", () => {
+  assert.deepEqual(
+    settleCooldownWindow(1, 1000, 1000 + WINDOW + 1, WINDOW, 2),
+    {
+      shouldSwitch: false,
+      count: 0,
+      windowStartAt: 0,
+    },
+  );
+});
+
+await runAll();

package/src/clash/checker.js

@@ -403,11 +403,18 @@ export function loadHealthyList(country = null) {
     if (!existsSync(_healthyFile)) return _emptyList();
     const d = JSON.parse(readFileSync(_healthyFile, "utf-8"));
     const allNodes = Array.isArray(d.nodes) ? d.nodes : [];
+    const allDelays = d.delays && typeof d.delays === "object" ? d.delays : {};
     const filter = country || CONFIG.nodeCountryFilter;
     const { filtered, excluded } = filterNodesByCountry(allNodes, filter);
+    const delays = {};
+    for (const n of filtered) {
+      const v = allDelays[n];
+      if (typeof v === "number" && v > 0) delays[n] = v;
+    }
     return {
       updated: d.updated || "",
       nodes: filtered,
+      delays,
       totalNodes: allNodes.length,
       excluded,
       countryFilter: filter || null,
@@ -418,11 +425,15 @@ export function loadHealthyList(country = null) {
   return _emptyList();
 }
 
-export function saveHealthyList(nodes) {
+export function saveHealthyList(nodes, delays = {}) {
   try {
     writeFileSync(
       _healthyFile,
-      JSON.stringify({ updated: new Date().toISOString(), nodes }, null, 2),
+      JSON.stringify(
+        { updated: new Date().toISOString(), nodes, delays: delays || {} },
+        null,
+        2,
+      ),
       "utf-8",
     );
   } catch (e) {
@@ -434,6 +445,7 @@ function _emptyList() {
   return {
     updated: "",
     nodes: [],
+    delays: {},
     totalNodes: 0,
     excluded: 0,
     countryFilter: null,

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);
   }
@@ -552,7 +561,12 @@ export class ClashDaemon {
         country: checker.CONFIG.nodeCountryFilter,
       });
       const elapsed = ((Date.now() - start) / 1000).toFixed(0);
-      checker.saveHealthyList(r.nodes);
+      const delays = {};
+      for (const it of r.results || []) {
+        if (typeof it.delay === "number" && it.delay > 0)
+          delays[it.node] = it.delay;
+      }
+      checker.saveHealthyList(r.nodes, delays);
       // 清理切换历史中已不在候选集的节点，防止 Map 无限增长
       if (c._switchHistory && c._switchHistory.size) {
         const keep = new Set(r.nodes);
@@ -662,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(
@@ -771,6 +792,7 @@ export class ClashDaemon {
       healthyNodesCount: list.nodes.length,
       healthyNodesTotal: list.totalNodes,
       healthyNodes: list.nodes.slice(0, 50),
+      healthyNodeDelays: list.delays || {},
     });
     return base;
   }

package/src/cli/comments.js

@@ -284,10 +284,11 @@ class CdpSessionManager {
     this.browser = await ensureBrowserReady(opts);
     this.page = await this._ensurePage();
     this.lastRecycleAt = Date.now();
-    // 端口切换时重置运行计时
-    if (oldPort !== undefined && oldPort !== this.port) {
-      this.sessionStartTime = Date.now();
-    }
+    // 重建会话后重置运行计时（无论是否换端口）。
+    // 旧逻辑只在换端口时重置，而默认 switchPortOnRecycle=false，
+    // 导致 48min 定时轮换触发后计时不归零，之后每次内存采样（30s）
+    // 都再次满足超时条件 → 每 30s 反复重建会话（“一直在切换”）
+    this.sessionStartTime = Date.now();
   }
 
   /** 内存检查 + 定时轮换 + 按需回收（每 30s 最多采样一次） */

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/args.js

@@ -414,8 +414,8 @@ function parseWebserverArgs(args) {
   let webserverLog = false;
   // 默认安全限速：3 请求/秒。限速突发容量自动跟随 pool-size（见下方返回）。
   let webserverRate = 3;
-  // CDN 限流冷却时长（秒），默认 180（3 分钟）
-  let webserverCooldown = 180;
+  // CDN 限流冷却时长（秒），默认 100（2 次重启 + 切节点流程节奏）
+  let webserverCooldown = 100;
   // 默认汇报到 ~/.tt-help.json 中配置的 server 地址
   let webserverNotify = defaultServer;
 
@@ -438,10 +438,10 @@ function parseWebserverArgs(args) {
     } else if (arg === "--cooldown") {
       const next = args[i + 1];
       if (next && !next.startsWith("--")) {
-        webserverCooldown = parseInt(next) || 180;
+        webserverCooldown = parseInt(next) || 100;
         i++;
       } else {
-        webserverCooldown = 180; // 缺省回退到默认值
+        webserverCooldown = 100; // 缺省回退到默认值
       }
     } else if (arg === "--log") {
       webserverLog = true;

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);