tt-help-cli-ycl 1.4.122 → 1.4.124

package/package.json

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

@@ -165,10 +165,12 @@ function getBrowserMemory(port = null) {
             `}; ` +
             `Write-Output $sum`;
         } else {
+          // 无端口场景：Get-Process（.NET API，不依赖 WMI）统计全部 msedge 工作集，
+          // 与原 Get-CimInstance 全量求和行为等价；WMI 损坏/禁用的机器也能返回
           ps1Content =
-            `$procs = Get-CimInstance Win32_Process -Filter "Name LIKE 'msedge%'" -ErrorAction SilentlyContinue; ` +
+            `$procs = Get-Process msedge -ErrorAction SilentlyContinue; ` +
             `$sum = 0; ` +
-            `foreach ($p in $procs) { $sum += $p.WorkingSetSize }; ` +
+            `foreach ($p in $procs) { $sum += $p.WorkingSet64 }; ` +
             `Write-Output $sum`;
         }
         writeFileSync(ps1Path, ps1Content);

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

@@ -109,10 +109,12 @@ function getBrowserMemory(port = null) {
             `}; ` +
             `Write-Output $sum`;
         } else {
+          // 无端口场景：Get-Process（.NET API，不依赖 WMI）统计全部 msedge 工作集，
+          // 与原 Get-CimInstance 全量求和行为等价；WMI 损坏/禁用的机器也能返回
           ps1Content =
-            `$procs = Get-CimInstance Win32_Process -Filter "Name LIKE 'msedge%'" -ErrorAction SilentlyContinue; ` +
+            `$procs = Get-Process msedge -ErrorAction SilentlyContinue; ` +
             `$sum = 0; ` +
-            `foreach ($p in $procs) { $sum += $p.WorkingSetSize }; ` +
+            `foreach ($p in $procs) { $sum += $p.WorkingSet64 }; ` +
             `Write-Output $sum`;
         }
         writeFileSync(ps1Path, ps1Content);
@@ -1089,21 +1091,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 +1355,7 @@ export async function handleScoreAll(parsed) {
         // 浏览器窗口被手动关闭（CDP 断开）→ 自动退出，避免无限重试循环
         if (isBrowserDisconnected(browser, e)) {
           log(`🚪 浏览器窗口已关闭 (${e?.message || ""})，score-all 自动退出`);
-          cleanup();
+          await cleanup();
           return;
         }
         // 区分网络错误和业务错误
@@ -1445,15 +1473,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 +1809,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 +2072,7 @@ export async function handleTagRefresh(parsed) {
         // 浏览器窗口被手动关闭（CDP 断开）→ 自动退出，避免无限重试循环
         if (isBrowserDisconnected(browser, e)) {
           log(`🚪 浏览器窗口已关闭 (${e?.message || ""})，refresh 自动退出`);
-          cleanup();
+          await cleanup();
           return;
         }
         const isNetworkError =
@@ -2048,6 +2094,7 @@ export async function handleTagRefresh(parsed) {
       }
     }
   } finally {
-    cleanup();
+    // 正常路径退出（无信号）：清理资源但不强制 process.exit
+    await cleanup({ noExit: true });
   }
 }

package/src/lib/api-interceptor.js

