tt-help-cli-ycl 1.3.82 → 1.3.84

package/src/cli/explore.js

@@ -24,6 +24,7 @@ import {
 } from "../lib/browser/cdp.js";
 import { showResourceUsage } from "../utils/index.js";
 import { HealthChecker } from "../lib/browser/health-checker.js";
+import { createApiClient } from "../lib/api-client.js";
 import path from "path";
 import os from "os";
 
@@ -46,24 +47,6 @@ async function withRetry(label, fn) {
   }
 }
 
-async function apiPost(url, body) {
-  return withRetry(`POST ${url}`, async () => {
-    const res = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body),
-    });
-    return res.json();
-  });
-}
-
-async function apiGet(url) {
-  return withRetry(`GET ${url}`, async () => {
-    const res = await fetch(url);
-    return res.json();
-  });
-}
-
 export async function handleExplore(options) {
   const {
     exploreUsernames,
@@ -118,15 +101,6 @@ export async function handleExplore(options) {
 
     setDelayConfig(explorePreset);
 
-    await apiGet(`${serverUrl}/api/stats`);
-
-    if (exploreUsernames && exploreUsernames.length > 0) {
-      const { added, skipped } = await apiPost(`${serverUrl}/api/users`, {
-        usernames: exploreUsernames,
-      });
-      console.error(`种子用户: ${added} 个新增, ${skipped} 个已存在`);
-    }
-
     console.error(`\n国家筛选: ${exploreLocation}`);
     if (exploreJobLocations) console.error(`任务国家: ${exploreJobLocations}`);
     console.error(`视频采集: ${exploreMaxVideos || 1}`);
@@ -168,6 +142,17 @@ export async function handleExplore(options) {
 
     console.error(`CDP 端口: ${cdpOptions.port}, 用户编号: ${userId}`);
     console.error(`浏览器配置: ${path.basename(cdpOptions.userDataDir)}`);
+
+    const { apiGet, apiPost } = createApiClient({ meta: { port: cdpOptions.port } });
+
+    await apiGet(`${serverUrl}/api/stats`);
+
+    if (exploreUsernames && exploreUsernames.length > 0) {
+      const { added, skipped } = await apiPost(`${serverUrl}/api/users`, {
+        usernames: exploreUsernames,
+      });
+      console.error(`种子用户: ${added} 个新增, ${skipped} 个已存在`);
+    }
     if (!explorePort) {
       const portRange = `${currentAccount.port}-${currentAccount.port + healthChecker.accounts.length - 1}`;
       console.error(
@@ -264,144 +249,121 @@ export async function handleExplore(options) {
     const FOLLOW_BLOCK_THRESHOLD = 10 * 60 * 1000; // 10分钟
 
     while (!shuttingDown) {
-      const jobQuery = exploreJobLocations
-        ? `${serverUrl}/api/job?userId=${encodeURIComponent(userId)}&locations=${encodeURIComponent(exploreJobLocations)}&loggedIn=${loggedIn}`
-        : `${serverUrl}/api/job?userId=${encodeURIComponent(userId)}&loggedIn=${loggedIn}`;
-      const job = await apiGet(jobQuery);
-      if (!job.hasJob) {
-        console.error(`\n[Explore] 当前无任务，${exploreInterval} 秒后重试...`);
-        await new Promise((r) => setTimeout(r, exploreInterval * 1000));
-        continue;
-      }
+      try {
+        const jobQuery = exploreJobLocations
+          ? `${serverUrl}/api/job?userId=${encodeURIComponent(userId)}&locations=${encodeURIComponent(exploreJobLocations)}&loggedIn=${loggedIn}`
+          : `${serverUrl}/api/job?userId=${encodeURIComponent(userId)}&loggedIn=${loggedIn}`;
+        const job = await apiGet(jobQuery);
+        if (!job.hasJob) {
+          console.error(
+            `\n[Explore] 当前无任务，${exploreInterval} 秒后重试...`,
+          );
+          await new Promise((r) => setTimeout(r, exploreInterval * 1000));
+          continue;
+        }
 
-      const username = job.user.uniqueId;
-      processedCount++;
+        const username = job.user.uniqueId;
+        processedCount++;
 
-      if (processedCount % 10 === 0) {
-        showResourceUsage();
-      }
+        if (processedCount % 10 === 0) {
+          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,
-          );
-          const followRemaining = Math.max(
-            0,
-            Math.round(FOLLOW_BLOCK_THRESHOLD / 60000) - followElapsed,
-          );
-          followStatus = ` | 关注/粉丝上次成功 ${followElapsed} 分钟前 | 封禁检测 ${followRemaining} 分钟后`;
+        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}`);
         }
-        console.error(`\n[健康检查] ${checkResult.info}${followStatus}`);
-      }
 
-      // 切换任务前检测验证码
-      const switchCaptcha = await detectCaptcha(page);
-      if (switchCaptcha && switchCaptcha.visible) {
-        console.error(`\n[验证码] 切换任务前检测到验证码，等待3分钟...`);
-        captchaCount++;
-        console.error(`  [验证码] 累计 ${captchaCount} 次`);
+        // 切换任务前检测验证码
+        const switchCaptcha = await detectCaptcha(page);
+        if (switchCaptcha && switchCaptcha.visible) {
+          console.error(`\n[验证码] 切换任务前检测到验证码，等待3分钟...`);
+          captchaCount++;
+          console.error(`  [验证码] 累计 ${captchaCount} 次`);
+
+          // 等待3分钟
+          await new Promise((r) => setTimeout(r, 3 * 60 * 1000));
+
+          // 尝试关闭
+          const closeResult = await closeCaptcha(page);
+          if (closeResult.success) {
+            console.error(`  [验证码] 已关闭`);
+          } else {
+            console.error(`  [验证码] 关闭失败: ${closeResult.reason}`);
+          }
 
-        // 等待3分钟
-        await new Promise((r) => setTimeout(r, 3 * 60 * 1000));
+          // 上报
+          await withRetry("report captcha", () =>
+            apiPost(`${serverUrl}/api/error-report`, {
+              userId,
+              username: "unknown",
+              errorType: "captcha",
+              errorMessage: "切换任务前检测到验证码",
+              stage: "between-tasks",
+              errorStack: "",
+            }),
+          ).catch(() => {});
 
-        // 尝试关闭
-        const closeResult = await closeCaptcha(page);
-        if (closeResult.success) {
-          console.error(`  [验证码] 已关闭`);
-        } else {
-          console.error(`  [验证码] 关闭失败: ${closeResult.reason}`);
+          // 累计2次切换账户
+          if (captchaCount >= 2) {
+            await handleAccountSwitch(`验证码累计 ${captchaCount} 次`);
+            captchaCount = 0;
+          }
         }
 
-        // 上报
-        await withRetry("report captcha", () =>
-          apiPost(`${serverUrl}/api/error-report`, {
-            userId,
-            username: "unknown",
-            errorType: "captcha",
-            errorMessage: "切换任务前检测到验证码",
-            stage: "between-tasks",
-            errorStack: "",
-          }),
-        ).catch(() => {});
-
-        // 累计2次切换账户
-        if (captchaCount >= 2) {
-          await handleAccountSwitch(`验证码累计 ${captchaCount} 次`);
-          captchaCount = 0;
+        // 关注/粉丝封禁检测移到健康检查中（仅登录状态下）
+        if (loggedIn && exploreEnableFollow) {
+          const followElapsed = Date.now() - lastFollowSuccessTime;
+          if (followElapsed > FOLLOW_BLOCK_THRESHOLD) {
+            const minutes = Math.round(followElapsed / 60000);
+            console.error(
+              `\n[封禁检测] 关注/粉丝功能已 ${minutes} 分钟未成功获取，切换到下一个账户...`,
+            );
+            await handleAccountSwitch(`关注/粉丝功能被封`);
+          }
         }
-      }
 
-      // 关注/粉丝封禁检测移到健康检查中（仅登录状态下）
-      if (loggedIn && exploreEnableFollow) {
-        const followElapsed = Date.now() - lastFollowSuccessTime;
-        if (followElapsed > FOLLOW_BLOCK_THRESHOLD) {
-          const minutes = Math.round(followElapsed / 60000);
-          console.error(
-            `\n[封禁检测] 关注/粉丝功能已 ${minutes} 分钟未成功获取，切换到下一个账户...`,
-          );
-          await handleAccountSwitch(`关注/粉丝功能被封`);
+        if (consecutiveNetworkErrors > 0) {
+          const waitTime =
+            consecutiveNetworkErrors <= 2
+              ? 0
+              : consecutiveNetworkErrors <= 5
+                ? 30000
+                : 300000;
+          if (waitTime > 0) {
+            console.error(
+              `  [网络] 连续 ${consecutiveNetworkErrors} 次网络异常，等待 ${waitTime / 1000}s 后重试...`,
+            );
+            await new Promise((r) => setTimeout(r, waitTime));
+          }
         }
-      }
 
-      if (consecutiveNetworkErrors > 0) {
-        const waitTime =
-          consecutiveNetworkErrors <= 2
-            ? 0
-            : consecutiveNetworkErrors <= 5
-              ? 30000
-              : 300000;
-        if (waitTime > 0) {
-          console.error(
-            `  [网络] 连续 ${consecutiveNetworkErrors} 次网络异常，等待 ${waitTime / 1000}s 后重试...`,
-          );
-          await new Promise((r) => setTimeout(r, waitTime));
-        }
-      }
+        console.error(`\n[${processedCount}] 探索 @${username}...`);
 
-      console.error(`\n[${processedCount}] 探索 @${username}...`);
-
-      const { switchMax } = getDelayConfig();
-      await delay(switchMax, switchMax * 3);
-
-      let result = await processExplore(
-        page,
-        username,
-        {
-          maxVideos: exploreMaxVideos,
-          enableFollow: exploreEnableFollow,
-          loggedIn, // 传入登录状态，避免每次调用 isLoggedIn(page)
-          maxFollowing: exploreMaxFollowing,
-          maxFollowers: exploreMaxFollowers,
-          location: exploreLocation,
-          proxyServer: cdpOptions.proxyServer || null,
-          browser,
-        },
-        console.error,
-      );
+        const { switchMax } = getDelayConfig();
+        await delay(switchMax, switchMax * 3);
 
-      // 浏览器关闭检测：processExplore 内部 catch 了异常，需要从 result.error 判断
-      if (result.error && isBrowserClosedError(new Error(result.error))) {
-        const newBrowser = await relaunchBrowser(
-          cdpOptions,
-          cdpOptions.port || 9222,
-        );
-        browser = newBrowser;
-        const newPage = await setupNewPage(browser);
-        Object.assign(page, newPage);
-        // 重试当前用户
-        result = await processExplore(
+        let result = await processExplore(
           page,
           username,
           {
             maxVideos: exploreMaxVideos,
             enableFollow: exploreEnableFollow,
-            loggedIn, // 传入登录状态
+            loggedIn, // 传入登录状态，避免每次调用 isLoggedIn(page)
             maxFollowing: exploreMaxFollowing,
             maxFollowers: exploreMaxFollowers,
             location: exploreLocation,
@@ -410,36 +372,24 @@ export async function handleExplore(options) {
           },
           console.error,
         );
-      }
 
-      if (result.restricted) {
-        consecutiveNetworkErrors = 0;
-        await apiPost(`${serverUrl}/api/job/${username}`, {
-          restricted: true,
-          userInfo: result.userInfo || {},
-        });
-        if (exploreMaxUsers > 0 && processedCount >= exploreMaxUsers) {
-          console.error(`\n已达上限 ${exploreMaxUsers} 个用户，停止处理`);
-          break;
-        }
-        continue;
-      }
-
-      if (result.error) {
-        consecutiveNetworkErrors++;
-        errorCount++;
-
-        // 临时性错误：自动重试一次
-        if (result.retryable) {
-          console.error(`  [临时错误] 等待 5 秒后重试 @${username}...`);
-          await new Promise((r) => setTimeout(r, 5000));
+        // 浏览器关闭检测：processExplore 内部 catch 了异常，需要从 result.error 判断
+        if (result.error && isBrowserClosedError(new Error(result.error))) {
+          const newBrowser = await relaunchBrowser(
+            cdpOptions,
+            cdpOptions.port || 9222,
+          );
+          browser = newBrowser;
+          const newPage = await setupNewPage(browser);
+          Object.assign(page, newPage);
+          // 重试当前用户
           result = await processExplore(
             page,
             username,
             {
               maxVideos: exploreMaxVideos,
               enableFollow: exploreEnableFollow,
-              loggedIn,
+              loggedIn, // 传入登录状态
               maxFollowing: exploreMaxFollowing,
               maxFollowers: exploreMaxFollowers,
               location: exploreLocation,
@@ -448,126 +398,188 @@ export async function handleExplore(options) {
             },
             console.error,
           );
-          // 重试成功后继续正常流程
-          if (!result.error) {
-            consecutiveNetworkErrors = 0;
-            errorCount--;
-          }
         }
 
-        if (result.error) {
-          // 上报错误（重试后仍有错误才上报）
+        if (result.restricted) {
+          consecutiveNetworkErrors = 0;
           await apiPost(`${serverUrl}/api/job/${username}`, {
-            error: result.error,
+            restricted: true,
+            userInfo: result.userInfo || {},
           });
-          const errorType = result.error.startsWith("被封:")
-            ? "被封"
-            : consecutiveNetworkErrors > 1
-              ? "network"
-              : "other";
-          await withRetry("report error", () =>
-            apiPost(`${serverUrl}/api/error-report`, {
-              userId,
-              username,
-              errorType,
-              errorMessage: result.error,
-              stage: "process",
-              errorStack: result.errorStack || "",
-            }),
-          ).catch(() => {});
-          if (errorType === "被封") {
-            blockedCount++;
-            console.error(`  [被封] 累计 ${blockedCount} 次`);
-            if (blockedCount >= 3) {
-              await handleAccountSwitch(`账号被封累计 ${blockedCount} 次`);
-              blockedCount = 0;
-            }
-            continue;
-          }
           if (exploreMaxUsers > 0 && processedCount >= exploreMaxUsers) {
             console.error(`\n已达上限 ${exploreMaxUsers} 个用户，停止处理`);
             break;
           }
           continue;
         }
-      }
 
-      if (result.captchaDetected) {
-        captchaCount++;
-        console.error(`  [验证码] 累计 ${captchaCount} 次`);
+        if (result.error) {
+          consecutiveNetworkErrors++;
+          errorCount++;
+
+          // 临时性错误：自动重试一次
+          if (result.retryable) {
+            console.error(`  [临时错误] 等待 5 秒后重试 @${username}...`);
+            await new Promise((r) => setTimeout(r, 5000));
+            result = await processExplore(
+              page,
+              username,
+              {
+                maxVideos: exploreMaxVideos,
+                enableFollow: exploreEnableFollow,
+                loggedIn,
+                maxFollowing: exploreMaxFollowing,
+                maxFollowers: exploreMaxFollowers,
+                location: exploreLocation,
+                proxyServer: cdpOptions.proxyServer || null,
+                browser,
+              },
+              console.error,
+            );
+            // 重试成功后继续正常流程
+            if (!result.error) {
+              consecutiveNetworkErrors = 0;
+              errorCount--;
+            }
+          }
 
-        await withRetry("report captcha", () =>
-          apiPost(`${serverUrl}/api/error-report`, {
-            userId,
-            username,
-            errorType: "captcha",
-            errorMessage: result.captchaMessage || "页面出现验证码",
-            stage: result.captchaStage || "video-page",
-            errorStack: "",
-          }),
-        ).catch(() => {});
-
-        // 累计2次验证码，切换账户
-        if (captchaCount >= 2) {
-          await handleAccountSwitch(`验证码累计 ${captchaCount} 次`);
-          captchaCount = 0;
+          if (result.error) {
+            // 上报错误（重试后仍有错误才上报）
+            await apiPost(`${serverUrl}/api/job/${username}`, {
+              error: result.error,
+            });
+            const errorType = result.error.startsWith("被封:")
+              ? "被封"
+              : consecutiveNetworkErrors > 1
+                ? "network"
+                : "other";
+            await withRetry("report error", () =>
+              apiPost(`${serverUrl}/api/error-report`, {
+                userId,
+                username,
+                errorType,
+                errorMessage: result.error,
+                stage: "process",
+                errorStack: result.errorStack || "",
+              }),
+            ).catch(() => {});
+            if (errorType === "被封") {
+              blockedCount++;
+              console.error(`  [被封] 累计 ${blockedCount} 次`);
+              if (blockedCount >= 3) {
+                await handleAccountSwitch(`账号被封累计 ${blockedCount} 次`);
+                blockedCount = 0;
+              }
+              continue;
+            }
+            if (exploreMaxUsers > 0 && processedCount >= exploreMaxUsers) {
+              console.error(`\n已达上限 ${exploreMaxUsers} 个用户，停止处理`);
+              break;
+            }
+            continue;
+          }
         }
-      }
 
-      consecutiveNetworkErrors = 0;
+        if (result.captchaDetected) {
+          captchaCount++;
+          console.error(`  [验证码] 累计 ${captchaCount} 次`);
 
-      // 更新关注/粉丝成功时间（仅登录状态下）
-      if (result.hasFollowData && result.keepFollow) {
-        const totalFollows =
-          (result.discoveredFollowing || []).length +
-          (result.discoveredFollowers || []).length;
-        if (totalFollows > 0) {
-          lastFollowSuccessTime = Date.now();
+          await withRetry("report captcha", () =>
+            apiPost(`${serverUrl}/api/error-report`, {
+              userId,
+              username,
+              errorType: "captcha",
+              errorMessage: result.captchaMessage || "页面出现验证码",
+              stage: result.captchaStage || "video-page",
+              errorStack: "",
+            }),
+          ).catch(() => {});
+
+          // 累计2次验证码，切换账户
+          if (captchaCount >= 2) {
+            await handleAccountSwitch(`验证码累计 ${captchaCount} 次`);
+            captchaCount = 0;
+          }
         }
-      }
 
-      const guessedLocation = result.locationCreated || null;
-
-      const payload = {
-        userInfo: result.userInfo || {},
-        discoveredFollowing: (result.discoveredFollowing || []).map((f) => ({
-          handle: Array.isArray(f) ? f[0] : f,
-          displayName: Array.isArray(f) ? f[1] : null,
-          guessedLocation,
-        })),
-        discoveredFollowers: (result.discoveredFollowers || []).map((f) => ({
-          handle: Array.isArray(f) ? f[0] : f,
-          displayName: Array.isArray(f) ? f[1] : null,
-          guessedLocation,
-        })),
-        processed: result.processed,
-        hasFollowData: result.hasFollowData,
-        keepFollow: result.keepFollow,
-        locationCreated: result.locationCreated,
-        noVideo: result.noVideo,
-        collectedVideos: result.collectedVideos,
-      };
-      await apiPost(`${serverUrl}/api/job/${username}`, payload);
-
-      // 视频登记
-      if (result.videoList && result.videoList.length > 0) {
-        const { registered, skipped } = await apiPost(
-          `${serverUrl}/api/videos`,
-          {
-            sourceUser: username,
-            videoList: result.videoList,
-            locationCreated: result.locationCreated,
-            ttSeller: result.userInfo?.ttSeller || false,
-          },
-        );
-        console.error(`  视频登记: ${registered} 条新增, ${skipped} 条已存在`);
-      }
+        consecutiveNetworkErrors = 0;
+
+        // 更新关注/粉丝成功时间（仅登录状态下）
+        if (result.hasFollowData && result.keepFollow) {
+          const totalFollows =
+            (result.discoveredFollowing || []).length +
+            (result.discoveredFollowers || []).length;
+          if (totalFollows > 0) {
+            lastFollowSuccessTime = Date.now();
+          }
+        }
+
+        const guessedLocation = result.locationCreated || null;
+
+        const payload = {
+          userInfo: result.userInfo || {},
+          discoveredFollowing: (result.discoveredFollowing || []).map((f) => ({
+            handle: Array.isArray(f) ? f[0] : f,
+            displayName: Array.isArray(f) ? f[1] : null,
+            guessedLocation,
+          })),
+          discoveredFollowers: (result.discoveredFollowers || []).map((f) => ({
+            handle: Array.isArray(f) ? f[0] : f,
+            displayName: Array.isArray(f) ? f[1] : null,
+            guessedLocation,
+          })),
+          processed: result.processed,
+          hasFollowData: result.hasFollowData,
+          keepFollow: result.keepFollow,
+          locationCreated: result.locationCreated,
+          noVideo: result.noVideo,
+          collectedVideos: result.collectedVideos,
+        };
+        await apiPost(`${serverUrl}/api/job/${username}`, payload);
+
+        // 视频登记
+        if (result.videoList && result.videoList.length > 0) {
+          const { registered, skipped } = await apiPost(
+            `${serverUrl}/api/videos`,
+            {
+              sourceUser: username,
+              videoList: result.videoList,
+              locationCreated: result.locationCreated,
+              ttSeller: result.userInfo?.ttSeller || false,
+            },
+          );
+          console.error(
+            `  视频登记: ${registered} 条新增, ${skipped} 条已存在`,
+          );
+        }
 
-      console.error("  已提交");
+        console.error("  已提交");
 
-      if (exploreMaxUsers > 0 && processedCount >= exploreMaxUsers) {
-        console.error(`\n已达上限 ${exploreMaxUsers} 个用户，停止处理`);
-        break;
+        if (exploreMaxUsers > 0 && processedCount >= exploreMaxUsers) {
+          console.error(`\n已达上限 ${exploreMaxUsers} 个用户，停止处理`);
+          break;
+        }
+      } catch (e) {
+        // 浏览器关闭错误：自动重建 browser + page，然后重试当前轮次
+        if (isBrowserClosedError(e)) {
+          console.error(
+            `\n[浏览器] 检测到浏览器关闭 (${e.message})，正在重建...`,
+          );
+          const newBrowser = await relaunchBrowser(
+            cdpOptions,
+            cdpOptions.port || 9222,
+          );
+          browser = newBrowser;
+          const newPage = await setupNewPage(browser);
+          Object.assign(page, newPage);
+          // 重建后等待页面稳定
+          await new Promise((r) => setTimeout(r, 3000));
+          console.error(`[浏览器] 已重建，继续处理...`);
+          continue;
+        }
+        // 其他未预期错误：打印堆栈并跳过本轮
+        console.error(`\n[未捕获错误] ${e.message}`);
+        console.error(e.stack || "");
       }
     }