tt-help-cli-ycl 1.4.92 → 1.4.93

package/package.json

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

package/src/watchdog/agent.js

@@ -16,7 +16,7 @@ import {
 import { ProcessManager } from "./process-manager.js";
 import {
   getVersion,
-  spawnUpgraderAndWait,
+  spawnUpgrader,
   isGlobalInstall,
   startUpgradeChecker,
 } from "./upgrader.js";
@@ -574,23 +574,13 @@ export class WatchdogAgent {
 
     this.upgradeChecker = startUpgradeChecker({
       onUpdateAvailable: async ({ current, latest }) => {
-        // 简化升级：spawn 独立升级器下载，下载期间业务/心跳完全不受影响；
-        // 下载成功后才停业务并退出，由新版接管（避免"边停边起"与二次 taskkill 竞态）
+        // 独立升级器方案（无中间文件）：spawn 升级进程 U（fire-and-forget），U 负责「下载 / 起新版 / 信号通知退出」。
+        // 下载期间业务/心跳不受影响；下载失败 U 自行退出，本进程保持运行；
+        // 新版起来后 U 发 SIGTERM → 本进程 gracefulShutdown 停业务/daemon 后退出，新版接管。
         console.error(
           `[upgrade] ${current} → ${latest}，启动升级程序（下载期间业务不受影响）`,
         );
-        const outcome = await spawnUpgraderAndWait(this._buildRestartParams());
-        if (outcome !== "ok") {
-          console.error(
-            `[upgrade] 升级未完成（${outcome === "fail" ? "下载失败" : "升级程序无响应"}），保持当前版本运行`,
-          );
-          return;
-        }
-        console.error(
-          `[upgrade] 新版本已下载，停止业务与 daemon 后退出，新版将接管`,
-        );
-        await this.stop();
-        process.exit(0);
+        spawnUpgrader(this._buildRestartParams());
       },
     });
   }

package/src/watchdog/upgrader.js

@@ -1,12 +1,13 @@
 /**
  * 自动升级模块 — 检测 tt-help-cli-ycl 新版本并执行升级
  *
- * 仅全局安装模式启用。每 10 分钟查询 npm registry，
- * 发现新版本 → 回调通知 agent → agent 负责停进程 → 升级 → 重启。
+ * 仅全局安装模式启用。每 10 分钟查询 npm registry 发现新版本，
+ * 由旧 watchdog spawn 独立升级进程 U：U 负责「下载 → 验证代码 → 杀旧 → 启新」，
+ * 见 runUpgradeMode。旧 watchdog 收到 SIGTERM 后优雅退出，新版接管。
  */
 
 import { exec, spawn } from "child_process";
-import { readFileSync, writeFileSync, unlinkSync, openSync } from "fs";
+import { readFileSync, openSync } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
 import { homedir, tmpdir } from "os";
@@ -113,6 +114,60 @@ export function performUpgrade() {
   });
 }
 