@@ -260,11 +260,23 @@ async function fetchUserVideosAPI(
 ) {
   log(`  [API拦截] 获取 @${username} 视频 ...`);
 
-  // CDP 健康检查：带超时保护。页面主线程死锁时 evaluate 可能长时间无响应，
-  // 超时后自动刷新页面恢复（实测刷新页面即可解除死锁）
+  const {
+    blockedRetryWaitsMs = DEFAULT_BLOCKED_RETRY_WAITS,
+    cdpProbeTimeoutMs = 10000, // 单次探活超时
+    cdpObserveWaitMs = 20000, // 观察等待间隔（页面转圈加载期）
+    cdpObserveRounds = 2, // 观察轮数
+    cdpReloadSettleMs = 5000, // 刷新后缓冲等待，让加载高峰过去
+    cdpReloadProbeTimeoutMs = 20000, // 刷新后重检窗口
+  } = options;
+
+  // CDP 健康检查：带超时保护，区分"页面忙"与"页面死"。
+  // evaluate 排队在页面主线程上，加载中的慢页面（肉眼可见转圈）10s 轮不到执行很正常，
+  // 此时是忙不是死：先观察等待（默认 2 轮 x 20s），慢页面通常在此期间自然加载完自愈。
+  // 观察后仍无响应才刷新页面（实测刷新可解除主线程死锁）；刷新后页面处于最忙的加载期，
+  // 先缓冲等待再以更宽松的窗口重检，避免误杀正在恢复的页面。
   const evalWithTimeout = (label, ms) =>
     Promise.race([
-      page.evaluate(() => 1),
+      page.evaluate(() => document.readyState),
       new Promise((_, reject) =>
         setTimeout(
           () => reject(new Error(`${label} 超时（${ms / 1000}s）`)),
@@ -273,23 +285,50 @@ async function fetchUserVideosAPI(
       ),
     ]);
 
+  let healthy = false;
   try {
-    await evalWithTimeout("CDP 健康检查", 10000);
+    const state = await evalWithTimeout("CDP 健康检查", cdpProbeTimeoutMs);
+    healthy = true;
+    if (state !== "complete") {
+      log(`  [API拦截] 健康检查通过，页面加载中 (readyState=${state})`);
+    }
   } catch (e) {
-    log(`  [API拦截] CDP 连接异常: ${e.message}，刷新页面恢复...`);
+    // 观察阶段：慢页面几十秒内通常自愈，期间不做任何操作
+    log(
+      `  [API拦截] CDP 探活超时: ${e.message}，页面可能仍在加载，观察等待...`,
+    );
+    for (let round = 1; round <= cdpObserveRounds && !healthy; round++) {
+      await new Promise((r) => setTimeout(r, cdpObserveWaitMs));
+      try {
+        await evalWithTimeout(
+          `观察重检 ${round}/${cdpObserveRounds}`,
+          cdpProbeTimeoutMs,
+        );
+        healthy = true;
+        log(`  [API拦截] 页面已恢复（观察 ${round} 轮后）`);
+      } catch (e2) {
+        log(
+          `  [API拦截] 观察 ${round}/${cdpObserveRounds} 后仍无响应: ${e2.message}`,
+        );
+      }
+    }
+  }
+
+  if (!healthy) {
+    log(`  [API拦截] 观察后仍无响应，刷新页面恢复...`);
     await page
       .reload({ waitUntil: "domcontentloaded", timeout: 30000 })
       .catch(() => {});
+    await new Promise((r) => setTimeout(r, cdpReloadSettleMs));
     try {
-      await evalWithTimeout("刷新后重检", 10000);
-      log(`  [API拦截] 页面已恢复`);
+      await evalWithTimeout("刷新后重检", cdpReloadProbeTimeoutMs);
+      log(`  [API拦截] 页面已恢复（刷新后）`);
     } catch (e2) {
       throw new Error(`CDP 连接异常（刷新后仍失败）: ${e2.message}`);
     }
   }
 
   let apiRequestUrlRef = { value: null };
-  const { blockedRetryWaitsMs = DEFAULT_BLOCKED_RETRY_WAITS } = options;
   const retryWaits = Array.isArray(blockedRetryWaitsMs)
     ? blockedRetryWaitsMs
     : DEFAULT_BLOCKED_RETRY_WAITS;

package/src/lib/browser/cdp.js

@@ -70,6 +70,25 @@ function checkEdgeArgs() {
   });
 }
 
+/**
+ * 解析 netstat -ano 输出，返回监听指定端口的 PID 列表（去重）。
+ * 不依赖 WMI，适配 WMI 损坏/禁用的 Windows 机器。
+ * @param {string} netstatOutput
+ * @param {number} port
+ * @returns {string[]}
+ */
+export function parseNetstatListeningPids(netstatOutput, port) {
+  const pids = [];
+  for (const line of netstatOutput.split(/\r?\n/)) {
+    // LISTENING 状态 + 精确端口匹配（端口后必须跟空白，避免 8222 误匹配 18222）
+    if (!line.includes("LISTENING") || !line.includes(`:${port} `)) continue;
+    const parts = line.trim().split(/\s+/);
+    const pid = parts[parts.length - 1];
+    if (/^\d+$/.test(pid) && !pids.includes(pid)) pids.push(pid);
+  }
+  return pids;
+}
+
 function killEdgeProcesses(targetDir, port) {
   return new Promise((resolve) => {
     const platform = os.platform();
@@ -120,39 +139,31 @@ function killEdgeProcesses(targetDir, port) {
       }
     } else if (platform === "win32") {
       if (port) {
-        // 用端口匹配（纯数字，无编码问题），而不是 userDataDir 路径（中文路径会乱码）
+        // 不依赖 WMI：Get-CimInstance 在 WMI 损坏/禁用的机器上查不到进程（KILLED_PIDS 为空）。
+        // 改为 netstat 按监听端口找 PID（CDP 端口由浏览器主进程监听），taskkill /F /T 杀进程树
+        let killCmds = "";
         try {
-          const ps1Path = path.join(os.tmpdir(), `kill-edge-${Date.now()}.ps1`);
-          const ps1Content =
-            `$procs = Get-CimInstance Win32_Process -Filter "Name='msedge.exe'" 2>$null; ` +
-            `$count = 0; ` +
-            `$pids = @(); ` +
-            `foreach ($p in $procs) { ` +
-            `  if ($p.CommandLine -and $p.CommandLine -like "*--remote-debugging-port=${port}*") { ` +
-            `    $pids += $p.ProcessId; ` +
-            `    Stop-Process -Id $p.ProcessId -Force -ErrorAction SilentlyContinue; ` +
-            `    $count++ ` +
-            `  } ` +
-            `}; ` +
-            `Write-Output "KILLED_PIDS: $($pids -join ',')"; ` +
-            `Start-Sleep -Milliseconds 500; ` +
-            `Get-ChildItem "$env:LOCALAPPDATA\\Microsoft\\Edge\\Singleton*" -ErrorAction SilentlyContinue | Remove-Item -Force; ` +
-            `Write-Output $count`;
-          fs.writeFileSync(ps1Path, ps1Content);
-          const result = execSync(
-            `powershell.exe -ExecutionPolicy Bypass -File "${ps1Path}"`,
-          )
-            .toString()
-            .trim();
-          console.error(`[killEdgeProcesses] Windows PS result: ${result}`);
-          try {
-            fs.unlinkSync(ps1Path);
-          } catch {}
-          command = "exit 0";
+          const netstatOut = execSync("netstat -ano", {
+            encoding: "utf-8",
+            timeout: 5000,
+            windowsHide: true,
+          });
+          const pids = parseNetstatListeningPids(netstatOut, port);
+          if (pids.length > 0) {
+            killCmds = pids
+              .map((pid) => `taskkill /F /T /PID ${pid} 2>nul`)
+              .join(" & ");
+            console.error(
+              `[killEdgeProcesses] 端口 ${port} 监听进程 PID: ${pids.join(", ")}`,
+            );
+          }
         } catch (e) {
-          console.error(`[killEdgeProcesses] Windows PS failed: ${e.message}`);
-          command = "taskkill /F /IM msedge.exe 2>nul || exit 0";
+          console.error(`[killEdgeProcesses] netstat 查询失败: ${e.message}`);
         }
+        // 找不到监听进程 = 浏览器可能已退出，不做按进程名的兜底（避免误杀其他端口实例）
+        command = killCmds
+          ? `(${killCmds}); del /f /q "%LOCALAPPDATA%\\Microsoft\\Edge\\Singleton*" 2>nul; exit 0`
+          : "exit 0";
       } else {
         command = "taskkill /F /IM msedge.exe 2>nul || exit 0";
       }

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

package/src/watchdog/process-manager.js

@@ -122,12 +122,13 @@ function splitCommand(cmdLine) {
 function getProcessStats(pid) {
   try {
     if (IS_WIN) {
-      // 与 tag.js handleScoreAll 一致：用临时 .ps1 + Get-CimInstance Win32_Process + WorkingSetSize
+      // 用 Get-Process（.NET System.Diagnostics.Process API），不依赖 WMI。
+      // 部分机器 WMI 损坏/禁用时 Get-CimInstance 返回空，导致内存读取为 0
       const ps1Path = join(tmpdir(), `wd-proc-${pid}-${Date.now()}.ps1`);
       try {
         const ps1Content =
-          `$p = Get-CimInstance Win32_Process -Filter "ProcessId='${pid}'" -ErrorAction SilentlyContinue; ` +
-          `if ($p) { Write-Output $p.WorkingSetSize } else { Write-Output 0 }`;
+          `$p = Get-Process -Id ${pid} -ErrorAction SilentlyContinue; ` +
+          `if ($p) { Write-Output $p.WorkingSet64 } else { Write-Output 0 }`;
         writeFileSync(ps1Path, ps1Content);
         const stdout = execSync(
           `powershell.exe -NoProfile -ExecutionPolicy Bypass -File "${ps1Path}"`,
@@ -176,6 +177,7 @@ function getProcessStats(pid) {
 
 // Windows: 从 cmd.exe 往下找真正的 node.exe PID（shell:true 时 cmd.exe 是中间层）
 function getChildPid(parentPid) {
+  // 主路径：WMI 查询（原逻辑不变，WMI 正常机器零变化）
   try {
     const out = execSync(
       `powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter 'ParentProcessId=${parentPid}' | Where-Object { $_.Name -notlike 'conhost*' } | Select-Object -First 1 -ExpandProperty ProcessId"`,
@@ -187,6 +189,22 @@ function getChildPid(parentPid) {
       },
     ).trim();
     return parseInt(out, 10) || 0;
+  } catch {
+    // WMI 损坏/禁用时 Get-CimInstance 直接报错，落入 fallback
+  }
+  // fallback：不依赖 WMI，用 Get-Process（.NET API）按启动时间找
+  // cmd.exe 之后最早启动的 node.exe（watchdog spawn 后 3s 才调用，node 应已启动）
+  try {
+    const out = execSync(
+      `powershell -NoProfile -Command "$cmd = Get-Process -Id ${parentPid} -ErrorAction SilentlyContinue; if ($cmd) { Get-Process node -ErrorAction SilentlyContinue | Where-Object { $_.StartTime -ge $cmd.StartTime } | Sort-Object StartTime | Select-Object -First 1 -ExpandProperty Id }"`,
+      {
+        encoding: "utf-8",
+        timeout: 3000,
+        stdio: ["ignore", "pipe", "ignore"],
+        windowsHide: true,
+      },
+    ).trim();
+    return parseInt(out, 10) || 0;
   } catch {
     return 0;
   }

package/src/watchdog/upgrader.js

@@ -350,8 +350,9 @@ async function snapshotAllProcesses() {
           });
       }
     }
-  } catch {
+  } catch (e) {
     /* 快照失败时返回空，清理环节自然跳过 */
+    console.error(`[upgrader] 进程表快照失败（WMI 不可用？）: ${e.message}`);
   }
   return rows;
 }
@@ -465,7 +466,8 @@ async function listWatchdogPids() {
       .split(/\r?\n/)
       .map((s) => parseInt(s.trim(), 10))
       .filter((n) => n > 0);
-  } catch {
+  } catch (e) {
+    console.error(`[upgrader] 枚举 watchdog 进程失败（WMI 不可用？）: ${e.message}`);
     return [];
   }
 }