tt-help-cli-ycl 1.4.166 → 1.4.167

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tt-help-cli-ycl",
-  "version": "1.4.166",
+  "version": "1.4.167",
   "description": "TikTok user & video data scraper - extract ttSeller, verified, locationCreated from HTML source",
   "type": "module",
   "bin": {
@@ -48,4 +48,4 @@
   "devDependencies": {
     "better-sqlite3": "^12.10.0"
   }
-}
+}

package/scripts/deploy-node.sh

@@ -0,0 +1,83 @@
+#!/bin/bash
+# 将本地 tiktok-cli 打包部署到 Windows 采集节点（试运行，不经 npm registry）
+# 用法:
+#   ./scripts/deploy-node.sh tiktok-210                  # 打包+传输+远程安装+校验
+#   ./scripts/deploy-node.sh tiktok-210 --bump           # 先把 package.json 版本号 +1 再打包
+#   ./scripts/deploy-node.sh tiktok-210 --bump --restart # 安装后重启走 CDP 的命令进程
+#                                                        #（watchdog 检测到退出会用新代码自动拉起）
+# 流程: (可选)升版本号 → npm pack → scp → 远程 npm install -g → 校验 → (可选)重启命令
+# 前提: ~/.ssh/config 已配置节点别名（如 tiktok-210，经跳板机），BatchMode 免密可用
+# 说明:
+#   - 无需停进程再安装：采集客户端不加载 better-sqlite3（只有 videostats/watch 服务端用），无文件锁
+#   - watchdog 自升级：npm 覆盖安装后守护进程经 upgrader.js 自动重启，受管命令随后重建
+#   - 节点上保留 tgz 安装包，回滚时 npm install -g 旧版 tgz 即可
+set -euo pipefail
+
+ALIAS="${1:?用法: deploy-node.sh <ssh别名> [--bump] [--restart]}"
+shift || true
+DO_BUMP=0
+DO_RESTART=0
+for a in "$@"; do
+  case "$a" in
+    --bump) DO_BUMP=1 ;;
+    --restart) DO_RESTART=1 ;;
+    *) echo "未知参数: $a"; exit 1 ;;
+  esac
+done
+
+cd "$(dirname "$0")/.."
+
+if [ "$DO_BUMP" = 1 ]; then
+  node -e "
+    const fs = require('fs');
+    const p = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+    const m = p.version.split('.');
+    m[2] = Number(m[2]) + 1;
+    p.version = m.join('.');
+    fs.writeFileSync('package.json', JSON.stringify(p, null, 2) + '\n');
+    console.log('版本号 ->', p.version);
+  "
+fi
+
+NAME=$(node -p "require('./package.json').name")
+VER=$(node -p "require('./package.json').version")
+TGZ="${NAME}-${VER}.tgz"
+
+echo "==> npm pack"
+rm -f "$TGZ"
+TGZ=$(npm pack 2>/dev/null | tail -1)
+echo "包: $TGZ ($(du -h "$TGZ" | cut -f1))"
+
+echo "==> scp → $ALIAS"
+scp -o ConnectTimeout=25 -o BatchMode=yes "$TGZ" "$ALIAS:$TGZ" 2>&1 |
+  grep -vE 'post-quantum|openssh.com/pq|store now|upgraded|CLIXML|^Warning|Permanently added' >/dev/null
+echo "已传输到 %USERPROFILE%\\$TGZ"
+
+echo "==> 远程 npm install -g"
+ssh -o ConnectTimeout=25 -o BatchMode=yes "$ALIAS" \
+  "npm install -g %USERPROFILE%\\$TGZ 2>&1" |
+  grep -vE 'post-quantum|openssh.com/pq|store now|upgraded|CLIXML|^Warning|Permanently added' |
+  tail -3
+
+echo "==> 校验远程版本"
+REMOTE_VER=$(
+  ssh -o ConnectTimeout=25 -o BatchMode=yes "$ALIAS" "tt-help --version 2>nul" 2>/dev/null |
+    grep -vE 'post-quantum|openssh.com/pq|store now|upgraded|CLIXML|^Warning|Permanently added' |
+    tail -1 | tr -d '\r'
+)
+if [ "$REMOTE_VER" = "$VER" ]; then
+  echo "✓ 远程版本 $REMOTE_VER"
+else
+  echo "✗ 版本不一致: 期望 $VER, 实际 '${REMOTE_VER:-空}'"
+  exit 1
+fi
+
+if [ "$DO_RESTART" = 1 ]; then
+  echo "==> 重启走 CDP 的命令进程（排除 watchdog/webserver，浏览器进程保留、新客户端直接重连）"
+  ssh -o ConnectTimeout=25 -o BatchMode=yes "$ALIAS" 'powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \"Name='node.exe'\" | Where-Object { $_.CommandLine -match \"cli\.js\" -and $_.CommandLine -notmatch \"watchdog|webserver\" } | ForEach-Object { taskkill /F /PID $_.ProcessId }"' 2>&1 |
+    grep -vE 'post-quantum|openssh.com/pq|store now|upgraded|CLIXML|^Warning|Permanently added' |
+    head -10 || true
+  echo "（watchdog 检测到异常退出后会在 5-30s 内用新代码自动拉起，Edge 进程保留、客户端直连不重启浏览器）"
+fi
+
+echo "==> 完成"

