tt-help-cli-ycl 1.3.61 → 1.3.63

package/src/cli/refresh.js

@@ -3,61 +3,82 @@ import {
   isBrowserClosedError,
   relaunchBrowser,
 } from "../lib/browser/page.js";
-import { delay, setDelayConfig } from "../scraper/modules/page-helpers.js";
+import {
+  delay,
+  getDelayConfig,
+  setDelayConfig,
+} from "../scraper/modules/page-helpers.js";
+import {
+  detectCaptcha,
+  closeCaptcha,
+} from "../scraper/modules/captcha-handler.js";
 import { userId as configuredUserId, saveUserId } from "../lib/constants.js";
 import { getMacOrUuid } from "../lib/mac-or-uuid.js";
-import { ensureBrowserReady as ensureBrowserReadyCDP } from "../lib/browser/cdp.js";
-import { processRefresh } from "../scraper/refresh-core.js";
+import {
+  ensureBrowserReady as ensureBrowserReadyCDP,
+  switchAccount,
+} from "../lib/browser/cdp.js";
+import { HealthChecker } from "../lib/browser/health-checker.js";
 import path from "path";
 import os from "os";
 
-async function withRetry(fn, maxRetries = 5) {
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+const MAX_RETRY_WAIT = 5 * 60 * 1000;
+const STARTUP_TIKTOK_URL = "https://www.tiktok.com/@ycl5007";
+
+async function withRetry(label, fn) {
+  let backoff = 1000;
+  while (true) {
     try {
       return await fn();
-    } catch (e) {
-      if (attempt < maxRetries) {
-        const waitTime =
-          attempt <= 2
-            ? 5000 + Math.random() * 5000
-            : attempt <= 4
-              ? 10000 + Math.random() * 10000
-              : 20000 + Math.random() * 10000;
-        console.error(
-          `  [网络] 请求失败 (${attempt}/${maxRetries})，${Math.round(waitTime / 1000)}s 后重试...`,
-        );
-        await delay(waitTime / 1000, waitTime / 1000);
-      } else {
-        throw e;
-      }
+    } catch (err) {
+      console.error(
+        `[连接] ${label} 失败: ${err.message}，${backoff / 1000}秒后重试...`,
+      );
+      await new Promise((r) => setTimeout(r, backoff));
+      if (backoff < MAX_RETRY_WAIT) backoff *= 2;
     }
   }
 }
 
-async function apiGet(url) {
-  const resp = await fetch(url);
-  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
-  return resp.json();
+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 apiPost(url, body) {
-  const resp = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body),
+async function apiGet(url) {
+  return withRetry(`GET ${url}`, async () => {
+    const res = await fetch(url);
+    return res.json();
   });
-  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
-  return resp.json();
 }
 
 export async function handleRefresh(options) {
   const {
     explorePreset,
+    exploreInterval,
+    exploreEnableFollow,
+    exploreMaxFollowing,
+    exploreMaxFollowers,
+    exploreLocation,
+    exploreMaxUsers,
+    serverUrl,
     explorePort,
-    exploreProfile,
+    exploreBasePort,
+    explorePortCount,
     exploreUserId,
-    serverUrl,
+    exploreMaxVideos,
+    exploreProfile,
+    exploreRedoMaxAge,
+    exploreProxy,
   } = options;
+
+  let userId = exploreUserId || configuredUserId;
   let browser = null;
   let shuttingDown = false;
 
@@ -81,7 +102,6 @@ export async function handleRefresh(options) {
   process.once("SIGTERM", onSigterm);
 
   try {
-    let userId = exploreUserId || configuredUserId;
     if (!userId) {
       userId = await getMacOrUuid();
       saveUserId(userId);
@@ -90,196 +110,450 @@ export async function handleRefresh(options) {
 
     setDelayConfig(explorePreset);
 
-    console.error(`\n=== Refresh 模式 ===`);
+    // 连接服务器验证
+    await apiGet(`${serverUrl}/api/stats`);
+
+    console.error(`\n=== Refresh 模式（基于 explore） ===`);
     console.error(`服务器: ${serverUrl}`);
-    console.error(`CDP 端口: ${explorePort || 9222}, 用户编号: ${userId}`);
-    if (exploreProfile) console.error(`浏览器配置: ${exploreProfile}`);
-    console.error(`刷新: 视频 100 + 关注 100 + 粉丝 100`);
-    console.error(`新用户探索: 评论 + 猜你喜欢 + 关注/粉丝`);
+    console.error(`视频采集: ${exploreMaxVideos || 16}`);
+    console.error(`关注/粉丝: ${exploreEnableFollow ? "启用" : "禁用"} (${exploreMaxFollowing}/${exploreMaxFollowers})`);
+    console.error(`国家筛选: ${exploreLocation}`);
+    console.error(`空闲间隔: ${exploreInterval || 30} 秒`);
+    if (exploreMaxUsers > 0) console.error(`上限: ${exploreMaxUsers} 个用户`);
+
+    const healthChecker = new HealthChecker({
+      basePort: exploreBasePort,
+      totalAccounts: explorePortCount,
+    });
+    let currentAccount = healthChecker.getCurrentAccount();
 
     const cdpOptions = {};
-    if (explorePort) cdpOptions.port = explorePort;
-    if (exploreProfile) {
+    if (explorePort) {
+      cdpOptions.port = explorePort;
+      cdpOptions.userDataDir = path.join(
+        os.homedir(),
+        "Library",
+        "Application Support",
+        `Microsoft Edge For Testing_p${explorePort}`,
+      );
+    } else if (exploreProfile) {
       cdpOptions.userDataDir = path.join(
         os.homedir(),
         "Library",
         "Application Support",
         `Microsoft Edge For Testing_${exploreProfile}`,
       );
+      cdpOptions.port = currentAccount.port;
+    } else {
+      cdpOptions.port = currentAccount.port;
+      cdpOptions.userDataDir = currentAccount.userDataDir;
+    }
+
+    if (exploreProxy) {
+      cdpOptions.proxyServer = exploreProxy;
+    }
+
+    console.error(`CDP 端口: ${cdpOptions.port}, 用户编号: ${userId}`);
+    console.error(`浏览器配置: ${path.basename(cdpOptions.userDataDir)}`);
+    if (!explorePort && !exploreProfile) {
+      const portRange = `${currentAccount.port}-${currentAccount.port + healthChecker.accounts.length - 1}`;
+      console.error(
+        `端口轮换范围: ${portRange}（共 ${healthChecker.accounts.length} 个）`,
+      );
     }
 
     browser = await ensureBrowserReadyCDP(cdpOptions);
+    const { processExplore } = await import("../scraper/explore-core.js");
+    const { isLoggedIn } = await import("../lib/browser/page.js");
+
     const page = await getOrCreatePage(browser);
 
+    // 导航到 TikTok 页面
+    await page.goto(STARTUP_TIKTOK_URL, {
+      waitUntil: "domcontentloaded",
+    });
+
+    // 检测登录状态
+    let loggedIn = await isLoggedIn(page);
+    console.error(`登录状态: ${loggedIn ? "已登录" : "未登录"}`);
+
+    // 全局拦截图片资源
+    await page.route("**/*", (route) => {
+      const resourceType = route.request().resourceType();
+      if (resourceType === "image" || resourceType === "stylesheet") {
+        route.abort();
+      } else {
+        route.continue();
+      }
+    });
+
+    // 账户切换后，重新初始化 page
+    async function setupNewPage(newBrowser) {
+      const newPage = await getOrCreatePage(newBrowser);
+      await newPage.route("**/*", (route) => {
+        const resourceType = route.request().resourceType();
+        if (resourceType === "image" || resourceType === "stylesheet") {
+          route.abort();
+        } else {
+          route.continue();
+        }
+      });
+      return newPage;
+    }
+
+    async function handleAccountSwitch(reason) {
+      console.error(`\n[健康检查] ${reason}，切换到下一个账户...`);
+      const oldAccount = currentAccount;
+      const nextAccount = healthChecker.getNextAccount();
+      currentAccount = nextAccount;
+      const newBrowser = await switchAccount(
+        { port: oldAccount.port, userDataDir: oldAccount.userDataDir },
+        { port: nextAccount.port, userDataDir: nextAccount.userDataDir },
+      );
+      browser = newBrowser;
+      const newPage = await setupNewPage(browser);
+      Object.assign(page, newPage);
+      Object.assign(cdpOptions, {
+        port: nextAccount.port,
+        userDataDir: nextAccount.userDataDir,
+      });
+      console.error(`[健康检查] 已切换到端口 ${nextAccount.port}`);
+      await page.goto(STARTUP_TIKTOK_URL, {
+        waitUntil: "domcontentloaded",
+      });
+      loggedIn = await isLoggedIn(page);
+      console.error(
+        `[健康检查] 新账户登录状态: ${loggedIn ? "已登录" : "未登录"}`,
+      );
+      lastFollowSuccessTime = Date.now();
+      captchaCount = 0;
+      blockedCount = 0;
+      consecutiveNetworkErrors = 0;
+    }
+
     let processedCount = 0;
     let errorCount = 0;
     let consecutiveNetworkErrors = 0;
+    let captchaCount = 0;
+    let blockedCount = 0;
+    let lastFollowSuccessTime = Date.now();
+    const FOLLOW_BLOCK_THRESHOLD = 10 * 60 * 1000;
 
     console.error(`\n开始循环刷新任务...\n`);
 
-    while (!shuttingDown) {
+    while (true) {
+      if (shuttingDown) break;
+
+      // 健康检查
+      const checkResult = healthChecker.check();
+      if (checkResult.shouldSwitch) {
+        await handleAccountSwitch(checkResult.reason);
+      } else if (checkResult.info && processedCount % 10 === 0) {
+        const followElapsed = loggedIn && exploreEnableFollow
+          ? Math.round((Date.now() - lastFollowSuccessTime) / 60000)
+          : 0;
+        const followStatus =
+          loggedIn && exploreEnableFollow
+            ? ` | 关注/粉丝上次成功 ${followElapsed} 分钟前`
+            : "";
+        console.error(`\n[健康检查] ${checkResult.info}${followStatus}`);
+      }
+
+      // 领取 redo 任务
+      let redoUrl = `${serverUrl}/api/redo-job?userId=${userId}`;
+      if (exploreRedoMaxAge > 0) {
+        redoUrl += `&maxAge=${exploreRedoMaxAge}`;
+      }
+      let job = null;
       try {
-        const jobData = await withRetry(() =>
-          apiGet(`${serverUrl}/api/redo-job?userId=${userId}`),
+        job = await apiGet(redoUrl);
+      } catch (e) {
+        consecutiveNetworkErrors++;
+        console.error(
+          `  [网络] 获取任务失败 (${consecutiveNetworkErrors}): ${e.message}`
         );
+        await new Promise((r) => setTimeout(r, 10000));
+        continue;
+      }
 
-        if (!jobData.hasJob) {
-          console.error(`\n[空闲] 暂无 redo 任务，30s 后重试...`);
-          await delay(30000, 30000);
-          continue;
+      if (!job.hasJob) {
+        console.error(`\n[空闲] 暂无 redo 任务，${exploreInterval || 30}s 后重试...`);
+        await new Promise((r) => setTimeout(r, (exploreInterval || 30) * 1000));
+        consecutiveNetworkErrors = 0;
+        continue;
+      }
+
+      consecutiveNetworkErrors = 0;
+      const username = job.user.uniqueId;
+      const nickname = job.user.nickname;
+      console.error(`\n[${processedCount}] 刷新 @${username}...`);
+
+      // 切换任务前检测验证码
+      const captchaResult = await detectCaptcha(page);
+      if (captchaResult && captchaResult.visible) {
+        console.error(`\n[验证码] 切换任务前检测到验证码，等待3分钟...`);
+        captchaCount++;
+        console.error(`  [验证码] 累计 ${captchaCount} 次`);
+
+        await new Promise((r) => setTimeout(r, 180000));
+
+        const closeResult = await closeCaptcha(page);
+        if (closeResult.success) {
+          console.error("  [验证码] 已关闭验证码");
+          await new Promise((r) => setTimeout(r, 10000));
+        } else {
+          console.error("  [验证码] 无法关闭验证码，继续处理");
         }
 
-        const { uniqueId, nickname } = jobData.user;
-        consecutiveNetworkErrors = 0;
-        processedCount++;
+        await withRetry("report captcha", () =>
+          apiPost(`${serverUrl}/api/error-report`, {
+            userId,
+            username: "unknown",
+            errorType: "captcha",
+            errorMessage: "切换任务前检测到验证码",
+            stage: "between-tasks",
+            errorStack: "",
+          }),
+        ).catch(() => {});
 
-        console.error(
-          `\n[${processedCount}] 刷新 @${uniqueId} (${nickname || "未知"})...`,
-        );
+        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 (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));
+        }
+      }
 
-        const result = await processRefresh(
+      const { switchMax } = getDelayConfig();
+      await delay(switchMax, switchMax * 3);
+
+      let result = await processExplore(
+        page,
+        username,
+        {
+          maxVideos: exploreMaxVideos || 16,
+          enableFollow: exploreEnableFollow !== false,
+          loggedIn,
+          maxFollowing: exploreMaxFollowing || 100,
+          maxFollowers: exploreMaxFollowers || 100,
+          location: exploreLocation,
+          browser,
+        },
+        console.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,
-          uniqueId,
-          serverUrl,
+          username,
           {
-            maxFollowing: 100,
-            maxFollowers: 100,
-            maxVideos: 100,
+            maxVideos: exploreMaxVideos || 16,
+            enableFollow: exploreEnableFollow !== false,
+            loggedIn,
+            maxFollowing: exploreMaxFollowing || 100,
+            maxFollowers: exploreMaxFollowers || 100,
+            location: exploreLocation,
+            browser,
           },
           console.error,
         );
+      }
 
-        if (result.restricted) {
-          console.error(`  @${uniqueId} 页面受限，跳过`);
-          await apiPost(`${serverUrl}/api/redo-job/${uniqueId}`, {
-            restricted: true,
-            userInfo: result.userInfo || {},
-          });
-          continue;
+      if (result.restricted) {
+        consecutiveNetworkErrors = 0;
+        await apiPost(`${serverUrl}/api/redo-job/${username}`, {
+          restricted: true,
+          userInfo: result.userInfo || {},
+        });
+        if (exploreMaxUsers > 0 && processedCount >= exploreMaxUsers) {
+          console.error(`\n已达上限 ${exploreMaxUsers} 个用户，停止处理`);
+          break;
         }
+        continue;
+      }
 
-        if (result.error) {
-          // 浏览器关闭检测
-          if (isBrowserClosedError(new Error(result.error))) {
-            const newBrowser = await relaunchBrowser(
-              cdpOptions,
-              explorePort || 9222,
-            );
-            browser = newBrowser;
-            const newPage = await getOrCreatePage(browser);
-            Object.assign(page, newPage);
-            // 重试当前用户
-            const retryResult = await processRefresh(
-              page,
-              uniqueId,
-              serverUrl,
-              {
-                maxFollowing: 100,
-                maxFollowers: 100,
-                maxVideos: 100,
-              },
-              console.error,
-            );
-            Object.assign(result, retryResult);
-            // 继续下方逻辑，检查重试后的 result
-          } else {
-            consecutiveNetworkErrors++;
-            errorCount++;
-            console.error(`  [错误] ${result.error}`);
-
-            if (consecutiveNetworkErrors >= 3) {
-              console.error(
-                `  [警告] 连续 ${consecutiveNetworkErrors} 次错误，等待 60s 后重试...`,
-              );
-              await delay(60000, 60000);
-              consecutiveNetworkErrors = 0;
-            }
+      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 || 16,
+              enableFollow: exploreEnableFollow !== false,
+              loggedIn,
+              maxFollowing: exploreMaxFollowing || 100,
+              maxFollowers: exploreMaxFollowers || 100,
+              location: exploreLocation,
+              browser,
+            },
+            console.error,
+          );
+          if (!result.error) {
+            consecutiveNetworkErrors = 0;
+            errorCount--;
+          }
+        }
 
-            await apiPost(`${serverUrl}/api/redo-job/${uniqueId}`, {
-              error: result.error,
-              userInfo: result.userInfo || {},
-            });
-            const errorType =
-              consecutiveNetworkErrors > 1 ? "network" : "other";
+        if (result.error) {
+          await apiPost(`${serverUrl}/api/redo-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: uniqueId,
+              username,
               errorType,
               errorMessage: result.error,
               stage: "process",
               errorStack: result.errorStack || "",
-            }).catch(() => {});
+            }),
+          ).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.captchaDetected) {
-          await apiPost(`${serverUrl}/api/error-report`, {
+        await withRetry("report captcha", () =>
+          apiPost(`${serverUrl}/api/error-report`, {
             userId,
-            username: uniqueId,
+            username,
             errorType: "captcha",
             errorMessage: result.captchaMessage || "页面出现验证码",
             stage: result.captchaStage || "video-page",
             errorStack: "",
-          });
+          }),
+        ).catch(() => {});
+
+        if (captchaCount >= 2) {
+          await handleAccountSwitch(`验证码累计 ${captchaCount} 次`);
+          captchaCount = 0;
         }
+      }
 
-        consecutiveNetworkErrors = 0;
+      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;
+      processedCount++;
 
-        await apiPost(`${serverUrl}/api/redo-job/${uniqueId}`, {
-          userInfo: result.userInfo || {},
-          discoveredVideoAuthors: (result.discoveredVideoAuthors || []).map(
-            (item) =>
-              typeof item === "object" ? { ...item, guessedLocation } : item,
-          ),
-          discoveredCommentAuthors: (result.discoveredCommentAuthors || []).map(
-            (author) => ({ author, guessedLocation }),
-          ),
-          discoveredGuessAuthors: (result.discoveredGuessAuthors || []).map(
-            (author) => ({ author, guessedLocation }),
-          ),
-          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,
-          })),
-          newUsersAdded: result.newUsersAdded || 0,
-          collectedVideos: result.collectedVideos || 0,
-        });
+      const guessedLocation = result.locationCreated || null;
 
-        console.error(
-          `  [完成] 视频: ${result.collectedVideos}, 评论作者: ${result.discoveredCommentAuthors?.length || 0}, 关注: ${result.discoveredFollowing?.length || 0}, 粉丝: ${result.discoveredFollowers?.length || 0}, 新增用户: ${result.newUsersAdded}`,
+      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/redo-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} 条已存在`);
+      }
 
-        await delay(3000, 5000);
-      } catch (e) {
-        consecutiveNetworkErrors++;
-        errorCount++;
-        console.error(`\n[错误] ${e.message}`);
+      console.error("  已提交");
 
-        if (consecutiveNetworkErrors >= 3) {
-          console.error(
-            `[警告] 连续 ${consecutiveNetworkErrors} 次网络异常，等待 60s 后重试...`,
-          );
-          await delay(60000, 60000);
-          consecutiveNetworkErrors = 0;
-        } else {
-          const waitTime =
-            consecutiveNetworkErrors <= 2
-              ? 5000 + Math.random() * 5000
-              : 10000 + Math.random() * 10000;
-          console.error(`  等待 ${Math.round(waitTime / 1000)}s 后重试...`);
-          await delay(waitTime / 1000, waitTime / 1000);
-        }
+      if (exploreMaxUsers > 0 && processedCount >= exploreMaxUsers) {
+        console.error(`\n已达上限 ${exploreMaxUsers} 个用户，停止处理`);
+        break;
       }
     }
+
+    const stats = await apiGet(`${serverUrl}/api/stats`);
+    console.error(`\n完成: ${processedCount} 个用户处理, ${errorCount} 个出错`);
+    console.error(
+      `  总用户: ${stats.totalUsers}, 已完成: ${stats.processedUsers}, 待处理: ${stats.pendingUsers}, 错误: ${stats.errorUsers}`,
+    );
   } finally {
     process.removeListener("SIGINT", onSigint);
     process.removeListener("SIGTERM", onSigterm);