tt-help-cli-ycl 1.4.126 → 1.4.128

package/package.json

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

package/scripts/test-daemon-switch-history.mjs

@@ -0,0 +1,141 @@
+/**
+ * daemon 切换历史排序单测（无需 Clash 运行）
+ * 验证 _sortCandidates / _markSwitch 的纯时间轮换（后进后出）行为
+ */
+import { ClashDaemon } from "../src/clash/daemon.js";
+
+let pass = 0;
+let fail = 0;
+function ok(cond, name, detail = "") {
+  if (cond) {
+    pass++;
+    console.log(`  ✓ ${name}`);
+  } else {
+    fail++;
+    console.error(`  ✗ ${name} ${detail}`);
+  }
+}
+
+const d = new ClashDaemon({});
+const nodes = ["A", "B", "C", "D"];
+const T0 = Date.now();
+
+// T1 无历史 → 原序
+{
+  const c = { proxyPort: 1 };
+  ok(
+    JSON.stringify(d._sortCandidates(nodes, c)) === JSON.stringify(nodes),
+    "T1 无历史保持原序",
+  );
+}
+
+// T2 切过沉底，未切过保持原序
+{
+  const c = { proxyPort: 2 };
+  c._switchHistory = new Map([["B", T0 - 10_000]]);
+  const r = d._sortCandidates(nodes, c);
+  ok(r.join() === "A,C,D,B", "T2 切过沉底，未切过保持原序", r.join());
+}
+
+// T3 切过按切换时间升序，未切过最前
+{
+  const c = { proxyPort: 3 };
+  c._switchHistory = new Map([
+    ["C", T0 - 2_000],
+    ["A", T0 - 1_000],
+  ]);
+  const r = d._sortCandidates(nodes, c);
+  ok(r.join() === "B,D,C,A", "T3 切过按切换时间升序，未切过最前", r.join());
+}
+
+// T4 全部切过 → 完全按切换时间轮换
+{
+  const c = { proxyPort: 4 };
+  c._switchHistory = new Map([
+    ["A", T0 - 4_000],
+    ["B", T0 - 1_000],
+    ["C", T0 - 3_000],
+    ["D", T0 - 2_000],
+  ]);
+  const r = d._sortCandidates(nodes, c);
+  ok(r.join() === "A,C,D,B", "T4 全切过按切换时间轮换", r.join());
+}
+
+// T5 无时间窗口：无论多久前切过都按时间排队（不恢复 delay 原序）
+{
+  const c = { proxyPort: 5 };
+  c._switchHistory = new Map([["C", T0 - 3_600_000]]); // 1 小时前切过
+  const r = d._sortCandidates(nodes, c);
+  ok(r.join() === "A,B,D,C", "T5 无窗口：1 小时前切过仍沉底", r.join());
+}
+
+// T6 排序不改原数组
+{
+  ok(nodes.join() === "A,B,C,D", "T6 原数组未被修改");
+}
+
+// T7 _markSwitch 惰性初始化 + 更新
+{
+  const c = { proxyPort: 6 };
+  d._markSwitch(c, "A");
+  ok(
+    c._switchHistory instanceof Map && c._switchHistory.has("A"),
+    "T7 _markSwitch 惰性初始化并记录",
+  );
+  const t1 = c._switchHistory.get("A");
+  d._markSwitch(c, "A");
+  ok(c._switchHistory.get("A") >= t1, "T8 _markSwitch 重复记录更新时间戳");
+}
+
+// T9 时间戳相同时稳定排序（V8 sort 稳定，保持原相对序）
+{
+  const c = { proxyPort: 7 };
+  c._switchHistory = new Map([
+    ["A", T0 - 100],
+    ["B", T0 - 100],
+  ]);
+  const r = d._sortCandidates(nodes, c);
+  ok(r.join() === "C,D,A,B", "T9 相同时间戳保持原相对序（稳定排序）", r.join());
+}
+
+// T10 壳页判定：200 + 无跳转 + 无 error + 无 title → 壳页
+ok(
+  d._isShellPage({ error: null, httpCode: 200, numRedirects: 0, title: "" }) ===
+    true,
+  "T10 壳页判定：200+无title → true",
+);
+// T11 健康页（有 title）→ 非壳页
+ok(
+  d._isShellPage({
+    error: null,
+    httpCode: 200,
+    numRedirects: 0,
+    title: "TikTok - Make Your Day",
+  }) === false,
+  "T11 健康页有 title → false",
+);
+// T12 连接错误 → 非壳页
+ok(
+  d._isShellPage({
+    error: "timeout",
+    httpCode: 0,
+    numRedirects: 0,
+    title: "",
+  }) === false,
+  "T12 连接错误 → false",
+);
+// T13 跳转 → 非壳页
+ok(
+  d._isShellPage({ error: null, httpCode: 200, numRedirects: 1, title: "" }) ===
+    false,
+  "T13 跳转 → false",
+);
+// T14 非 200 → 非壳页
+ok(
+  d._isShellPage({ error: null, httpCode: 403, numRedirects: 0, title: "" }) ===
+    false,
+  "T14 非 200 → false",
+);
+
+console.log(`\n结果: ${pass} 通过 / ${fail} 失败`);
+process.exit(fail ? 1 : 0);

