tt-help-cli-ycl 1.4.172 → 1.4.176

package/src/cli/explore.js

@@ -26,7 +26,18 @@ import {
   switchAccount,
 } from "../lib/browser/cdp.js";
 import { showResourceUsage } from "../utils/index.js";
-import { HealthChecker } from "../lib/browser/health-checker.js";
+import {
+  HealthChecker,
+  MEMORY_THRESHOLD,
+  ROTATE_INTERVAL_MS,
+} from "../lib/browser/health-checker.js";
+import {
+  createLoginPoolClient,
+  whoAmI,
+  gotoTiktok,
+  injectPoolAccount,
+  ensurePoolLogin,
+} from "../lib/login-pool-client.js";
 import { createApiClient } from "../lib/api-client.js";
 import { createCDNHandler } from "../lib/cdn-handler.js";
 import { proxyPortOf, triggerProxySwitch } from "../clash/proxy-switch.js";
@@ -67,6 +78,7 @@ export async function handleExplore(options) {
     exploreMaxUsers,
     serverUrl,
     explorePort,
+    exploreNoPool,
     exploreBasePort,
     explorePortCount,
     exploreUserId,
@@ -83,11 +95,22 @@ export async function handleExplore(options) {
   let browser = null;
   let cdpOptions = null;
   let shuttingDown = false;
+  // 登录池（pool 模式）：账号从账号中心动态取，原地切号替代换端口
+  let poolClient = null; // 账号中心客户端
+  let poolAccount = null; // 当前在手账号（含 cookies 与租约 id）
+  let poolAccountSince = Date.now(); // 当前账号开始使用时刻（48min 换号计时）
 
   const shutdown = async (signal) => {
     if (shuttingDown) return;
     shuttingDown = true;
-    console.error(`\n[Explore] 收到 ${signal}，正在关闭浏览器...`);
+    console.error(`\n[Explore] 收到 ${signal}，正在关闭...`);
+    // 登录池模式：先还号（本地 profile 保留当前登录态，clearOnNode 默认否），再关浏览器
+    if (poolClient && poolAccount) {
+      await poolClient
+        .release(poolAccount)
+        .then(() => console.error(`[登录池] 已释放 @${poolAccount.username}`))
+        .catch((e) => console.error(`[登录池] 释放失败（忽略）: ${e.message}`));
+    }
     // 先杀死 Edge 进程（CDP 模式下 browser.close() 只断开连接，不杀进程）
     if (cdpOptions) {
       await killEdgeProcesses(cdpOptions.userDataDir, cdpOptions.port);
@@ -141,14 +164,28 @@ export async function handleExplore(options) {
     console.error(`服务器: ${serverUrl}（断开会自动重连）`);
     if (exploreMaxUsers > 0) console.error(`上限: ${exploreMaxUsers} 个用户`);
 
-    const healthChecker = new HealthChecker({
-      basePort: exploreBasePort,
-      totalAccounts: explorePortCount,
-    });
+    const poolMode = !exploreNoPool;
+    const poolPort = explorePort || exploreBasePort || 9222;
+    const healthChecker = poolMode
+      ? new HealthChecker({ basePort: poolPort, totalAccounts: 1 })
+      : new HealthChecker({
+          basePort: exploreBasePort,
+          totalAccounts: explorePortCount,
+        });
     let currentAccount = healthChecker.getCurrentAccount();
 
     cdpOptions = {};
-    if (explorePort) {
+    if (poolMode) {
+      // 登录池模式：端口退化为节点本地固定槽位（无轮换），账号从账号中心动态取。
+      // --base-port 兼容旧命令配置：作为固定口使用（轮换已取消）；--port-count 无意义，打日志忽略
+      cdpOptions.port = explorePort || exploreBasePort || 9222;
+      cdpOptions.userDataDir = path.join(
+        os.homedir(),
+        "Library",
+        "Application Support",
+        `Microsoft Edge For Testing_p${cdpOptions.port}`,
+      );
+    } else if (explorePort) {
       // 固定端口模式（调试用，关闭自动轮换）
       cdpOptions.port = explorePort;
       cdpOptions.userDataDir = path.join(
@@ -178,6 +215,21 @@ export async function handleExplore(options) {
 
     console.error(`CDP 端口: ${cdpOptions.port}, 用户编号: ${userId}`);
     console.error(`浏览器配置: ${path.basename(cdpOptions.userDataDir)}`);
+    if (poolMode) {
+      console.error(
+        `登录池模式: 账号中心 ${serverUrl}，端口固定 ${cdpOptions.port}（--no-pool 回退端口轮换）`,
+      );
+      if (exploreBasePort && !explorePort) {
+        console.error(
+          `  [--base-port ${exploreBasePort}] 在 pool 模式下作为固定端口使用（轮换已取消）`,
+        );
+      }
+      if (explorePortCount != null) {
+        console.error(
+          `  [--port-count ${explorePortCount}] 在 pool 模式下无意义（无端口轮换），已忽略`,
+        );
+      }
+    }
 
     const { apiGet, apiPost } = createApiClient({
       meta: { port: cdpOptions.port },
@@ -191,7 +243,7 @@ export async function handleExplore(options) {
       });
       console.error(`种子用户: ${added} 个新增, ${skipped} 个已存在`);
     }
-    if (!explorePort) {
+    if (!poolMode && !explorePort) {
       const portRange = `${currentAccount.port}-${currentAccount.port + healthChecker.accounts.length - 1}`;
       console.error(
         `端口轮换范围: ${portRange}（共 ${healthChecker.accounts.length} 个）`,
@@ -212,8 +264,50 @@ export async function handleExplore(options) {
       });
     });
 
-    // 检测登录状态（启动时只检测一次）
-    let loggedIn = await safeCheckLogin(page);
+    // 检测登录状态（legacy 模式启动时只检测一次；pool 模式在取号注入后置位）
+    let loggedIn = false;
+    if (poolMode) {
+      poolClient = createLoginPoolClient({
+        serverUrl,
+        userId,
+        port: cdpOptions.port,
+        appName: "explore",
+      });
+      // 取号 + 注入验证（60s 退避重试至 30min，仍失败退出交 watchdog 重启循环）
+      const startupDeadline = Date.now() + 30 * 60 * 1000;
+      while (!poolAccount) {
+        try {
+          poolAccount = await poolClient.acquire();
+        } catch (e) {
+          if (Date.now() > startupDeadline || shuttingDown) {
+            await poolFatalExit(`取号失败超过 30 分钟（${e.message}）`);
+          }
+          console.error(`[登录池] 取号失败: ${e.message}，60 秒后重试...`);
+          await new Promise((r) => setTimeout(r, 60 * 1000));
+          continue;
+        }
+        // 以号为主键：拿到的号直接注入验证（本地磁盘态与取号结果无关）
+        const r = await injectPoolAccount(page, poolAccount, {
+          verifyUsername: poolAccount.username,
+        }).catch((e) => ({ ok: false, reason: e.message }));
+        if (r.ok) {
+          loggedIn = true;
+          console.error(`[登录池] @${poolAccount.username} 注入验证 ✓`);
+          break;
+        }
+        console.error(
+          `[登录池] @${poolAccount.username} 注入验证失败（${r.reason}），释放回池换下一个...`,
+        );
+        await poolClient.release(poolAccount).catch(() => {});
+        poolAccount = null;
+        if (Date.now() > startupDeadline || shuttingDown) {
+          await poolFatalExit("启动取号注入未成功（30 分钟窗口耗尽）");
+        }
+        await new Promise((r) => setTimeout(r, 10 * 1000));
+      }
+    } else {
+      loggedIn = await safeCheckLogin(page);
+    }
 
     // 全局拦截图片资源，减少内存占用和加载时间
     await page.route("**/*", (route) => {
@@ -239,7 +333,117 @@ export async function handleExplore(options) {
       return newPage;
     }
 
+    // ── 登录池模式辅助 ──
+
+    /** 致命退出：杀 Edge + 退出（启动期取号/注入超时等） */
+    async function poolFatalExit(msg) {
+      console.error(`[登录池] ${msg}`);
+      if (cdpOptions) {
+        await killEdgeProcesses(cdpOptions.userDataDir, cdpOptions.port).catch(() => {});
+      }
+      await browser?.close().catch(() => {});
+      process.exit(1);
+    }
+
+    /**
+     * 换号（以号为主键）：先取新号（旧号仍在手，无空窗）→ 注入验证 → 还旧号。
+     * 候选最多试 5 个（注入失败的释放回池）；池空/服务器不可达 → 保旧号返回 false，
+     * 由主循环「无在手账号」补取逻辑兑底。
+     */
+    async function switchPoolAccount(reason) {
+      console.error(`\n[换号] ${reason}，从账号中心取新账号...`);
+      for (let attempt = 0; attempt < 5; attempt++) {
+        let next = null;
+        try {
+          next = await poolClient.acquire();
+        } catch (e) {
+          console.error(
+            `[换号] 取新号失败（${e.message}）${poolAccount ? `，保留当前账号 @${poolAccount.username}` : "，将在主循环补取"}`,
+          );
+          return false;
+        }
+        const r = await injectPoolAccount(page, next, {
+          verifyUsername: next.username,
+        }).catch((e) => ({ ok: false, reason: e.message }));
+        if (!r.ok) {
+          console.error(
+            `[换号] @${next.username} 注入验证失败（${r.reason}），释放候选换下一个...`,
+          );
+          await poolClient.release(next).catch(() => {});
+          continue;
+        }
+        // 新号验证通过：切换在手状态，再还旧号（谁持账号谁还）
+        const prev = poolAccount;
+        poolAccount = next;
+        poolAccountSince = Date.now();
+        loggedIn = true;
+        lastFollowSuccessTime = Date.now();
+        captchaCount = 0;
+        blockedCount = 0;
+        cdn.reset();
+        consecutiveNetworkErrors = 0;
+        console.error(`[换号] @${prev ? prev.username + " → " : ""}@${next.username} 注入验证通过 ✓`);
+        if (prev) {
+          await poolClient
+            .release(prev)
+            .then(() => console.error(`[换号] 旧号 @${prev.username} 已还池`))
+            .catch((e) =>
+              console.error(`[换号] 旧号释放失败（忽略，TTL 兑底）: ${e.message}`),
+            );
+        }
+        return true;
+      }
+      console.error(`[换号] 连续 5 个候选注入验证失败，保留现场等待下轮重试`);
+      await apiPost(`${serverUrl}/api/error-report`, {
+        userId,
+        username: poolAccount ? poolAccount.username : "unknown",
+        errorType: "account_switch_failed",
+        errorMessage: "连续5个候选账号注入验证失败（详情见节点日志）",
+        stage: "account-switch",
+      }).catch(() => {});
+      return false;
+    }
+
+    /** 浏览器重建/重启后恢复登录态：磁盘态一致则免注入，否则用内存 cookies 补注入 */
+    async function restorePoolLogin() {
+      if (!poolAccount) return false;
+      const r = await ensurePoolLogin(page, poolAccount).catch((e) => ({
+        ok: false,
+        reason: e.message,
+      }));
+      if (r.ok) {
+        loggedIn = true;
+        console.error(
+          `[登录池] 登录态已恢复 @${poolAccount.username}${r.injected ? "（重新注入）" : "（磁盘态一致）"}`,
+        );
+        return true;
+      }
+      console.error(`[登录池] 登录态恢复失败（${r.reason}），转入换号流程`);
+      return await switchPoolAccount(`浏览器重启后无法恢复 @${poolAccount.username} 的登录态`);
+    }
+
+    /** 内存超限：同号重启浏览器（不换号——内存是浏览器进程问题，不是账号问题） */
+    async function restartPoolBrowser(reason) {
+      console.error(
+        `\n[浏览器] ${reason}，同号重启浏览器（@${poolAccount ? poolAccount.username : "无在手账号"}）...`,
+      );
+      try {
+        const relaunched = await relaunchBrowser(cdpOptions, cdpOptions.port || 9222);
+        browser = relaunched;
+        const rebuiltPage = await setupNewPage(browser);
+        Object.assign(page, rebuiltPage);
+      } catch (e) {
+        console.error(`[浏览器] 重启失败: ${e.message}，转入换号流程`);
+        return await switchPoolAccount(`浏览器重启失败（${e.message}）`);
+      }
+      return await restorePoolLogin();
+    }
+
     async function handleAccountSwitch(reason) {
+      if (poolMode) {
+        await switchPoolAccount(reason);
+        return;
+      }
       console.error(`\n[健康检查] ${reason}，切换到下一个账户...`);
       const oldAccount = currentAccount;
       const nextAccount = healthChecker.getNextAccount();
@@ -407,6 +611,14 @@ export async function handleExplore(options) {
 
     while (!shuttingDown) {
       try {
+        // 登录池模式：无在手账号（上次换号未完成/候选全败）先补取，补不到退避后重来
+        if (poolMode && !poolAccount) {
+          const ok = await switchPoolAccount("补取账号（当前无在手租约）");
+          if (!ok) {
+            await new Promise((r) => setTimeout(r, 60 * 1000));
+            continue;
+          }
+        }
         // 周期性同步服务端目标国家（内部节流，几乎零开销）
         if (!options.locationExplicit) {
           const synced = await syncTargetLocationsFromServer(serverUrl);
@@ -431,23 +643,44 @@ export async function handleExplore(options) {
           showResourceUsage();
         }
 
-        const checkResult = healthChecker.check();
-        if (checkResult.shouldSwitch) {
-          await handleAccountSwitch(checkResult.reason);
-        } else if (checkResult.info && processedCount % 10 === 0) {
-          // 关注/粉丝封禁检测状态（仅登录状态）
-          let followStatus = "";
-          if (loggedIn && exploreEnableFollow) {
-            const followElapsed = Math.round(
-              (Date.now() - lastFollowSuccessTime) / 60000,
+        if (poolMode) {
+          // 登录池模式：内存超限→同号重启浏览器；48min→换号（原地切号，不换端口）
+          const memRatio = healthChecker.memoryUsage();
+          const elapsedMs = Date.now() - poolAccountSince;
+          if (memRatio >= MEMORY_THRESHOLD) {
+            await restartPoolBrowser(`系统内存 ${(memRatio * 100).toFixed(1)}% 超阈值`);
+          } else if (elapsedMs >= ROTATE_INTERVAL_MS) {
+            await handleAccountSwitch(
+              `当前账号已运行 ${Math.round(elapsedMs / 60000)} 分钟`,
             );
-            const followRemaining = Math.max(
+          } else if (processedCount % 10 === 0) {
+            const remainMin = Math.max(
               0,
-              Math.round(FOLLOW_BLOCK_THRESHOLD / 60000) - followElapsed,
+              Math.round((ROTATE_INTERVAL_MS - elapsedMs) / 60000),
+            );
+            console.error(
+              `\n[巡检] @${poolAccount.username} | 内存 ${(memRatio * 100).toFixed(1)}% | 距换号 ${remainMin} 分钟`,
             );
-            followStatus = ` | 关注/粉丝上次成功 ${followElapsed} 分钟前 | 封禁检测 ${followRemaining} 分钟后`;
           }
-          console.error(`\n[健康检查] ${checkResult.info}${followStatus}`);
+        } else {
+          const checkResult = healthChecker.check();
+          if (checkResult.shouldSwitch) {
+            await handleAccountSwitch(checkResult.reason);
+          } else if (checkResult.info && processedCount % 10 === 0) {
+            // 关注/粉丝封禁检测状态（仅登录状态）
+            let followStatus = "";
+            if (loggedIn && exploreEnableFollow) {
+              const followElapsed = Math.round(
+                (Date.now() - lastFollowSuccessTime) / 60000,
+              );
+              const followRemaining = Math.max(
+                0,
+                Math.round(FOLLOW_BLOCK_THRESHOLD / 60000) - followElapsed,
+              );
+              followStatus = ` | 关注/粉丝上次成功 ${followElapsed} 分钟前 | 封禁检测 ${followRemaining} 分钟后`;
+            }
+            console.error(`\n[健康检查] ${checkResult.info}${followStatus}`);
+          }
         }
 
         // 切换任务前检测验证码
@@ -546,6 +779,7 @@ export async function handleExplore(options) {
           browser = newBrowser;
           const newPage = await setupNewPage(browser);
           Object.assign(page, newPage);
+          if (poolMode) await restorePoolLogin();
           // 重试当前用户
           result = await processExplore(
             page,
@@ -805,6 +1039,7 @@ export async function handleExplore(options) {
           browser = newBrowser;
           const newPage = await setupNewPage(browser);
           Object.assign(page, newPage);
+          if (poolMode) await restorePoolLogin();
           // 重建后等待页面稳定
           await new Promise((r) => setTimeout(r, 3000));
           console.error(`[浏览器] 已重建，继续处理...`);
@@ -816,11 +1051,22 @@ export async function handleExplore(options) {
       }
     }
 
+    // 登录池模式：自然退出（上限达量/任务空转退出等）也必须还号，否则租约被占到 TTL
+    if (poolClient && poolAccount) {
+      await poolClient
+        .release(poolAccount)
+        .then(() => console.error(`[登录池] 已释放 @${poolAccount.username}`))
+        .catch((e) => console.error(`[登录池] 释放失败（忽略）: ${e.message}`));
+    }
+
     const stats = await apiGet(`${serverUrl}/api/stats`);
     console.error(`\n完成: ${processedCount} 个用户处理, ${errorCount} 个出错`);
     console.error(
       `  总用户: ${stats.totalUsers}, 已完成: ${stats.processedUsers}, 待处理: ${stats.pendingUsers}, 错误: ${stats.errorUsers}`,
     );
+    // CDP 连接会挂住 node event loop（browser.close 只断连不保证 loop 清空，
+    // 见知识库 POC 坑①/F-6 实录）——自然退出必须显式 exit，否则进程悬挂
+    process.exit(0);
   } finally {
     process.removeListener("SIGINT", onSigint);
     process.removeListener("SIGTERM", onSigterm);