tt-help-cli-ycl 1.4.126 → 1.4.130

package/scripts/verify-stop-command.mjs

@@ -0,0 +1,159 @@
+// verify-stop-command.mjs — 211 上验证修复后的"看门狗关闭"完整时序
+// 模拟：看门狗托管业务命令 refresh-mini --port 19223，业务启动 Edge CDP 实例。
+// 修复后 stopCommand 顺序：先 killEdgeProcesses(端口) 杀浏览器 → 再 taskkill 业务进程树。
+// 验证：Edge 进程树全灭（端口释放）+ 业务进程被杀。
+import { execSync, spawn } from "node:child_process";
+
+const PKG =
+  process.env.APPDATA.replace(/\\/g, "/") +
+  "/npm/node_modules/tt-help-cli-ycl";
+// 包内真实函数（当前 1.4.128 的 netstat 实现）
+const { killEdgeProcesses } = await import(
+  "file:///" + PKG + "/src/lib/browser/cdp.js"
+);
+
+const PORT = 19223;
+const USER_DATA_DIR =
+  process.env.TEMP.replace(/\\/g, "/") + "/edge-test-" + PORT;
+
+// 修复后的 extractCdpPorts（与本地 process-manager.js 修改一致）
+const BROWSER_CMD_RE =
+  /\b(?:explore|auto|attach|scrape|comments|refresh|recheck|precheck|search|videos|videostats|open|tag|login-check)\b/;
+function extractCdpPorts(cmdLine) {
+  const baseMatch = cmdLine.match(/--base-port\s+(\d+)/);
+  if (baseMatch) {
+    const base = parseInt(baseMatch[1], 10);
+    const countMatch = cmdLine.match(/--port-count\s+(\d+)/);
+    const count = countMatch ? parseInt(countMatch[1], 10) : 1;
+    const ports = [];
+    for (let i = 0; i < count; i++) ports.push(base + i);
+    return ports;
+  }
+  if (BROWSER_CMD_RE.test(cmdLine)) {
+    const m = cmdLine.match(/--port\s+(\d+)/);
+    if (m) return [parseInt(m[1], 10)];
+  }
+  return [];
+}
+
+const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function listeningPids(port) {
+  const out = execSync("netstat -ano", {
+    encoding: "utf-8",
+    timeout: 5000,
+    windowsHide: true,
+  });
+  const pids = [];
+  for (const line of out.split(/\r?\n/)) {
+    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 pidAlive(pid) {
+  try {
+    const out = execSync(`tasklist /FI "PID eq ${pid}" /NH`, {
+      encoding: "utf-8",
+      timeout: 5000,
+      windowsHide: true,
+    });
+    // 解析输出文本判断（tasklist 无匹配时可能仍 exit 0，不能依赖退出码）
+    return new RegExp("\\b" + pid + "\\b").test(out);
+  } catch {
+    return false;
+  }
+}
+
+async function cleanup() {
+  for (const pid of listeningPids(PORT)) {
+    try {
+      execSync(`taskkill /F /T /PID ${pid}`, {
+        stdio: "ignore",
+        windowsHide: true,
+      });
+    } catch {}
+  }
+  try {
+    execSync(`rd /s /q "${USER_DATA_DIR}"`, {
+      stdio: "ignore",
+      windowsHide: true,
+    });
+  } catch {}
+}
+
+async function main() {
+  const CMD_LINE = `tt-help refresh-mini --preset slow --port ${PORT} --rotate-min 0`;
+
+  // [1] 端口提取（修复后逻辑）
+  const ports = extractCdpPorts(CMD_LINE);
+  console.log("[1] extractCdpPorts(" + CMD_LINE + ") = " + JSON.stringify(ports));
+  if (JSON.stringify(ports) !== JSON.stringify([PORT])) {
+    console.log("RESULT: FAIL（端口提取不对）");
+    process.exit(1);
+  }
+
+  // [2] 启动业务进程（node 长驻占位）与 Edge CDP 实例（脱离进程树，模拟 start 启动）
+  const biz = spawn(
+    process.execPath,
+    ["-e", "setInterval(()=>{},1000)"],
+    { stdio: ["ignore", "ignore", "ignore"], windowsHide: true },
+  );
+  console.log("[2] 业务进程 PID = " + biz.pid);
+
+  execSync(
+    `start "" msedge --remote-debugging-port=${PORT} --user-data-dir="${USER_DATA_DIR}" --no-first-run --no-default-browser-check --disable-background-mode --disable-component-update --disable-crash-reporter --disable-breakpad --disable-sync --disable-background-networking`,
+    { stdio: "ignore", windowsHide: true },
+  );
+
+  let edgePids = [];
+  for (let i = 0; i < 30; i++) {
+    await delay(1000);
+    edgePids = listeningPids(PORT);
+    if (edgePids.length > 0) break;
+  }
+  console.log("[2] Edge 监听 " + PORT + " PID = " + JSON.stringify(edgePids));
+  if (edgePids.length === 0) {
+    console.log("RESULT: SETUP_FAIL（Edge 未监听端口）");
+    await cleanup();
+    try { biz.kill(); } catch {}
+    process.exit(2);
+  }
+
+  // [3] 修复后的 stopCommand 顺序：先杀浏览器，再杀业务进程树
+  console.log("[3] 先 killEdgeProcesses(null, " + PORT + ") ...");
+  for (const port of ports) {
+    await killEdgeProcesses(null, port);
+  }
+  await delay(2000);
+  const edgeAfter = listeningPids(PORT);
+  console.log("[3] 杀浏览器后端口监听 = " + JSON.stringify(edgeAfter));
+
+  console.log("[3] 再 taskkill /F /T /PID " + biz.pid + " ...");
+  try {
+    execSync(`taskkill /F /T /PID ${biz.pid}`, {
+      stdio: "ignore",
+      timeout: 5000,
+      windowsHide: true,
+    });
+  } catch (e) {
+    console.log("[3] taskkill 业务返回: " + e.message);
+  }
+  await delay(3000);
+  const bizAlive = pidAlive(biz.pid);
+  console.log("[3] 业务进程存活: " + bizAlive);
+
+  const ok = edgeAfter.length === 0 && !bizAlive;
+  console.log(ok ? "RESULT: PASS" : "RESULT: FAIL");
+  await cleanup();
+  process.exit(ok ? 0 : 1);
+}
+
+main().catch(async (e) => {
+  console.error("脚本异常: " + e.message);
+  await cleanup();
+  process.exit(3);
+});

package/src/clash/daemon.js

@@ -20,8 +20,10 @@ function fmtCountries(v) {
   return list.length ? list.join(",") : "无";
 }
 
-// failover 切换冷却期（默认 45s，可经 opts.failoverCooldownMs 覆盖）
-const FAILOVER_COOLDOWN_MS = 45_000;
+// failover 检查窗口（默认 10 分钟，与候选集 delay 初测周期对齐；可经 opts.failoverCooldownMs 覆盖）
+const FAILOVER_COOLDOWN_MS = 600_000;
+// 窗口内探针健康时的切换阈值（默认 3：前 2 次仅检查，第 3 次按业务级封禁轮换）
+const FAILOVER_ESCAPE_AFTER = 3;
 
 // ══════════════════════════════════════════════
 // ClashDaemon
@@ -35,6 +37,10 @@ export class ClashDaemon {
       opts.failoverCooldownMs > 0
         ? opts.failoverCooldownMs
         : FAILOVER_COOLDOWN_MS;
+    this.failoverEscapeAfter =
+      opts.failoverEscapeAfter > 0
+        ? opts.failoverEscapeAfter
+        : FAILOVER_ESCAPE_AFTER;
     this.dryRun = !!opts.dryRun;
     // 控制端发现参数（CLI 显式值优先，内部再合并 ~/.tt-help.json）
     this._discoverOpts = {
@@ -84,6 +90,45 @@ export class ClashDaemon {
     return run;
   }
 
+  /** 记录一次成功切换（failover/巡检/手动切换共用），供候选排序使用 */
+  _markSwitch(c, nodeName) {
+    if (!c || !nodeName) return;
+    c._switchHistory = c._switchHistory || new Map();
+    c._switchHistory.set(nodeName, Date.now());
+  }
+
+  /**
+   * 壳页判定：TikTok SSR 降级响应（HTTP 200 + 无跳转 + 无 error + 无 title）。
+   * 壳页 = 加载页（data-downgrade 骨架屏），链路正常、浏览器会自行渲染，不算节点故障。
+   */
+  _isShellPage(h) {
+    return (
+      !!h && !h.error && h.httpCode === 200 && h.numRedirects === 0 && !h.title
+    );
+  }
+
+  /**
+   * 候选排序（切换历史感知，纯时间轮换）：
+   * 业务级封禁（TikTok 风控）探针无法感知，用"最近切换时间"作为唯一可靠信号，
+   * 让 failover/巡检在候选池内公平轮换，避免少数节点间反复横跳。
+   * 排序规则：
+   *   - 从未切过的节点排最前（保持 delay 原序，新入池节点优先尝试）
+   *   - 切过的节点按切换时间升序沉底（最早切换的先试，最近切换的最后试 = 后进后出）
+   * 轮完一圈自然回访最早切过的节点（等于重新评估），无需时间窗口过期。
+   */
+  _sortCandidates(nodes, c) {
+    const hist = c && c._switchHistory;
+    if (!hist || !hist.size || !Array.isArray(nodes)) return nodes;
+    return [...nodes].sort((a, b) => {
+      const aLast = hist.get(a) || 0;
+      const bLast = hist.get(b) || 0;
+      if (aLast && bLast) return aLast - bLast; // 都切过：最早切换的先试
+      if (aLast) return 1; // 仅 a 切过：沉底
+      if (bLast) return -1;
+      return 0; // 都未切过：保持 delay 原序（Array.sort 稳定排序）
+    });
+  }
+
   /** 将全局 api/checker 上下文指向指定控制器 */
   _useController(c) {
     api.configure({ port: c.port, secret: c.secret });
@@ -271,7 +316,7 @@ export class ClashDaemon {
       const node = await api
         .getCurrentNode(checker.CONFIG.groupName)
         .catch(() => "?");
-      const h = checker.checkNodeHealth();
+      let h = checker.checkNodeHealth();
       this._writeHealth(c, {
         node,
         healthy: h.healthy,
@@ -290,6 +335,45 @@ export class ClashDaemon {
         return;
       }
 
+      // 空壳页（TikTok SSR 降级响应）：链路可用、浏览器会自行渲染，
+      // 切换无收益且会打断业务连接，不触发切换
+      if (this._isShellPage(h)) {
+        c._apiFailCount = 0;
+        this._log(
+          `~ [${c.proxyPort}] 空壳页（降级响应，链路正常），不切换 (${(h.sizeDownload / 1024).toFixed(0)}KB ${h.timeTotal.toFixed(1)}s)`,
+        );
+        return this._writeHealth(c, {
+          node,
+          healthy: true,
+          httpCode: h.httpCode,
+          timeTotal: h.timeTotal,
+          sizeDownload: h.sizeDownload,
+          title: h.title,
+          shellPage: true,
+        });
+      }
+
+      // 真异常先复测一次：过滤瞬时抖动（截断/丢包），连续异常才进入切换
+      const firstReason =
+        h.error || `HTTP ${h.httpCode} ${(h.sizeDownload / 1024).toFixed(0)}KB`;
+      await new Promise((r) => setTimeout(r, 3000));
+      const hr = checker.checkNodeHealth();
+      if (hr.healthy || this._isShellPage(hr)) {
+        this._log(
+          `~ [${c.proxyPort}] 复测恢复（首次异常: ${firstReason}），不切换`,
+        );
+        return this._writeHealth(c, {
+          node,
+          healthy: true,
+          httpCode: hr.httpCode,
+          timeTotal: hr.timeTotal,
+          sizeDownload: hr.sizeDownload,
+          title: hr.title,
+          shellPage: this._isShellPage(hr) ? true : undefined,
+        });
+      }
+      h = hr; // 复测仍异常，以最新数据为准
+
       const reason =
         h.error || `HTTP ${h.httpCode} ${(h.sizeDownload / 1024).toFixed(0)}KB`;
       const { nodes } = checker.loadHealthyList();
@@ -320,17 +404,20 @@ export class ClashDaemon {
         `✗ [${c.proxyPort}] 巡检异常 [${reason}]，开始从候选集切换 (当前 ${node})`,
       );
       // 逐个切换候选 + 内容验证，第一个满足即采用
+      // 排序：切过的节点按切换时间沉底（后进后出），优先尝试"最久没被切过"的节点
+      const ordered = this._sortCandidates(nodes, c);
       let target = null;
       let h2 = null;
-      for (const cand of nodes) {
+      for (const cand of ordered) {
         if (cand === node) continue;
         this._log(`↺ [${c.proxyPort}] 尝试候选: ${cand} [原因: ${reason}]`);
         if (!(await checker.switchToNode(cand))) {
           this._log(`  ↺ ${cand} 切换失败，下一个`);
           continue;
         }
+        this._markSwitch(c, cand);
         h2 = checker.checkNodeHealth();
-        if (h2.healthy) {
+        if (h2.healthy || this._isShellPage(h2)) {
           target = cand;
           break;
         }
@@ -340,6 +427,7 @@ export class ClashDaemon {
       if (!target) {
         // 全部候选不可用，恢复原节点
         await checker.switchToNode(node).catch(() => {});
+        this._markSwitch(c, node);
         await api.closeAllConnections().catch(() => {});
         this._log(
           `✗ [${c.proxyPort}] 恢复原节点 ${node}（原因: ${reason} — 候选全部不可用）`,
@@ -428,6 +516,13 @@ export class ClashDaemon {
       });
       const elapsed = ((Date.now() - start) / 1000).toFixed(0);
       checker.saveHealthyList(r.nodes);
+      // 清理切换历史中已不在候选集的节点，防止 Map 无限增长
+      if (c._switchHistory && c._switchHistory.size) {
+        const keep = new Set(r.nodes);
+        for (const k of [...c._switchHistory.keys()]) {
+          if (!keep.has(k)) c._switchHistory.delete(k);
+        }
+      }
       c._meta.lastBenchmark = new Date().toISOString();
       c._meta.healthyNodesTotal = r.total;
       c._meta.healthyNodesCount = r.nodes.length;
@@ -489,6 +584,7 @@ export class ClashDaemon {
           lastSwitch: `manual → ${cmd.node} (失败)`,
         });
       }
+      this._markSwitch(c, cmd.node);
       const h = checker.checkNodeHealth();
       // 切换后断开所有旧连接，浏览器立即重建到新节点（同巡检切换）
       await api.closeAllConnections().catch(() => {});
@@ -512,32 +608,48 @@ export class ClashDaemon {
   /**
    * 看门狗指令: 主动故障切换（不依赖巡检发现，强制从候选集切下一个可用节点）
    * 用于业务进程连续报错（CDN限流/网络异常/封 IP 等）时换出口节点
+   *
+   * failover 三级响应（2026-08-22，替代原 45s 冷却）：
+   *   1. 每次 failover 先检查当前节点（消除冷却期外盲切）；
+   *   2. 探针不健康 → 立即切换（有依据才切，无视窗口）；
+   *   3. 探针健康 → 窗口内默认只检查不切换；同一窗口内 failover 到达
+   *      failoverEscapeAfter 次（默认 3）→ 视为业务级封禁（curl 探针感知不到
+   *      TikTok 业务风控）→ 按轮换逻辑切一次。
+   * 实际切换（成功或恢复原节点）或触发候选初测后重置窗口与计数，给新节点干净
+   * 观察窗口；窗口 = failoverCooldownMs（默认 10 分钟，与候选集初测周期对齐）。
+   * 按控制端独立记录（多控制端互不影响）；对外接口（命令动作/IPC/health）不变。
    */
   async _handleFailover(cmd, c) {
     try {
-      // ── failover 冷却 + 健康验证（2026-08-18）──
-      // 冷却期内再次收到 failover：先验证当前节点健康，健康则跳过并续冷却
-      // （持续健康 → 持续不切，避免冷却期结束后又白切健康节点；同时过滤滞后/重连误报），
-      // 不健康才继续切换。按控制端独立记录冷却（多控制端互不影响）；
-      // 对外接口（命令动作 / IPC / health 格式）保持不变。
+      const reason = (cmd && cmd.reason) || "看门狗主动故障切换";
       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;
-        }
+      const w =
+        c._failoverWindow || (c._failoverWindow = { startAt: 0, count: 0 });
+      if (now - w.startAt >= this.failoverCooldownMs) {
+        w.startAt = now;
+        w.count = 0;
+      }
+      w.count += 1;
+
+      // 第 1 级：先检查当前节点（壳页 = 链路正常，按健康对待，与巡检口径一致）
+      const h = checker.checkNodeHealth();
+      const probeOk = !!h && (h.healthy || this._isShellPage(h));
+      if (probeOk && w.count < this.failoverEscapeAfter) {
         this._log(
-          `🔄 冷却期内节点不健康 [${c.proxyPort}]，继续故障切换（有依据才切）`,
+          `🔄 [${c.proxyPort}] 探针健康，窗口内第 ${w.count}/${this.failoverEscapeAfter} 次 failover 仅检查不切换 [${reason}]`,
+        );
+        return;
+      }
+      if (probeOk) {
+        this._log(
+          `🔄 [${c.proxyPort}] 窗口内第 ${w.count} 次 failover：探针健康但业务持续报错，按业务级封禁轮换 [${reason}]`,
+        );
+      } else {
+        this._log(
+          `🔄 [${c.proxyPort}] 探针不健康（${(h && (h.error || `HTTP ${h.httpCode}`)) || "无响应"}），立即故障切换 [${reason}]`,
         );
       }
-      c._lastFailoverAt = now;
 
-      const reason = (cmd && cmd.reason) || "看门狗主动故障切换";
       const node = await api
         .getCurrentNode(checker.CONFIG.groupName)
         .catch(() => "?");
@@ -547,28 +659,39 @@ export class ClashDaemon {
       const { nodes } = checker.loadHealthyList();
       if (!nodes.length) {
         this._log("🔄 候选集为空，触发 delay 初测");
+        // 初测即处置：重置窗口，避免健康探测每轮重复触发初测
+        w.startAt = now;
+        w.count = 0;
         await this._runDelayProbeController(c);
         return;
       }
       // 逐个切换候选 + 内容验证，第一个满足即采用（跳过当前节点）
+      // 排序：切过的节点按切换时间沉底（后进后出），优先尝试"最久没被切过"的节点
+      const ordered = this._sortCandidates(nodes, c);
       let target = null;
       let h2 = null;
-      for (const cand of nodes) {
+      for (const cand of ordered) {
         if (cand === node) continue;
         this._log(`↺ 尝试候选: ${cand}`);
         if (!(await checker.switchToNode(cand))) {
           this._log(`  ↺ ${cand} 切换失败，下一个`);
           continue;
         }
+        this._markSwitch(c, cand);
         h2 = checker.checkNodeHealth();
-        if (h2.healthy) {
+        if (h2.healthy || this._isShellPage(h2)) {
           target = cand;
           break;
         }
         this._log(`  ↺ ${cand} 内容验证未通过，下一个`);
       }
+      // 本次 failover 已尽力处置（成功切换或恢复原节点）：重置窗口，给新节点干净观察窗口
+      w.startAt = now;
+      w.count = 0;
+
       if (!target) {
         await checker.switchToNode(node).catch(() => {});
+        this._markSwitch(c, node);
         await api.closeAllConnections().catch(() => {});
         this._log(
           `✗ failover [${reason}] — 候选全部不可用，恢复原节点 ${node}`,
@@ -707,5 +830,8 @@ if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
     secret: getArg("--secret") || undefined,
     selection: getArg("--selection") || undefined,
     configPaths: configPaths.length ? configPaths : undefined,
+    failoverCooldownMs: parseInt(getArg("--failover-cooldown-ms")) || undefined,
+    failoverEscapeAfter:
+      parseInt(getArg("--failover-escape-after")) || undefined,
   }).start();
 }

package/src/cli/refresh-mini.js

@@ -576,22 +576,49 @@ export async function handleRefreshMini(options) {
 
       if (result.error) {
         const isBlocked = result.error.startsWith("被封:");
-        consecutiveTaskErrors++;
+        // 导航打断（多为切换节点后的网络重建期）不计入连续任务错误，
+        // 避免"切换 → 掐断连接 → 导航打断 → 计错 → 再切换"的循环
+        const isNavBreak = result.error.includes(
+          "Execution context was destroyed",
+        );
+        if (!isNavBreak) consecutiveTaskErrors++;
         errorCount++;
 
-        // 临时性错误：自动重试一次
+        // 临时性错误：自动重试
         if (result.retryable) {
-          console.error(`  [临时错误] 等待 5 秒后重试 @${username}...`);
-          await sleep(5000);
-          result = await processExplore(
-            page,
-            username,
-            processOptions(),
-            console.error,
-          );
-          if (!result.error) {
-            consecutiveTaskErrors = 0;
-            errorCount--;
+          if (isNavBreak) {
+            // 与被封同款渐退等待：30/40/50s，给切换后的网络重建时间
+            const navWaits = [30_000, 40_000, 50_000];
+            for (let retry = 0; retry < navWaits.length; retry++) {
+              console.error(
+                `  [网络重建] 导航打断（切换节点后），等待 ${navWaits[retry] / 1000}s 稳定后第 ${retry + 1}/${navWaits.length} 次重试 @${username}...`,
+              );
+              await sleep(navWaits[retry]);
+              result = await processExplore(
+                page,
+                username,
+                processOptions(),
+                console.error,
+              );
+              if (!result.error) {
+                consecutiveTaskErrors = 0;
+                errorCount--;
+                break;
+              }
+            }
+          } else {
+            console.error(`  [临时错误] 等待 5 秒后重试 @${username}...`);
+            await sleep(5000);
+            result = await processExplore(
+              page,
+              username,
+              processOptions(),
+              console.error,
+            );
+            if (!result.error) {
+              consecutiveTaskErrors = 0;
+              errorCount--;
+            }
           }
         }
 

package/src/watchdog/agent.js

@@ -24,7 +24,7 @@ import {
 import { writeFileSync, existsSync, readFileSync } from "fs";
 import { spawn } from "child_process";
 import { join, dirname } from "path";
-import { homedir } from "os";
+import { homedir, tmpdir } from "os";
 import { fileURLToPath } from "url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -32,6 +32,36 @@ const homeDir = homedir() || process.env.HOME || process.env.USERPROFILE || "";
 const TT_HELP_CONFIG = join(homeDir, ".tt-help.json");
 const IS_WIN = process.platform === "win32";
 
+// ── 升级配套（绕开 WMI）──
+// 部分 Windows 机器 WMI（WinMgmt）损坏，升级器用 Get-CimInstance 查进程表会失效，
+// 导致旧 cmd 窗口不关、新版存活误判。故升级链改为：
+//   1. 本进程启动时设置控制台窗口标题 → 升级器按标题匹配（tasklist /V）关旧窗
+//   2. 本进程启动时写存活标记文件 → 升级器读文件确认新版存活（不再枚举进程表）
+const STARTED_FILE = join(tmpdir(), "tt-help-watchdog-started.json");
+const WINDOW_TITLE_TAG = "tt-help-watchdog";
+
+/** 设置控制台窗口标题（仅 Windows 交互窗口生效，ESC ]0 转义；失败静默） */
+function setConsoleTitle(clientId) {
+  if (process.platform !== "win32") return;
+  try {
+    process.stdout.write(`\x1b]0;${WINDOW_TITLE_TAG} (${clientId})\x07`);
+  } catch {}
+}
+
+/** 写存活标记文件（升级器据此确认新版 watchdog 已启动，绕开 WMI） */
+function writeStartedFile() {
+  try {
+    writeFileSync(
+      STARTED_FILE,
+      JSON.stringify({
+        pid: process.pid,
+        version: getVersion(),
+        ts: Date.now(),
+      }),
+    );
+  } catch {}
+}
+
 // ── 业务日志错误统计 → 触发节点切换 ──
 // 识别采集程序日志里已有的错误分类标签（explore 等已打标），连续错误达标则切换出口节点
 const NETWORK_ERROR_PATTERNS = [
@@ -173,6 +203,9 @@ export class WatchdogAgent {
   }) {
     this.serverUrl = serverUrl.replace(/\/+$/, "");
     this.clientId = clientId;
+    // 升级配套：设窗口标题（升级器按标题关旧窗）+ 写存活文件（升级器做存活校验）
+    setConsoleTitle(clientId);
+    writeStartedFile();
     this.intervalMs = intervalMs;
     this.spawnDaemon = !!spawnDaemon;
     this.loginCheckIntervalMs = Math.max(

package/src/watchdog/process-manager.js

@@ -78,16 +78,29 @@ function printProcessLine(id, msg) {
   }
 }
 
-// 从命令行中提取 CDP 端口列表（解析 --base-port 和 --port-count）
+// 会启动 CDP 浏览器的采集类命令（用于识别单端口形式 --port 的归属）
+// 排除 webserver/watch 等 --port 是服务端口的命令，避免误杀
+const BROWSER_CMD_RE =
+  /\b(?:explore|auto|attach|scrape|comments|refresh|recheck|precheck|search|videos|videostats|open|tag|login-check)\b/;
+
+// 从命令行中提取 CDP 端口列表（解析 --base-port/--port-count 和单端口 --port）
 function extractCdpPorts(cmdLine) {
-  const match = cmdLine.match(/--base-port\s+(\d+)/);
-  if (!match) return [];
-  const base = parseInt(match[1], 10);
-  const countMatch = cmdLine.match(/--port-count\s+(\d+)/);
-  const count = countMatch ? parseInt(countMatch[1], 10) : 1;
-  const ports = [];
-  for (let i = 0; i < count; i++) ports.push(base + i);
-  return ports;
+  // 多端口形式：--base-port N [--port-count M] → N..N+M-1
+  const baseMatch = cmdLine.match(/--base-port\s+(\d+)/);
+  if (baseMatch) {
+    const base = parseInt(baseMatch[1], 10);
+    const countMatch = cmdLine.match(/--port-count\s+(\d+)/);
+    const count = countMatch ? parseInt(countMatch[1], 10) : 1;
+    const ports = [];
+    for (let i = 0; i < count; i++) ports.push(base + i);
+    return ports;
+  }
+  // 单端口形式（如 refresh-mini --port 5222）：仅浏览器类命令提取
+  if (BROWSER_CMD_RE.test(cmdLine)) {
+    const m = cmdLine.match(/--port\s+(\d+)/);
+    if (m) return [parseInt(m[1], 10)];
+  }
+  return [];
 }
 
 // 引号感知的命令拆分："a b" "c d" → ["a b", "c d"]
@@ -382,6 +395,13 @@ export class ProcessManager extends EventEmitter {
         const cmdLine = info.cmdDef?.command || "";
         const ports = extractCdpPorts(cmdLine);
 
+        // 必须先杀浏览器再杀业务进程树：业务进程被强杀后 Edge 主进程可能随之
+        // 退出、CDP 端口释放，此时按端口找监听 PID 会落空，导致 Edge 子进程残留。
+        // 先杀时端口必在监听，netstat 找 PID → taskkill /T 可杀干净整个 Edge 进程树。
+        for (const port of ports) {
+          killEdgeProcesses(null, port);
+        }
+
         if (IS_WIN) {
           // Windows: shell:true 产生 cmd.exe 中间层，必须杀整个进程树
           execSync(`taskkill /PID ${info.child.pid} /T /F`, {
@@ -401,10 +421,6 @@ export class ProcessManager extends EventEmitter {
           }, 2000);
         }
 
-        // 全平台：关闭脱离进程树的浏览器（open -a / start msedge 启动的）
-        for (const port of ports) {
-          killEdgeProcesses(null, port);
-        }
       } catch (e) {
         console.error(`[watchdog] 停止命令 ${cmdId} 失败: ${e.message}`);
       }