tt-help-cli-ycl 1.4.121 → 1.4.123

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tt-help-cli-ycl",
-  "version": "1.4.121",
+  "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/attach.js

@@ -163,8 +163,16 @@ export async function handleAttach(options) {
         ) {
           throw new CDNBlockedError(data.error);
         }
-        // 其余失败（瞬时 503/5xx）返回 null，由服务端后续重新排队
-        return null;
+        // 其余失败（504 超时 / 503 / 502 / 500 等）：抛出带状态码与错误详情的异常，
+        // 让外层日志显示真实原因（如 page.goto 超时）而非笼统"未获取到用户信息"。
+        // 行为不变：failCount++、不标记 needRefresh、服务端后续重新排队重试。
+        const detail =
+          (data && typeof data.error === "string" && data.error) ||
+          res.statusText ||
+          "unknown";
+        const err = new Error(`webserver ${res.status}: ${detail}`);
+        err.statusCode = res.status;
+        throw err;
       }
       // 业务结果：TikTok 明确 statusCode（209002 验证码等）→ 返回上层走"已记录"分支
       if (data && data.error && data.tiktokStatusCode) {

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

@@ -177,8 +177,16 @@ export async function handlePrecheck(options) {
           ) {
             throw new CDNBlockedError(data.error);
           }
-          // 其余失败（瞬时 503/5xx）返回 null，由服务端后续重新排队
-          return null;
+          // 其余失败（504 超时 / 503 / 502 / 500 等）：抛出带状态码与错误详情的异常，
+          // 让外层日志显示真实原因（如 page.goto 超时）而非笼统"未获取到用户信息"。
+          // 行为不变：failCount++、不标记 needRefresh、服务端后续重新排队重试。
+          const detail =
+            (data && typeof data.error === "string" && data.error) ||
+            res.statusText ||
+            "unknown";
+          const err = new Error(`webserver ${res.status}: ${detail}`);
+          err.statusCode = res.status;
+          throw err;
         }
         // 业务结果：TikTok 明确 statusCode（209002 验证码等）→ 返回上层走"已记录"分支
         if (data && data.error && data.tiktokStatusCode) {

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

@@ -3989,86 +3989,187 @@ async function wdSetCountries() {
 
 // ── 登录检测端口配置区域（看门狗面板中每个客户端卡片） ──
 
+// userId -> 详情展开状态（跨刷新保留）
+var _wdLoginExpanded = {};
+
+function wdToggleLoginDetail(userId) {
+  _wdLoginExpanded[userId] = !_wdLoginExpanded[userId];
+  var el = document.getElementById("wdLoginDetail-" + wdEscId(userId));
+  if (el) {
+    el.style.display = _wdLoginExpanded[userId] ? "grid" : "none";
+  }
+}
+
+var _wdLoginStatusLabel = {
+  logged_in: ["已登录", "#4ade80"],
+  expired: ["已过期", "#fbbf24"],
+  error: ["失败", "#f87171"],
+  logged_out: ["未登录", "#f87171"],
+};
+
+function wdLoginStatusLabel(s) {
+  return _wdLoginStatusLabel[s] || ["未登录", "#888"];
+}
+
 function renderLoginSection(c, userId, loginPorts) {
   if (!userId) return "";
   var cfgEntry = (loginPorts && loginPorts[userId]) || {};
   var configured =
     cfgEntry.ports && cfgEntry.ports.length ? cfgEntry.ports : [];
   var report = c.loginReport || null;
-  var reportHtml;
+
+  // 配置按钮：只显示端口数量，完整列表放 title
+  var cfgBtn = tag(
+    "button",
+    {
+      onclick: "wdShowLoginPortsModal('" + esc(userId) + "')",
+      style:
+        "padding:2px 8px;font-size:11px;background:#333;color:#4ade80;" +
+        "border:1px solid #444;border-radius:3px;cursor:pointer",
+      title:
+        "配置要定期检测登录状态的 CDP 端口（逗号分隔，留空清空）\n当前: " +
+        (configured.length ? configured.join(",") : "无"),
+    },
+    (configured.length ? configured.length + "端口" : "未配置") + " ⚙️",
+  );
+
+  var head =
+    styled("span", "font-size:14px", "🔑") +
+    styled("span", "color:#888", "登录检测:") +
+    cfgBtn;
+
+  var wrapStyle =
+    "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) {
-    reportHtml = styled(
-      "span",
-      "color:#555;margin-left:auto",
-      configured.length ? "等待客户端上报..." : "",
+    return styled(
+      "div",
+      wrapStyle,
+      head + styled("span", "color:#555;margin-left:auto", "等待客户端上报..."),
     );
-  } else if (report.error) {
-    var et = report.checkedAt
-      ? new Date(report.checkedAt).toLocaleTimeString("zh-CN")
-      : "?";
-    reportHtml =
-      styled("span", "color:#888;margin-left:auto", "最近检测(" + et + "): ") +
-      styled("span", "color:#f87171", "失败");
-  } else if (report.ports && report.ports.length) {
-    var et2 = report.checkedAt
-      ? new Date(report.checkedAt).toLocaleTimeString("zh-CN")
-      : "?";
-    var badges = report.ports
-      .map(function (r) {
-        var color =
-          r.status === "logged_in"
-            ? "#4ade80"
-            : r.status === "expired"
-              ? "#fbbf24"
-              : r.status === "error"
-                ? "#f87171"
-                : "#888";
-        var label =
-          r.status === "logged_in"
-            ? "已登录"
-            : r.status === "expired"
-              ? "已过期"
-              : r.status === "error"
-                ? "失败"
-                : "未登录";
-        var txt =
-          r.port +
-          " " +
-          label +
-          (r.status === "logged_in" && r.account ? " @" + r.account : "");
-        return styled(
+  }
+
+  var et = report.checkedAt
+    ? new Date(report.checkedAt).toLocaleTimeString("zh-CN", {
+        hour: "2-digit",
+        minute: "2-digit",
+      })
+    : "?";
+
+  if (report.error) {
+    return styled(
+      "div",
+      wrapStyle,
+      head +
+        styled(
           "span",
-          "color:" +
-            color +
-            ";background:#0d1117;border:1px solid #333;padding:1px 6px;border-radius:4px",
-          txt,
-        );
+          "color:#f87171;margin-left:auto",
+          "最近检测(" + et + ") 失败",
+        ),
+    );
+  }
+
+  var ports = Array.isArray(report.ports) ? report.ports : [];
+  if (!ports.length) {
+    return styled(
+      "div",
+      wrapStyle,
+      head + styled("span", "color:#555;margin-left:auto", "无结果"),
+    );
+  }
+
+  // 汇总统计 + 异常端口内联提示
+  var ok = 0;
+  var abnormal = [];
+  var hasError = false;
+  for (var i = 0; i < ports.length; i++) {
+    var r = ports[i];
+    if (r.status === "logged_in") {
+      ok++;
+    } else {
+      var lb = wdLoginStatusLabel(r.status);
+      abnormal.push({ port: r.port, label: lb[0] });
+      if (r.status === "error" || r.status === "logged_out") hasError = true;
+    }
+  }
+  var sumColor = abnormal.length
+    ? hasError
+      ? "#f87171"
+      : "#fbbf24"
+    : "#4ade80";
+  var summaryTxt =
+    ok + "/" + ports.length + " 已登录" + (abnormal.length ? "" : " ✓");
+  if (abnormal.length) {
+    var shown = abnormal
+      .slice(0, 3)
+      .map(function (a) {
+        return a.port + " " + a.label;
       })
-      .join(" ");
-    reportHtml =
-      styled("span", "color:#888;margin-left:auto", "最近检测(" + et2 + "): ") +
-      badges;
-  } else {
-    reportHtml = styled("span", "color:#555;margin-left:auto", "无结果");
+      .join(", ");
+    summaryTxt +=
+      " ⚠ " + shown + (abnormal.length > 3 ? " +" + (abnormal.length - 3) : "");
   }
+
+  // 明细（默认折叠，点汇总展开/收起）
+  var detailHtml = "";
+  for (var j = 0; j < ports.length; j++) {
+    var r2 = ports[j];
+    var lb2 = wdLoginStatusLabel(r2.status);
+    detailHtml += styled(
+      "div",
+      "display:flex;gap:6px;align-items:center;font-size:11px",
+      styled("span", "color:#888;min-width:42px", r2.port) +
+        styled("span", "color:" + lb2[1], lb2[0]) +
+        (r2.status === "logged_in" && r2.account
+          ? styled("span", "color:#4ade80", "@" + r2.account)
+          : ""),
+    );
+  }
+
   return styled(
     "div",
-    "margin-top:6px;padding:6px 8px;background:#111;border-radius:6px;" +
-      "display:flex;align-items:center;gap:8px;font-size:12px;flex-wrap:wrap",
-    styled("span", "font-size:14px", "🔑") +
-      styled("span", "color:#888", "登录检测:") +
+    "margin-top:6px;padding:6px 8px;background:#111;border-radius:6px;font-size:12px",
+    styled(
+      "div",
+      "display:flex;align-items:center;gap:8px;flex-wrap:wrap",
+      head +
+        tag(
+          "span",
+          {
+            style:
+              "color:" +
+              sumColor +
+              ";margin-left:auto;cursor:pointer;text-decoration:underline dotted",
+            onclick: "wdToggleLoginDetail('" + esc(userId) + "')",
+            title: "点击展开/收起各端口明细",
+          },
+          summaryTxt,
+        ) +
+        styled("span", "color:#555", "最近 " + et),
+    ) +
       tag(
-        "button",
+        "div",
         {
-          onclick: "wdShowLoginPortsModal('" + esc(userId) + "')",
+          id: "wdLoginDetail-" + wdEscId(userId),
           style:
-            "padding:2px 8px;font-size:11px;background:#333;color:#4ade80;" +
-            "border:1px solid #444;border-radius:3px;cursor:pointer",
-          title: "配置要定期检测登录状态的 CDP 端口（逗号分隔，留空清空）",
+            "display:" +
+            (_wdLoginExpanded[userId] ? "grid" : "none") +
+            ";grid-template-columns:repeat(auto-fill,minmax(170px,1fr));" +
+            "gap:3px 16px;margin-top:6px;padding-top:6px;border-top:1px dashed #2a2a3a",
         },
-        (configured.length ? configured.join(",") : "未配置") + " ⚙️",
-      ) +
-      reportHtml,
+        detailHtml,
+      ),
   );
 }
 

package/src/watch/public/index.html

@@ -686,7 +686,7 @@
     </div>
   </div>
 
-  <script src="app.js?v=20260816b"></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 };
         }
       }