tt-help-cli-ycl 1.4.107 → 1.4.110

package/package.json

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

package/src/watchdog/upgrader.js

@@ -255,33 +255,149 @@ async function terminateProcess(pid, waitMs = 5000) {
   return false;
 }
 
-/** 枚举指定父进程的直接子进程 PID（Windows: PowerShell；POSIX: pgrep） */
-async function listChildPids(parentPid) {
-  if (!parentPid) return [];
+/**
+ * Windows：向 targetPid 所在控制台发送 CTRL_C_EVENT（等效用户在 cmd 窗口按 Ctrl+C）。
+ * 旧 watchdog 收到后触发 SIGINT → gracefulShutdown → 优雅停业务进程后退出。
+ * 实现：PowerShell P/Invoke AttachConsole（attach 到目标控制台）+
+ *       GenerateConsoleCtrlEvent(0, 0)（发给共享该控制台的所有进程）。
+ * 非 Windows / attach 失败（目标无控制台）返回 false，由调用方强杀兜底。
+ */
+async function sendConsoleCtrlC(targetPid) {
+  if (process.platform !== "win32" || !targetPid) return false;
+  const ps =
+    "Add-Type -TypeDefinition 'using System;using System.Runtime.InteropServices;" +
+    'public class CC{[DllImport("kernel32.dll",SetLastError=true)]public static extern bool FreeConsole();' +
+    '[DllImport("kernel32.dll",SetLastError=true)]public static extern bool AttachConsole(uint p);' +
+    '[DllImport("kernel32.dll",SetLastError=true)]public static extern bool GenerateConsoleCtrlEvent(uint e,uint g);}\';' +
+    `[void][CC]::FreeConsole();$ok=[CC]::AttachConsole(${Number(targetPid)});Write-Output $ok;if($ok){[void][CC]::GenerateConsoleCtrlEvent(0,0)};exit 0`;
+  // 注意：信号发出后 PowerShell 自己也会收到 Ctrl+C 而退出（execFile 报错），
+  // 因此手动包装只取 stdout（True=attach 成功=信号已发出），忽略 exit code。
+  const { stdout } = await new Promise((resolve) => {
+    execFile(
+      "powershell.exe",
+      ["-NoProfile", "-Command", ps],
+      { timeout: 15000, windowsHide: true },
+      (err, out) => resolve({ stdout: String(out || "") }),
+    );
+  });
+  return /True/i.test(stdout);
+}
+
+/** 轮询探测进程是否退出（不发送任何信号） */
+async function waitProcessExit(pid, waitMs) {
+  if (!pid) return true;
+  const deadline = Date.now() + waitMs;
+  while (Date.now() < deadline) {
+    try {
+      process.kill(pid, 0);
+    } catch {
+      return true;
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return false;
+}
+
+/** 向上遍历父链，返回 cmd.exe 祖先进程 PID（旧 watchdog 所在窗口，升级后关窗用） */
+function listCmdAncestorPids(rows, pid) {
+  const byId = new Map(rows.map((r) => [r.pid, r]));
+  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;
+  }
+  return out;
+}
+
+/** 一次拉取全进程表 [{pid, ppid, cmd}]（Windows: CIM；POSIX: ps） */
+async function snapshotAllProcesses() {
+  const rows = [];
   try {
     if (process.platform === "win32") {
       const ps =
-        `Get-CimInstance Win32_Process -Filter "ParentProcessId=${parentPid}" ` +
-        `| Select-Object -ExpandProperty ProcessId`;
+        "Get-CimInstance Win32_Process | ForEach-Object { Write-Output (" +
+        "$_.ProcessId.ToString() + '|' + $_.ParentProcessId.ToString() + '|' + $_.CommandLine) }";
       const { stdout } = await execFileP(
         "powershell.exe",
         ["-NoProfile", "-Command", ps],
-        { timeout: 15000, windowsHide: true },
+        { timeout: 20000, windowsHide: true },
       );
-      return String(stdout)
-        .split(/\r?\n/)
-        .map((s) => parseInt(s.trim(), 10))
-        .filter((n) => n > 0);
+      for (const line of String(stdout).split(/\r?\n/)) {
+        const m = line.match(/^(\d+)\|(\d+)\|(.*)$/);
+        if (m)
+          rows.push({
+            pid: parseInt(m[1], 10),
+            ppid: parseInt(m[2], 10),
+            cmd: m[3] || "",
+          });
+      }
+    } else {
+      const { stdout } = await execFileP("ps", ["-eo", "pid=,ppid=,args="], {
+        timeout: 20000,
+      });
+      for (const line of String(stdout).split(/\n/)) {
+        const m = line.match(/^\s*(\d+)\s+(\d+)\s+(.*)$/);
+        if (m)
+          rows.push({
+            pid: parseInt(m[1], 10),
+            ppid: parseInt(m[2], 10),
+            cmd: m[3] || "",
+          });
+      }
     }
-    const { stdout } = await execFileP("pgrep", ["-P", String(parentPid)], {
-      timeout: 15000,
-    });
-    return String(stdout)
-      .split(/\r?\n/)
-      .map((s) => parseInt(s.trim(), 10))
-      .filter((n) => n > 0);
   } catch {
-    return [];
+    /* 快照失败时返回空，清理环节自然跳过 */
+  }
+  return rows;
+}
+
+/**
+ * BFS 枚举 rootPid 的所有后代 PID（含孙进程），排除 excludePid。
+ * 必须基于【杀旧前】的全表快照：Windows 上业务命令经 cmd 中间层启动，
+ * 杀旧后中间层死亡导致父链断裂，再枚举会漏掉孙进程（211 实测：
+ * webserver 成孤儿占端口，新版拉起 EADDRINUSE）。
+ */
+function listDescendantPids(rows, rootPid, excludePid = 0) {
+  if (!rootPid) return [];
+  const result = new Set();
+  const queue = [rootPid];
+  while (queue.length > 0) {
+    const cur = queue.shift();
+    for (const r of rows) {
+      if (r.ppid === cur && r.pid !== excludePid && !result.has(r.pid)) {
+        result.add(r.pid);
+        queue.push(r.pid);
+      }
+    }
+  }
+  return [...result];
+}
+
+/** 快照中「父进程已死」的孤儿业务进程（本包 node 业务，排除 watchdog/upgrader 自身） */
+function listOrphanBusinessPids(rows) {
+  const alive = new Set(rows.map((r) => r.pid));
+  return rows
+    .filter(
+      (r) =>
+        r.cmd.includes("tt-help-cli-ycl") &&
+        !/watchdog|upgrader/.test(r.cmd) &&
+        !alive.has(r.ppid),
+    )
+    .map((r) => r.pid);
+}
+
+/** 探测进程是否存活（Windows kill(pid,0)；EPERM 也视为存活） */
+async function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return !!(e && e.code === "EPERM");
   }
 }
 