package/src/cli/attach.js

@@ -160,13 +160,26 @@ export async function handleAttach(options) {
         data = await res.json();
       } catch {}
       if (!res.ok) {
-        // CDN 限流：抛 CDNBlockedError，外层据此冷却（webserver 模式同样生效）
+        // CDN 限流：抛 CDNBlockedError，外层据此冷却（webserver 模式同样生效）。
+        // 服务端冷却期返回 503 + error="CDN cooldown active, cooling IP"（server.mjs），
+        // 并携带 cdnCooldownSec=剩余秒数，一并识别；秒数挂到 err.serverCooldownSec
+        // 供外层精确对齐冷却窗口，避免冷却期整批空转猛冲。
         if (
           data &&
           typeof data.error === "string" &&
-          data.error.includes("CDN限流")
+          (data.error.includes("CDN限流") ||
+            data.error.includes("CDN cooldown"))
         ) {
-          throw new CDNBlockedError(data.error);
+          const cdnErr = new CDNBlockedError(data.error);
+          if (data.cdnCooldownSec > 0)
+            cdnErr.serverCooldownSec = data.cdnCooldownSec;
+          throw cdnErr;
+        }
+        if (data && data.cdnCooldownSec > 0) {
+          // 文案兜底：只要响应带冷却秒数字段就按 CDN 限流处理
+          const cdnErr = new CDNBlockedError("CDN限流 (cooldown)");
+          cdnErr.serverCooldownSec = data.cdnCooldownSec;
+          throw cdnErr;
         }
         // 其余失败（504 超时 / 503 / 502 / 500 等）：抛出带状态码与错误详情的异常，
         // 让外层日志显示真实原因（如 page.goto 超时）而非笼统"未获取到用户信息"。
@@ -221,6 +234,7 @@ export async function handleAttach(options) {
     let browserRestartCount = 0;
     let taskBatchCount = 0;
     let consecutiveCdnBlocks = 0; // 连续 CDN 限流轮数（自适应：前几次切换节点，之后长等待）
+    let consecutiveHighFail = 0; // 连续高失败率轮数（webserver 模式通用阶梯冷却）
 
     while (!shuttingDown) {
       loopCount++;
@@ -299,6 +313,7 @@ export async function handleAttach(options) {
       let successCount = 0;
       let failCount = 0;
       let cdnBlockedCount = 0;
+      let serverCdnCooldownSec = 0; // 服务端告知的剩余冷却秒数（webserver 503 响应携带）
       let needRestart = false;
 
       // 收集抓取成功的任务，记录抓取失败的
@@ -308,8 +323,16 @@ export async function handleAttach(options) {
           const { uniqueId, info, error } = result.value;
           if (error) {
             if (error instanceof CDNBlockedError) {
-              attachLog(`  ⚠ @${uniqueId} CDN限流 (Access Denied)`);
+              attachLog(
+                error.serverCooldownSec
+                  ? `  ⚠ @${uniqueId} CDN限流 (服务端冷却中，剩余 ${error.serverCooldownSec}s)`
+                  : `  ⚠ @${uniqueId} CDN限流 (Access Denied)`,
+              );
               cdnBlockedCount++;
+              serverCdnCooldownSec = Math.max(
+                serverCdnCooldownSec,
+                error.serverCooldownSec || 0,
+              );
               failCount++;
             } else if (isBrowserClosedError(error)) {
               needRestart = true;
@@ -384,9 +407,13 @@ export async function handleAttach(options) {
 
       attachLog(`  本批结果: ${successCount} 成功, ${failCount} 失败\n`);
 
-      // CDN 限流比例超过 30% 时：自适应策略（前几次切节点，连续限流则长等待）
+      // 失败率冷却策略：
+      // - 本地浏览器模式（scraper）：CDN 限流 >30% 触发切节点 + 冷却（主动绕过）
+      // - webserver 模式：统一按总失败率阶梯冷却（出口在远端，分类对客户端无意义，
+      //   唯一手段是等；冷却期服务端 503 会带 cdnCooldownSec，优先精确对齐窗口）
       const cdnRatio = tasks.length > 0 ? cdnBlockedCount / tasks.length : 0;
-      if (cdnRatio > 0.3) {
+      const failRatio = tasks.length > 0 ? failCount / tasks.length : 0;
+      if (cdnRatio > 0.3 && scraper) {
         consecutiveCdnBlocks++;
         // 冷却指数退避：60s→120s→240s→…上限 300s（切换后短等，持续限流则长等窗口过去）
         const coolDownSeconds = Math.min(
@@ -394,12 +421,7 @@ export async function handleAttach(options) {
           MAX_CDN_COOLDOWN_SEC,
         );
         const shouldSwitch = consecutiveCdnBlocks <= MAX_CDN_SWITCH_ATTEMPTS;
-        if (!scraper) {
-          // webserver 模式：限流发生在远端 webserver 出口，本地切节点无效，仅冷却等待
-          attachLog(
-            `  [Attach] CDN限流比例 ${(cdnRatio * 100).toFixed(0)}% (${cdnBlockedCount}/${tasks.length})，webserver 模式不切节点，冷却 ${coolDownSeconds} 秒...`,
-          );
-        } else if (shouldSwitch) {
+        if (shouldSwitch) {
           // 用现有 IPC 接口通知 daemon 从候选集切下一个健康节点（换 IP 绕过 CDN 限流）
           try {
             writeCommand({
@@ -417,16 +439,42 @@ export async function handleAttach(options) {
           );
         }
         await new Promise((r) => setTimeout(r, coolDownSeconds * 1000));
-        if (scraper) {
-          await recycleScraper(
-            scraper,
-            `CDN限流比例过高 (${cdnBlockedCount}/${tasks.length})`,
-          );
-          browserRestartCount++;
-        }
+        await recycleScraper(
+          scraper,
+          `CDN限流比例过高 (${cdnBlockedCount}/${tasks.length})`,
+        );
+        browserRestartCount++;
+        taskBatchCount = 0;
+      } else if (
+        webserverUrl &&
+        tasks.length >= 5 &&
+        failRatio > 0.5
+      ) {
+        // webserver 模式统一阶梯：总失败率 >50% 即冷却（含 CDN 限流/goto 超时/
+        // 验证码/网络错误等所有类型）。首次 30s 低代价试探，连续则指数升级
+        // 30→60→120→240→300s 封顶；服务端告知冷却剩余秒数时优先精确对齐；
+        // 失败率回落 ≤30% 清零
+        consecutiveHighFail++;
+        const coolDownSeconds = serverCdnCooldownSec
+          ? Math.min(
+              Math.max(serverCdnCooldownSec + 5, 30),
+              MAX_CDN_COOLDOWN_SEC,
+            )
+          : Math.min(
+              30 * Math.pow(2, consecutiveHighFail - 1),
+              MAX_CDN_COOLDOWN_SEC,
+            );
+        const cdnTag = cdnBlockedCount
+          ? `（其中 CDN限流 ${cdnBlockedCount}）`
+          : "";
+        attachLog(
+          `  [Attach] 失败率 ${(failRatio * 100).toFixed(0)}% (${failCount}/${tasks.length})${cdnTag}，冷却 ${coolDownSeconds} 秒...`,
+        );
+        await new Promise((r) => setTimeout(r, coolDownSeconds * 1000));
         taskBatchCount = 0;
       } else {
         consecutiveCdnBlocks = 0; // 正常批次重置连续限流计数
+        if (failRatio <= 0.3) consecutiveHighFail = 0; // 失败率回落清零阶梯计数
       }
 
       if (scraper) {

package/src/lib/browser/cdp.js

@@ -222,22 +222,66 @@ function killEdgeProcesses(targetDir, port) {
   });
 }
 
+/** 查询监听指定端口的进程 PID 列表（netstat，不依赖 WMI）；查询失败返回 [] */
+function getListeningPidsOnPort(port) {
+  try {
+    const out = execSync("netstat -ano", {
+      encoding: "utf-8",
+      timeout: 10000,
+      windowsHide: true,
+    });
+    return parseNetstatListeningPids(out, port);
+  } catch {
+    return [];
+  }
+}
+
+/** tasklist 验证 PID 存活且属于 msedge（不依赖 WMI）：true/false；查询失败返回 null */
+function isEdgePidAliveWin(pid) {
+  try {
+    const out = execSync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, {
+      encoding: "utf-8",
+      timeout: 5000,
+      windowsHide: true,
+    });
+    return out.toLowerCase().includes("msedge");
+  } catch {
+    return null;
+  }
+}
+
 /**
- * 查找"残留" Edge 主进程：命令行包含指定 user-data-dir、但不带
- * --remote-debugging-port（Edge 自动更新/崩溃自恢复、上次强杀残留等，
- * 占着 profile 却没监听 CDP 端口）。
- * 排除带 --type= 的子进程：渲染进程等子进程同样带 user-data-dir 却没有
- * CDP 参数，误杀会打断同 profile 的健康实例。
+ * 读取 profile 目录下 lockfile 里的数字（ProcessSingleton 持有者 PID 候选）。
+ * Chromium 写入格式随版本有差异，返回前 5 个数字串，由调用方逐一验证。
+ */
+function readLockPidCandidates(userDataDir) {
+  try {
+    const content = fs.readFileSync(path.join(userDataDir, "lockfile"), "utf-8");
+    return (content.match(/\d+/g) || []).slice(0, 5);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 查找"残留" Edge 主进程：占着指定 user-data-dir 的实例（调用前已确认
+ * CDP 端口未监听，故带 --remote-debugging-port 参数的僵死实例同样算残留）。
+ * 排除带 --type= 的子进程：渲染进程等子进程同样带 user-data-dir，
+ * 误杀会打断同 profile 的健康实例。
  *
  * 这类实例必须先杀掉再启动：否则新 msedge 会因 Chromium ProcessSingleton
  * 把命令行转发给旧实例，变成"旧实例开一个 about:blank 新 tab"，CDP 端口
  * 永远起不来 → 等待超时 → watchdog 自动重启 → 每轮再开一个 tab。
  *
  * killEdgeProcesses 在 Windows 上按监听端口找 PID，对这类实例无效，
- * 故单独按命令行匹配精确清理。
+ * 故单独按命令行/lockfile 匹配精确清理，且不依赖 WMI：
+ *  1. PowerShell 枚举 msedge 命令行按 user-data-dir 匹配（需 WMI，
+ *     WMI 损坏的机器上可能返回空）
+ *  2. lockfile 兜底：读 profile 目录 lockfile 中的 PID，用 tasklist 验证
+ *     存活且是 msedge（不依赖 WMI，覆盖 WMI 损坏 + 带 CDP 参数的僵死实例）
  *
  * @param {string} targetDir - user-data-dir 路径
- * @returns {string[]|null} PID 列表；无法枚举进程命令行（PowerShell/WMI 不可用）时返回 null
+ * @returns {string[]|null} PID 列表；命令行枚举失败且 lockfile 无可信结论时返回 null
  */
 function findStaleEdgePids(targetDir) {
   const platform = os.platform();
@@ -245,31 +289,61 @@ function findStaleEdgePids(targetDir) {
     let out;
     if (platform === "win32") {
       // PowerShell 为主（wmic 已从新版 Win11 移除；项目其他模块同样依赖 PowerShell）
-      out = decodeWinOutput(
-        execSync(
-          'powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.Name -eq \'msedge.exe\' } | ForEach-Object { Write-Output ($_.ProcessId.ToString() + \'|\' + $_.CommandLine) }"',
-          { encoding: "buffer", timeout: 10000, windowsHide: true },
-        ),
-      );
-    } else {
-      out = execSync("ps -eo pid,args", {
-        encoding: "utf-8",
-        timeout: 10000,
-      });
+      let byCmdline = null;
+      try {
+        out = decodeWinOutput(
+          execSync(
+            'powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.Name -eq \'msedge.exe\' } | ForEach-Object { Write-Output ($_.ProcessId.ToString() + \'|\' + $_.CommandLine) }"',
+            { encoding: "buffer", timeout: 10000, windowsHide: true },
+          ),
+        );
+        const dirLower = targetDir.toLowerCase();
+        const pids = [];
+        for (const line of out.split(/\r?\n/)) {
+          const lower = line.toLowerCase();
+          if (!lower.includes(dirLower)) continue; // 只匹配本 profile
+          // 边界保护：避免 _p9222 误匹配 _p92221 这类前缀目录
+          const idx = lower.indexOf(dirLower);
+          const next = lower[idx + dirLower.length];
+          if (next && /[a-z0-9_]/.test(next)) continue;
+          if (lower.includes("--type=")) continue; // 子进程，误杀会打断健康实例
+          // 提取 PID：win 格式 "PID|命令行"
+          const m = line.match(/^\s*(\d+)\|/);
+          if (m && !pids.includes(m[1])) pids.push(m[1]);
+        }
+        byCmdline = pids;
+      } catch (e) {
+        console.error(`[findStaleEdgePids] PowerShell 枚举失败: ${e.message}`);
+        byCmdline = null;
+      }
+      if (byCmdline && byCmdline.length > 0) return byCmdline;
+
+      // lockfile 兑底：WMI 损坏时命令行枚举为空/失败；或残留实例带 CDP
+      // 参数时命令行匹配可能误报为空，lockfile 直接给出持有者 PID
+      for (const cand of readLockPidCandidates(targetDir)) {
+        if (isEdgePidAliveWin(cand) === true) return [cand];
+      }
+
+      // 命令行枚举失败且 lockfile 没找到活持有者 → 无法判断
+      if (byCmdline === null) return null;
+      return [];
     }
+
+    out = execSync("ps -eo pid,args", {
+      encoding: "utf-8",
+      timeout: 10000,
+    });
     const dirLower = targetDir.toLowerCase();
     const pids = [];
     for (const line of out.split(/\r?\n/)) {
       const lower = line.toLowerCase();
       if (!lower.includes(dirLower)) continue; // 只匹配本 profile
-      // 边界保护：避免 _p9222 误匹配 _p92221 这类前缀目录
       const idx = lower.indexOf(dirLower);
       const next = lower[idx + dirLower.length];
       if (next && /[a-z0-9_]/.test(next)) continue;
-      if (lower.includes("remote-debugging-port")) continue; // 健康 CDP 实例，不动
       if (lower.includes("--type=")) continue; // 子进程，误杀会打断健康实例
-      // 提取 PID：win 格式 "PID|命令行"，unix 格式 "  PID 命令行"
-      const m = line.match(/^\s*(\d+)(?:\||\s)/);
+      // 提取 PID：unix 格式 "  PID 命令行"
+      const m = line.match(/^\s*(\d+)\s/);
       if (m && !pids.includes(m[1])) pids.push(m[1]);
     }
     return pids;
@@ -308,6 +382,66 @@ function killEdgeStale(pids) {
   });
 }
 
+/**
+ * CDP 等待超时后的现场诊断：端口被谁占用、msedge 进程总数、profile 锁持有者。
+ * 输出随超时错误一起打印/上报，远程节点无需人工登录即可定位问题。
+ * @param {number} port
+ * @param {string} userDataDir
+ * @returns {string} 形如 "[诊断] ...; ..." 的摘要；收集失败返回 ""
+ */
+function collectTimeoutDiagnostics(port, userDataDir) {
+  const parts = [];
+  try {
+    if (os.platform() === "win32") {
+      const listenPids = getListeningPidsOnPort(port);
+      if (listenPids.length > 0) {
+        const names = listenPids.map((pid) => {
+          try {
+            const out = execSync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, {
+              encoding: "utf-8",
+              timeout: 5000,
+              windowsHide: true,
+            });
+            return out.split(",")[0]?.replace(/"/g, "").trim() || pid;
+          } catch {
+            return pid;
+          }
+        });
+        parts.push(
+          `端口 ${port} 正被监听但 CDP 未响应 (PID: ${listenPids.join(", ")}, 进程: ${names.join(", ")})`,
+        );
+      } else {
+        parts.push(`端口 ${port} 无任何进程监听`);
+      }
+      try {
+        const out = execSync(
+          'tasklist /FI "IMAGENAME eq msedge.exe" /FO CSV /NH',
+          {
+            encoding: "utf-8",
+            timeout: 5000,
+            windowsHide: true,
+          },
+        );
+        const count = out
+          .split(/\r?\n/)
+          .filter((l) => l.toLowerCase().includes("msedge")).length;
+        parts.push(`msedge 进程总数: ${count}`);
+      } catch {}
+      const lockPids = readLockPidCandidates(userDataDir).filter(
+        (pid) => isEdgePidAliveWin(pid) !== false,
+      );
+      parts.push(
+        lockPids.length
+          ? `profile lockfile 持有者: ${lockPids.join(", ")}`
+          : "profile lockfile 无存活持有者",
+      );
+    }
+  } catch (e) {
+    parts.push(`诊断收集失败: ${e.message}`);
+  }
+  return parts.length ? `[诊断] ${parts.join("; ")}` : "";
+}
+
 function launchEdgeWithCDP(port, userDataDir, proxyServer) {
   return new Promise((resolve, reject) => {
     const platform = os.platform();
@@ -405,14 +539,32 @@ export async function ensureBrowserReady(options = {}) {
         console.error(`CDP 端口 ${port} 未就绪，正在启动 Edge 浏览器...`);
       }
     }
-    // 残留实例清理：占着该 user-data-dir 却没开 CDP 的旧 Edge 必须先杀掉，
-    // 否则 launch 会被 ProcessSingleton 转发成"旧实例开新 tab"，CDP 永远起不来。
+    // （Windows）CDP 端口被非 Edge 进程占用 → 立即报错，避免干等 60 秒超时
+    if (os.platform() === "win32") {
+      const listenPids = getListeningPidsOnPort(port);
+      if (listenPids.length > 0) {
+        const isEdge = listenPids.map((pid) => isEdgePidAliveWin(pid));
+        if (isEdge.every((v) => v === false)) {
+          throw new Error(
+            `CDP 端口 ${port} 被非 Edge 进程占用 (PID: ${listenPids.join(", ")})，` +
+              `无法启动浏览器。请释放该端口或更换 --cdp-port`,
+          );
+        }
+        // Edge 在监听但 HTTP 未响应 → 视为僵死，按残留处理（下方清理）
+      }
+    }
+
+    // 残留实例清理：占着该 user-data-dir 但 CDP 端口未监听的旧 Edge 必须先杀掉
+    //（含带 --remote-debugging-port 参数的僵死实例），否则 launch 会被
+    // ProcessSingleton 转发成"旧实例开新 tab"，CDP 永远起不来。
     const stalePids = findStaleEdgePids(userDataDir);
     if (stalePids === null) {
-      console.error("[浏览器] 无法枚举 Edge 进程命令行，跳过残留实例检测");
+      console.error(
+        "[浏览器] 无法判断是否存在残留 Edge 实例（WMI/lockfile 均不可用），跳过清理",
+      );
     } else if (stalePids.length > 0) {
       console.error(
-        `[浏览器] 检测到占用 ${path.basename(userDataDir)} 但未开 CDP 的残留 Edge 实例 (PID: ${stalePids.join(", ")})，正在清理...`,
+        `[浏览器] 检测到占用 ${path.basename(userDataDir)} 但 CDP 端口未监听的残留 Edge 实例 (PID: ${stalePids.join(", ")})，正在清理...`,
       );
       await killEdgeStale(stalePids);
       await new Promise((r) => setTimeout(r, 3000));
@@ -427,8 +579,11 @@ export async function ensureBrowserReady(options = {}) {
       os.platform() === "win32" ? 60000 : 30000,
     );
     if (!launched) {
+      const diag = collectTimeoutDiagnostics(port, userDataDir);
+      if (diag) console.error(`[浏览器] ${diag}`);
       throw new Error(
-        `等待 CDP 端口 ${port} 超时。请确认 Edge 浏览器已安装，\n` +
+        `等待 CDP 端口 ${port} 超时。${diag ? diag + "\n" : ""}` +
+          `请确认 Edge 浏览器已安装，\n` +
           `或手动启动: Microsoft Edge --remote-debugging-port=${port} [参见 cdp.js extraArgs]`,
       );
     }

package/src/watch/data-store.js

@@ -1260,6 +1260,10 @@ export function createStore(filePath, options = {}) {
     return data;
   }
 
+  // 空级跳过记忆（claimNextJob 用）：key = "level|国家列表"，value = 首次全 miss 时间。
+  // 某来源级（如 seed）全部国家分支 miss 后，TTL 内跳过该级，避免每次领任务空跑
+  const levelEmptyCache = new Map();
+
   async function claimNextJob(
     userId,
     expireMs = 5 * 60 * 1000,
@@ -1391,24 +1395,42 @@ export function createStore(filePath, options = {}) {
       // 非 pinned 优先级：seed → seller → follow → other，每级 × 3 个 location tier × (hasVideo / noVideoReq)
       const priorities = [
         {
+          name: "seed",
           filter: `instr(COALESCE(sources, ''), '"seed"') > 0`,
           loggedInOnly: false,
         },
         {
+          name: "seller",
           filter: `tt_seller = 1 AND verified = 0`,
           loggedInOnly: true,
           sellerAnyCountry: true,
         },
         {
+          name: "follow",
           filter: `(instr(COALESCE(sources, ''), '"following"') > 0 OR instr(COALESCE(sources, ''), '"follower"') > 0 OR instr(COALESCE(sources, ''), '"comment"') > 0)`,
           loggedInOnly: false,
         },
-        { filter: `1 = 1`, loggedInOnly: false },
+        { name: "other", filter: `1 = 1`, loggedInOnly: false },
       ];
 
+      // 空级跳过记忆：某来源级（如 seed）全部国家分支 miss 后，记录时间；
+      // TTL 内该级整体跳过（池子空了没必要每次领任务都空跑 24国×2 条查询，
+      // 2026-09-29 实测 seed 空级每次烧 1.4s CPU 是 watch 饱和主因）。
+      // TTL 过期后恢复探测一次——refill 补进新任务即可自动恢复。
+      const LEVEL_EMPTY_TTL = 60 * 1000;
+      for (const p of priorities) {
+        if (p.loggedInOnly && !loggedIn) continue;
+        const levelKey = `${p.name}|${orderedCountries.join(",")}`;
+        const emptySince = levelEmptyCache.get(levelKey);
+        if (emptySince && now - emptySince < LEVEL_EMPTY_TTL) {
+          p.skip = true; // 标记跳过，下面构建分支时跳过
+        }
+      }
+
       let basePrio = 4;
       for (const p of priorities) {
         if (p.loggedInOnly && !loggedIn) continue;
+        if (p.skip) continue;
         // 逐国顺序分支：配置内国家按优先级顺序；未传子集时末尾补“配置外国家”兑底。
         // 空位置（loc=''）只在首个国家的分支参与：首国的 noVideoReq 分支 miss 即意味着
         // 空位置池已耗尽，后续分支无需再 OR ''（避免反复扫描空位置大池）
@@ -1421,6 +1443,7 @@ export function createStore(filePath, options = {}) {
         // 传了国家子集时对应国家的商家仍优先，领完再兜任意国家（含空位置商家）；
         // 未传国家时同理（配置内各国 → 配置外 → 任意）。其他来源级分支不受影响。
         if (p.sellerAnyCountry) locationBranches.push(null); // null → 任意国家分支
+        p._branchStart = branches.length; // 记录该级分支区间（用于判空）
         let subPrio = 0;
         for (const loc of locationBranches) {
           // 商家任意国家分支：不限 guessed_location（含空位置的商家）
@@ -1453,12 +1476,16 @@ export function createStore(filePath, options = {}) {
           );
           subPrio++;
         }
+        p._branchEnd = branches.length;
         basePrio += 2;
       }
 
-      // 逐级执行：首个命中分支的最优行即领取结果（未命中继续下一优先级分支）
+      // 逐级执行：首个命中分支的最优行即领取结果（未命中继续下一优先级分支）。
+      // 同时记录哪些来源级全部 miss → 写入 levelEmptyCache（下次领取 TTL 内直接跳过该级）
       let selectedRow = null;
-      for (const b of branches) {
+      let bi = 0;
+      for (; bi < branches.length; bi++) {
+        const b = branches[bi];
         selectedRow =
           getDb()
             .prepare(
@@ -1468,6 +1495,18 @@ export function createStore(filePath, options = {}) {
         if (selectedRow) break;
       }
 
+      // 记录空级：分支按优先级顺序执行，命中所处级之前的所有来源级必然全 miss；
+      // 空级写入 levelEmptyCache（TTL 内下次领取直接跳过），命中级清除记忆
+      // bi = 命中分支下标（未命中则停在 branches.length）
+      const hitIdx = bi;
+      for (const p of priorities) {
+        if (p.loggedInOnly && !loggedIn) continue;
+        if (p._branchStart == null) continue; // 被 skip 跳过的级无分支，保留原记忆
+        const levelKey = `${p.name}|${orderedCountries.join(",")}`;
+        if (hitIdx >= p._branchEnd) levelEmptyCache.set(levelKey, now);
+        else levelEmptyCache.delete(levelKey);
+      }
+
       if (selectedRow) {
         getDb()
           .prepare(