tt-help-cli-ycl 1.4.122 → 1.4.123

package/package.json

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

package/src/clash/daemon.js

@@ -20,6 +20,9 @@ function fmtCountries(v) {
   return list.length ? list.join(",") : "无";
 }
 
+// failover 切换冷却期（默认 45s，可经 opts.failoverCooldownMs 覆盖）
+const FAILOVER_COOLDOWN_MS = 45_000;
+
 // ══════════════════════════════════════════════
 // ClashDaemon
 // ══════════════════════════════════════════════
@@ -28,6 +31,10 @@ export class ClashDaemon {
   constructor(opts = {}) {
     this.intervalMs = (opts.intervalSec || 120) * 1000;
     this.benchmarkMs = (opts.benchmarkMin || 10) * 60 * 1000; // 候选集刷新默认 10 分钟
+    this.failoverCooldownMs =
+      opts.failoverCooldownMs > 0
+        ? opts.failoverCooldownMs
+        : FAILOVER_COOLDOWN_MS;
     this.dryRun = !!opts.dryRun;
     // 控制端发现参数（CLI 显式值优先，内部再合并 ~/.tt-help.json）
     this._discoverOpts = {
@@ -508,6 +515,28 @@ export class ClashDaemon {
    */
   async _handleFailover(cmd, c) {
     try {
+      // ── failover 冷却 + 健康验证（2026-08-18）──
+      // 冷却期内再次收到 failover：先验证当前节点健康，健康则跳过并续冷却
+      // （持续健康 → 持续不切，避免冷却期结束后又白切健康节点；同时过滤滞后/重连误报），
+      // 不健康才继续切换。按控制端独立记录冷却（多控制端互不影响）；
+      // 对外接口（命令动作 / IPC / health 格式）保持不变。
+      const now = Date.now();
+      const lastAt = c._lastFailoverAt || 0;
+      if (lastAt > 0 && now - lastAt < this.failoverCooldownMs) {
+        const h = checker.checkNodeHealth();
+        if (h && h.healthy) {
+          c._lastFailoverAt = now; // 续冷却：持续健康则持续不切
+          this._log(
+            `🔄 冷却期内节点健康 [${c.proxyPort}]，跳过重复 failover（上次判定 ${Math.round((now - lastAt) / 1000)}s 前）`,
+          );
+          return;
+        }
+        this._log(
+          `🔄 冷却期内节点不健康 [${c.proxyPort}]，继续故障切换（有依据才切）`,
+        );
+      }
+      c._lastFailoverAt = now;
+
       const reason = (cmd && cmd.reason) || "看门狗主动故障切换";
       const node = await api
         .getCurrentNode(checker.CONFIG.groupName)

package/src/clash/proxy-switch.js

@@ -0,0 +1,65 @@
+/**
+ * 代理切换（failover）共享工具 — explore / refresh 使用
+ *
+ * 通过 clash/ipc.js 的文件 IPC 黑盒接口与 clash-daemon 通信：
+ *   writeCommand({action:"failover", ...}, proxyPort) → daemon 切换 Clash 出口节点
+ *   浏览器仍走同一个 Clash 端口（--proxy），节点切换对浏览器透明，无需重启浏览器。
+ *
+ * 简单策略：遇到 CDN 限流 / 被封 → 发切换命令 + 固定等待生效，不轮询回执。
+ */
+import { readHealth, writeCommand } from "./ipc.js";
+
+const DEFAULT_SWITCH_WAIT_MS = 30_000; // 触发后等待节点切换生效
+
+/** 从代理 URL 解析端口（http://127.0.0.1:7890 → 7890），无法解析返回 0（默认通道） */
+export function proxyPortOf(url) {
+  if (!url) return 0;
+  try {
+    const u = new URL(url);
+    const p = parseInt(u.port, 10);
+    return p > 0 ? p : 0;
+  } catch {
+    const m = String(url).match(/:(\d+)/);
+    return m ? parseInt(m[1], 10) : 0;
+  }
+}
+
+/** 用 daemon 的 IPC 健康状态判断其是否存活（黑盒接口：clash-health.json，按通道端口） */
+export function isDaemonAlive(port = 0) {
+  const h = readHealth(port);
+  return !!(h && !h.stale);
+}
+
+/**
+ * 触发代理切换：向 daemon 发 failover 命令，等待节点切换生效后返回。
+ * - 未配置代理（port=0）→ 跳过并提示，返回 false
+ * - daemon 未运行 → 打印提示（writeCommand 无害，无人读取），仍按 waitMs 等待返回
+ * @param {string} reason 切换原因
+ * @param {number} [proxyPort] 代理通道端口（0=默认通道）
+ * @param {number} [waitMs] 等待毫秒数，默认 30000
+ * @returns {boolean} 是否发起了切换（有代理端口）
+ */
+export async function triggerProxySwitch(
+  reason,
+  proxyPort = 0,
+  waitMs = DEFAULT_SWITCH_WAIT_MS,
+) {
+  if (!proxyPort) {
+    console.error(`  [代理] 未配置代理，跳过切换（${reason}）`);
+    return false;
+  }
+  if (!isDaemonAlive(proxyPort)) {
+    console.error(
+      `  [代理] clash-daemon 未运行（通道 ${proxyPort}），切换命令可能无人处理（${reason}）`,
+    );
+  }
+  console.error(
+    `  [代理] 触发切换（${reason}，通道 ${proxyPort}），等待 ${Math.round(waitMs / 1000)}s 生效...`,
+  );
+  writeCommand(
+    { action: "failover", reason: `proxy-switch: ${reason}`, proxyPort },
+    proxyPort,
+  );
+  await new Promise((r) => setTimeout(r, waitMs));
+  return true;
+}

package/src/cli/explore.js

@@ -27,6 +27,7 @@ import { showResourceUsage } from "../utils/index.js";
 import { HealthChecker } from "../lib/browser/health-checker.js";
 import { createApiClient } from "../lib/api-client.js";
 import { createCDNHandler } from "../lib/cdn-handler.js";
+import { proxyPortOf, triggerProxySwitch } from "../clash/proxy-switch.js";
 import path from "path";
 import os from "os";
 
@@ -144,6 +145,7 @@ export async function handleExplore(options) {
     // 未配置则不注入 proxyServer，浏览器走系统默认代理。
     // 本地地址不再自动解析/强制 requireClashOrExit（与 refresh-mini 一致）。
     const resolvedProxy = exploreProxy || configuredProxy || null;
+    const proxyPort = proxyPortOf(resolvedProxy);
     if (resolvedProxy) {
       cdpOptions.proxyServer = resolvedProxy;
       console.error(
@@ -517,6 +519,8 @@ export async function handleExplore(options) {
         if (result.cdnBlocked) {
           consecutiveNetworkErrors++;
           errorCount++;
+          // 遇到 CDN 即触发代理切换（等待 30s 生效），原退避/切账户逻辑保留
+          await triggerProxySwitch(`CDN限流 @${username}`, proxyPort);
           await cdn.handle(result, username);
           continue;
         }
@@ -576,6 +580,8 @@ export async function handleExplore(options) {
             if (errorType === "被封") {
               blockedCount++;
               console.error(`  [被封] 累计 ${blockedCount} 次`);
+              // 触发代理切换（api-interceptor 已内置 30/40/50s 重试，到这里仍封直接切代理）
+              await triggerProxySwitch(`账号被封 @${username}`, proxyPort);
               if (blockedCount >= 3) {
                 await handleAccountSwitch(`账号被封累计 ${blockedCount} 次`);
                 blockedCount = 0;

package/src/cli/refresh.js

@@ -26,6 +26,7 @@ import {
 import { HealthChecker } from "../lib/browser/health-checker.js";
 import { createApiClient } from "../lib/api-client.js";
 import { createCDNHandler } from "../lib/cdn-handler.js";
+import { proxyPortOf, triggerProxySwitch } from "../clash/proxy-switch.js";
 import path from "path";
 import os from "os";
 
@@ -80,6 +81,7 @@ export async function handleRefresh(options) {
   // 未配置则不注入 proxyServer，浏览器走系统默认代理。
   const effectiveProxy = exploreProxy || configuredProxy;
   const resolvedProxy = effectiveProxy || null;
+  const proxyPort = proxyPortOf(resolvedProxy);
 
   let userId = exploreUserId || configuredUserId;
   let browser = null;
@@ -546,6 +548,8 @@ export async function handleRefresh(options) {
       if (result.cdnBlocked) {
         consecutiveNetworkErrors++;
         errorCount++;
+        // 遇到 CDN 即触发代理切换（等待 30s 生效），原退避/切账户逻辑保留
+        await triggerProxySwitch(`CDN限流 @${username}`, proxyPort);
         await cdn.handle(result, username);
         continue;
       }
@@ -605,6 +609,8 @@ export async function handleRefresh(options) {
           if (errorType === "被封") {
             blockedCount++;
             console.error(`  [被封] 累计 ${blockedCount} 次`);
+            // 触发代理切换（api-interceptor 已内置 30/40/50s 重试，到这里仍封直接切代理）
+            await triggerProxySwitch(`账号被封 @${username}`, proxyPort);
             if (blockedCount >= 3) {
               await handleAccountSwitch(`账号被封累计 ${blockedCount} 次`);
               blockedCount = 0;

package/src/cli/tag.js

@@ -1089,21 +1089,47 @@ export async function handleScoreAll(parsed) {
   log(`  客户端 ID: ${clientId.substring(0, 8)}...`);
   log("");
 
-  // Ctrl+C 时关闭浏览器和 scraper
-  const cleanup = () => {
+  // Ctrl+C / SIGTERM 时关闭浏览器和 scraper
+  // 注意：process.exit 必须放在异步清理（killEdgeProcesses）完成之后，
+  // 否则 exec 杀浏览器的命令来不及执行，Edge 窗口会残留
+  let cleaningUp = false;
+  let signalCount = 0;
+  const cleanup = async ({ noExit = false } = {}) => {
+    if (cleaningUp) return;
+    cleaningUp = true;
     log("\n正在清理资源...");
-    if (enrichScraper) enrichScraper.close().catch(() => {});
-    killEdgeProcesses(null, cdpPort);
-    process.exit(0);
+    if (enrichScraper) await enrichScraper.close().catch(() => {});
+    log("正在关闭 CDP 浏览器...");
+    try {
+      await Promise.race([
+        killEdgeProcesses(null, cdpPort),
+        new Promise((r) => setTimeout(r, 5000)),
+      ]);
+      log("浏览器已关闭");
+    } catch (e) {
+      log(`关闭浏览器失败: ${e.message}`);
+    }
+    if (!noExit) process.exit(0);
+  };
+  const onSignal = (signal) => {
+    signalCount++;
+    if (signalCount > 1) {
+      // 第二次信号：清理可能卡住，强制退出
+      log(`\n再次收到 ${signal}，强制退出`);
+      process.exit(signal === "SIGTERM" ? 143 : 130);
+    }
+    log(`\n收到 ${signal}，正在清理资源...`);
+    cleanup().catch(() => process.exit(1));
   };
-  process.on("SIGINT", cleanup);
+  process.on("SIGINT", () => onSignal("SIGINT"));
+  process.on("SIGTERM", () => onSignal("SIGTERM"));
 
   try {
     while (true) {
       // 检测浏览器窗口是否被手动关闭（CDP 断开）→ 自动退出
       if (isBrowserDisconnected(browser)) {
         log("🚪 检测到浏览器窗口已关闭，score-all 自动退出");
-        cleanup();
+        await cleanup();
         return;
       }
       try {
@@ -1327,7 +1353,7 @@ export async function handleScoreAll(parsed) {
         // 浏览器窗口被手动关闭（CDP 断开）→ 自动退出，避免无限重试循环
         if (isBrowserDisconnected(browser, e)) {
           log(`🚪 浏览器窗口已关闭 (${e?.message || ""})，score-all 自动退出`);
-          cleanup();
+          await cleanup();
           return;
         }
         // 区分网络错误和业务错误
@@ -1445,15 +1471,9 @@ export async function handleScoreAll(parsed) {
       }
     }
   } finally {
-    if (enrichScraper) await enrichScraper.close();
-    log("✅ TikTokScraper 已关闭");
-    log("正在关闭 CDP 浏览器...");
-    try {
-      killEdgeProcesses(null, cdpPort);
-      log("浏览器已关闭");
-    } catch (e) {
-      log(`关闭浏览器失败: ${e.message}`);
-    }
+    // 正常路径退出（无信号）：清理资源但不强制 process.exit，
+    // 让事件循环自然结束；信号路径已在 cleanup 内 exit
+    await cleanup({ noExit: true });
   }
 }
 
@@ -1787,20 +1807,44 @@ export async function handleTagRefresh(parsed) {
   log(`  客户端 ID: ${clientId.substring(0, 8)}...`);
   log("");
 
-  const cleanup = () => {
+  let cleaningUp = false;
+  let signalCount = 0;
+  const cleanup = async ({ noExit = false } = {}) => {
+    if (cleaningUp) return;
+    cleaningUp = true;
     log("\n正在清理资源...");
-    if (enrichScraper) enrichScraper.close().catch(() => {});
-    killEdgeProcesses(null, cdpPort);
-    process.exit(0);
+    if (enrichScraper) await enrichScraper.close().catch(() => {});
+    log("正在关闭 CDP 浏览器...");
+    try {
+      await Promise.race([
+        killEdgeProcesses(null, cdpPort),
+        new Promise((r) => setTimeout(r, 5000)),
+      ]);
+      log("浏览器已关闭");
+    } catch (e) {
+      log(`关闭浏览器失败: ${e.message}`);
+    }
+    if (!noExit) process.exit(0);
+  };
+  const onSignal = (signal) => {
+    signalCount++;
+    if (signalCount > 1) {
+      // 第二次信号：清理可能卡住，强制退出
+      log(`\n再次收到 ${signal}，强制退出`);
+      process.exit(signal === "SIGTERM" ? 143 : 130);
+    }
+    log(`\n收到 ${signal}，正在清理资源...`);
+    cleanup().catch(() => process.exit(1));
   };
-  process.on("SIGINT", cleanup);
+  process.on("SIGINT", () => onSignal("SIGINT"));
+  process.on("SIGTERM", () => onSignal("SIGTERM"));
 
   try {
     while (true) {
       // 检测浏览器窗口是否被手动关闭（CDP 断开）→ 自动退出
       if (isBrowserDisconnected(browser)) {
         log("🚪 检测到浏览器窗口已关闭，refresh 自动退出");
-        cleanup();
+        await cleanup();
         return;
       }
       try {
@@ -2026,7 +2070,7 @@ export async function handleTagRefresh(parsed) {
         // 浏览器窗口被手动关闭（CDP 断开）→ 自动退出，避免无限重试循环
         if (isBrowserDisconnected(browser, e)) {
           log(`🚪 浏览器窗口已关闭 (${e?.message || ""})，refresh 自动退出`);
-          cleanup();
+          await cleanup();
           return;
         }
         const isNetworkError =
@@ -2048,6 +2092,7 @@ export async function handleTagRefresh(parsed) {
       }
     }
   } finally {
-    cleanup();
+    // 正常路径退出（无信号）：清理资源但不强制 process.exit
+    await cleanup({ noExit: true });
   }
 }

package/src/watch/public/app.js

@@ -4042,16 +4042,21 @@ function renderLoginSection(c, userId, loginPorts) {
     "margin-top:6px;padding:6px 8px;background:#111;border-radius:6px;" +
     "display:flex;align-items:center;gap:8px;font-size:12px;flex-wrap:wrap";
 
+  // 未配置端口 → 只显示配置按钮，不展示任何历史/上报的检测状态。
+  // 否则会与"未配置"并存显示删除配置前的旧结果，误导用户。
+  if (!configured.length) {
+    return styled(
+      "div",
+      wrapStyle,
+      head + styled("span", "color:#555;margin-left:auto", ""),
+    );
+  }
+
   if (!report) {
     return styled(
       "div",
       wrapStyle,
-      head +
-        styled(
-          "span",
-          "color:#555;margin-left:auto",
-          configured.length ? "等待客户端上报..." : "",
-        ),
+      head + styled("span", "color:#555;margin-left:auto", "等待客户端上报..."),
     );
   }
 

package/src/watch/public/index.html

@@ -686,7 +686,7 @@
     </div>
   </div>
 
-  <script src="app.js?v=20260817"></script>
+  <script src="app.js?v=20260818"></script>
 </body>
 
 </html>

package/src/watchdog/agent.js

@@ -352,6 +352,7 @@ export class WatchdogAgent {
     if (!this.running || !this._errorTriggerEnabled) return;
     const now = Date.now();
     const scanned = this.processManager.scanErrorLogs(NETWORK_ERROR_RE);
+    let failoverTriggered = false; // 本轮是否已触发全局切换
     for (const { cmdId, cmdDef, newErrors } of scanned) {
       if (!isCollectorCommand(cmdDef)) continue;
       let st = this._errorStates.get(cmdId) || {
@@ -359,6 +360,10 @@ export class WatchdogAgent {
         firstErrorAt: 0,
         lastErrorAt: 0,
       };
+      if (failoverTriggered) {
+        // 本轮已有进程触发全局切换 → 该进程也从新计数开始（防同轮接力触发）
+        st = { consecutive: 0, firstErrorAt: 0, lastErrorAt: 0 };
+      }
       const hadNew = newErrors.length > 0;
       for (const line of newErrors) {
         // 错误间隔超阈值 → 连续中断，重新计数
@@ -381,7 +386,11 @@ export class WatchdogAgent {
             `[watchdog] ${cmdId} 连续 ${st.consecutive} 次错误（≥${this._errorTriggerCount}次，持续≥${this._errorTriggerMinMs / 60000}min），触发节点切换`,
           );
           this._triggerFailover(cmdId);
-          // 切换后重新计数
+          // 切换是全局的（所有子进程共用节点）：清空全部错误计数，
+          // 让新节点有干净的观察窗口，旧节点错误不再驱动后续切换；
+          // 触发者自身也重新计数（含本轮后续错误行，从 0 累计）。
+          this._errorStates.clear();
+          failoverTriggered = true;
           st = { consecutive: 0, firstErrorAt: 0, lastErrorAt: 0 };
         }
       }