package/scripts/test-wmi-free-upgrade.mjs

@@ -0,0 +1,98 @@
+/**
+ * 测试：升级链绕开 WMI 的新逻辑（2026-08-21）
+ * 范围（macOS 可测部分）：
+ *  1. parseCsvLine：tasklist /FO CSV 输出解析（引号/逗号边界）
+ *  2. 模拟 tasklist /V 输出的窗口标题匹配过滤逻辑（复算与实现一致的筛选规则）
+ *  3. agent 构造即写存活标记文件（STARTED_FILE），内容含 pid/version
+ */
+import assert from "assert";
+import { readFileSync, rmSync } from "fs";
+import { join, dirname } from "path";
+import { tmpdir } from "os";
+import { fileURLToPath } from "url";
+
+const { parseCsvLine } = await import("../src/watchdog/upgrader.js");
+
+let pass = 0;
+const ok = (msg) => {
+  pass++;
+  console.log(`  ✓ ${msg}`);
+};
+
+// ── 1. parseCsvLine ──
+const L1 = '"conhost.exe","5234","Console","2","8,312 K","Running","x\\user","0:00:01","tt-help-watchdog (F-7@WIN)"';
+const f1 = parseCsvLine(L1);
+assert.strictEqual(f1[0], "conhost.exe", "映像名");
+assert.strictEqual(f1[1], "5234", "PID");
+assert.strictEqual(f1[3], "2", "会话#");
+assert.strictEqual(f1[4], "8,312 K", "带逗号字段 8,312 K");
+assert.strictEqual(f1[8], "tt-help-watchdog (F-7@WIN)", "窗口标题");
+ok("parseCsvLine: 常规行（含带逗号字段）");
+
+// 标题内含转义引号（CSV 标准：双引号 "" 转义）
+const L2 = '"cmd.exe","999","Console","2","1,024 K","Running","x\\user","0:00:00","say ""hi"", tt-help-watchdog"';
+const f2 = parseCsvLine(L2);
+assert.strictEqual(f2[8], 'say "hi", tt-help-watchdog', "标题含转义引号与逗号");
+ok("parseCsvLine: 标题含转义引号+逗号");
+
+// 无引号行（表头）
+const f3 = parseCsvLine("映像名称,PID,会话名,会话#,内存使用,状态,用户名,CPU 时间,窗口标题");
+assert.strictEqual(f3.length, 9, "表头 9 列");
+ok("parseCsvLine: 无引号表头");
+
+// ── 2. 模拟 tasklist /V 输出做标题匹配过滤（复算实现逻辑） ──
+const mockTasklist = [
+  '"映像名称","PID","会话名","会话#","内存使用","状态","用户名","CPU 时间","窗口标题"',
+  '"System Idle Process","0","Services","0","8 K","Unknown","NT AUTHORITY\\SYSTEM","1:23:45:55","N/A"',
+  '"conhost.exe","5234","Console","2","8,312 K","Running","x\\user","0:00:01","tt-help-watchdog (F-7@WIN-AADJ1HTCCAQ)"',
+  '"cmd.exe","4000","Console","2","4,444 K","Running","x\\user","0:00:00","N/A"',
+  '"conhost.exe","7777","Console","2","2,048 K","Running","x\\user","0:00:00","C:\\Windows\\system32\\cmd.exe"',
+  '"node.exe","6400","Console","2","120,000 K","Running","x\\user","0:00:10","N/A"',
+  '"cmd.exe","6401","Console","2","3,000 K","Running","x\\user","0:00:00","tt-help-watchdog (old)"',
+];
+const TAG = "tt-help-watchdog";
+const matched = [];
+for (const line of mockTasklist) {
+  if (!line.toLowerCase().includes(TAG.toLowerCase())) continue;
+  const fields = parseCsvLine(line);
+  if (fields.length < 2) continue;
+  const name = (fields[0] || "").toLowerCase();
+  if (!name.includes("conhost") && !name.includes("cmd")) continue;
+  const pid = parseInt(fields[1], 10);
+  if (pid > 0) matched.push(pid);
+}
+assert.deepStrictEqual(
+  [...new Set(matched)].sort((a, b) => a - b),
+  [5234, 6401],
+  "只匹配到标题含 tag 的 conhost/cmd，普通窗口/其他进程不误匹配",
+);
+ok("标题匹配过滤: 命中旧窗口 conhost+cmd，排除无关进程");
+
+// ── 3. agent 构造即写存活标记文件 ──
+const STARTED_FILE = join(tmpdir(), "tt-help-watchdog-started.json");
+rmSync(STARTED_FILE, { force: true });
+const { WatchdogAgent } = await import("../src/watchdog/agent.js");
+const agent = new WatchdogAgent({
+  serverUrl: "http://127.0.0.1:3001",
+  clientId: "test@unit",
+  intervalMs: 15000,
+});
+assert.ok(agent, "agent 构造成功");
+const st = JSON.parse(readFileSync(STARTED_FILE, "utf-8"));
+assert.strictEqual(st.pid, process.pid, "pid=当前进程");
+assert.ok(typeof st.version === "string" && st.version.length > 0, "version 非空");
+assert.ok(st.ts > 0, "ts 存在");
+ok(`存活文件写入: pid=${st.pid}, version=${st.version}`);
+
+// 重复构造覆盖写（模拟新版 watchdog 启动覆盖旧文件）
+const agent2 = new WatchdogAgent({
+  serverUrl: "http://127.0.0.1:3001",
+  clientId: "test2@unit",
+});
+const st2 = JSON.parse(readFileSync(STARTED_FILE, "utf-8"));
+assert.strictEqual(st2.pid, process.pid, "覆盖写仍有效");
+ok("存活文件: 重复构造覆盖写正常");
+
+// 清理测试文件
+rmSync(STARTED_FILE, { force: true });
+console.log(`\n全部通过: ${pass} 项`);