@@ -289,11 +405,10 @@ async function listChildPids(parentPid) {
 async function forceKillTree(pid) {
   try {
     if (process.platform === "win32") {
-      await execFileP(
-        "taskkill.exe",
-        ["/PID", String(pid), "/T", "/F"],
-        { timeout: 15000, windowsHide: true },
-      );
+      await execFileP("taskkill.exe", ["/PID", String(pid), "/T", "/F"], {
+        timeout: 15000,
+        windowsHide: true,
+      });
     } else {
       process.kill(pid, "SIGKILL");
     }
@@ -302,34 +417,24 @@ async function forceKillTree(pid) {
   }
 }
 
-/**
- * 清理旧 watchdog 残留的子进程（升级后不留孤儿占端口/资源）。
- * 流程：枚举直接子进程（排除 excludePid）→ 逐个强杀整棵子树 → 等 1s → 复查残留再杀。
- * 背景：Windows 上 SIGTERM=强杀，旧 watchdog 的业务子进程（webserver 等）会变孤儿；
- *       macOS/Linux 上优雅退出未完成（SIGKILL 兜底）时同样需要清理。
- * @returns {Promise<number[]>} 被清理的 PID 列表
- */
-async function killChildProcesses(parentPid, excludePid = 0) {
+/** 按 PID 列表逐个强杀（存活才杀），等 1s 后复查再杀一轮 */
+async function killPidList(pids, label) {
   const killed = [];
-  const firstRound = (await listChildPids(parentPid)).filter(
-    (p) => p !== excludePid,
-  );
-  for (const pid of firstRound) {
-    await forceKillTree(pid);
-    killed.push(pid);
+  for (const pid of pids) {
+    if (await isProcessAlive(pid)) {
+      await forceKillTree(pid);
+      killed.push(pid);
+    }
   }
   if (killed.length > 0) {
-    console.error(
-      `[upgrade-proc] 已清理旧 watchdog 残留子进程: ${killed.join(", ")}`,
-    );
+    console.error(`[upgrade-proc] ${label}: ${killed.join(", ")}`);
     await new Promise((r) => setTimeout(r, 1000));
-    // 复查：仍有残留则再杀一轮
-    const remain = (await listChildPids(parentPid)).filter(
-      (p) => p !== excludePid,
-    );
-    for (const pid of remain) {
-      await forceKillTree(pid);
-      killed.push(pid);
+    // 复查：仍存活的再杀一轮（防杀树竞态）
+    for (const pid of pids) {
+      if (await isProcessAlive(pid)) {
+        await forceKillTree(pid);
+        if (!killed.includes(pid)) killed.push(pid);
+      }
     }
   }
   return killed;
@@ -437,18 +542,46 @@ export async function runUpgradeMode(argv) {
   }
   console.error(`[upgrade-proc] 新版本验证通过 (${verify.version})`);
 
-  // 3) 杀旧：先优雅发退出信号 → 等待 → 检测残留子进程 → 强杀
-  //      Windows 上 SIGTERM=强杀（无优雅），旧 watchdog 的业务子进程（webserver 等）
-  //      会变孤儿占端口，因此杀旧后必须检测并强杀残留子进程（排除 U 自己）。
+  // 3) 杀旧：先优雅退出（等效 Ctrl+C）→ 等待 → 强杀兜底 → 按快照清理进程树 → 关旧窗口
+  //      Windows 上 process.kill(SIGTERM)=强杀（无优雅），但用户在 cmd 窗口按 Ctrl+C
+  //      会触发旧 watchdog 的 SIGINT → gracefulShutdown 优雅停业务。因此先向旧 watchdog
+  //      的控制台发送 CTRL_C_EVENT（等效手动按键），8s 未退再强杀兜底；随后按【杀旧前】
+  //      快照强杀整棵后代树（排除 U 自己；杀旧后中间层死亡会断父链，必须提前快照），
+  //      再兜底清理「父已死」的孤儿业务进程，最后关闭旧 watchdog 所在的 cmd 窗口。
   console.error(`[upgrade-proc] 通知旧 watchdog (pid=${oldPid}) 退出 ...`);
-  const exited = await terminateProcess(oldPid, 5000);
+  const procSnapshot = await snapshotAllProcesses();
+  const descPids = listDescendantPids(procSnapshot, oldPid, process.pid);
+  const cmdAncestors = listCmdAncestorPids(procSnapshot, oldPid);
+
+  let exited = false;
+  const gracefulSent =
+    process.platform === "win32" && (await sendConsoleCtrlC(oldPid));
+  if (gracefulSent) {
+    console.error(
+      `[upgrade-proc] 已发送 Ctrl+C（等效手动按键），等待旧 watchdog 优雅停止业务...`,
+    );
+    exited = await waitProcessExit(oldPid, 8000);
+  }
   if (exited) {
-    console.error(`[upgrade-proc] 旧 watchdog 已退出`);
+    console.error(`[upgrade-proc] 旧 watchdog 已优雅退出`);
   } else {
-    console.error(`[upgrade-proc] 旧 watchdog 未在 5s 内退出，已强制终止`);
-    await new Promise((r) => setTimeout(r, 1000)); // 给强杀一点生效时间
+    if (gracefulSent) {
+      console.error(`[upgrade-proc] 旧 watchdog 未在 8s 内优雅退出，强制终止`);
+    }
+    exited = await terminateProcess(oldPid, 5000);
+    if (exited) {
+      console.error(`[upgrade-proc] 旧 watchdog 已退出`);
+    } else {
+      console.error(`[upgrade-proc] 旧 watchdog 未在 5s 内退出，已强制终止`);
+      await new Promise((r) => setTimeout(r, 1000)); // 给强杀一点生效时间
+    }
   }
-  await killChildProcesses(oldPid, process.pid);
+  await killPidList(descPids, "已清理旧 watchdog 进程树");
+  // 兜底：快照时父链已断（中间层先死）的孤儿业务进程，杀旧后按特征清理
+  const orphanPids = listOrphanBusinessPids(await snapshotAllProcesses());
+  await killPidList(orphanPids, "已清理孤儿业务进程");
+  // 关闭旧 watchdog 所在的 cmd 窗口（业务已停，窗口只剩空壳提示符）
+  await killPidList(cmdAncestors, "已关闭旧 cmd 窗口");
 
   // 4) 旧进程已退，启新版 watchdog
   //     Windows：显式弹独立交互 cmd 窗口（start → cmd /k），日志直接显示在窗口，