tt-help-cli-ycl 1.4.90 → 1.4.92

package/package.json

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

package/src/cli/explore.js

@@ -72,6 +72,7 @@ export async function handleExplore(options) {
     exploreMaxVideos,
     exploreProxy,
     exploreWebserver,
+    exploreNoProduct,
   } = options;
 
   let userId = exploreUserId || configuredUserId;
@@ -472,6 +473,7 @@ export async function handleExplore(options) {
             location: exploreLocation,
             proxyServer: cdpOptions.proxyServer || null,
             webserverUrl: exploreWebserver || null,
+            noProduct: !!exploreNoProduct,
           },
           console.error,
         );
@@ -498,6 +500,7 @@ export async function handleExplore(options) {
               location: exploreLocation,
               proxyServer: cdpOptions.proxyServer || null,
               webserverUrl: exploreWebserver || null,
+              noProduct: !!exploreNoProduct,
               browser,
             },
             console.error,
@@ -546,6 +549,7 @@ export async function handleExplore(options) {
                 location: exploreLocation,
                 proxyServer: cdpOptions.proxyServer || null,
                 webserverUrl: exploreWebserver || null,
+                noProduct: !!exploreNoProduct,
                 browser,
               },
               console.error,

package/src/cli/refresh.js

@@ -70,6 +70,7 @@ export async function handleRefresh(options) {
     exploreRedoMaxAge,
     exploreProxy,
     exploreWebserver,
+    exploreNoProduct,
   } = options;
   const effectiveProxy = exploreProxy || configuredProxy;
   let resolvedProxy = effectiveProxy;
@@ -489,6 +490,7 @@ export async function handleRefresh(options) {
           browser,
           proxyServer: cdpOptions.proxyServer || null,
           webserverUrl: exploreWebserver || null,
+          noProduct: !!exploreNoProduct,
         },
         console.error,
       );
@@ -516,6 +518,7 @@ export async function handleRefresh(options) {
             browser,
             proxyServer: cdpOptions.proxyServer || null,
             webserverUrl: exploreWebserver || null,
+            noProduct: !!exploreNoProduct,
           },
           console.error,
         );
@@ -565,6 +568,7 @@ export async function handleRefresh(options) {
               browser,
               proxyServer: cdpOptions.proxyServer || null,
               webserverUrl: exploreWebserver || null,
+              noProduct: !!exploreNoProduct,
             },
             console.error,
           );

package/src/lib/args.js