+/**
+ * 下载后验证：确认 npm install 真正换了版本，且新版主模块能加载（冒烟）
+ * 验证通过才允许杀旧 → 启新；失败则旧 watchdog 不受影响继续运行
+ */
+async function verifyUpgradedPackage(beforeVersion) {
+  const now = getVersion();
+  if (now === "unknown")
+    return { ok: false, reason: "读不到全局包版本（package.json 缺失）" };
+  if (now === beforeVersion)
+    return {
+      ok: false,
+      reason: `版本未变化（仍 ${now}），疑似 npm install 未生效`,
+    };
+  const smoke = await smokeTestMainModule();
+  if (!smoke.ok) return { ok: false, reason: smoke.reason };
+  return { ok: true, version: now };
+}
+
+/** 冒烟：spawn 子进程加载新版主模块（仅加载不执行业务），能加载则代码/依赖基本可用 */
+function smokeTestMainModule(timeoutMs = 15_000) {
+  return new Promise((resolve) => {
+    const mainModulePath = join(__dirname, "..", "..", "src", "main.js");
+    const code = `import(${JSON.stringify(
+      mainModulePath,
+    )}).then(()=>process.exit(0)).catch((e)=>{console.error(e&&e.message||e);process.exit(1)})`;
+    let child;
+    try {
+      child = spawn(process.execPath, ["--input-type=module", "-e", code], {
+        stdio: ["ignore", "ignore", "pipe"],
+        windowsHide: true,
+      });
+    } catch (e) {
+      resolve({ ok: false, reason: `冒烟启动失败: ${e.message}` });
+      return;
+    }
+    let err = "";
+    child.stderr?.on("data", (d) => (err += d.toString()));
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {}
+      resolve({ ok: false, reason: `冒烟超时 ${timeoutMs}ms` });
+    }, timeoutMs);
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      resolve(
+        code === 0
+          ? { ok: true }
+          : { ok: false, reason: `冒烟失败: ${err.slice(0, 200)}` },
+      );
+    });
+  });
+}
+
 /**
  * 启动定时升级检测
  * @param {{intervalMs?: number, onUpdateAvailable?: function}} opts
@@ -161,194 +216,181 @@ export function startUpgradeChecker({
 // 独立升级器（直接运行模式）
 // ══════════════════════════════════════════════
 //
-// 设计目标：让升级变得简单、无竞态。
-//   旧 watchdog 检测到新版 → spawn 独立升级器（detached）→ 旧 watchdog 继续正常运行（业务不断）
-//   升级器：npm install → 写结果文件 → 等旧 watchdog 退出 → spawn 新版 watchdog → 自身退出
-//   旧 watchdog 看到结果 ok → 停心跳/停业务/停 daemon → 退出，由新版接管。
-//
-// 结果文件：tmpdir/tt-help-upgrade-result.json
-//  - 由升级器写入 { status: "ok" | "fail", error?, at }，旧 watchdog 轮询读取
-//
-// 用法（旧 watchdog 调用）：
-//   node upgrader.js --upgrade --old-pid <pid> [--interactive] [--server ...] [--client-id ...] [--interval ...] [--no-daemon]
-
-const UPGRADE_RESULT_FILE = join(tmpdir(), "tt-help-upgrade-result.json");
+// 设计（定稿，无中间文件）：旧 watchdog 检测到新版 → spawn 独立升级进程 U（detached）
+//   U：npm install 下载 →【验证代码】→【杀旧】→【启新】
+//   - 下载失败 / 验证未通过（版本未变、新版主模块加载失败）→ 不杀旧，旧 watchdog 继续跑
+//   - 验证通过 → SIGTERM 旧 watchdog（优雅，5s 未退强杀兜底）→ 无并存窗口 → 启新版一定能起来
+// 关键：U 的 stdout/stderr 独立落盘（tmpdir/tt-help-upgrader-*.log），旧 watchdog 退出后日志不断，可定位。
 
-function writeUpgradeResult(state) {
+/** 打开日志文件（追加模式）并打印路径；失败返回 undefined（stdio 回退到 ignore） */
+function openLogFile(prefix, label, what) {
   try {
-    writeFileSync(
-      UPGRADE_RESULT_FILE,
-      JSON.stringify({ ...state, at: Date.now() }, null, 2),
-      "utf-8",
-    );
-  } catch {}
+    const logPath = join(tmpdir(), `${prefix}-${Date.now()}.log`);
+    console.error(`[${label}] ${what}: ${logPath}`);
+    return openSync(logPath, "a");
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * spawn 子进程（升级器 / 新版 watchdog 共用）
+ * interactive：继承控制台；否则 detached 后台运行，stdout/stderr 落到 logFd
+ * @param {string[]} args 子进程完整参数（node 脚本路径 + 参数）
+ * @returns {import("child_process").ChildProcess}
+ */
+function spawnChild(args, { interactive = false, logFd } = {}) {
+  const child = spawn(process.execPath, args, {
+    detached: !interactive,
+    stdio: interactive
+      ? "inherit"
+      : ["ignore", logFd || "ignore", logFd || "ignore"],
+    windowsHide: !interactive,
+  });
+  if (!interactive) child.unref();
+  return child;
 }
 
-/** 轮询等待指定 pid 退出，返回是否已退出（超时返回 false） */
-async function waitProcessExit(
-  pid,
-  { timeoutMs = 60_000, pollMs = 1000 } = {},
-) {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
+/**
+ * 终止进程：先 SIGTERM（优雅），轮询等待退出；窗口内未退出则 SIGKILL 兜底。
+ * Windows 注意：process.kill(pid, "SIGTERM") 在 Windows 上即强制终止（无优雅退出）。
+ * @returns {Promise<boolean>} 是否在窗口内退出（false = 已强杀兜底）
+ */
+async function terminateProcess(pid, waitMs = 5000) {
+  if (!pid) return true;
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return true; // 进程已不存在
+  }
+  const deadline = Date.now() + waitMs;
+  while (Date.now() < deadline) {
     try {
-      process.kill(pid, 0); // 存在则继续等
+      process.kill(pid, 0); // 0 仅探测存活；抛错 = 已退出
+      await new Promise((r) => setTimeout(r, 500));
     } catch {
-      return true; // 已退出
+      return true;
     }
-    await new Promise((r) => setTimeout(r, pollMs));
   }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {}
   return false;
 }
 
+/** 新版 watchdog 的 CLI 参数（透传 server/clientId/interval/noDaemon，保证与旧版一致） */
+function buildWatchdogArgs({ serverUrl, clientId, intervalSec, noDaemon }) {
+  const args = ["watchdog"];
+  if (serverUrl) args.push("--server", serverUrl);
+  if (clientId) args.push("--client-id", clientId);
+  args.push("--interval", String(intervalSec));
+  if (noDaemon) args.push("--no-daemon");
+  return args;
+}
+
 /**
  * 独立升级器主流程（由旧 watchdog 以子进程方式启动）
+ * 顺序：下载 → 验证代码 → 杀旧 → 启新。任一步失败都不杀旧，业务不断。
  * @param {string[]} argv - process.argv.slice(2)
  */
 export async function runUpgradeMode(argv) {
   const get = (f) => (argv.includes(f) ? argv[argv.indexOf(f) + 1] : undefined);
-  const oldPid = parseInt(get("--old-pid"), 10) || 0;
   const interactive = argv.includes("--interactive");
   const serverUrl = get("--server");
   const clientId = get("--client-id");
   const intervalSec = parseInt(get("--interval"), 10) || 15;
   const noDaemon = argv.includes("--no-daemon");
+  // 旧 watchdog pid：显式 --old-pid > 父进程 pid（默认由旧 watchdog spawn 时即父进程）
+  const oldPid =
+    (argv.includes("--old-pid") ? parseInt(get("--old-pid"), 10) : 0) ||
+    process.ppid;
 
+  // 1) 下载
   console.error(
     `[upgrade-proc] 开始下载新版: npm install -g ${PACKAGE}@latest ...`,
   );
+  const beforeVersion = getVersion(); // 下载前版本，用于验证 npm install 真正生效
   const result = await performUpgrade();
   if (!result.success) {
     const err = result.output.substring(0, 300);
-    console.error(`[upgrade-proc] 下载失败: ${err}`);
-    writeUpgradeResult({ status: "fail", error: err });
+    console.error(`[upgrade-proc] 下载失败，保持当前版本运行: ${err}`);
     process.exit(1);
   }
-  console.error(`[upgrade-proc] 下载完成，通知旧 watchdog 退出`);
-  writeUpgradeResult({ status: "ok" });
 
-  // 等旧 watchdog 退出，避免与其 stopAll 竞态（它退出后才会让新版接管业务）
-  if (oldPid) {
-    const exited = await waitProcessExit(oldPid);
-    if (!exited) {
-      console.error(
-        `[upgrade-proc] 等待旧 watchdog(pid=${oldPid}) 退出超时，继续启动新版`,
-      );
-    }
+  // 2) 下载后验证：版本确实更新 + 新版主模块能加载（冒烟）；通过才允许杀旧
+  const verify = await verifyUpgradedPackage(beforeVersion);
+  if (!verify.ok) {
+    console.error(
+      `[upgrade-proc] 新版本验证未通过，不切换，保持当前版本运行: ${verify.reason}`,
+    );
+    process.exit(1);
   }
+  console.error(`[upgrade-proc] 新版本验证通过 (${verify.version})`);
 
-  // 启动新版 watchdog（interactive 时继承控制台接管窗口；否则后台 + 日志文件）
-  const cliPath = join(
-    dirname(fileURLToPath(import.meta.url)),
-    "..",
-    "..",
-    "cli.js",
-  );
-  const args = ["watchdog"];
-  if (serverUrl) args.push("--server", serverUrl);
-  if (clientId) args.push("--client-id", clientId);
-  args.push("--interval", String(intervalSec));
-  if (noDaemon) args.push("--no-daemon");
-
-  let logFd = undefined;
-  try {
-    const logPath = join(tmpdir(), `tt-help-watchdog-${Date.now()}.log`);
-    logFd = openSync(logPath, "a");
-    console.error(`[upgrade-proc] 新版 watchdog 日志: ${logPath}`);
-  } catch {}
+  // 3) 杀旧：SIGTERM 优雅优先，5s 未退强杀兜底（U 不卡死）
+  console.error(`[upgrade-proc] 通知旧 watchdog (pid=${oldPid}) 退出 ...`);
+  const 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)); // 给强杀一点生效时间
+  }
 
