tt-help-cli-ycl 1.4.126 → 1.4.130

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