@@ -182,6 +182,7 @@ function parseExploreArgs(args) {
   let exploreMaxVideos = 16;
   let exploreProxy = null;
   let exploreWebserver = null;
+  let exploreNoProduct = false;
 
   const positional = [];
   const PRESETS = ["fast", "normal", "slow", "stealth"];
@@ -224,6 +225,8 @@ function parseExploreArgs(args) {
       exploreProxy = args[++i];
     } else if (arg === "--webserver") {
       exploreWebserver = args[++i];
+    } else if (arg === "--no-product") {
+      exploreNoProduct = true;
     } else {
       positional.push(arg);
     }
@@ -266,6 +269,7 @@ function parseExploreArgs(args) {
     exploreMaxVideos,
     exploreProxy,
     exploreWebserver,
+    exploreNoProduct,
     urls: [],
     outputFormat: "json",
     exploreCount: 0,
@@ -510,6 +514,7 @@ function parseRefreshArgs(args) {
   let exploreProxy = null;
   let exploreJobLocations = null;
   let exploreWebserver = null;
+  let exploreNoProduct = false;
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -541,6 +546,8 @@ function parseRefreshArgs(args) {
       exploreProxy = args[++i];
     } else if (arg === "--webserver") {
       exploreWebserver = args[++i];
+    } else if (arg === "--no-product") {
+      exploreNoProduct = true;
     } else if (arg === "--location") {
       exploreLocation = args[++i];
     } else if (arg === "--job-locations") {
@@ -573,6 +580,7 @@ function parseRefreshArgs(args) {
     exploreRedoMaxAge,
     exploreProxy,
     exploreWebserver,
+    exploreNoProduct,
     serverUrl,
     urls: [],
     outputFormat: "json",

package/src/scraper/explore-core.js

@@ -27,6 +27,7 @@ async function processExplore(page, username, options, log) {
     locationMode = "explore", // "explore" | "refresh"
     proxyServer = null,
     webserverUrl = null,
+    noProduct = false,
   } = options;
 
   const result = {
@@ -130,8 +131,9 @@ async function processExplore(page, username, options, log) {
         seoUrl: topVideo.seoUrl || null,
       };
 
-      // 如果有商品链接，通过 WebService API 抓取商品详情页（评分、销量等）
-      if (topVideo.seoUrl && options.webserverUrl) {
+      // 如果有商品链接且未禁用，通过 WebService API 抓取商品详情页（评分、销量等）
+      // --no-product 时跳过（由独立商品程序异步补抓，避免阻塞 explore/refresh 主流程）
+      if (topVideo.seoUrl && options.webserverUrl && !noProduct) {
         try {
           const resp = await fetch(
             `${options.webserverUrl}/api/tiktok/product`,

package/src/watchdog/agent.js

@@ -16,14 +16,14 @@ import {
 import { ProcessManager } from "./process-manager.js";
 import {
   getVersion,
-  performUpgrade,
+  spawnUpgraderAndWait,
   isGlobalInstall,
   startUpgradeChecker,
 } from "./upgrader.js";
-import { writeFileSync, existsSync, readFileSync, openSync } from "fs";
+import { writeFileSync, existsSync, readFileSync } from "fs";
 import { spawn } from "child_process";
 import { join, dirname } from "path";
-import { homedir, tmpdir } from "os";
+import { homedir } from "os";
 import { fileURLToPath } from "url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -574,32 +574,39 @@ export class WatchdogAgent {
 
     this.upgradeChecker = startUpgradeChecker({
       onUpdateAvailable: async ({ current, latest }) => {
-        console.error(`[upgrade] ${current} → ${latest}`);
-        // 升级流程：先标记 daemon 主动关闭（避免 kill 后被崩溃自愈重新拉起旧版），再停业务与 daemon
-        this._daemonStopping = true;
-        this.processManager.stopAll();
-        this._killClashDaemon();
-
-        const result = await performUpgrade();
-        if (result.success) {
-          this.ttHelpVersion = latest;
+        // 简化升级：spawn 独立升级器下载，下载期间业务/心跳完全不受影响；
+        // 下载成功后才停业务并退出，由新版接管（避免"边停边起"与二次 taskkill 竞态）
+        console.error(
+          `[upgrade] ${current} → ${latest}，启动升级程序（下载期间业务不受影响）`,
+        );
+        const outcome = await spawnUpgraderAndWait(this._buildRestartParams());
+        if (outcome !== "ok") {
           console.error(
-            `[upgrade] 升级成功 (${latest})，重启 watchdog 使新版 clash daemon 生效`,
+            `[upgrade] 升级未完成（${outcome === "fail" ? "下载失败" : "升级程序无响应"}），保持当前版本运行`,
           );
-          // 重启自身进程加载新代码（内部 daemon 路径优先），新进程会拉起新版 daemon
-          this._restartSelf();
           return;
         }
-        // 升级失败：恢复 daemon 与业务，保持当前进程运行
         console.error(
-          `[upgrade] 失败: ${result.output.substring(0, 200)}，恢复运行`,
+          `[upgrade] 新版本已下载，停止业务与 daemon 后退出，新版将接管`,
         );
-        this._recoverAfterFailedUpgrade();
-        await this._sendHeartbeat();
+        await this.stop();
+        process.exit(0);
       },
     });
   }
 
+  /** 构建新版 watchdog 重启所需参数（透传给独立升级器） */
+  _buildRestartParams() {
+    return {
+      serverUrl: this.serverUrl,
+      clientId: this.clientId,
+      intervalSec: Math.max(5, Math.round(this.intervalMs / 1000)),
+      spawnDaemon: this.spawnDaemon,
+      interactive: !!process.stdout.isTTY,
+      oldPid: process.pid,
+    };
+  }
+
   /**
    * 启动 clash daemon 子进程
    * daemon 负责代理节点健康巡检和故障切换，watchdog 不阻塞等待
@@ -724,110 +731,6 @@ export class WatchdogAgent {
     this.clashDaemon = null;
   }
 
-  /**
-   * 升级后重启自身进程（加载新代码）
-   * 用 cli.js watchdog 子进程替换当前进程，保证新版本内部 daemon 路径逻辑生效。
-   * 带存活确认与兜底：新进程确认存活后才退出旧进程；启动失败则回退保持旧进程运行。
-   */
-  _restartSelf() {
-    const cliPath = join(__dirname, "..", "..", "cli.js");
-    const args = ["watchdog"];
-    if (this.serverUrl) args.push("--server", this.serverUrl);
-    if (this.clientId) args.push("--client-id", this.clientId);
-    if (!this.spawnDaemon) args.push("--no-daemon");
-    args.push(
-      "--interval",
-      String(Math.max(5, Math.round(this.intervalMs / 1000))),
-    );
-
-    // 交互式终端（用户在 cmd 窗口里手动跑 tt-help watchdog）：
-    // 升级重启后接管原控制台窗口继续显示（stdio inherit + 不 detached），窗口不消失
-    const interactive = !!process.stdout.isTTY;
-
-    // 非交互（计划任务/脚本/无人值守）时，新进程日志重定向到文件，崩溃有据可查
-    let logFd = undefined;
-    try {
-      const logPath = join(
-        tmpdir(),
-        `tt-help-watchdog-restart-${Date.now()}.log`,
-      );
-      logFd = openSync(logPath, "a");
-      console.error(`[upgrade] 新进程日志: ${logPath}`);
-    } catch {}
-    const out = logFd ?? "ignore";
-
-    let child;
-    try {
-      child = spawn(process.execPath, [cliPath, ...args], {
-        // 交互式：继承原 cmd 窗口一直显示；非交互：后台运行 + 日志文件
-        detached: !interactive,
-        stdio: interactive ? "inherit" : ["ignore", out, out],
-        windowsHide: !interactive, // 交互时不隐藏，保留可见窗口
-      });
-    } catch (e) {
-      console.error(`[upgrade] 重启自身失败: ${e.message}，保持旧进程运行`);
-      this._recoverAfterFailedUpgrade();
-      return;
-    }
-    // 非交互后台进程独立存活（父进程退出不影响）；交互式继承窗口无需 unref
-    if (!interactive) child.unref();
-
-    // 存活确认：轮询新进程是否正常存活，确认后才退出旧进程
-    let exited = false;
-    let exitCode = null;
-    let exitSignal = null;
-    child.once("exit", (c, s) => {
-      exited = true;
-      exitCode = c;
-      exitSignal = s;
-    });
-
-    console.error(
-      `[upgrade] 新版 watchdog 已启动 (pid=${child.pid})，等待存活确认...`,
-    );
-    let attempts = 0;
-    const confirm = () => {
-      attempts++;
-      if (exited) {
-        console.error(
-          `[upgrade] 新版 watchdog 启动后即退出 (code=${exitCode}, signal=${exitSignal})，回退保持旧进程`,
-        );
-        this._recoverAfterFailedUpgrade();
-        return;
-      }
-      try {
-        process.kill(child.pid, 0); // 抛错说明进程已不存在
-      } catch {
-        console.error(
-          `[upgrade] 新版 watchdog 进程不存在 (pid=${child.pid})，回退保持旧进程`,
-        );
-        this._recoverAfterFailedUpgrade();
-        return;
-      }
-      if (attempts >= 6) {
-        console.error(`[upgrade] 新版 watchdog 存活确认，旧进程退出`);
-        this.stop();
-        setTimeout(() => process.exit(0), 500);
-        return;
-      }
-      setTimeout(confirm, 1000);
-    };
-    setTimeout(confirm, 1000);
-  }
-
-  /**
-   * 升级/重启失败后的回退恢复：重新拉起 daemon 并同步业务进程
-   */
-  _recoverAfterFailedUpgrade() {
-    this._daemonStopping = false;
-    if (this.spawnDaemon && !this.clashDaemon) {
-      console.error(`[upgrade] 恢复 clash daemon...`);
-      this._spawnClashDaemon();
-    }
-    console.error(`[upgrade] 恢复业务进程（等待心跳同步命令）...`);
-    this._sendHeartbeat().catch(() => {});
-  }
-
   /**
    * 信号处理
    */

package/src/watchdog/upgrader.js

@@ -5,11 +5,11 @@
  * 发现新版本 → 回调通知 agent → agent 负责停进程 → 升级 → 重启。
  */
 
-import { exec } from "child_process";
-import { readFileSync } from "fs";
+import { exec, spawn } from "child_process";
+import { readFileSync, writeFileSync, unlinkSync, openSync } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
-import { homedir } from "os";
+import { homedir, tmpdir } from "os";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PKG_PATH = join(__dirname, "..", "..", "package.json");
@@ -156,3 +156,199 @@ 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");
+
+function writeUpgradeResult(state) {
+  try {
+    writeFileSync(
+      UPGRADE_RESULT_FILE,
+      JSON.stringify({ ...state, at: Date.now() }, null, 2),
+      "utf-8",
+    );
+  } catch {}
+}
+
+/** 轮询等待指定 pid 退出，返回是否已退出（超时返回 false） */
+async function waitProcessExit(
+  pid,
+  { timeoutMs = 60_000, pollMs = 1000 } = {},
+) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      process.kill(pid, 0); // 存在则继续等
+    } catch {
+      return true; // 已退出
+    }
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+  return false;
+}
+
+/**
+ * 独立升级器主流程（由旧 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");
+
+  console.error(
+    `[upgrade-proc] 开始下载新版: npm install -g ${PACKAGE}@latest ...`,
+  );
+  const result = await performUpgrade();
+  if (!result.success) {
+    const err = result.output.substring(0, 300);
+    console.error(`[upgrade-proc] 下载失败: ${err}`);
+    writeUpgradeResult({ status: "fail", error: 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}) 退出超时，继续启动新版`,
+      );
+    }
+  }
+
+  // 启动新版 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 {}
+
+  let child;
+  try {
+    child = spawn(process.execPath, [cliPath, ...args], {
+      detached: !interactive,
+      stdio: interactive
+        ? "inherit"
+        : ["ignore", logFd || "ignore", logFd || "ignore"],
+      windowsHide: !interactive,
+    });
+    if (!interactive) child.unref();
+  } 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">}
+ */
+export function spawnUpgraderAndWait({
+  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 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);
+  });
+}
+
+// 直接运行时自动进入独立升级器模式
+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);
+  });
+}