tt-help-cli-ycl 1.4.123 → 1.4.125

package/package.json

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

package/src/cli/comments.js

@@ -165,10 +165,12 @@ function getBrowserMemory(port = null) {
             `}; ` +
             `Write-Output $sum`;
         } else {
+          // 无端口场景：Get-Process（.NET API，不依赖 WMI）统计全部 msedge 工作集，
+          // 与原 Get-CimInstance 全量求和行为等价；WMI 损坏/禁用的机器也能返回
           ps1Content =
-            `$procs = Get-CimInstance Win32_Process -Filter "Name LIKE 'msedge%'" -ErrorAction SilentlyContinue; ` +
+            `$procs = Get-Process msedge -ErrorAction SilentlyContinue; ` +
             `$sum = 0; ` +
-            `foreach ($p in $procs) { $sum += $p.WorkingSetSize }; ` +
+            `foreach ($p in $procs) { $sum += $p.WorkingSet64 }; ` +
             `Write-Output $sum`;
         }
         writeFileSync(ps1Path, ps1Content);

package/src/cli/open.js

@@ -93,14 +93,20 @@ export async function handleOpen(parsed) {
     // Ctrl+C 关闭浏览器
     process.on("SIGINT", async () => {
       console.error("\n正在关闭浏览器...");
+      // 先优雅断开 CDP 连接（带 3s 超时保护）：进程已被强杀时 close() 会挂起等 close 事件
       try {
-        console.error(`[SIGINT] 正在终止 Edge 进程 (端口: ${port})`);
-        await killEdgeProcesses(userDataDir, port);
-        console.error("[SIGINT] Edge 进程已终止，正在关闭浏览器连接...");
-        await browser.close();
+        await Promise.race([
+          browser.close(),
+          new Promise((r) => setTimeout(r, 3000)),
+        ]);
       } catch (e) {
-        console.error(`[SIGINT] 关闭浏览器时出错: ${e.message}`);
+        console.error(`[SIGINT] 断开浏览器连接时出错: ${e.message}`);
       }
+      // 再强杀 Edge 进程兜底（优雅关闭不保证退出浏览器进程）
+      console.error(`[SIGINT] 正在终止 Edge 进程 (端口: ${port})`);
+      await killEdgeProcesses(userDataDir, port).catch((e) => {
+        console.error(`[SIGINT] 终止 Edge 进程失败: ${e.message}`);
+      });
       console.error("浏览器已关闭");
       process.exit(0);
     });

package/src/cli/tag.js

@@ -109,10 +109,12 @@ function getBrowserMemory(port = null) {
             `}; ` +
             `Write-Output $sum`;
         } else {
+          // 无端口场景：Get-Process（.NET API，不依赖 WMI）统计全部 msedge 工作集，
+          // 与原 Get-CimInstance 全量求和行为等价；WMI 损坏/禁用的机器也能返回
           ps1Content =
-            `$procs = Get-CimInstance Win32_Process -Filter "Name LIKE 'msedge%'" -ErrorAction SilentlyContinue; ` +
+            `$procs = Get-Process msedge -ErrorAction SilentlyContinue; ` +
             `$sum = 0; ` +
-            `foreach ($p in $procs) { $sum += $p.WorkingSetSize }; ` +
+            `foreach ($p in $procs) { $sum += $p.WorkingSet64 }; ` +
             `Write-Output $sum`;
         }
         writeFileSync(ps1Path, ps1Content);

package/src/lib/api-interceptor.js

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

package/src/lib/browser/cdp.js

@@ -70,6 +70,25 @@ function checkEdgeArgs() {
   });
 }
 
