tt-help-cli-ycl 1.4.89 → 1.4.90

package/package.json

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

package/scripts/test-country-fix.mjs

@@ -0,0 +1,280 @@
+#!/usr/bin/env node
+/**
+ * 回归测试：节点国家配置收敛修复（2026-08-12）
+ *
+ * 背景：daemon 启动硬编码 --country US，且服务端幂等基准是"是否下发过"，
+ * 导致 daemon 重启（崩溃自愈/升级/机器重启）回退 US 后服务端不补发 → 一直用美国节点。
+ *
+ * 运行方式（务必用隔离 TMPDIR，避免污染真实 clash-*.json / 服务端配置）：
+ *   TMPDIR=$(mktemp -d) node scripts/test-country-fix.mjs
+ *
+ * 覆盖：
+ *   A. 服务端幂等基准 = 客户端实际生效国家（核心修复）
+ *      - daemon 重启回退 US 后，服务端补发 JP
+ *      - daemon 已生效 JP 时，幂等不重复下发
+ *      - daemon 未上报时，下发
+ *      - 多国配置且已生效时，幂等不重复下发
+ *   B. daemon 逗号分隔多国 --country 参数解析
+ *   C. checker normalizeCountries / filterNodesByCountry 回归
+ *   D. 客户端 daemon 启动兜底：读 clash-health.json 上次生效国家 → join(",")
+ */
+
+import { mkdtempSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+let passed = 0;
+let failed = 0;
+function ok(cond, name, extra = "") {
+  if (cond) {
+    passed++;
+    console.log(`  ✅ ${name}`);
+  } else {
+    failed++;
+    console.log(`  ❌ ${name}  ${extra}`);
+  }
+}
+
+// ── 隔离 HOME：避免读写真实服务端配置 ~/.tt-help-watchdog.json ──
+const fakeHome = mkdtempSync(join(tmpdir(), "tt-wd-home-"));
+process.env.HOME = fakeHome;
+process.env.USERPROFILE = fakeHome;
+
+function fakeRes() {
+  return {
+    status: 0,
+    body: null,
+    writeHead(code) {
+      this.status = code;
+    },
+    end(b) {
+      this.body = b;
+    },
+  };
+}
+async function wdCall(mod, path, method, params, body) {
+  const res = fakeRes();
+  await mod.tryHandleWatchdogRoute(path, method, params, body, res);
+  return { status: res.status, data: res.body ? JSON.parse(res.body) : null };
+}
+
+console.log("\n═══ A. 服务端幂等基准 = 客户端实际生效国家 ═══");
+const wd = await import("../src/watch/watchdog-server.js");
+
+// A1 配置 T1 → JP
+let r = await wdCall(
+  wd,
+  "/api/watchdog/set-country-filter",
+  "POST",
+  {},
+  {
+    userId: "T1",
+    countries: ["JP"],
+  },
+);
+ok(
+  r.status === 200 && JSON.stringify(r.data.countries) === '["JP"]',
+  "A1 配置 T1 → JP",
+  JSON.stringify(r.data),
+);
+
+// A2 心跳：daemon 回退 US（重启后）→ 服务端应补发 JP（核心修复点，旧逻辑因 lastSent 幂等不会下发）
+r = await wdCall(
+  wd,
+  "/api/watchdog/heartbeat",
+  "POST",
+  { clientId: "c1" },
+  {
+    config: { userId: "T1" },
+    clashHealth: { meta: { countryFilter: ["US"] } },
+  },
+);
+let cmds = (r.data && r.data.clashCommands) || [];
+ok(
+  cmds.some(
+    (c) =>
+      c.action === "setCountryFilter" &&
+      JSON.stringify(c.countries) === '["JP"]',
+  ),
+  "A2 daemon 生效 US(重启回退) → 补发 setCountryFilter JP",
+  JSON.stringify(cmds),
+);
+
+// A3 心跳：daemon 已生效 JP → 幂等不重复下发
+r = await wdCall(
+  wd,
+  "/api/watchdog/heartbeat",
+  "POST",
+  { clientId: "c1" },
+  {
+    config: { userId: "T1" },
+    clashHealth: { meta: { countryFilter: ["JP"] } },
+  },
+);
+cmds = (r.data && r.data.clashCommands) || [];
+ok(
+  !cmds.some((c) => c.action === "setCountryFilter"),
+  "A3 daemon 生效 JP → 幂等不下发",
+  JSON.stringify(cmds),
+);
+
+// A4 心跳：daemon 未上报 clashHealth → 下发
+r = await wdCall(
+  wd,
+  "/api/watchdog/heartbeat",
+  "POST",
+  { clientId: "c1" },
+  {
+    config: { userId: "T1" },
+    clashHealth: null,
+  },
+);
+cmds = (r.data && r.data.clashCommands) || [];
+ok(
+  cmds.some(
+    (c) =>
+      c.action === "setCountryFilter" &&
+      JSON.stringify(c.countries) === '["JP"]',
+  ),
+  "A4 daemon 未上报 → 下发 setCountryFilter JP",
+  JSON.stringify(cmds),
+);
+
+// A5 多国配置 US+JP 且 daemon 已生效 US+JP → 幂等不下发
+// 注：配置动作本身会立即入队一次下发（配置后本该生效一次），首轮心跳取走后再验证幂等
+await wdCall(
+  wd,
+  "/api/watchdog/set-country-filter",
+  "POST",
+  {},
+  {
+    userId: "T2",
+    countries: ["US", "JP"],
+  },
+);
+r = await wdCall(
+  wd,
+  "/api/watchdog/heartbeat",
+  "POST",
+  { clientId: "c2" },
+  {
+    config: { userId: "T2" },
+    clashHealth: { meta: { countryFilter: ["US", "JP"] } },
+  },
+);
+cmds = (r.data && r.data.clashCommands) || [];
+ok(
+  cmds.some(
+    (c) =>
+      c.action === "setCountryFilter" &&
+      JSON.stringify(c.countries) === '["US","JP"]',
+  ),
+  "A5a 配置后首次心跳取走命令",
+  JSON.stringify(cmds),
+);
+r = await wdCall(
+  wd,
+  "/api/watchdog/heartbeat",
+  "POST",
+  { clientId: "c2" },
+  {
+    config: { userId: "T2" },
+    clashHealth: { meta: { countryFilter: ["US", "JP"] } },
+  },
+);
+cmds = (r.data && r.data.clashCommands) || [];
+ok(
+  !cmds.some((c) => c.action === "setCountryFilter"),
+  "A5 多国且已生效 → 幂等不下发",
+  JSON.stringify(cmds),
+);
+
+console.log("\n═══ B. daemon 逗号分隔多国 --country 解析 ═══");
+const { ClashDaemon } = await import("../src/clash/daemon.js");
+const checker = await import("../src/clash/checker.js");
+
+const cases = [
+  ["US,JP", ["US", "JP"], "US,JP 逗号分隔 → 多国并集"],
+  ["JP", ["JP"], "JP 单国"],
+  ["us, jp", ["US", "JP"], "小写+空格归一"],
+  [undefined, null, "未传 country → 不过滤"],
+];
+for (const [input, expect, name] of cases) {
+  checker.CONFIG.nodeCountryFilter = null;
+  new ClashDaemon({ country: input });
+  const got = checker.CONFIG.nodeCountryFilter;
+  ok(JSON.stringify(got) === JSON.stringify(expect), name, JSON.stringify(got));
+}
+checker.CONFIG.nodeCountryFilter = null;
+
+console.log("\n═══ C. checker 国家过滤回归 ═══");
+ok(
+  JSON.stringify(checker.normalizeCountries(["us", " JP", "US"])) ===
+    '["US","JP"]',
+  "C1 数组去重大写",
+);
+ok(
+  JSON.stringify(checker.normalizeCountries("jp")) === '["JP"]',
+  "C2 字符串大写",
+);
+ok(checker.normalizeCountries(null).length === 0, "C3 null → 空");
+ok(checker.normalizeCountries("").length === 0, "C4 空串 → 空");
+// 注意：checker.normalizeCountries 不拆分逗号（拆分在 daemon constructor），单字符串"US,JP"保持为一个元素
+ok(
+  JSON.stringify(checker.normalizeCountries("US,JP")) === '["US,JP"]',
+  "C5 单字符串逗号不拆分（保持向后兼容）",
+);
+const nodes = ["🇺🇸美国A", "🇯🇵日本A", "🇩🇪德国A", "无旗帜节点"];
+let fr = checker.filterNodesByCountry(nodes, ["US", "JP"]);
+ok(
+  fr.filtered.length === 2 && fr.excluded === 2,
+  "C6 多国并集过滤（US+JP 命中 2）",
+  JSON.stringify(fr),
+);
+fr = checker.filterNodesByCountry(nodes, ["ZZ"]);
+ok(
+  fr.filtered.length === 4 && fr.excluded === 0,
+  "C7 未知国家向后兼容返回全部",
+);
+fr = checker.filterNodesByCountry(nodes, null);
+ok(fr.filtered.length === 4 && fr.excluded === 0, "C8 null 不过滤");
+
+console.log("\n═══ D. 客户端 daemon 启动兜底（读上次生效国家）═══");
+const { getClashHealth } = await import("../src/watchdog/reporter.js");
+const healthPath = join(tmpdir(), "clash-health.json");
+
+writeFileSync(
+  healthPath,
+  JSON.stringify({
+    meta: { countryFilter: ["JP"] },
+    lastCheck: new Date().toISOString(),
+  }),
+);
+let prev = getClashHealth()?.meta?.countryFilter;
+ok(
+  Array.isArray(prev) && JSON.stringify(prev) === '["JP"]',
+  "D1 读到上次生效国家 JP",
+  JSON.stringify(prev),
+);
+let countryArg = Array.isArray(prev) && prev.length ? prev.join(",") : "US";
+ok(countryArg === "JP", "D2 单国 join → 'JP'", countryArg);
+
+writeFileSync(
+  healthPath,
+  JSON.stringify({
+    meta: { countryFilter: ["US", "JP"] },
+    lastCheck: new Date().toISOString(),
+  }),
+);
+prev = getClashHealth()?.meta?.countryFilter;
+countryArg = Array.isArray(prev) && prev.length ? prev.join(",") : "US";
+ok(countryArg === "US,JP", "D3 多国 join → 'US,JP'", countryArg);
+
+// 无上次生效记录（clashHealth 缺失）→ 兜底 US
+const nonePrev = null?.meta?.countryFilter;
+const noneArg =
+  Array.isArray(nonePrev) && nonePrev.length ? nonePrev.join(",") : "US";
+ok(noneArg === "US", "D4 无记录 → 兜底 US");
+
+console.log(`\n结果: ${passed} 通过, ${failed} 失败`);
+process.exit(failed ? 1 : 0);

package/src/clash/daemon.js

@@ -25,14 +25,22 @@ function fmtCountries(v) {
 export class ClashDaemon {
   constructor(opts = {}) {
     this.intervalMs = (opts.intervalSec || 120) * 1000;
-    this.benchmarkMs = (opts.benchmarkMin || 40) * 60 * 1000;
+    this.benchmarkMs = (opts.benchmarkMin || 10) * 60 * 1000; // 候选集刷新默认 10 分钟
     this.dryRun = !!opts.dryRun;
     this._running = false;
     this._timers = [];
     this._waitTimer = null; // 等待 Clash 就绪的重试定时器
     this._startedOnce = false; // 首次启动标记（banner/信号只打印注册一次）
     this._benchmarkRunning = false;
-    const initCountries = normalizeCountries(opts.country);
+    // 支持逗号分隔字符串（如 "US,JP"），便于 watchdog 以 --country 透传上次生效的多国配置
+    let initCountriesRaw = opts.country;
+    if (
+      typeof initCountriesRaw === "string" &&
+      initCountriesRaw.includes(",")
+    ) {
+      initCountriesRaw = initCountriesRaw.split(",");
+    }
+    const initCountries = normalizeCountries(initCountriesRaw);
     if (initCountries.length) checker.CONFIG.nodeCountryFilter = initCountries;
     this._meta = {
       groupName: checker.CONFIG.groupName,
@@ -171,21 +179,24 @@ export class ClashDaemon {
         h.error || `HTTP ${h.httpCode} ${(h.sizeDownload / 1024).toFixed(0)}KB`;
       const { nodes } = checker.loadHealthyList();
       if (!nodes.length) {
-        this._log(`✗ ${reason} — 候选集为空，触发 delay 初测`);
+        this._log(`✗ 巡检异常 [${reason}] — 候选集为空，触发 delay 初测`);
         await this._runDelayProbe();
         return;
       }
       if (this.dryRun) {
-        this._log(`[DRY-RUN] 当前节点异常，候选: ${nodes.length} 个`);
+        this._log(
+          `[DRY-RUN] 当前节点 ${node} 异常 [${reason}]，候选: ${nodes.length} 个`,
+        );
         return;
       }
 
+      this._log(`✗ 巡检异常 [${reason}]，开始从候选集切换 (当前 ${node})`);
       // 逐个切换候选 + 内容验证，第一个满足即采用
       let target = null;
       let h2 = null;
       for (const cand of nodes) {
         if (cand === node) continue;
-        this._log(`↺ 尝试候选: ${cand}`);
+        this._log(`↺ 尝试候选: ${cand} [原因: ${reason}]`);
         if (!(await checker.switchToNode(cand))) {
           this._log(`  ↺ ${cand} 切换失败，下一个`);
           continue;
@@ -201,19 +212,19 @@ export class ClashDaemon {
       if (!target) {
         // 全部候选不可用，恢复原节点
         await checker.switchToNode(node).catch(() => {});
-        this._log(`✗ ${reason} — 候选全部不可用，恢复原节点`);
+        this._log(`✗ 恢复原节点 ${node}（原因: ${reason} — 候选全部不可用）`);
         ipc.writeHealth({
           node,
           healthy: false,
           error: `${reason} — 候选全部不可用`,
-          lastSwitch: "failover: 候选全部不可用",
+          lastSwitch: `巡检恢复(${reason}): → ${node}`,
           meta: this._buildMeta(),
         });
         return;
       }
 
       this._log(
-        `⚠ ${node} → ${target} (${h2.timeTotal.toFixed(1)}s ${(h2.sizeDownload / 1024).toFixed(0)}KB)`,
+        `⚠ 节点切换 [巡检异常: ${reason}]: ${node} → ${target} (${h2.timeTotal.toFixed(1)}s ${(h2.sizeDownload / 1024).toFixed(0)}KB)`,
       );
       ipc.writeHealth({
         node: target,
@@ -222,7 +233,7 @@ export class ClashDaemon {
         timeTotal: h2.timeTotal,
         sizeDownload: h2.sizeDownload,
         title: h2.title,
-        lastSwitch: `${node} → ${target}`,
+        lastSwitch: `巡检异常(${reason}): ${node} → ${target}`,
         meta: this._buildMeta(),
       });
     } catch (e) {
@@ -323,12 +334,13 @@ export class ClashDaemon {
    * 看门狗指令: 主动故障切换（不依赖巡检发现，强制从候选集切下一个可用节点）
    * 用于业务进程连续报错（CDN限流/网络异常/封 IP 等）时换出口节点
    */
-  async _handleFailover() {
+  async _handleFailover(cmd) {
     try {
+      const reason = (cmd && cmd.reason) || "看门狗主动故障切换";
       const node = await api
         .getCurrentNode(checker.CONFIG.groupName)
         .catch(() => "?");
-      this._log(`🔄 看门狗指令: 触发故障切换 (当前: ${node})`);
+      this._log(`🔄 看门狗指令: 触发故障切换 [${reason}] (当前: ${node})`);
       const { nodes } = checker.loadHealthyList();
       if (!nodes.length) {
         this._log("🔄 候选集为空，触发 delay 初测");
@@ -354,16 +366,18 @@ export class ClashDaemon {
       }
       if (!target) {
         await checker.switchToNode(node).catch(() => {});
-        this._log(`✗ failover: 候选全部不可用，恢复原节点`);
+        this._log(
+          `✗ failover [${reason}] — 候选全部不可用，恢复原节点 ${node}`,
+        );
         return ipc.writeHealth({
           node,
           healthy: false,
-          error: "failover: 候选全部不可用",
-          lastSwitch: "failover: 候选全部不可用",
+          error: `failover(${reason}): 候选全部不可用`,
+          lastSwitch: `failover恢复(${reason}): → ${node}`,
           meta: this._buildMeta(),
         });
       }
-      this._log(`⚠ failover: ${node} → ${target}`);
+      this._log(`⚠ 节点切换 [${reason}]: ${node} → ${target}`);
       ipc.writeHealth({
         node: target,
         healthy: h2.healthy,
@@ -371,7 +385,7 @@ export class ClashDaemon {
         timeTotal: h2.timeTotal,
         sizeDownload: h2.sizeDownload,
         title: h2.title,
-        lastSwitch: `failover: ${node} → ${target}`,
+        lastSwitch: `${reason}: ${node} → ${target}`,
         meta: this._buildMeta(),
       });
     } catch (e) {
@@ -464,7 +478,7 @@ function _buildCmdHandlers(daemon) {
       }
     },
     switchNode: (cmd) => daemon._handleSwitchNode(cmd),
-    failover: () => daemon._handleFailover(),
+    failover: (cmd) => daemon._handleFailover(cmd),
   };
 }
 

package/src/cli/clash-daemon.js

@@ -1,7 +1,7 @@
 /**
  * clash-daemon CLI 命令入口
  *
- * 用法: tt-help clash-daemon [--interval 120] [--benchmark 40] [--country US] [--dry-run]
+ * 用法: tt-help clash-daemon [--interval 120] [--benchmark 10] [--country US] [--dry-run]
  */
 import { ClashDaemon } from "../clash/daemon.js";
 

package/src/cli/tag.js

@@ -6,7 +6,7 @@ import path from "path";
 import readline from "readline";
 import { fetchTagData, enrichVideosWithLocation } from "../lib/tag-fetcher.js";
 import { killEdgeProcesses, ensureBrowserReady } from "../lib/browser/cdp.js";
-import { getOrCreatePage } from "../lib/browser/page.js";
+import { getOrCreatePage, isBrowserClosedError } from "../lib/browser/page.js";
 import { TikTokScraper } from "../lib/tiktok-scraper.mjs";
 import {
   DEFAULT_TARGET_LOCATIONS,
@@ -48,6 +48,24 @@ function resolveTargetCountries(countries) {
   return countries || DEFAULT_SCORE_COUNTRIES;
 }
 
+/**
+ * 判断浏览器是否已断开（用户手动关窗口 / CDP 断开）。
+ * 用于让采集循环（score-all / refresh）在浏览器被关闭后自动退出，避免无限重试。
+ */
+function isBrowserDisconnected(browser, e) {
+  if (e && isBrowserClosedError(e)) return true;
+  try {
+    if (
+      browser &&
+      typeof browser.isConnected === "function" &&
+      !browser.isConnected()
+    ) {
+      return true;
+    }
+  } catch {}
+  return false;
+}
+
 function formatMemoryUsage(mem = process.memoryUsage()) {
   return `rss:${(mem.rss / 1024 / 1024).toFixed(0)}MB heap:${(mem.heapUsed / 1024 / 1024).toFixed(0)}MB ext:${(mem.external / 1024 / 1024).toFixed(0)}MB ab:${(mem.arrayBuffers / 1024 / 1024).toFixed(0)}MB`;
 }
@@ -1082,6 +1100,12 @@ export async function handleScoreAll(parsed) {
 
   try {
     while (true) {
+      // 检测浏览器窗口是否被手动关闭（CDP 断开）→ 自动退出
+      if (isBrowserDisconnected(browser)) {
+        log("🚪 检测到浏览器窗口已关闭，score-all 自动退出");
+        cleanup();
+        return;
+      }
       try {
         // 从服务端取下一个 new 标签（同时查剩余数量）
         const tagsRes = await fetch(
@@ -1300,6 +1324,12 @@ export async function handleScoreAll(parsed) {
         await maybeRecycleForMemory();
         await randomDelay(3000, 7000);
       } catch (e) {
+        // 浏览器窗口被手动关闭（CDP 断开）→ 自动退出，避免无限重试循环
+        if (isBrowserDisconnected(browser, e)) {
+          log(`🚪 浏览器窗口已关闭 (${e?.message || ""})，score-all 自动退出`);
+          cleanup();
+          return;
+        }
         // 区分网络错误和业务错误
         const isNetworkError =
           e.code === "ECONNREFUSED" ||
@@ -1767,6 +1797,12 @@ export async function handleTagRefresh(parsed) {
 
   try {
     while (true) {
+      // 检测浏览器窗口是否被手动关闭（CDP 断开）→ 自动退出
+      if (isBrowserDisconnected(browser)) {
+        log("🚪 检测到浏览器窗口已关闭，refresh 自动退出");
+        cleanup();
+        return;
+      }
       try {
         // 从服务端获取下一个 productive 标签
         const taskRes = await fetch(
@@ -1987,6 +2023,12 @@ export async function handleTagRefresh(parsed) {
         await maybeRecycleForMemory();
         await randomDelay(3000, 7000);
       } catch (e) {
+        // 浏览器窗口被手动关闭（CDP 断开）→ 自动退出，避免无限重试循环
+        if (isBrowserDisconnected(browser, e)) {
+          log(`🚪 浏览器窗口已关闭 (${e?.message || ""})，refresh 自动退出`);
+          cleanup();
+          return;
+        }
         const isNetworkError =
           e.code === "ECONNREFUSED" ||
           e.code === "ENOTFOUND" ||

package/src/lib/args.js

@@ -665,7 +665,7 @@ function parseWatchdogArgs(args) {
 
 function parseClashDaemonArgs(args) {
   let interval = 120;
-  let benchmark = 40;
+  let benchmark = 10;
   let dryRun = false;
   let country = null;
 
@@ -674,7 +674,7 @@ function parseClashDaemonArgs(args) {
     if (arg === "--interval") {
       interval = parseInt(args[++i]) || 120;
     } else if (arg === "--benchmark") {
-      benchmark = parseInt(args[++i]) || 40;
+      benchmark = parseInt(args[++i]) || 10;
     } else if (arg === "--country") {
       country = args[++i] || null;
     } else if (arg === "--dry-run") {

package/src/lib/constants.js

@@ -393,7 +393,7 @@ const HELP_TEXT = [
   "    看门狗启动时会自动拉起此守护进程",
   "    选项:",
   "      --interval <秒>          巡检间隔，默认 120 秒（2分钟）",
-  "      --benchmark <分钟>       候选集 delay 初测间隔，默认 40 分钟",
+  "      --benchmark <分钟>       候选集 delay 初测间隔，默认 10 分钟",
   "      --country <国家代码>     只保留指定国家节点，默认不过滤",
   "                               支持: US, GB, DE, FR, JP, KR, SG, HK, TW, RU 等",
   "      --dry-run                只检测不切换（调试用）",

package/src/watch/watchdog-server.js

@@ -330,11 +330,17 @@ async function handleHeartbeat(params, body, res) {
   const userId = (body.config && body.config.userId) || "";
   const commands = getClientCommands(userId);
 
-  // 幂等下发节点国家配置（默认 US；配置变化时才入队，daemon 端相同则忽略）
+  // 幂等下发节点国家配置（默认 US）
+  // 幂等基准 = 客户端 daemon 实际生效国家（body.clashHealth.meta.countryFilter），而非"是否下发过"。
+  // 否则 daemon 重启（崩溃自愈/升级/机器重启）回退到 --country US 后，服务端会因"配置没变"而不补发，
+  // 导致实际一直用美国节点（生效与配置不一致）。
   const countries = getClientCountries(userId);
   const countryKey = JSON.stringify(countries);
+  const activeKey = JSON.stringify(
+    body.clashHealth?.meta?.countryFilter || null,
+  );
   const pending = clashCmdQueue.get(userId) || [];
-  if (countryKey !== lastSentCountries.get(userId)) {
+  if (countryKey !== activeKey) {
     pending.push({ action: "setCountryFilter", countries });
     lastSentCountries.set(userId, countryKey);
   }

package/src/watchdog/agent.js

@@ -195,6 +195,7 @@ export class WatchdogAgent {
     this._errorTriggerCount = ERROR_TRIGGER_COUNT;
     this._errorTriggerMinMs = ERROR_MIN_MS;
     this._errorTriggerBreakMs = ERROR_BREAK_MS;
+    this._lastErrorTriggerKey = null; // 上次配置指纹（幂等打印用）
   }
 
   /**
@@ -303,6 +304,10 @@ export class WatchdogAgent {
       this._errorTriggerMinMs = cfg.minMinutes * 60 * 1000;
     if (cfg?.breakSeconds > 0)
       this._errorTriggerBreakMs = cfg.breakSeconds * 1000;
+    // 幂等打印：参数没变化就不刷屏（心跳每次都会带 errorTrigger，此前会每次心跳都打一条）
+    const key = `${this._errorTriggerEnabled}|${this._errorTriggerCount}|${this._errorTriggerMinMs}|${this._errorTriggerBreakMs}`;
+    if (key === this._lastErrorTriggerKey) return;
+    this._lastErrorTriggerKey = key;
     console.error(
       `[watchdog] 错误触发切换: ${this._errorTriggerEnabled ? "已启用" : "已禁用"} (连续${this._errorTriggerCount}次 / 持续${this._errorTriggerMinMs / 60000}min / 中断${this._errorTriggerBreakMs / 1000}s)`,
     );
@@ -323,6 +328,7 @@ export class WatchdogAgent {
         firstErrorAt: 0,
         lastErrorAt: 0,
       };
+      const hadNew = newErrors.length > 0;
       for (const line of newErrors) {
         // 错误间隔超阈值 → 连续中断，重新计数
         if (
@@ -349,6 +355,15 @@ export class WatchdogAgent {
         }
       }
       this._errorStates.set(cmdId, st);
+      // 动态进度：仅本轮扫描到新增错误时打印（扫描间隔 30s，天然低频不刷屏）
+      if (hadNew && st.consecutive > 0 && st.firstErrorAt) {
+        const durMs = now - st.firstErrorAt;
+        const durMin = Math.floor(durMs / 60000);
+        const durSec = Math.floor((durMs % 60000) / 1000);
+        console.error(
+          `[watchdog] 错误累计: ${cmdId} 连续 ${st.consecutive} 次 / 已持续 ${durMin}min${durSec}s (阈值: 连续${this._errorTriggerCount}次/持续${this._errorTriggerMinMs / 60000}min)`,
+        );
+      }
     }
     // 无新错误的进程：长时间无错误则重置连续计数
     for (const [cmdId, st] of this._errorStates) {
@@ -367,7 +382,10 @@ export class WatchdogAgent {
   async _triggerFailover(cmdId) {
     try {
       const ipc = await import("../clash/ipc.js");
-      ipc.writeCommand({ action: "failover" });
+      ipc.writeCommand({
+        action: "failover",
+        reason: `业务进程${cmdId ? ` ${cmdId}` : ""} 连续错误触发`,
+      });
       console.error(`[watchdog] 已下发 failover 命令 (触发源: ${cmdId})`);
     } catch (e) {
       console.error(`[watchdog] 下发 failover 失败: ${e.message}`);
@@ -597,12 +615,23 @@ export class WatchdogAgent {
     }
 
     console.error(`[watchdog] 启动代理守护: ${daemonPath}`);
+    // 上次生效的国家优先（从 daemon 写入的 clash-health.json 读取），避免重启回退到硬编码 US
+    // 服务端心跳会按"实际生效 vs 配置"收敛，这里作为下发前窗口/服务端不可达时的兜底
+    let countryArg = "US";
     try {
-      const child = spawn(process.execPath, [daemonPath, "--country", "US"], {
-        stdio: ["ignore", "pipe", "pipe"],
-        detached: false,
-        windowsHide: true, // Windows 隐藏控制台窗口
-      });
+      const prev = getClashHealth()?.meta?.countryFilter;
+      if (Array.isArray(prev) && prev.length) countryArg = prev.join(",");
+    } catch {}
+    try {
+      const child = spawn(
+        process.execPath,
+        [daemonPath, "--country", countryArg],
+        {
+          stdio: ["ignore", "pipe", "pipe"],
+          detached: false,
+          windowsHide: true, // Windows 隐藏控制台窗口
+        },
+      );
 
       child.stdout?.on("data", (d) => {
         // daemon 日志通过 stderr 输出，stdout 静默

package/src/watchdog/llm-analyzer.js

@@ -15,18 +15,34 @@ export async function analyzeProcessLogs(processLogs, llmFetch) {
   const results = [];
   for (const proc of processLogs) {
     try {
-      console.error(`[llm-analyzer] 分析 ${proc.cmdId.substring(0, 40)}... (${proc.logs.length} 行日志)`);
+      console.error(
+        `[llm-analyzer] 分析 ${proc.cmdId.substring(0, 40)}... (${proc.logs.length} 行日志)`,
+      );
       const content = await llmFetch({
-        messages: [{ role: "user", content: buildPrompt(proc.cmdId, proc.logs.slice(-200).join("\n"), proc.uptimeSeconds, proc.restartCount) }],
+        messages: [
+          {
+            role: "user",
+            content: buildPrompt(
+              proc.cmdId,
+              proc.logs.slice(-200).join("\n"),
+              proc.uptimeSeconds,
+              proc.restartCount,
+            ),
+          },
+        ],
         max_tokens: 256,
         temperature: 0.1,
         enable_thinking: false,
       });
       const parsed = parseResponse(content);
-      console.error(`[llm-analyzer] ${proc.cmdId.substring(0, 30)} → ${parsed.severity}: ${parsed.summary}`);
+      console.error(
+        `[llm-analyzer] ${proc.cmdId.substring(0, 30)} → ${parsed.severity}: ${parsed.summary}`,
+      );
       results.push({ cmdId: proc.cmdId, ...parsed });
     } catch (e) {
-      console.error(`[llm-analyzer] ${proc.cmdId.substring(0, 30)} 失败: ${e.message}`);
+      console.error(
+        `[llm-analyzer] ${proc.cmdId.substring(0, 30)} 失败: ${e.message}`,
+      );
     }
   }
   return results;
@@ -39,21 +55,32 @@ async function createStandaloneFetch() {
     const { existsSync, readFileSync } = await import("fs");
     const { join } = await import("path");
     const { homedir } = await import("os");
-    const homeDir = homedir() || process.env.HOME || process.env.USERPROFILE || "";
+    const homeDir =
+      homedir() || process.env.HOME || process.env.USERPROFILE || "";
     let fileCfg = {};
     try {
       const cfgPath = join(homeDir, ".tt-help.json");
-      if (existsSync(cfgPath)) fileCfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
+      if (existsSync(cfgPath))
+        fileCfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
     } catch {}
-    const url = process.env.LLM_URL || fileCfg.llmUrl || "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions";
+    const url =
+      process.env.LLM_URL ||
+      fileCfg.llmUrl ||
+      "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions";
     const apiKey = process.env.LLM_API_KEY || fileCfg.llmApiKey || "";
     const model = process.env.LLM_MODEL || fileCfg.llmModel || "auto";
-    if (!apiKey) { console.error("[llm-analyzer] 未配置 LLM_API_KEY"); return null; }
+    if (!apiKey) {
+      console.error("[llm-analyzer] 未配置 LLM_API_KEY");
+      return null;
+    }
     console.error(`[llm-analyzer] 客户端模式: ${model} @ ${url}`);
     return async ({ messages, max_tokens = 256, temperature = 0.1 }) => {
       const resp = await fetch(url, {
         method: "POST",
-        headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+        },
         body: JSON.stringify({ model, messages, max_tokens, temperature }),
         signal: AbortSignal.timeout(30000),
       });
@@ -72,9 +99,17 @@ async function createStandaloneFetch() {
 // ── Prompt ──
 
 function buildPrompt(cmdId, logs, uptimeSeconds, restartCount) {
-  const uptime = uptimeSeconds >= 3600
-    ? Math.round(uptimeSeconds / 3600) + "h"
-    : uptimeSeconds + "s";
+  const uptime =
+    uptimeSeconds >= 3600
+      ? Math.round(uptimeSeconds / 3600) + "h"
+      : uptimeSeconds + "s";
+  const logText = logs || "(无日志)";
+  // 统计错误码 209002（TikTok 验证码/风控）出现次数，写入 prompt 避免 LLM 误判为故障
+  const captchaCount = logText.split("209002").length - 1;
+  const captchaNote =
+    captchaCount > 0
+      ? `\n背景: 日志中出现 ${captchaCount} 处错误码 209002（TikTok 验证码/风控，正常现象，程序会自动重试），判断时请忽略它们，不要当作 error，也不要在建议里写"账号被封禁/更换账号/更换IP"。`
+      : "";
   return `你是 TikTok 数据采集工具的运维助手。以下是进程 "${cmdId}" 的最近 10 分钟日志，请分析是否有异常。
 
 进程信息:
@@ -83,15 +118,16 @@ function buildPrompt(cmdId, logs, uptimeSeconds, restartCount) {
 - 历史重启: ${restartCount} 次
 
 最近日志:
-${logs || "(无日志)"}
+${logText}${captchaNote}
 
 请返回 JSON（仅 JSON，无其他内容）:
 {"severity":"ok"|"warn"|"error","summary":"一句话中文总结，不超过 50 字","suggestions":["建议1","建议2"]}
 
 判断标准:
 - ok: 无异常，正常运行
-- warn: 有偶发错误（验证码、403、超时 < 3次）或内存偏高
-- error: 严重错误（连续崩溃、登录失效、端口占用、大量 403）
+- warn: 有偶发错误（403、超时 < 3次）或内存偏高
+- error: 严重错误（连续崩溃、登录失效、端口占用、大量 403/超时）
+- 重要: 错误码 209002 = 验证码/风控，是正常限流，不是故障，不算 error；只有真正的登录失效/崩溃/端口占用才算 error
 - 每个 suggestions 是简洁可操作的建议，不超过 3 条`;
 }
 
@@ -100,15 +136,31 @@ ${logs || "(无日志)"}
 function parseResponse(content) {
   try {
     const parsed = JSON.parse(content);
-    return { severity: parsed.severity || "ok", summary: parsed.summary || "", suggestions: Array.isArray(parsed.suggestions) ? parsed.suggestions.slice(0, 3) : [] };
+    return {
+      severity: parsed.severity || "ok",
+      summary: parsed.summary || "",
+      suggestions: Array.isArray(parsed.suggestions)
+        ? parsed.suggestions.slice(0, 3)
+        : [],
+    };
   } catch {
     const match = content.match(/\{[\s\S]*\}/);
     if (match) {
       try {
         const parsed = JSON.parse(match[0]);
-        return { severity: parsed.severity || "ok", summary: parsed.summary || "", suggestions: Array.isArray(parsed.suggestions) ? parsed.suggestions.slice(0, 3) : [] };
+        return {
+          severity: parsed.severity || "ok",
+          summary: parsed.summary || "",
+          suggestions: Array.isArray(parsed.suggestions)
+            ? parsed.suggestions.slice(0, 3)
+            : [],
+        };
       } catch {}
     }
-    return { severity: "warn", summary: content.substring(0, 100), suggestions: [] };
+    return {
+      severity: "warn",
+      summary: content.substring(0, 100),
+      suggestions: [],
+    };
   }
 }

package/src/webserver/server.mjs

@@ -86,6 +86,9 @@ let scraperInitPromise = null;
 let restartPromise = null; // 防重入：同一时间只允许一个 restartScraper
 let consecutiveErrors = 0;
 const MAX_CONSECUTIVE_ERRORS = 10;
+// TikTok 明确返回的状态码中可重试的（验证码/风控 209002）；
+// 其余明确状态码（10202 被封、10221 不存在等）虽不可重试，同样属于业务结果而非 webserver 故障
+const TIKTOK_RETRYABLE_NORMAL_CODES = new Set([209002]);
 let warmTimer = null;
 let lastWarmTime = 0;
 let healthTimer = null; // 每 10 分钟健康心跳日志（始终输出，防假死检测误判重启）
@@ -252,15 +255,29 @@ async function handleTiktokUser(req, res) {
     });
   }
 
+  if (result.error && result.statusCode) {
+    // TikTok 明确返回的状态码（209002 验证码、10202 被封、10221 不存在等）：
+    // 属业务结果而非 webserver 故障，不计入连续错误、不触发 scraper 重启
+    const retryable = TIKTOK_RETRYABLE_NORMAL_CODES.has(result.statusCode);
+    apiLog(
+      `[webserver] user business | ${clientIP} | @${body.uniqueId} | ${elapsed}ms | statusCode=${result.statusCode}${retryable ? " (可重试)" : ""}`,
+    );
+    recordRequest(true);
+    return sendJSON(res, 503, {
+      error: `TikTok statusCode=${result.statusCode}`,
+      retryable,
+      tiktokStatusCode: result.statusCode,
+    });
+  }
   if (result.error) {
+    // 无明确状态码但 error（解析/结构异常）→ 才算 webserver 故障
     console.error(
-      `[webserver] user FAIL | ${clientIP} | @${body.uniqueId} | ${elapsed}ms | TikTok statusCode=${result.statusCode}`,
+      `[webserver] user FAIL | ${clientIP} | @${body.uniqueId} | ${elapsed}ms | parse error (无明确 statusCode)`,
     );
     recordRequest(false);
     return sendJSON(res, 502, {
-      error: `TikTok error (statusCode=${result.statusCode})`,
+      error: "TikTok error (无明确 statusCode)",
       retryable: false,
-      tiktokStatusCode: result.statusCode,
     });
   }