tt-help-cli-ycl 1.4.125 → 1.4.126

package/package.json

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

package/src/cli/open.js

@@ -90,8 +90,8 @@ export async function handleOpen(parsed) {
 
     browser = await ensureBrowserReady(cdpOptions);
 
-    // Ctrl+C 关闭浏览器
-    process.on("SIGINT", async () => {
+    // Ctrl+C 关闭浏览器：优雅断开优先（超时保护），强杀进程兜底，最后强制退出
+    const shutdown = async () => {
       console.error("\n正在关闭浏览器...");
       // 先优雅断开 CDP 连接（带 3s 超时保护）：进程已被强杀时 close() 会挂起等 close 事件
       try {
@@ -109,7 +109,8 @@ export async function handleOpen(parsed) {
       });
       console.error("浏览器已关闭");
       process.exit(0);
-    });
+    };
+    process.on("SIGINT", shutdown);
 
     console.error("");
     console.error("浏览器已启动并连接成功");

package/src/lib/api-interceptor.js

@@ -251,17 +251,16 @@ async function attemptItemListFetch(page, username, log, apiRequestUrlRef) {
   };
 }
 
-async function fetchUserVideosAPI(
-  page,
-  username,
-  maxVideos,
-  log,
-  options = {},
-) {
-  log(`  [API拦截] 获取 @${username} 视频 ...`);
-
+/**
+ * CDP 健康检查：带超时保护，区分"页面忙"与"页面死"。
+ * evaluate 排队在页面主线程上，加载中的慢页面（肉眼可见转圈）10s 轮不到执行很正常，
+ * 此时是忙不是死：先观察等待（默认 2 轮 x 20s），慢页面通常在此期间自然加载完自愈。
+ * 观察后仍无响应才刷新页面（实测刷新可解除主线程死锁）；刷新后页面处于最忙的加载期，
+ * 先缓冲等待再以更宽松的窗口重检，避免误杀正在恢复的页面。
+ * 全部失败抛 "CDP 连接异常（刷新后仍失败）"。
+ */
+async function checkCdpHealth(page, options, log) {
   const {
-    blockedRetryWaitsMs = DEFAULT_BLOCKED_RETRY_WAITS,
     cdpProbeTimeoutMs = 10000, // 单次探活超时
     cdpObserveWaitMs = 20000, // 观察等待间隔（页面转圈加载期）
     cdpObserveRounds = 2, // 观察轮数
@@ -269,11 +268,6 @@ async function fetchUserVideosAPI(
     cdpReloadProbeTimeoutMs = 20000, // 刷新后重检窗口
   } = options;
 
-  // CDP 健康检查：带超时保护，区分"页面忙"与"页面死"。
-  // evaluate 排队在页面主线程上，加载中的慢页面（肉眼可见转圈）10s 轮不到执行很正常，
-  // 此时是忙不是死：先观察等待（默认 2 轮 x 20s），慢页面通常在此期间自然加载完自愈。
-  // 观察后仍无响应才刷新页面（实测刷新可解除主线程死锁）；刷新后页面处于最忙的加载期，
-  // 先缓冲等待再以更宽松的窗口重检，避免误杀正在恢复的页面。
   const evalWithTimeout = (label, ms) =>
     Promise.race([
       page.evaluate(() => document.readyState),
@@ -285,49 +279,62 @@ async function fetchUserVideosAPI(
       ),
     ]);
 
-  let healthy = false;
+  // 首探：成功（即使页面仍在加载）即认为健康
   try {
     const state = await evalWithTimeout("CDP 健康检查", cdpProbeTimeoutMs);
-    healthy = true;
     if (state !== "complete") {
       log(`  [API拦截] 健康检查通过，页面加载中 (readyState=${state})`);
     }
+    return;
   } catch (e) {
-    // 观察阶段：慢页面几十秒内通常自愈，期间不做任何操作
     log(
       `  [API拦截] CDP 探活超时: ${e.message}，页面可能仍在加载，观察等待...`,
     );
-    for (let round = 1; round <= cdpObserveRounds && !healthy; round++) {
-      await new Promise((r) => setTimeout(r, cdpObserveWaitMs));
-      try {
-        await evalWithTimeout(
-          `观察重检 ${round}/${cdpObserveRounds}`,
-          cdpProbeTimeoutMs,
-        );
-        healthy = true;
-        log(`  [API拦截] 页面已恢复（观察 ${round} 轮后）`);
-      } catch (e2) {
-        log(
-          `  [API拦截] 观察 ${round}/${cdpObserveRounds} 后仍无响应: ${e2.message}`,
-        );
-      }
-    }
   }
 
-  if (!healthy) {
-    log(`  [API拦截] 观察后仍无响应，刷新页面恢复...`);
-    await page
-      .reload({ waitUntil: "domcontentloaded", timeout: 30000 })
-      .catch(() => {});
-    await new Promise((r) => setTimeout(r, cdpReloadSettleMs));
+  // 观察阶段：慢页面几十秒内通常自愈，期间不做任何操作
+  for (let round = 1; round <= cdpObserveRounds; round++) {
+    await new Promise((r) => setTimeout(r, cdpObserveWaitMs));
     try {
-      await evalWithTimeout("刷新后重检", cdpReloadProbeTimeoutMs);
-      log(`  [API拦截] 页面已恢复（刷新后）`);
+      await evalWithTimeout(
+        `观察重检 ${round}/${cdpObserveRounds}`,
+        cdpProbeTimeoutMs,
+      );
+      log(`  [API拦截] 页面已恢复（观察 ${round} 轮后）`);
+      return;
     } catch (e2) {
-      throw new Error(`CDP 连接异常（刷新后仍失败）: ${e2.message}`);
+      log(
+        `  [API拦截] 观察 ${round}/${cdpObserveRounds} 后仍无响应: ${e2.message}`,
+      );
     }
   }
 
+  // 观察后仍无响应才刷新页面
+  log(`  [API拦截] 观察后仍无响应，刷新页面恢复...`);
+  await page
+    .reload({ waitUntil: "domcontentloaded", timeout: 30000 })
+    .catch(() => {});
+  await new Promise((r) => setTimeout(r, cdpReloadSettleMs));
+  try {
+    await evalWithTimeout("刷新后重检", cdpReloadProbeTimeoutMs);
+    log(`  [API拦截] 页面已恢复（刷新后）`);
+  } catch (e2) {
+    throw new Error(`CDP 连接异常（刷新后仍失败）: ${e2.message}`);
+  }
+}
+
+async function fetchUserVideosAPI(
+  page,
+  username,
+  maxVideos,
+  log,
+  options = {},
+) {
+  log(`  [API拦截] 获取 @${username} 视频 ...`);
+
+  await checkCdpHealth(page, options, log);
+
+  const { blockedRetryWaitsMs = DEFAULT_BLOCKED_RETRY_WAITS } = options;
   let apiRequestUrlRef = { value: null };
   const retryWaits = Array.isArray(blockedRetryWaitsMs)
     ? blockedRetryWaitsMs

package/src/lib/browser/cdp.js

@@ -70,6 +70,19 @@ function checkEdgeArgs() {
   });
 }
 
+/**
+ * 解码 Windows 命令输出：中文系统 taskkill 输出为 GBK，
+ * 先按 UTF-8 解码，出现乱码替换符（U+FFFD）时改用 GBK 重解。
+ */
+function decodeWinOutput(data) {
+  if (!Buffer.isBuffer(data)) return String(data ?? "").trim();
+  let text = new TextDecoder("utf-8").decode(data);
+  if (text.includes("\uFFFD")) {
+    text = new TextDecoder("gbk").decode(data);
+  }
+  return text.trim();
+}
+
 /**
  * 解析 netstat -ano 输出，返回监听指定端口的 PID 列表（去重）。
  * 不依赖 WMI，适配 WMI 损坏/禁用的 Windows 机器。
@@ -89,6 +102,58 @@ export function parseNetstatListeningPids(netstatOutput, port) {
   return pids;
 }
 
+/**
+ * Windows：按监听端口杀掉 Edge 主进程及其进程树（不依赖 WMI，
+ * Get-CimInstance 在 WMI 损坏/禁用的机器上查不到进程）。
+ * 返回后续清理 Singleton 锁文件的命令。
+ */
+function killEdgeOnWindowsByPort(port) {
+  let killCmds = "";
+  try {
+    const netstatOut = execSync("netstat -ano", {
+      encoding: "utf-8",
+      timeout: 5000,
+      windowsHide: true,
+    });
+    const pids = parseNetstatListeningPids(netstatOut, port);
+    if (pids.length > 0) {
+      // 不重定向 stderr：taskkill 的错误信息（拒绝访问/找不到进程）需要可见
+      killCmds = pids.map((pid) => `taskkill /F /T /PID ${pid}`).join(" & ");
+      console.error(
+        `[killEdgeProcesses] 端口 ${port} 监听进程 PID: ${pids.join(", ")}`,
+      );
+    }
+  } catch (e) {
+    console.error(`[killEdgeProcesses] netstat 查询失败: ${e.message}`);
+  }
+
+  if (killCmds) {
+    // 同步执行并打印结果：taskkill 失败（权限/会话不匹配等）必须可见，不能静默吞掉
+    try {
+      const out = execSync(`(${killCmds})`, {
+        encoding: "buffer",
+        timeout: 15000,
+        windowsHide: true,
+      });
+      const lines = decodeWinOutput(out).split(/\r?\n/).filter(Boolean);
+      console.error(
+        `[killEdgeProcesses] taskkill 结果: ${lines.join(" | ") || "(无输出)"}`,
+      );
+    } catch (e) {
+      console.error(`[killEdgeProcesses] taskkill 失败: ${e.message}`);
+      const detail = decodeWinOutput(
+        Buffer.concat([
+          Buffer.isBuffer(e.stdout) ? e.stdout : Buffer.alloc(0),
+          Buffer.isBuffer(e.stderr) ? e.stderr : Buffer.alloc(0),
+        ]),
+      );
+      if (detail) console.error(`[killEdgeProcesses] 详情: ${detail}`);
+    }
+  }
+
+  return `del /f /q "%LOCALAPPDATA%\\Microsoft\\Edge\\Singleton*" 2>nul; exit 0`;
+}
+
 function killEdgeProcesses(targetDir, port) {
   return new Promise((resolve) => {
     const platform = os.platform();
@@ -138,53 +203,11 @@ function killEdgeProcesses(targetDir, port) {
           'killall -9 "Microsoft Edge" 2>/dev/null; rm -f ~/Library/Caches/Microsoft\\ Edge/Singleton*; true';
       }
     } else if (platform === "win32") {
-      if (port) {
-        // 不依赖 WMI：Get-CimInstance 在 WMI 损坏/禁用的机器上查不到进程（KILLED_PIDS 为空）。
-        // 改为 netstat 按监听端口找 PID（CDP 端口由浏览器主进程监听），taskkill /F /T 杀进程树
-        let killCmds = "";
-        try {
-          const netstatOut = execSync("netstat -ano", {
-            encoding: "utf-8",
-            timeout: 5000,
-            windowsHide: true,
-          });
-          const pids = parseNetstatListeningPids(netstatOut, port);
-          if (pids.length > 0) {
-            // 不重定向 stderr：taskkill 的错误信息（拒绝访问/找不到进程）需要可见
-            killCmds = pids
-              .map((pid) => `taskkill /F /T /PID ${pid}`)
-              .join(" & ");
-            console.error(
-              `[killEdgeProcesses] 端口 ${port} 监听进程 PID: ${pids.join(", ")}`,
-            );
-          }
-        } catch (e) {
-          console.error(`[killEdgeProcesses] netstat 查询失败: ${e.message}`);
-        }
-        if (killCmds) {
-          // 同步执行并打印结果：taskkill 失败（权限/会话不匹配等）必须可见，不能静默吞掉
-          const killCmd = `(${killCmds})`;
-          try {
-            const out = execSync(killCmd, {
-              encoding: "utf-8",
-              timeout: 15000,
-              windowsHide: true,
-            });
-            const lines = out.trim().split(/\r?\n/).filter(Boolean);
-            console.error(
-              `[killEdgeProcesses] taskkill 结果: ${lines.join(" | ") || "(无输出)"}`,
-            );
-          } catch (e) {
-            console.error(`[killEdgeProcesses] taskkill 失败: ${e.message}`);
-            const detail = `${e.stdout || ""}${e.stderr || ""}`.trim();
-            if (detail) console.error(`[killEdgeProcesses] 详情: ${detail}`);
-          }
-        }
-        // 找不到监听进程 = 浏览器可能已退出，不做按进程名的兜底（避免误杀其他端口实例）
-        command = `del /f /q "%LOCALAPPDATA%\\Microsoft\\Edge\\Singleton*" 2>nul; exit 0`;
-      } else {
-        command = "taskkill /F /IM msedge.exe 2>nul || exit 0";
-      }
+      // 有端口：按监听端口杀进程树（找不到监听进程 = 浏览器可能已退出，
+      // 不做按进程名的兜底，避免误杀其他端口实例）
+      command = port
+        ? killEdgeOnWindowsByPort(port)
+        : "taskkill /F /IM msedge.exe 2>nul || exit 0";
     } else {
       if (targetDir) {
         const escapedDir = targetDir.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");

package/src/watchdog/process-manager.js

@@ -175,36 +175,45 @@ function getProcessStats(pid) {
   }
 }
 
+/**
+ * Windows: 执行 PowerShell -Command 并返回 stdout（trim 后）。
+ * 统一 execSync 选项，避免各处重复配置。
+ */
+function runPowerShell(psCommand, timeoutMs = 3000) {
+  return execSync(`powershell -NoProfile -Command "${psCommand}"`, {
+    encoding: "utf-8",
+    timeout: timeoutMs,
+    stdio: ["ignore", "pipe", "ignore"],
+    windowsHide: true, // Windows 隐藏控制台窗口
+  }).trim();
+}
+
 // Windows: 从 cmd.exe 往下找真正的 node.exe PID（shell:true 时 cmd.exe 是中间层）
 function getChildPid(parentPid) {
-  // 主路径：WMI 查询（原逻辑不变，WMI 正常机器零变化）
+  // 主路径：WMI 查询（WMI 正常机器零变化）
   try {
-    const out = execSync(
-      `powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter 'ParentProcessId=${parentPid}' | Where-Object { $_.Name -notlike 'conhost*' } | Select-Object -First 1 -ExpandProperty ProcessId"`,
-      {
-        encoding: "utf-8",
-        timeout: 3000,
-        stdio: ["ignore", "pipe", "ignore"],
-        windowsHide: true, // Windows 隐藏控制台窗口
-      },
-    ).trim();
-    return parseInt(out, 10) || 0;
+    return (
+      parseInt(
+        runPowerShell(
+          `Get-CimInstance Win32_Process -Filter 'ParentProcessId=${parentPid}' | Where-Object { $_.Name -notlike 'conhost*' } | Select-Object -First 1 -ExpandProperty ProcessId`,
+        ),
+        10,
+      ) || 0
+    );
   } catch {
     // WMI 损坏/禁用时 Get-CimInstance 直接报错，落入 fallback
   }
   // fallback：不依赖 WMI，用 Get-Process（.NET API）按启动时间找
   // cmd.exe 之后最早启动的 node.exe（watchdog spawn 后 3s 才调用，node 应已启动）
   try {
-    const out = execSync(
-      `powershell -NoProfile -Command "$cmd = Get-Process -Id ${parentPid} -ErrorAction SilentlyContinue; if ($cmd) { Get-Process node -ErrorAction SilentlyContinue | Where-Object { $_.StartTime -ge $cmd.StartTime } | Sort-Object StartTime | Select-Object -First 1 -ExpandProperty Id }"`,
-      {
-        encoding: "utf-8",
-        timeout: 3000,
-        stdio: ["ignore", "pipe", "ignore"],
-        windowsHide: true,
-      },
-    ).trim();
-    return parseInt(out, 10) || 0;
+    return (
+      parseInt(
+        runPowerShell(
+          `$cmd = Get-Process -Id ${parentPid} -ErrorAction SilentlyContinue; if ($cmd) { Get-Process node -ErrorAction SilentlyContinue | Where-Object { $_.StartTime -ge $cmd.StartTime } | Sort-Object StartTime | Select-Object -First 1 -ExpandProperty Id }`,
+        ),
+        10,
+      ) || 0
+    );
   } catch {
     return 0;
   }