-  let child;
+  // 4) 旧进程已退，启新版 watchdog（无并存窗口，一定能起来）
+  console.error(`[upgrade-proc] 启动新版 watchdog ...`);
+  const cliPath = join(__dirname, "..", "..", "cli.js");
+  const args = buildWatchdogArgs({ serverUrl, clientId, intervalSec, noDaemon });
+  const logFd = openLogFile(
+    "tt-help-watchdog",
+    "upgrade-proc",
+    "新版 watchdog 日志",
+  );
   try {
-    child = spawn(process.execPath, [cliPath, ...args], {
-      detached: !interactive,
-      stdio: interactive
-        ? "inherit"
-        : ["ignore", logFd || "ignore", logFd || "ignore"],
-      windowsHide: !interactive,
-    });
-    if (!interactive) child.unref();
+    const child = spawnChild([cliPath, ...args], { interactive, logFd });
+    console.error(`[upgrade-proc] 新版 watchdog 已启动 (pid=${child.pid})`);
   } catch (e) {
     console.error(`[upgrade-proc] 新版 watchdog 启动失败: ${e.message}`);
     process.exit(1);
   }
-  console.error(`[upgrade-proc] 新版 watchdog 已启动 (pid=${child.pid})`);
   process.exit(0);
 }
 
 /**
- * 旧 watchdog 调用：spawn 独立升级器并轮询结果文件
- * @returns {Promise<"ok"|"fail"|"timeout">}
+ * 旧 watchdog 调用：spawn 独立升级器（fire-and-forget，不等待、不写中间文件）
+ * 升级器负责「下载 → 验证 → 杀旧 → 启新」（见 runUpgradeMode）；本进程收到 SIGTERM 优雅退出。
+ * 非交互时升级器 stdout/stderr 落盘（进程退出后日志不断，可定位问题）
+ * @returns {import("child_process").ChildProcess|null} 升级器子进程（spawn 失败返回 null）
  */
