tt-help-cli-ycl 1.3.62 → 1.3.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tt-help-cli-ycl",
-  "version": "1.3.62",
+  "version": "1.3.63",
   "description": "TikTok user & video data scraper - extract ttSeller, verified, locationCreated from HTML source",
   "type": "module",
   "bin": {

package/src/cli/explore.js

@@ -78,6 +78,7 @@ export async function handleExplore(options) {
     explorePortCount,
     exploreUserId,
     exploreMaxVideos,
+    exploreProxy,
   } = options;
 
   let userId = exploreUserId || configuredUserId;
@@ -150,6 +151,10 @@ export async function handleExplore(options) {
       cdpOptions.userDataDir = currentAccount.userDataDir;
     }
 
+    if (exploreProxy) {
+      cdpOptions.proxyServer = exploreProxy;
+    }
+
     console.error(`CDP 端口: ${cdpOptions.port}, 用户编号: ${userId}`);
     console.error(`浏览器配置: ${path.basename(cdpOptions.userDataDir)}`);
     if (!explorePort) {

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);

package/src/lib/args.js

@@ -180,6 +180,7 @@ function parseExploreArgs(args) {
   let explorePortCount = null;
   let exploreUserId = null;
   let exploreMaxVideos = 16;
+  let exploreProxy = null;
 
   const positional = [];
   const PRESETS = ["fast", "normal", "slow", "stealth"];
@@ -218,6 +219,8 @@ function parseExploreArgs(args) {
       exploreUserId = args[++i];
     } else if (arg === "--max-videos") {
       exploreMaxVideos = parseInt(args[++i]) || 16;
+    } else if (arg === "--proxy") {
+      exploreProxy = args[++i];
     } else {
       positional.push(arg);
     }
@@ -258,6 +261,7 @@ function parseExploreArgs(args) {
     explorePortCount,
     exploreUserId,
     exploreMaxVideos,
+    exploreProxy,
     urls: [],
     outputFormat: "json",
     exploreCount: 0,
@@ -439,39 +443,77 @@ function parseDbImportArgs(args) {
 function parseRefreshArgs(args) {
   let serverUrl = defaultServer;
   let explorePreset = "normal";
-  let exploreMaxComments = 10;
-  let exploreMaxGuess = 0;
+  let exploreInterval = 30;
+  let exploreEnableFollow = true;
+  let exploreMaxFollowing = 100;
+  let exploreMaxFollowers = 100;
+  let exploreLocation = DEFAULT_TARGET_LOCATIONS_CSV;
+  let exploreMaxUsers = 0;
   let explorePort = null;
+  let exploreBasePort = null;
+  let explorePortCount = null;
   let exploreProfile = null;
   let exploreUserId = null;
+  let exploreMaxVideos = 16;
+  let exploreRedoMaxAge = 0;
+  let exploreProxy = null;
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--server") {
       serverUrl = args[++i];
-    } else if (arg === "--comments") {
-      exploreMaxComments = parseInt(args[++i]) || 10;
-    } else if (arg === "--guess") {
-      exploreMaxGuess = parseInt(args[++i]) || 0;
     } else if (arg === "--preset") {
       explorePreset = args[++i];
+    } else if (arg === "-i" || arg === "--interval") {
+      exploreInterval = parseInt(args[++i], 10) || 30;
     } else if (arg === "--port") {
       explorePort = parseInt(args[++i]) || 9222;
+    } else if (arg === "--base-port") {
+      exploreBasePort = parseInt(args[++i]) || 9222;
+    } else if (arg === "--port-count") {
+      explorePortCount = parseInt(args[++i]) || 10;
     } else if (arg === "--profile") {
       exploreProfile = args[++i];
     } else if (arg === "--user-id") {
       exploreUserId = args[++i];
+    } else if (arg === "--max-videos") {
+      exploreMaxVideos = parseInt(args[++i]) || 16;
+    } else if (arg === "--max-following") {
+      exploreMaxFollowing = parseInt(args[++i]) || 100;
+    } else if (arg === "--max-followers") {
+      exploreMaxFollowers = parseInt(args[++i]) || 100;
+    } else if (arg === "--max-age") {
+      exploreRedoMaxAge = parseInt(args[++i]) || 43200;
+    } else if (arg === "--proxy") {
+      exploreProxy = args[++i];
+    } else if (arg === "--location") {
+      exploreLocation = args[++i];
+    } else if (arg === "--enable-follow") {
+      exploreEnableFollow = true;
+    } else if (arg === "--disable-follow") {
+      exploreEnableFollow = false;
+    } else if (arg === "--max-users") {
+      exploreMaxUsers = parseInt(args[++i]) || 0;
     }
   }
 
   return {
     subcommand: "refresh",
     explorePreset,
-    exploreMaxComments,
-    exploreMaxGuess,
+    exploreInterval,
+    exploreEnableFollow,
+    exploreMaxFollowing,
+    exploreMaxFollowers,
+    exploreLocation,
+    exploreMaxUsers,
     explorePort,
+    exploreBasePort,
+    explorePortCount,
     exploreProfile,
     exploreUserId,
+    exploreMaxVideos,
+    exploreRedoMaxAge,
+    exploreProxy,
     serverUrl,
     urls: [],
     outputFormat: "json",
@@ -721,6 +763,10 @@ export function parseArgs() {
     return parseDbImportArgs(args.slice(1));
   }
 
+  if (args.length > 0 && args[0] === "refresh") {
+    return parseRefreshArgs(args.slice(1));
+  }
+
   const urls = [];
   let inputFile = null;
   let outputFile = null;

package/src/lib/browser/cdp.js

@@ -143,7 +143,7 @@ function killEdgeProcesses(targetDir) {
   });
 }
 
-function launchEdgeWithCDP(port, userDataDir) {
+function launchEdgeWithCDP(port, userDataDir, proxyServer) {
   return new Promise((resolve, reject) => {
     const platform = os.platform();
     const edgePath = getEdgePath();
@@ -162,14 +162,19 @@ function launchEdgeWithCDP(port, userDataDir) {
       "--disable-breakpad",
       "--disable-background-networking",
       "--disable-sync",
-    ].join(" ");
+    ];
+    if (proxyServer) {
+      extraArgs.push(`--proxy-server="${proxyServer}"`);
+    }
+
+    const argsStr = extraArgs.join(" ");
 
     if (platform === "darwin") {
-      command = `open -a ${edgePath} --new --args ${extraArgs}`;
+      command = `open -a ${edgePath} --new --args ${argsStr}`;
     } else if (platform === "win32") {
-      command = `start msedge ${extraArgs}`;
+      command = `start msedge ${argsStr}`;
     } else {
-      command = `msedge ${extraArgs} &`;
+      command = `msedge ${argsStr} &`;
     }
 
     exec(command, (err) => {
@@ -194,6 +199,7 @@ export { killEdgeProcesses };
 export async function ensureBrowserReady(options = {}) {
   const port = options.port || DEFAULT_CDP_PORT;
   const userDataDir = options.userDataDir || DEFAULT_USER_DATA_DIR;
+  const proxyServer = options.proxyServer || null;
   const isCustom = port !== DEFAULT_CDP_PORT || !!options.userDataDir;
 
   const isReady = await checkCDPPort(port);

package/src/lib/constants.js

@@ -131,12 +131,33 @@ const HELP_TEXT = [
   "      --disable-follow          禁用关注/粉丝提取",
   "      --max-following <数量>    最大获取关注数，默认 50",
   "      --max-followers <数量>    最大获取粉丝数，默认 50",
-  "      --max-users <数量>        最大处理用户数，默认无限制",
-  "      -i, --interval <秒数>     无任务时轮询间隔，默认 10 秒",
-  "      --port <端口号>           固定 CDP 端口（调试用，关闭自动轮换）",
-  "      --base-port <端口号>      起始端口，默认 9222",
-  "      --port-count <数量>       端口数量（账户数），默认 10",
-  "      --user-id <编号>          客户端编号（设备ID），默认自动生成",
+      "      --max-users <数量>        最大处理用户数，默认无限制",
+      "      -i, --interval <秒数>     无任务时轮询间隔，默认 10 秒",
+      "      --port <端口号>           固定 CDP 端口（调试用，关闭自动轮换）",
+      "      --base-port <端口号>      起始端口，默认 9222",
+      "      --port-count <数量>       端口数量（账户数），默认 10",
+      "      --user-id <编号>          客户端编号（设备ID），默认自动生成",
+      "      --proxy <地址>            浏览器代理（如 socks5://127.0.0.1:1080）",
+      "",
+      "  tt-help refresh [选项]",
+      "    对目标商家用户进行轮回刷新，重新采集视频 + 关注 + 粉丝",
+      "    筛选条件: tt_seller=1, verified=0, 目标国家",
+      "    选项:",
+      "      --server <URL>            服务端地址，默认 http://127.0.0.1:3001",
+      `      --location <国家代码>     国家筛选，逗号分隔，默认 ${DEFAULT_TARGET_LOCATIONS_CSV}`,
+      "      --max-videos <数量>       每用户最大视频数，默认 16",
+      "      --enable-follow           启用关注/粉丝提取（默认启用）",
+      "      --disable-follow          禁用关注/粉丝提取",
+      "      --max-following <数量>    最大获取关注数，默认 100",
+      "      --max-followers <数量>    最大获取粉丝数，默认 100",
+      "      --max-users <数量>        最大处理用户数，默认无限制",
+      "      -i, --interval <秒数>     无任务时轮询间隔，默认 30 秒",
+      "      --max-age <秒数>          最小刷新间隔，默认 43200（12小时）",
+      "      --port <端口号>           固定 CDP 端口（调试用，关闭自动轮换）",
+      "      --base-port <端口号>      起始端口，默认 9222",
+      "      --port-count <数量>       端口数量（账户数），默认 10",
+      "      --user-id <编号>          客户端编号（设备ID），默认自动生成",
+      "      --proxy <地址>            浏览器代理（如 socks5://127.0.0.1:1080）",
   "",
   "  tt-help info <URL> [URL2 ...] [--onlyvideo]",
   "    获取用户/视频信息，支持多个 URL",
@@ -196,9 +217,10 @@ const HELP_TEXT = [
   "    -h, --help                显示帮助",
   "    --version                 显示版本号",
   "",
-  "  示例: tt-help info https://www.tiktok.com/@nike https://www.tiktok.com/@adidas",
-  "        tt-help explore qiqi23280 fast --location ES --max-comments 50",
-  "        tt-help config set server http://127.0.0.1:3001",
+      "  示例: tt-help info https://www.tiktok.com/@nike https://www.tiktok.com/@adidas",
+      "        tt-help explore qiqi23280 fast --location ES --max-comments 50",
+      "        tt-help refresh --server http://127.0.0.1:3001 --port 9222",
+      "        tt-help config set server http://127.0.0.1:3001",
   "        tt-help attach -p 5 -i 10",
   "        tt-help watch -o data/result.db",
   "        tt-help videostats data/result.db -p 3",

package/src/main.js

@@ -10,6 +10,7 @@ import { handleComments } from "./cli/comments.js";
 import { handleVideoStats } from "./cli/videostats.js";
 import { handleDbImport } from "./cli/db-import.js";
 import { handleWebserver } from "./cli/webserver.js";
+import { handleRefresh } from "./cli/refresh.js";
 
 async function main() {
   const parsed = parseArgs();
@@ -33,6 +34,8 @@ async function main() {
       return handleVideoStats(parsed);
     case "db-import":
       return handleDbImport(parsed);
+    case "refresh":
+      return handleRefresh(parsed);
   }
 
   const {

package/src/npm-main.js

@@ -6,6 +6,7 @@ import { handleAttach } from "./cli/attach.js";
 import { handleConfig, showConfig, showUsage, version } from "./cli/config.js";
 import { handleOpen } from "./cli/open.js";
 import { handleComments } from "./cli/comments.js";
+import { handleRefresh } from "./cli/refresh.js";
 
 function exitUnsupportedCommand(command) {
   console.error(
@@ -33,6 +34,8 @@ async function main() {
       return handleOpen(parsed);
     case "comments":
       return handleComments(parsed);
+    case "refresh":
+      return handleRefresh(parsed);
   }
 
   const {

package/src/watch/data-store.js

@@ -2786,9 +2786,10 @@ export function createStore(filePath) {
     return { saved: true, pinned: user.pinned };
   }
 
-  function getNextRedoJob(userId) {
+  function getNextRedoJob(userId, maxAgeSeconds = 43200) {
     if (db) {
       const now = Date.now();
+      const threshold = now - maxAgeSeconds * 1000;
       const defaultTime = new Date("2016-01-01T00:00:00Z").getTime();
       const targetLocations = [
         "CZ",
@@ -2813,11 +2814,12 @@ export function createStore(filePath) {
           WHERE tt_seller = 1
             AND verified = 0
             AND location_created IN (${placeholders})
+            AND COALESCE(refresh_time, ?) < ?
           ORDER BY COALESCE(refresh_time, ?) ASC
           LIMIT 1
         `,
         )
-        .get(...targetLocations, defaultTime);
+        .get(...targetLocations, defaultTime, threshold, defaultTime);
       if (!row) return null;
       db.prepare(
         "UPDATE jobs SET refresh_time = ?, updated_at = ? WHERE unique_id = ?",
@@ -2830,6 +2832,7 @@ export function createStore(filePath) {
     }
 
     const now = Date.now();
+    const threshold = now - maxAgeSeconds * 1000;
     const defaultTime = new Date("2016-01-01T00:00:00Z").getTime();
 
     // 筛选目标国家用户，按 refreshTime 升序取最远的（没有则默认 2016-01-01）
@@ -2855,13 +2858,19 @@ export function createStore(filePath) {
     );
     if (targetUsers.length === 0) return null;
 
-    targetUsers.sort((a, b) => {
+    const recentEnough = targetUsers.filter((u) => {
+      const rt = u.refreshTime || defaultTime;
+      return rt < threshold;
+    });
+    if (recentEnough.length === 0) return null;
+
+    recentEnough.sort((a, b) => {
       const ta = a.refreshTime || defaultTime;
       const tb = b.refreshTime || defaultTime;
       return ta - tb;
     });
 
-    const next = targetUsers[0];
+    const next = recentEnough[0];
     next.refreshTime = now;
     save();
     return {
@@ -2889,9 +2898,10 @@ export function createStore(filePath) {
           }
         }
       }
+      const newUsers = processDiscoveredUsers(result);
       const ret = updateJobInfo(uniqueId, user, false);
       if (ret.error) return { saved: false, error: ret.error };
-      return { saved: true };
+      return { saved: true, newUsers };
     }
 
     const user = getUser(uniqueId);
@@ -2908,8 +2918,8 @@ export function createStore(filePath) {
         }
       }
     }
-
-    return { saved: true };
+    const newUsers = processDiscoveredUsers(result);
+    return { saved: true, newUsers };
   }
 
   function reportClientError(

package/src/watch/public/app.js

@@ -368,6 +368,10 @@ function renderTable(users) {
       }
       const claimTime = u.claimedAt ? formatTime(u.claimedAt) : "-";
       const procTime = u.processedAt ? formatTime(u.processedAt) : "-";
+      const refreshTime =
+        u.ttSeller && !u.verified && u.refreshTime
+          ? formatTime(u.refreshTime)
+          : "-";
       const statusCodeDisplay =
         u.statusCode != null && u.statusCode !== 0
           ? `<span class="tag error" style="font-size:10px">${u.statusCode}</span>`
@@ -378,6 +382,7 @@ function renderTable(users) {
       <td data-label="粉丝">${fans}</td>
       <td data-label="视频">${videos}</td>
       <td data-label="国家">${loc}</td>
+      <td data-label="最近刷新" style="font-size:11px;color:#888">${refreshTime}</td>
       <td data-label="最近发布" style="font-size:11px;color:#888">${latestVideo}</td>
       <td data-label="猜测国家">${guessedLoc}</td>
       <td data-label="来源">${sources || "-"}</td>

package/src/watch/public/index.html

@@ -125,6 +125,7 @@
               <th>粉丝</th>
               <th>视频</th>
               <th>国家</th>
+              <th class="sortable" data-sort="refreshTime">最近刷新 <span class="sort-icon">↕</span></th>
               <th class="sortable" data-sort="latestVideoTime">最近发布 <span class="sort-icon">↕</span></th>
               <th>猜测国家</th>
               <th>来源</th>

package/src/watch/server.js

@@ -356,7 +356,8 @@ export function startWatchServer(dataAnchor, port = 3000, existingStore) {
 
       if (req.method === "GET" && routePath === "/api/redo-job") {
         const userId = params.userId || "";
-        const job = store.getNextRedoJob(userId);
+        const maxAge = parseInt(params.maxAge) || 43200;
+        const job = store.getNextRedoJob(userId, maxAge);
         if (job) {
           logJob("REDO-CLAIM", { user: job.uniqueId, clientId: userId });
           sendJSON(res, 200, { hasJob: true, user: job });
@@ -683,6 +684,7 @@ export function startWatchServer(dataAnchor, port = 3000, existingStore) {
             followerCount: u.followerCount,
             locationCreated: u.locationCreated,
             latestVideoTime: u.latestVideoTime,
+            refreshTime: u.refreshTime,
             guessedLocation: u.guessedLocation,
             pinned: u.pinned,
             processedAt: u.processedAt,

package/src/scraper/refresh-core.js

@@ -1,213 +0,0 @@
-import {
-  delay,
-  retryWithBackoff,
-  detectPageError,
-  assertPageUrl,
-} from "./modules/page-helpers.js";
-import { detectCaptcha } from "./modules/captcha-handler.js";
-import { getUserInfo, collectVideos } from "../videos/core.js";
-import { extractFollowAndFollowers } from "./modules/follow-extractor.js";
-import { processExplore } from "./explore-core.js";
-import { DEFAULT_TARGET_LOCATIONS_CSV } from "../lib/target-locations.js";
-
-export async function processRefresh(page, username, serverUrl, options, log) {
-  const { maxFollowing = 100, maxFollowers = 100, maxVideos = 100 } = options;
-
-  const result = {
-    userInfo: null,
-    discoveredVideoAuthors: [],
-    discoveredFollowing: [],
-    discoveredFollowers: [],
-    newUsersAdded: 0,
-    collectedVideos: 0,
-    error: null,
-  };
-
-  try {
-    log(`  访问 @${username} 主页...`);
-    const homeUrl = `https://www.tiktok.com/@${username}`;
-    await retryWithBackoff(
-      async () => {
-        await page.goto(homeUrl, {
-          waitUntil: "domcontentloaded",
-          timeout: 30000,
-        });
-        assertPageUrl(page, `@${username}`);
-      },
-      { log },
-    );
-    await page
-      .waitForSelector('[class*="DivVideoList"]', { timeout: 10000 })
-      .catch(() => {});
-    await delay(1000, 2000);
-
-    log("  获取用户信息...");
-    const info = await getUserInfo(page);
-    if (info) {
-      result.userInfo = info;
-      log(
-        `  用户: ${info.nickname || username} | 粉丝: ${info.followerCount || "-"} | 视频: ${info.videoCount || "-"}`,
-      );
-    }
-
-    const captcha = await detectCaptcha(page);
-    if (captcha && captcha.visible) {
-      log(`[验证码] @${username} 页面出现验证码`);
-      result.captchaDetected = true;
-      result.captchaStage = result.captchaStage || "video-page";
-      result.captchaMessage = result.captchaMessage || "视频页出现验证码";
-    }
-
-    // 采集视频
-    log(`  采集视频 (最多 ${maxVideos} 个)...`);
-    const videoList = await collectVideos(page, username, maxVideos, log);
-    const videoArray = videoList ? [...videoList.values()] : [];
-    result.collectedVideos = videoArray.length;
-    result.discoveredVideoAuthors = videoArray.map((v) => v.author);
-
-    if (videoArray.length <= 0) {
-      result.noVideo = true;
-      const pageError = await detectPageError(page);
-      if (pageError) {
-        result.restricted = true;
-        log(`  @${username} 页面受限（${pageError}），标记跳过`);
-      }
-      return result;
-    }
-
-    // 采集关注和粉丝
-    log(`  采集关注 (最多 ${maxFollowing}) + 粉丝 (最多 ${maxFollowers})...`);
-    try {
-      const followResult = await extractFollowAndFollowers(page, {
-        maxFollowing,
-        maxFollowers,
-      });
-      result.discoveredFollowing = followResult.following || [];
-      result.discoveredFollowers = followResult.followers || [];
-      log(
-        `  关注: ${result.discoveredFollowing.length}, 粉丝: ${result.discoveredFollowers.length}`,
-      );
-    } catch (e) {
-      log(`  [关注/粉丝采集失败] ${e.message}`);
-      result.discoveredFollowing = [];
-      result.discoveredFollowers = [];
-    }
-
-    // 处理新发现的用户（关注 + 粉丝），循环执行完整 explore
-    // follow-extractor 返回 [handle, displayName] 数组
-    const allDiscovered = [
-      ...result.discoveredFollowing.map((h) => ({
-        handle: Array.isArray(h) ? h[0] : h,
-        source: "refresh-following",
-      })),
-      ...result.discoveredFollowers.map((h) => ({
-        handle: Array.isArray(h) ? h[0] : h,
-        source: "refresh-follower",
-      })),
-    ];
-
-    for (const { handle, source } of allDiscovered) {
-      const uniqueId = handle.replace("@", "");
-
-      // 检查用户是否已存在
-      const existsResp = await fetch(
-        `${serverUrl}/api/user-exists/${encodeURIComponent(uniqueId)}`,
-      );
-      const existsData = await existsResp.json();
-
-      if (existsData.exists) {
-        continue;
-      }
-
-      log(`  [新用户] @${uniqueId} 不存在，开始探索 (来源: ${source})...`);
-      await delay(1000, 2000);
-
-      // 对新用户做完整 explore（与 explore 命令逻辑一致）
-      const exploreResult = await processExplore(
-        page,
-        uniqueId,
-        {
-          maxComments: 10,
-          maxGuess: 0,
-          enableFollow: true,
-          maxFollowing: 5,
-          maxFollowers: 5,
-          location: DEFAULT_TARGET_LOCATIONS_CSV,
-        },
-        log,
-      );
-
-      // 提交 explore 结果到服务端（和 explore 命令的 commitJob 一致）
-      if (exploreResult.userInfo) {
-        const guessedLocation = exploreResult.locationCreated || null;
-
-        const payload = {
-          userInfo: exploreResult.userInfo || {},
-          discoveredVideoAuthors: (
-            exploreResult.discoveredVideoAuthors || []
-          ).map((item) =>
-            typeof item === "object" ? { ...item, guessedLocation } : item,
-          ),
-          discoveredCommentAuthors: (
-            exploreResult.discoveredCommentAuthors || []
-          ).map((author) => ({ author, guessedLocation })),
-          discoveredGuessAuthors: (
-            exploreResult.discoveredGuessAuthors || []
-          ).map((author) => ({ author, guessedLocation })),
-          discoveredFollowing: (exploreResult.discoveredFollowing || []).map(
-            (f) => ({
-              handle: Array.isArray(f) ? f[0] : f,
-              displayName: Array.isArray(f) ? f[1] : null,
-              guessedLocation,
-            }),
-          ),
-          discoveredFollowers: (exploreResult.discoveredFollowers || []).map(
-            (f) => ({
-              handle: Array.isArray(f) ? f[0] : f,
-              displayName: Array.isArray(f) ? f[1] : null,
-              guessedLocation,
-            }),
-          ),
-          processed: exploreResult.processed,
-          hasFollowData: exploreResult.hasFollowData,
-          keepFollow: exploreResult.keepFollow,
-          locationCreated: exploreResult.locationCreated,
-          noVideo: exploreResult.noVideo,
-          restricted: exploreResult.restricted,
-          error: exploreResult.error,
-        };
-
-        const addResp = await fetch(
-          `${serverUrl}/api/explore-new/${uniqueId}`,
-          {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(payload),
-          },
-        );
-        const addResult = await addResp.json();
-
-        if (!addResult.saved) {
-          log(`  [跳过] @${uniqueId} 提交失败`);
-          continue;
-        }
-
-        result.newUsersAdded++;
-        if (exploreResult.captchaDetected) {
-          result.captchaDetected = true;
-        }
-        log(
-          `  [已提交] @${uniqueId} ${addResult.created ? "(新用户)" : "(已存在)"} | 发现: ${addResult.newUsers?.length || 0} 个`,
-        );
-      }
-
-      await delay(2000, 4000);
-    }
-  } catch (e) {
-    log(`  [错误] ${e.message}`);
-    result.error = e.message;
-    result.errorStack = e.stack || "";
-  }
-
-  return result;
-}