+/**
+ * 解析 netstat -ano 输出，返回监听指定端口的 PID 列表（去重）。
+ * 不依赖 WMI，适配 WMI 损坏/禁用的 Windows 机器。
+ * @param {string} netstatOutput
+ * @param {number} port
+ * @returns {string[]}
+ */
+export function parseNetstatListeningPids(netstatOutput, port) {
+  const pids = [];
+  for (const line of netstatOutput.split(/\r?\n/)) {
+    // LISTENING 状态 + 精确端口匹配（端口后必须跟空白，避免 8222 误匹配 18222）
+    if (!line.includes("LISTENING") || !line.includes(`:${port} `)) continue;
+    const parts = line.trim().split(/\s+/);
+    const pid = parts[parts.length - 1];
+    if (/^\d+$/.test(pid) && !pids.includes(pid)) pids.push(pid);
+  }
+  return pids;
+}
+
 function killEdgeProcesses(targetDir, port) {
   return new Promise((resolve) => {
     const platform = os.platform();
@@ -120,39 +139,49 @@ function killEdgeProcesses(targetDir, port) {
       }
     } else if (platform === "win32") {
       if (port) {
-        // 用端口匹配（纯数字，无编码问题），而不是 userDataDir 路径（中文路径会乱码）
+        // 不依赖 WMI：Get-CimInstance 在 WMI 损坏/禁用的机器上查不到进程（KILLED_PIDS 为空）。
+        // 改为 netstat 按监听端口找 PID（CDP 端口由浏览器主进程监听），taskkill /F /T 杀进程树
+        let killCmds = "";
         try {
-          const ps1Path = path.join(os.tmpdir(), `kill-edge-${Date.now()}.ps1`);
-          const ps1Content =
-            `$procs = Get-CimInstance Win32_Process -Filter "Name='msedge.exe'" 2>$null; ` +
-            `$count = 0; ` +
-            `$pids = @(); ` +
-            `foreach ($p in $procs) { ` +
-            `  if ($p.CommandLine -and $p.CommandLine -like "*--remote-debugging-port=${port}*") { ` +
-            `    $pids += $p.ProcessId; ` +
-            `    Stop-Process -Id $p.ProcessId -Force -ErrorAction SilentlyContinue; ` +
-            `    $count++ ` +
-            `  } ` +
-            `}; ` +
-            `Write-Output "KILLED_PIDS: $($pids -join ',')"; ` +
-            `Start-Sleep -Milliseconds 500; ` +
-            `Get-ChildItem "$env:LOCALAPPDATA\\Microsoft\\Edge\\Singleton*" -ErrorAction SilentlyContinue | Remove-Item -Force; ` +
-            `Write-Output $count`;
-          fs.writeFileSync(ps1Path, ps1Content);
-          const result = execSync(
-            `powershell.exe -ExecutionPolicy Bypass -File "${ps1Path}"`,
-          )
-            .toString()
-            .trim();
-          console.error(`[killEdgeProcesses] Windows PS result: ${result}`);
-          try {
-            fs.unlinkSync(ps1Path);
-          } catch {}
-          command = "exit 0";
+          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] Windows PS failed: ${e.message}`);
-          command = "taskkill /F /IM msedge.exe 2>nul || exit 0";
+          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";
       }

package/src/watchdog/process-manager.js

@@ -122,12 +122,13 @@ function splitCommand(cmdLine) {
 function getProcessStats(pid) {
   try {
     if (IS_WIN) {
-      // 与 tag.js handleScoreAll 一致：用临时 .ps1 + Get-CimInstance Win32_Process + WorkingSetSize
+      // 用 Get-Process（.NET System.Diagnostics.Process API），不依赖 WMI。
+      // 部分机器 WMI 损坏/禁用时 Get-CimInstance 返回空，导致内存读取为 0
       const ps1Path = join(tmpdir(), `wd-proc-${pid}-${Date.now()}.ps1`);
       try {
         const ps1Content =
-          `$p = Get-CimInstance Win32_Process -Filter "ProcessId='${pid}'" -ErrorAction SilentlyContinue; ` +
-          `if ($p) { Write-Output $p.WorkingSetSize } else { Write-Output 0 }`;
+          `$p = Get-Process -Id ${pid} -ErrorAction SilentlyContinue; ` +
+          `if ($p) { Write-Output $p.WorkingSet64 } else { Write-Output 0 }`;
         writeFileSync(ps1Path, ps1Content);
         const stdout = execSync(
           `powershell.exe -NoProfile -ExecutionPolicy Bypass -File "${ps1Path}"`,
@@ -176,6 +177,7 @@ function getProcessStats(pid) {
 
 // Windows: 从 cmd.exe 往下找真正的 node.exe PID（shell:true 时 cmd.exe 是中间层）
 function getChildPid(parentPid) {
+  // 主路径：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"`,
@@ -187,6 +189,22 @@ function getChildPid(parentPid) {
       },
     ).trim();
     return parseInt(out, 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;
   } catch {
     return 0;
   }

package/src/watchdog/upgrader.js

@@ -350,8 +350,9 @@ async function snapshotAllProcesses() {
           });
       }
     }
-  } catch {
+  } catch (e) {
     /* 快照失败时返回空，清理环节自然跳过 */
+    console.error(`[upgrader] 进程表快照失败（WMI 不可用？）: ${e.message}`);
   }
   return rows;
 }
@@ -465,7 +466,10 @@ async function listWatchdogPids() {
       .split(/\r?\n/)
       .map((s) => parseInt(s.trim(), 10))
       .filter((n) => n > 0);
-  } catch {
+  } catch (e) {
+    console.error(
+      `[upgrader] 枚举 watchdog 进程失败（WMI 不可用？）: ${e.message}`,
+    );
     return [];
   }
 }