-export function spawnUpgraderAndWait({
+export function spawnUpgrader({
   serverUrl,
   clientId,
   intervalSec = 15,
   spawnDaemon = true,
   interactive = false,
   oldPid = 0,
-  timeoutMs = 180_000,
 } = {}) {
-  return new Promise((resolve) => {
-    // 清理上次结果
-    try {
-      unlinkSync(UPGRADE_RESULT_FILE);
-    } catch {}
-
-    const upgraderPath = fileURLToPath(import.meta.url);
-    const args = ["--upgrade", "--old-pid", String(oldPid || process.pid)];
-    if (serverUrl) args.push("--server", serverUrl);
-    if (clientId) args.push("--client-id", clientId);
-    args.push("--interval", String(intervalSec));
-    if (!spawnDaemon) args.push("--no-daemon");
-    if (interactive) args.push("--interactive");
-
-    let child;
-    try {
-      child = spawn(process.execPath, [upgraderPath, ...args], {
-        // 交互：升级器接管控制台（后续新版 watchdog 也继承窗口）；非交互：后台 + 日志
-        detached: !interactive,
-        stdio: interactive ? "inherit" : ["ignore", "pipe", "pipe"],
-        windowsHide: !interactive,
-      });
-      if (!interactive) child.unref();
-    } catch (e) {
-      console.error(`[watchdog] 升级程序启动失败: ${e.message}`);
-      resolve("fail");
-      return;
-    }
-    child.stderr?.on("data", (d) => {
-      const m = d.toString().trim();
-      if (m) console.error(`[upgrade-proc] ${m.substring(0, 200)}`);
-    });
+  const upgraderPath = fileURLToPath(import.meta.url);
+  const args = ["--upgrade", "--old-pid", String(oldPid || process.ppid)];
+  if (serverUrl) args.push("--server", serverUrl);
+  if (clientId) args.push("--client-id", clientId);
+  args.push("--interval", String(intervalSec));
+  if (!spawnDaemon) args.push("--no-daemon");
+  if (interactive) args.push("--interactive");
 
-    const started = Date.now();
-    const timer = setInterval(() => {
-      try {
-        const data = JSON.parse(readFileSync(UPGRADE_RESULT_FILE, "utf-8"));
-        if (data && data.status) {
-          clearInterval(timer);
-          resolve(data.status === "ok" ? "ok" : "fail");
-        }
-      } catch {}
-      if (Date.now() - started > timeoutMs) {
-        clearInterval(timer);
-        try {
-          unlinkSync(UPGRADE_RESULT_FILE);
-        } catch {}
-        console.error(
-          `[watchdog] 升级程序 ${timeoutMs / 1000}s 无结果，放弃等待`,
-        );
-        resolve("timeout");
-      }
-    }, 2000);
-  });
+  const logFd = openLogFile("tt-help-upgrader", "watchdog", "升级程序日志");
+  try {
+    return spawnChild([upgraderPath, ...args], { interactive, logFd });
+  } catch (e) {
+    console.error(`[watchdog] 升级程序启动失败: ${e.message}`);
+    return null;
+  }
 }
 
 // 直接运行时自动进入独立升级器模式
 if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
   runUpgradeMode(process.argv.slice(2)).catch((e) => {
     console.error(`[upgrade-proc] 升级器异常: ${e.message}`);
-    writeUpgradeResult({ status: "fail", error: e.message });
     process.exit(1);
   });
 }