tt-help-cli-ycl 1.4.83 → 1.4.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tt-help-cli-ycl",
-  "version": "1.4.83",
+  "version": "1.4.87",
   "description": "TikTok user & video data scraper - extract ttSeller, verified, locationCreated from HTML source",
   "type": "module",
   "bin": {
@@ -43,7 +43,6 @@
     "axios": "^1.16.1",
     "https-proxy-agent": "^9.0.0",
     "playwright": "^1.59.1",
-    "tt-help-cli-ycl": "^1.3.36",
     "undici": "^8.1.0"
   },
   "devDependencies": {

package/src/clash/checker.js

@@ -81,6 +81,15 @@ export function checkClashAlive() {
   return checkClashAliveWithReason().alive;
 }
 
+/**
+ * 仅以 API 控制端口可达判定 Clash 就绪
+ * daemon 的节点读取/切换/delay 全部依赖 API 端口，进程存活不等于控制端口已开启
+ * （Clash Verge 进程可能已在跑但 RESTful API 未开启/端口未监听）
+ */
+export function checkClashApiAlive() {
+  return _detectApi();
+}
+
 export function checkClashAliveWithReason() {
   if (_detectProcess())
     return { alive: true, reason: "verge-mihomo 进程已运行" };
@@ -116,12 +125,25 @@ function _detectProcess() {
 function _detectApi() {
   try {
     const exe = IS_WIN ? "curl.exe" : "curl";
+    const devNull = IS_WIN ? "NUL" : "/dev/null";
     const r = spawnSync(
       exe,
-      ["-s", "--max-time", "3", `http://127.0.0.1:${CONFIG.apiPort}/version`],
+      [
+        "-s",
+        "--max-time",
+        "3",
+        "-o",
+        devNull,
+        "-w",
+        "%{http_code}",
+        `http://127.0.0.1:${CONFIG.apiPort}/version`,
+      ],
       { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] },
     );
-    return r.stdout.includes('"version"');
+    // 只要有 HTTP 响应（含 401 未授权）即代表控制端口已开启、正在监听；
+    // 认证由上层 api.js 的 Bearer secret 处理，不在此判定
+    const code = parseInt(String(r.stdout || "").trim(), 10);
+    return Number.isInteger(code) && code > 0 && code < 600;
   } catch {
     return false;
   }
@@ -226,10 +248,31 @@ function _isHealthyPage(error, httpCode, size, title, body) {
 // 4. 国家过滤
 // ══════════════════════════════════════════════
 
+/**
+ * 归一化国家配置为去重大写数组（支持字符串或数组）
+ * daemon 的国家配置下发与 checker 的节点过滤统一使用该入口，保证单一来源
+ */
+export function normalizeCountries(v) {
+  if (Array.isArray(v))
+    return [
+      ...new Set(v.map((c) => String(c).trim().toUpperCase()).filter(Boolean)),
+    ];
+  if (typeof v === "string" && v.trim()) return [v.trim().toUpperCase()];
+  return [];
+}
+
+/** 把国家过滤值归一化为匹配模式数组（多国取并集），未知国家自动忽略 */
+function getCountryPatterns(country) {
+  const pats = normalizeCountries(country)
+    .map((c) => COUNTRY_PATTERNS[c])
+    .filter(Boolean);
+  return pats.length ? pats : null;
+}
+
 export function filterNodesByCountry(nodes, country) {
-  if (!country || !COUNTRY_PATTERNS[country])
-    return { filtered: nodes, excluded: 0 };
-  const filtered = nodes.filter((n) => COUNTRY_PATTERNS[country].test(n));
+  const pats = getCountryPatterns(country);
+  if (!pats) return { filtered: nodes, excluded: 0 };
+  const filtered = nodes.filter((n) => pats.some((p) => p.test(n)));
   return { filtered, excluded: nodes.length - filtered.length };
 }
 
@@ -245,7 +288,7 @@ export function getSupportedCountries() {
  * 对 GLOBAL 组节点做 delay 初测（不切换当前节点）
  * 并发测延迟，筛出可连通且延迟达标的节点，按延迟升序返回，作为故障切换的候选集
  * @param {object} opts
- * @param {string} [opts.country=null] - 国家过滤（默认 CONFIG.nodeCountryFilter）
+ * @param {string|string[]} [opts.country=null] - 国家过滤（默认 CONFIG.nodeCountryFilter，支持多国数组）
  * @param {number} [opts.timeoutMs=5000] - 单节点超时（毫秒）
  * @param {number} [opts.thresholdMs=4000] - 延迟阈值（超过视为慢，不入选，毫秒）
  * @param {number} [opts.concurrency=10] - 并发数
@@ -304,6 +347,10 @@ export async function runDelayProbe({
 // 5. 健康节点列表持久化
 // ══════════════════════════════════════════════
 
+/**
+ * 读取健康节点列表（可按国家过滤）
+ * @param {string|string[]} [country=null] - 国家过滤（默认 CONFIG.nodeCountryFilter，支持多国数组）
+ */
 export function loadHealthyList(country = null) {
   try {
     if (!existsSync(HEALTHY_FILE)) return _emptyList();

package/src/clash/daemon.js

@@ -6,10 +6,18 @@
  */
 
 import { fileURLToPath } from "url";
+import { normalizeCountries } from "./checker.js";
 import * as api from "./api.js";
 import * as checker from "./checker.js";
 import * as ipc from "./ipc.js";
 
+// ── 国家过滤辅助（normalizeCountries 由 checker.js 提供单一来源） ──
+/** 国家配置显示（数组 join） */
+function fmtCountries(v) {
+  const list = normalizeCountries(v);
+  return list.length ? list.join(",") : "无";
+}
+
 // ══════════════════════════════════════════════
 // ClashDaemon
 // ══════════════════════════════════════════════
@@ -21,8 +29,11 @@ export class ClashDaemon {
     this.dryRun = !!opts.dryRun;
     this._running = false;
     this._timers = [];
+    this._waitTimer = null; // 等待 Clash 就绪的重试定时器
+    this._startedOnce = false; // 首次启动标记（banner/信号只打印注册一次）
     this._benchmarkRunning = false;
-    if (opts.country) checker.CONFIG.nodeCountryFilter = opts.country;
+    const initCountries = normalizeCountries(opts.country);
+    if (initCountries.length) checker.CONFIG.nodeCountryFilter = initCountries;
     this._meta = {
       groupName: checker.CONFIG.groupName,
       proxyUrl: checker.CONFIG.proxyUrl,
@@ -40,17 +51,39 @@ export class ClashDaemon {
   async start() {
     if (this._running) return;
     this._running = true;
-    this._logBanner();
-    this._setupSignals();
 
-    const { alive, reason } = checker.checkClashAliveWithReason();
+    // 首次进入时打印 banner 并注册信号（等待重试时不再重复）
+    if (!this._startedOnce) {
+      this._startedOnce = true;
+      this._logBanner();
+      this._setupSignals();
+    }
+
+    // 等待 Clash 就绪（容错启动顺序：先启 watchdog 后开 Clash 控制端口也可正常工作）
+    // 以 API 控制端口为准：进程在但控制端口未开启时同样等待，避免误判后所有 API 操作失败
+    const alive = checker.checkClashApiAlive();
+    const reason = alive
+      ? `API 端口 ${checker.CONFIG.apiPort} 可达`
+      : `Clash 控制端口 ${checker.CONFIG.apiPort} 未开启`;
     if (!alive) {
+      this._log(`⚠ Clash 未就绪：${reason}`);
       this._log(
-        `⚠ 代理不可用：${reason}\n请先启动 Clash Verge 并确保 API 端口 9097 已开启`,
+        `  等待 API 端口 ${checker.CONFIG.apiPort} 可用，10s 后重试（Clash 就绪后自动接入）...`,
       );
+      ipc.writeHealth({
+        node: "?",
+        healthy: false,
+        error: `等待 Clash 就绪: ${reason}`,
+        meta: this._buildMeta(),
+      });
       this._running = false;
+      this._waitTimer = setTimeout(() => this.start(), 10_000);
       return;
     }
+    // 等待期间的重试定时器已触发，清理引用
+    if (this._waitTimer) {
+      this._waitTimer = null;
+    }
     const proxyUrl = await checker.resolveAndSetProxyUrl();
     this._log(
       `✓ Clash 已连接 (${reason}), 代理端口: ${proxyUrl.replace("http://", "")}`,
@@ -83,6 +116,10 @@ export class ClashDaemon {
 
   async stop() {
     this._running = false;
+    if (this._waitTimer) {
+      clearTimeout(this._waitTimer);
+      this._waitTimer = null;
+    }
     this._timers.forEach(clearInterval);
     this._timers = [];
     this._log("守护进程已停止");
@@ -227,13 +264,15 @@ export class ClashDaemon {
   _pollCommands() {
     if (!this._running) return;
     try {
-      const cmd = ipc.readCommand();
-      if (!cmd) return;
-      const handler = this._cmdHandlers[cmd.action];
-      if (handler) {
-        handler(cmd);
-      } else {
-        this._log(`📋 未知命令: ${JSON.stringify(cmd)}`);
+      const cmds = ipc.readCommand();
+      if (!cmds) return;
+      for (const cmd of cmds) {
+        const handler = this._cmdHandlers[cmd.action];
+        if (handler) {
+          handler(cmd);
+        } else {
+          this._log(`📋 未知命令: ${JSON.stringify(cmd)}`);
+        }
       }
       ipc.clearCommand();
     } catch {}
@@ -273,6 +312,66 @@ export class ClashDaemon {
     }
   }
 
+  /**
+   * 看门狗指令: 主动故障切换（不依赖巡检发现，强制从候选集切下一个可用节点）
+   * 用于业务进程连续报错（CDN限流/网络异常/封 IP 等）时换出口节点
+   */
+  async _handleFailover() {
+    try {
+      const node = await api
+        .getCurrentNode(checker.CONFIG.groupName)
+        .catch(() => "?");
+      this._log(`🔄 看门狗指令: 触发故障切换 (当前: ${node})`);
+      const { nodes } = checker.loadHealthyList();
+      if (!nodes.length) {
+        this._log("🔄 候选集为空，触发 delay 初测");
+        await this._runDelayProbe();
+        return;
+      }
+      // 逐个切换候选 + 内容验证，第一个满足即采用（跳过当前节点）
+      let target = null;
+      let h2 = null;
+      for (const cand of nodes) {
+        if (cand === node) continue;
+        this._log(`↺ 尝试候选: ${cand}`);
+        if (!(await checker.switchToNode(cand))) {
+          this._log(`  ↺ ${cand} 切换失败，下一个`);
+          continue;
+        }
+        h2 = checker.checkNodeHealth();
+        if (h2.healthy) {
+          target = cand;
+          break;
+        }
+        this._log(`  ↺ ${cand} 内容验证未通过，下一个`);
+      }
+      if (!target) {
+        await checker.switchToNode(node).catch(() => {});
+        this._log(`✗ failover: 候选全部不可用，恢复原节点`);
+        return ipc.writeHealth({
+          node,
+          healthy: false,
+          error: "failover: 候选全部不可用",
+          lastSwitch: "failover: 候选全部不可用",
+          meta: this._buildMeta(),
+        });
+      }
+      this._log(`⚠ failover: ${node} → ${target}`);
+      ipc.writeHealth({
+        node: target,
+        healthy: h2.healthy,
+        httpCode: h2.httpCode,
+        timeTotal: h2.timeTotal,
+        sizeDownload: h2.sizeDownload,
+        title: h2.title,
+        lastSwitch: `failover: ${node} → ${target}`,
+        meta: this._buildMeta(),
+      });
+    } catch (e) {
+      this._log(`🔄 故障切换异常: ${e.message}`);
+    }
+  }
+
   // ── helpers ──
 
   _buildMeta() {
@@ -296,7 +395,7 @@ export class ClashDaemon {
 
   _logBanner() {
     const filterTag = checker.CONFIG.nodeCountryFilter
-      ? ` | 节点: ${checker.CONFIG.nodeCountryFilter}`
+      ? ` | 节点: ${fmtCountries(checker.CONFIG.nodeCountryFilter)}`
       : "";
     console.error("═".repeat(50));
     console.error("  Clash Verge 节点健康守护");
@@ -328,11 +427,17 @@ function _buildCmdHandlers(daemon) {
   return {
     setCountryFilter(cmd) {
       const prev = checker.CONFIG.nodeCountryFilter;
-      checker.CONFIG.nodeCountryFilter = cmd.country || null;
-      daemon._meta.countryFilter = checker.CONFIG.nodeCountryFilter;
-      daemon._log(
-        `📋 节点过滤: ${prev || "无"} → ${checker.CONFIG.nodeCountryFilter || "无"}`,
+      const next = normalizeCountries(
+        cmd.countries || (cmd.country ? [cmd.country] : []),
       );
+      checker.CONFIG.nodeCountryFilter = next.length ? next : null;
+      daemon._meta.countryFilter = checker.CONFIG.nodeCountryFilter;
+      daemon._log(`📋 节点过滤: ${fmtCountries(prev)} → ${fmtCountries(next)}`);
+      // 幂等：国家配置变化时才立即刷新候选集，避免每次心跳重复初测
+      if (JSON.stringify(prev || []) !== JSON.stringify(next)) {
+        daemon._log(`📋 国家变化，立即刷新候选集...`);
+        daemon._runDelayProbe().catch(() => {});
+      }
     },
     setTestUrl(cmd) {
       if (cmd.url) {
@@ -352,6 +457,7 @@ function _buildCmdHandlers(daemon) {
       }
     },
     switchNode: (cmd) => daemon._handleSwitchNode(cmd),
+    failover: () => daemon._handleFailover(),
   };
 }
 

package/src/clash/ipc.js

@@ -66,11 +66,13 @@ export function readHealth() {
 
 /**
  * 写入命令（watchdog 调用，daemon 轮询读取）
- * @param {object} cmd - 命令对象，如 { action: "setCountryFilter", country: "US" }
+ * 支持单条对象或命令数组，统一按数组存储，daemon 一次处理一批
+ * @param {object|object[]} cmd - 命令对象或命令数组，如 { action: "setCountryFilter", countries: ["US"] }
  */
 export function writeCommand(cmd) {
   try {
-    writeFileSync(CMD_FILE, JSON.stringify(cmd, null, 2), "utf-8");
+    const payload = Array.isArray(cmd) ? cmd : [cmd];
+    writeFileSync(CMD_FILE, JSON.stringify(payload, null, 2), "utf-8");
   } catch {
     /* 非关键路径 */
   }
@@ -80,8 +82,9 @@ export function readCommand() {
   try {
     if (!existsSync(CMD_FILE)) return null;
     const text = readFileSync(CMD_FILE, "utf-8").trim();
-    if (!text || text === "{}") return null;
-    return JSON.parse(text);
+    if (!text || text === "{}" || text === "[]") return null;
+    const parsed = JSON.parse(text);
+    return Array.isArray(parsed) ? parsed : [parsed];
   } catch {
     return null;
   }

package/src/cli/explore.js

@@ -32,6 +32,7 @@ import path from "path";
 import os from "os";
 
 const MAX_RETRY_WAIT = 5 * 60 * 1000;
+const MAX_REBUILD_ATTEMPTS = 5; // 账户切换后导航恢复：连续重启浏览器超过该次数仍失败则上报并退出
 const STARTUP_TIKTOK_URL = "https://www.tiktok.com/@ycl5007";
 const PAGE_GOTO_TIMEOUT = 60000; // 页面导航超时 60 秒（账户切换后需要更长时间）
 
@@ -45,7 +46,7 @@ async function withRetry(label, fn) {
         `[连接] ${label} 失败: ${err.message}，${backoff / 1000}秒后重试...`,
       );
       await new Promise((r) => setTimeout(r, backoff));
-      if (backoff < MAX_RETRY_WAIT) backoff *= 2;
+      backoff = Math.min(backoff * 2, MAX_RETRY_WAIT);
     }
   }
 }
@@ -244,13 +245,73 @@ export async function handleExplore(options) {
       console.error(
         `[健康检查] 已切换到端口 ${nextAccount.port}${effectiveProxy ? ", 代理: " + effectiveProxy : ""}`,
       );
-      // 切换账户后先导航到 TikTok 页面，再重新检测登录状态
-      await withRetry("账户切换后页面导航", async () => {
-        await page.goto(STARTUP_TIKTOK_URL, {
-          waitUntil: "domcontentloaded",
-          timeout: PAGE_GOTO_TIMEOUT,
-        });
-      });
+      // 切换账户后先导航到 TikTok 页面：退避重试 + 持续失败时重启浏览器重建 page。
+      // 重启超过 MAX_REBUILD_ATTEMPTS 次仍失败 → 上报并退出，避免僵尸进程。
+      let navFailures = 0;
+      let rebuildCount = 0;
+      let backoff = 1000;
+      while (true) {
+        try {
+          await page.goto(STARTUP_TIKTOK_URL, {
+            waitUntil: "domcontentloaded",
+            timeout: PAGE_GOTO_TIMEOUT,
+          });
+          rebuildCount = 0;
+          break;
+        } catch (err) {
+          navFailures++;
+          console.error(
+            `[连接] 账户切换后页面导航 失败 (${navFailures}): ${err.message}，${Math.round(backoff / 1000)}秒后重试...`,
+          );
+          if (isBrowserClosedError(err) || navFailures >= 3) {
+            rebuildCount++;
+            if (rebuildCount > MAX_REBUILD_ATTEMPTS) {
+              console.error(
+                `[致命] 账户切换后导航持续失败，已重启浏览器 ${rebuildCount - 1} 次仍无法恢复，上报后退出`,
+              );
+              await apiPost(`${serverUrl}/api/error-report`, {
+                userId,
+                username: "account-switch",
+                errorType: "account_switch_failed",
+                errorMessage: `账户切换后导航持续失败: ${err.message}`,
+                stage: "account-switch",
+                errorStack: err.stack || "",
+              }).catch(() => {});
+              if (cdpOptions) {
+                await killEdgeProcesses(
+                  cdpOptions.userDataDir,
+                  cdpOptions.port,
+                ).catch(() => {});
+              }
+              await browser?.close().catch(() => {});
+              console.error("[Explore] 已退出（账户切换无法恢复）");
+              process.exit(1);
+            }
+            // 浏览器已关闭或连续 3 次导航失败 → 重启浏览器 + 重建 page 后再试
+            console.error(
+              `  [恢复] (${rebuildCount}/${MAX_REBUILD_ATTEMPTS}) 重启浏览器 (端口 ${cdpOptions.port || 9222})...`,
+            );
+            try {
+              const relaunched = await relaunchBrowser(
+                cdpOptions,
+                cdpOptions.port || 9222,
+              );
+              browser = relaunched;
+              const rebuiltPage = await setupNewPage(browser);
+              Object.assign(page, rebuiltPage);
+              navFailures = 0;
+              backoff = 1000;
+              continue;
+            } catch (rebuildErr) {
+              console.error(
+                `  [恢复] 重启浏览器失败: ${rebuildErr.message}，等待后继续重试...`,
+              );
+            }
+          }
+          await new Promise((r) => setTimeout(r, backoff));
+          backoff = Math.min(backoff * 2, MAX_RETRY_WAIT);
+        }
+      }
       loggedIn = await safeCheckLogin(page);
       console.error(
         `[健康检查] 新账户登录状态: ${loggedIn ? "已登录" : "未登录"}`,

package/src/cli/refresh.js

@@ -31,6 +31,7 @@ import path from "path";
 import os from "os";
 
 const MAX_RETRY_WAIT = 5 * 60 * 1000;
+const MAX_REBUILD_ATTEMPTS = 5; // 账户切换后导航恢复：连续重启浏览器超过该次数仍失败则上报并退出
 const STARTUP_TIKTOK_URL = "https://www.tiktok.com/@ycl5007";
 const PAGE_GOTO_TIMEOUT = 60000; // 页面导航超时 60 秒（账户切换后需要更长时间）
 
@@ -44,7 +45,7 @@ async function withRetry(label, fn) {
         `[连接] ${label} 失败: ${err.message}，${backoff / 1000}秒后重试...`,
       );
       await new Promise((r) => setTimeout(r, backoff));
-      if (backoff < MAX_RETRY_WAIT) backoff *= 2;
+      backoff = Math.min(backoff * 2, MAX_RETRY_WAIT);
     }
   }
 }
@@ -228,9 +229,14 @@ export async function handleRefresh(options) {
       const oldAccount = currentAccount;
       const nextAccount = healthChecker.getNextAccount();
       currentAccount = nextAccount;
+      // 关键：把当前代理传给 switchAccount。
+      // 否则新启动的浏览器不带代理直连 TikTok，连接会被重置（ERR_CONNECTION_RESET），
+      // 之后无论怎么重试 goto 都过不去，程序卡死无法恢复。
+      const effectiveProxy = cdpOptions.proxyServer || resolvedProxy;
       const newBrowser = await switchAccount(
         { port: oldAccount.port, userDataDir: oldAccount.userDataDir },
         { port: nextAccount.port, userDataDir: nextAccount.userDataDir },
+        effectiveProxy,
       );
       browser = newBrowser;
       const newPage = await setupNewPage(browser);
@@ -238,17 +244,79 @@ export async function handleRefresh(options) {
       Object.assign(cdpOptions, {
         port: nextAccount.port,
         userDataDir: nextAccount.userDataDir,
+        ...(effectiveProxy ? { proxyServer: effectiveProxy } : {}),
       });
-      if (resolvedProxy) {
-        cdpOptions.proxyServer = resolvedProxy;
+      console.error(
+        `[健康检查] 已切换到端口 ${nextAccount.port}${effectiveProxy ? ", 代理: " + effectiveProxy : ""}`,
+      );
+      // 账户切换后重新导航：退避重试 + 持续失败时重启浏览器重建 page。
+      // 重启超过 MAX_REBUILD_ATTEMPTS 次仍失败 → 上报并退出，避免僵尸进程。
+      let navFailures = 0;
+      let rebuildCount = 0;
+      let backoff = 1000;
+      while (true) {
+        try {
+          await page.goto(STARTUP_TIKTOK_URL, {
+            waitUntil: "domcontentloaded",
+            timeout: PAGE_GOTO_TIMEOUT,
+          });
+          rebuildCount = 0;
+          break;
+        } catch (err) {
+          navFailures++;
+          console.error(
+            `[连接] 账户切换后页面导航 失败 (${navFailures}): ${err.message}，${Math.round(backoff / 1000)}秒后重试...`,
+          );
+          if (isBrowserClosedError(err) || navFailures >= 3) {
+            rebuildCount++;
+            if (rebuildCount > MAX_REBUILD_ATTEMPTS) {
+              // 恢复不了 → 上报并退出，避免无限重试占用进程
+              console.error(
+                `[致命] 账户切换后导航持续失败，已重启浏览器 ${rebuildCount - 1} 次仍无法恢复，上报后退出`,
+              );
+              await apiPost(`${serverUrl}/api/error-report`, {
+                userId,
+                username: "account-switch",
+                errorType: "account_switch_failed",
+                errorMessage: `账户切换后导航持续失败: ${err.message}`,
+                stage: "account-switch",
+                errorStack: err.stack || "",
+              }).catch(() => {});
+              if (cdpOptions) {
+                await killEdgeProcesses(
+                  cdpOptions.userDataDir,
+                  cdpOptions.port,
+                ).catch(() => {});
+              }
+              await browser?.close().catch(() => {});
+              console.error("[Refresh] 已退出（账户切换无法恢复）");
+              process.exit(1);
+            }
+            // 浏览器已关闭或连续 3 次导航失败 → 重启浏览器 + 重建 page 后再试
+            console.error(
+              `  [恢复] (${rebuildCount}/${MAX_REBUILD_ATTEMPTS}) 重启浏览器 (端口 ${cdpOptions.port || 9222})...`,
+            );
+            try {
+              const relaunched = await relaunchBrowser(
+                cdpOptions,
+                cdpOptions.port || 9222,
+              );
+              browser = relaunched;
+              const rebuiltPage = await setupNewPage(browser);
+              Object.assign(page, rebuiltPage);
+              navFailures = 0;
+              backoff = 1000;
+              continue;
+            } catch (rebuildErr) {
+              console.error(
+                `  [恢复] 重启浏览器失败: ${rebuildErr.message}，等待后继续重试...`,
+              );
+            }
+          }
+          await new Promise((r) => setTimeout(r, backoff));
+          backoff = Math.min(backoff * 2, MAX_RETRY_WAIT);
+        }
       }
-      console.error(`[健康检查] 已切换到端口 ${nextAccount.port}`);
-      await withRetry("账户切换后页面导航", async () => {
-        await page.goto(STARTUP_TIKTOK_URL, {
-          waitUntil: "domcontentloaded",
-          timeout: PAGE_GOTO_TIMEOUT,
-        });
-      });
       loggedIn = await isLoggedIn(page);
       console.error(
         `[健康检查] 新账户登录状态: ${loggedIn ? "已登录" : "未登录"}`,

package/src/cli/search.js

@@ -53,6 +53,7 @@ const DEFAULT_SERVER = cfgServer || "http://127.0.0.1:3000";
 const STARTUP_TIKTOK_URL = "https://www.tiktok.com/@ycl5007";
 const PAGE_GOTO_TIMEOUT = 60000;
 const MAX_RETRY_WAIT = 5 * 60 * 1000;
+const MAX_REBUILD_ATTEMPTS = 5; // 账户切换后导航恢复：连续重启浏览器超过该次数仍失败则上报并退出
 
 async function withRetry(label, fn) {
   let backoff = 1000;
@@ -64,7 +65,7 @@ async function withRetry(label, fn) {
         `[连接] ${label} 失败: ${err.message}，${backoff / 1000}秒后重试...`,
       );
       await new Promise((r) => setTimeout(r, backoff));
-      if (backoff < MAX_RETRY_WAIT) backoff *= 2;
+      backoff = Math.min(backoff * 2, MAX_RETRY_WAIT);
     }
   }
 }
@@ -286,13 +287,73 @@ export async function handleSearch(parsed) {
       log(
         `[健康检查] 已切换到端口 ${nextAccount.port}${resolvedProxy ? ", 代理: " + resolvedProxy : ""}`,
       );
-      // 重新导航并检测登录
-      await withRetry("账户切换后页面导航", async () => {
-        await page.goto(STARTUP_TIKTOK_URL, {
-          waitUntil: "domcontentloaded",
-          timeout: PAGE_GOTO_TIMEOUT,
-        });
-      });
+      // 重新导航并检测登录：退避重试 + 持续失败时重启浏览器重建 page。
+      // 重启超过 MAX_REBUILD_ATTEMPTS 次仍失败 → 上报并退出，避免僵尸进程。
+      let navFailures = 0;
+      let rebuildCount = 0;
+      let backoff = 1000;
+      while (true) {
+        try {
+          await page.goto(STARTUP_TIKTOK_URL, {
+            waitUntil: "domcontentloaded",
+            timeout: PAGE_GOTO_TIMEOUT,
+          });
+          rebuildCount = 0;
+          break;
+        } catch (err) {
+          navFailures++;
+          log(
+            `[连接] 账户切换后页面导航 失败 (${navFailures}): ${err.message}，${Math.round(backoff / 1000)}秒后重试...`,
+          );
+          if (isBrowserClosedError(err) || navFailures >= 3) {
+            rebuildCount++;
+            if (rebuildCount > MAX_REBUILD_ATTEMPTS) {
+              log(
+                `[致命] 账户切换后导航持续失败，已重启浏览器 ${rebuildCount - 1} 次仍无法恢复，上报后退出`,
+              );
+              await apiPost(`${baseUrl}/api/error-report`, {
+                userId,
+                username: "account-switch",
+                errorType: "account_switch_failed",
+                errorMessage: `账户切换后导航持续失败: ${err.message}`,
+                stage: "account-switch",
+                errorStack: err.stack || "",
+              }).catch(() => {});
+              if (cdpOptions) {
+                await killEdgeProcesses(
+                  cdpOptions.userDataDir,
+                  cdpOptions.port,
+                ).catch(() => {});
+              }
+              await browser?.close().catch(() => {});
+              log("[Search] 已退出（账户切换无法恢复）");
+              process.exit(1);
+            }
+            // 浏览器已关闭或连续 3 次导航失败 → 重启浏览器 + 重建 page 后再试
+            log(
+              `  [恢复] (${rebuildCount}/${MAX_REBUILD_ATTEMPTS}) 重启浏览器 (端口 ${cdpOptions.port || 9222})...`,
+            );
+            try {
+              const relaunched = await relaunchBrowser(
+                cdpOptions,
+                cdpOptions.port || 9222,
+              );
+              browser = relaunched;
+              const rebuiltPage = await setupNewPage(browser);
+              page = rebuiltPage;
+              navFailures = 0;
+              backoff = 1000;
+              continue;
+            } catch (rebuildErr) {
+              log(
+                `  [恢复] 重启浏览器失败: ${rebuildErr.message}，等待后继续重试...`,
+              );
+            }
+          }
+          await new Promise((r) => setTimeout(r, backoff));
+          backoff = Math.min(backoff * 2, MAX_RETRY_WAIT);
+        }
+      }
       loggedIn = await safeCheckLogin(page);
       log(`[健康检查] 新账户登录状态: ${loggedIn ? "已登录" : "未登录"}`);
       // 重新提取用户名