package/src/clash/daemon.js

@@ -84,6 +84,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 +310,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 +329,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 +398,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 +421,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 +510,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 +578,7 @@ export class ClashDaemon {
           lastSwitch: `manual → ${cmd.node} (失败)`,
         });
       }
+      this._markSwitch(c, cmd.node);
       const h = checker.checkNodeHealth();
       // 切换后断开所有旧连接，浏览器立即重建到新节点（同巡检切换）
       await api.closeAllConnections().catch(() => {});
@@ -551,17 +641,20 @@ export class ClashDaemon {
         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;
         }
@@ -569,6 +662,7 @@ export class ClashDaemon {
       }
       if (!target) {
         await checker.switchToNode(node).catch(() => {});
+        this._markSwitch(c, node);
         await api.closeAllConnections().catch(() => {});
         this._log(
           `✗ failover [${reason}] — 候选全部不可用，恢复原节点 ${node}`,

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

@@ -8,7 +8,7 @@
 
 import { exec, spawn, execFile } from "child_process";
 import { promisify } from "util";
-import { readFileSync, openSync } from "fs";
+import { readFileSync, openSync, unlinkSync } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
 import { homedir, tmpdir } from "os";
@@ -21,6 +21,12 @@ const homeDir = homedir() || process.env.HOME || process.env.USERPROFILE || "";
 const TT_HELP_CONFIG = join(homeDir, ".tt-help.json");
 const execFileP = promisify(execFile);
 
+// 升级链绕开 WMI 的配套常量（与 agent.js 保持一致）：
+// 部分 Windows 机器 WMI（WinMgmt）损坏，Get-CimInstance 查不到进程表 →
+// 关旧窗改用窗口标题匹配（tasklist /V），存活校验改用新版 watchdog 写出的标记文件
+const STARTED_FILE = join(tmpdir(), "tt-help-watchdog-started.json");
+const WINDOW_TITLE_TAG = "tt-help-watchdog";
+
 /**
  * 升级检测源：TT_HELP_REGISTRY 环境变量 > ~/.tt-help.json 的 npmRegistry > 官方 npmjs.org
  * 注意：检测源应与本机 npm install 使用的 registry 保持一致（默认 npm 自身配置）
@@ -298,22 +304,101 @@ async function waitProcessExit(pid, waitMs) {
   return false;
 }
 
-/** 向上遍历父链，返回 cmd.exe 祖先进程 PID（旧 watchdog 所在窗口，升级后关窗用） */
-function listCmdAncestorPids(rows, pid) {
-  const byId = new Map(rows.map((r) => [r.pid, r]));
+/** 解析一行 CSV（处理引号包裹的逗号/转义引号），用于解析 tasklist /FO CSV 输出 */
+export function parseCsvLine(line) {
   const out = [];
-  const seen = new Set();
-  let cur = byId.get(pid)?.ppid;
-  while (cur && !seen.has(cur)) {
-    seen.add(cur);
-    const r = byId.get(cur);
-    if (!r) break;
-    if (/cmd(\.exe)?\b/i.test(r.cmd || "")) out.push(cur);
-    cur = r.ppid;
+  let cur = "";
+  let inQ = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (inQ) {
+      if (c === '"') {
+        if (line[i + 1] === '"') {
+          cur += '"';
+          i++;
+        } else {
+          inQ = false;
+        }
+      } else {
+        cur += c;
+      }
+    } else if (c === '"') {
+      inQ = true;
+    } else if (c === ",") {
+      out.push(cur);
+      cur = "";
+    } else {
+      cur += c;
+    }
   }
+  out.push(cur);
   return out;
 }
 
+/**
+ * Windows：按窗口标题匹配 tasklist /V 输出中的控制台宿主进程 PID（绕开 WMI）。
+ * 窗口标题在 conhost.exe 行（Win10/11）或 cmd.exe 行（旧系统），两者都返回；
+ * 其余进程（含升级器 U 自身的隐藏 conhost，标题为空）不会误匹配。
+ */
+async function listWindowPidsByTitle(titleSubstr) {
+  if (process.platform !== "win32") return [];
+  try {
+    const { stdout } = await execFileP(
+      "tasklist.exe",
+      ["/V", "/FO", "CSV"],
+      { timeout: 20000, windowsHide: true },
+    );
+    const pids = [];
+    for (const line of String(stdout).split(/\r?\n/)) {
+      if (!line.toLowerCase().includes(titleSubstr.toLowerCase())) continue;
+      const fields = parseCsvLine(line);
+      if (fields.length < 2) continue;
+      const name = (fields[0] || "").toLowerCase();
+      if (!name.includes("conhost") && !name.includes("cmd")) continue;
+      const pid = parseInt(fields[1], 10);
+      if (pid > 0 && pid !== process.pid) pids.push(pid);
+    }
+    return [...new Set(pids)];
+  } catch (e) {
+    console.error(`[upgrade-proc] tasklist 查窗口失败: ${e.message}`);
+    return [];
+  }
+}
+
+/**
+ * 关闭旧 watchdog 所在的 cmd 窗口（绕开 WMI）：
+ * 旧 watchdog 启动时已把窗口标题设为含 WINDOW_TITLE_TAG 的串（agent.js），
+ * 此时新版窗口尚未弹出，匹配到的窗口即旧窗口 → taskkill 杀 conhost/cmd 关窗。
+ * 旧 watchdog 版本过旧（未设标题）或非窗口运行时匹配不到，跳过。
+ */
+async function killOldWatchdogWindow() {
+  if (process.platform !== "win32") return;
+  const pids = await listWindowPidsByTitle(WINDOW_TITLE_TAG);
+  if (pids.length === 0) {
+    console.error(
+      `[upgrade-proc] 未找到标题含 "${WINDOW_TITLE_TAG}" 的窗口（旧 watchdog 非窗口运行或版本过旧未设标题），跳过关旧窗`,
+    );
+    return;
+  }
+  await killPidList(pids, "已关闭旧 cmd 窗口");
+}
+
+/** 读存活标记文件（新版 watchdog 启动后写入 {pid, version, ts}） */
+function readStartedFile() {
+  try {
+    return JSON.parse(readFileSync(STARTED_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/** 删存活标记文件（spawn 新版前清掉旧 watchdog 的残留，确保读到的是新进程的） */
+function deleteStartedFile() {
+  try {
+    unlinkSync(STARTED_FILE);
+  } catch {}
+}
+
 /** 一次拉取全进程表 [{pid, ppid, cmd}]（Windows: CIM；POSIX: ps） */
 async function snapshotAllProcesses() {
   const rows = [];
@@ -441,24 +526,13 @@ async function killPidList(pids, label) {
   return killed;
 }
 
-/** 枚举当前所有 watchdog 进程 PID（存活校验前后对比用；不含升级器 U 自身） */
+/**
+ * 枚举当前所有 watchdog 进程 PID（仅 POSIX 存活校验前后对比用）。
+ * Windows 不再走这里——部分机器 WMI 损坏时枚举会静默返回空，已改为读
+ * 新版 watchdog 写出的存活标记文件（见 runUpgradeMode 第 5 步）。
+ */
 async function listWatchdogPids() {
   try {
-    if (process.platform === "win32") {
-      const ps =
-        `Get-CimInstance Win32_Process -Filter "Name='node.exe'" ` +
-        `| Where-Object { $_.CommandLine -match 'cli\\.js watchdog' } ` +
-        `| Select-Object -ExpandProperty ProcessId`;
-      const { stdout } = await execFileP(
-        "powershell.exe",
-        ["-NoProfile", "-Command", ps],
-        { timeout: 15000, windowsHide: true },
-      );
-      return String(stdout)
-        .split(/\r?\n/)
-        .map((s) => parseInt(s.trim(), 10))
-        .filter((n) => n > 0);
-    }
     const { stdout } = await execFileP("pgrep", ["-f", "cli.js watchdog"], {
       timeout: 15000,
     });
@@ -467,9 +541,7 @@ async function listWatchdogPids() {
       .map((s) => parseInt(s.trim(), 10))
       .filter((n) => n > 0);
   } catch (e) {
-    console.error(
-      `[upgrader] 枚举 watchdog 进程失败（WMI 不可用？）: ${e.message}`,
-    );
+    console.error(`[upgrader] 枚举 watchdog 进程失败: ${e.message}`);
     return [];
   }
 }
@@ -551,11 +623,11 @@ export async function runUpgradeMode(argv) {
   //      会触发旧 watchdog 的 SIGINT → gracefulShutdown 优雅停业务。因此先向旧 watchdog
   //      的控制台发送 CTRL_C_EVENT（等效手动按键），8s 未退再强杀兜底；随后按【杀旧前】
   //      快照强杀整棵后代树（排除 U 自己；杀旧后中间层死亡会断父链，必须提前快照），
-  //      再兜底清理「父已死」的孤儿业务进程，最后关闭旧 watchdog 所在的 cmd 窗口。
+  //      再兜底清理「父已死」的孤儿业务进程，最后关闭旧 watchdog 所在的 cmd 窗口
+  //      （按窗口标题匹配 tasklist /V，绕开 WMI——部分机器 WMI 损坏时快照为空）。
   console.error(`[upgrade-proc] 通知旧 watchdog (pid=${oldPid}) 退出 ...`);
   const procSnapshot = await snapshotAllProcesses();
   const descPids = listDescendantPids(procSnapshot, oldPid, process.pid);
-  const cmdAncestors = listCmdAncestorPids(procSnapshot, oldPid);
 
   let exited = false;
   const gracefulSent =
@@ -584,8 +656,9 @@ export async function runUpgradeMode(argv) {
   // 兜底：快照时父链已断（中间层先死）的孤儿业务进程，杀旧后按特征清理
   const orphanPids = listOrphanBusinessPids(await snapshotAllProcesses());
   await killPidList(orphanPids, "已清理孤儿业务进程");
-  // 关闭旧 watchdog 所在的 cmd 窗口（业务已停，窗口只剩空壳提示符）
-  await killPidList(cmdAncestors, "已关闭旧 cmd 窗口");
+  // 关闭旧 watchdog 所在的 cmd 窗口（业务已停，窗口只剩空壳提示符）；
+  // 按窗口标题匹配（不依赖 WMI），旧 watchdog 已设标题含 WINDOW_TITLE_TAG
+  await killOldWatchdogWindow();
 
   // 4) 旧进程已退，启新版 watchdog
   //     Windows：显式弹独立交互 cmd 窗口（start → cmd /k），日志直接显示在窗口，
@@ -602,9 +675,12 @@ export async function runUpgradeMode(argv) {
     process.platform === "win32"
       ? undefined
       : openLogFile("tt-help-watchdog", "upgrade-proc", "新版 watchdog 日志");
-  // 记录启动前的 watchdog 进程集合，用于存活校验前后对比（Windows 经 start 启动时
-  // 中间 cmd 秒退，不能检查其 PID）
-  const beforePids = await listWatchdogPids();
+  // Windows 存活校验改读新版 watchdog 写出的标记文件（WMI 损坏时枚举进程表失效），
+  // spawn 前先删掉旧 watchdog 的残留，确保读到的是新进程写的
+  if (process.platform === "win32") deleteStartedFile();
+  // POSIX：记录启动前的 watchdog 进程集合，用于存活校验前后对比
+  const beforePids =
+    process.platform === "win32" ? [] : await listWatchdogPids();
   let child;
   try {
     child = spawnNewWatchdog(cliPath, args, logFd);
@@ -620,20 +696,49 @@ export async function runUpgradeMode(argv) {
     process.exit(1);
   }
 
-  // 5) 存活校验：3s 后确认出现新增的 watchdog 进程；未存活则明确报错，不静默
+  // 5) 存活校验：3s 后确认新版 watchdog 存活；未存活则明确报错，不静默
   await new Promise((r) => setTimeout(r, 3000));
-  const newPids = (await listWatchdogPids()).filter(
-    (p) => !beforePids.includes(p),
-  );
-  if (newPids.length > 0) {
-    console.error(
-      `[upgrade-proc] 新版 watchdog 存活确认 (pid=${newPids.join(",")})，升级完成`,
-    );
+  if (process.platform === "win32") {
+    // Windows：轮询存活标记文件（新版 watchdog 启动即写，含 pid/version），
+    // 版本匹配且 pid 可探测存活才算确认。15s 超时未出现则报错。
+    const deadline = Date.now() + 15_000;
+    let st = null;
+    while (Date.now() < deadline && !st) {
+      const cur = readStartedFile();
+      if (
+        cur &&
+        cur.pid > 0 &&
+        String(cur.version) === String(verify.version) &&
+        (await isProcessAlive(cur.pid))
+      ) {
+        st = cur;
+      }
+      if (!st) await new Promise((r) => setTimeout(r, 1000));
+    }
+    if (st) {
+      console.error(
+        `[upgrade-proc] 新版 watchdog 存活确认 (pid=${st.pid}, v${st.version})，升级完成`,
+      );
+    } else {
+      console.error(
+        `[upgrade-proc] 新版 watchdog 启动后未存活，请查看窗口/日志排障`,
+      );
+      process.exit(1);
+    }
   } else {
-    console.error(
-      `[upgrade-proc] 新版 watchdog 启动后未存活，请查看窗口/日志排障`,
+    const newPids = (await listWatchdogPids()).filter(
+      (p) => !beforePids.includes(p),
     );
-    process.exit(1);
+    if (newPids.length > 0) {
+      console.error(
+        `[upgrade-proc] 新版 watchdog 存活确认 (pid=${newPids.join(",")})，升级完成`,
+      );
+    } else {
+      console.error(
+        `[upgrade-proc] 新版 watchdog 启动后未存活，请查看窗口/日志排障`,
+      );
+      process.exit(1);
+    }
   }
   process.exit(0);
 }