tt-help-cli-ycl 1.3.83 → 1.3.84

package/package.json

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

package/src/cli/attach.js

@@ -1,9 +1,9 @@
 import { TikTokScraper } from "../lib/tiktok-scraper.mjs";
 import { CDNBlockedError } from "../lib/parse-ssr.mjs";
 import { proxy as configuredProxy } from "../lib/constants.js";
+import { createApiClient } from "../lib/api-client.js";
 import v8 from "node:v8";
 
-const MAX_RETRY_WAIT = 5 * 60 * 1000;
 const HEAP_RESTART_RATIO = 0.72;
 const MAX_TASK_BATCHES_BEFORE_RESTART = 200;
 
@@ -17,39 +17,6 @@ function attachLog(message = "") {
   console.error(`[${formatNow()}] ${message}`);
 }
 
-async function withRetry(label, fn) {
-  let backoff = 1000;
-  while (true) {
-    try {
-      return await fn();
-    } catch (err) {
-      attachLog(
-        `[连接] ${label} 失败: ${err.message}，${backoff / 1000}秒后重试...`,
-      );
-      await new Promise((r) => setTimeout(r, backoff));
-      if (backoff < MAX_RETRY_WAIT) backoff *= 2;
-    }
-  }
-}
-
-async function apiGet(url) {
-  return withRetry(`GET ${url}`, async () => {
-    const res = await fetch(url);
-    return res.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();
-  });
-}
-
 function isBrowserClosedError(err) {
   if (!err) return false;
   const msg = err.message || err.toString() || "";
@@ -143,6 +110,8 @@ export async function handleAttach(options) {
     `[Attach] 并行数: ${attachParallel}, 空闲间隔: ${attachInterval}秒, 服务端: ${serverUrl}${countryStr}`,
   );
 
+  const { apiGet, apiPost } = createApiClient({ log: false });
+
   const scraper = new TikTokScraper({
     poolSize: attachPoolSize || 3,
     proxyServer: effectiveProxy || null,

package/src/cli/auto.js

@@ -6,6 +6,7 @@ import {
 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 { createApiClient } from "../lib/api-client.js";
 
 const MAX_RETRY_WAIT = 5 * 60 * 1000;
 
@@ -24,24 +25,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 handleAuto(options) {
   const {
     autoUsernames,
@@ -87,6 +70,8 @@ export async function handleAuto(options) {
       console.error(`[初始化] 未检测到本地用户编号，已生成并使用: ${userId}`);
     }
 
+    const { apiGet, apiPost } = createApiClient();
+
     const runOptions = {
       collectMax: autoCollectMax,
       scrapeDepth: autoScrapeDepth,

package/src/cli/comments.js

@@ -7,6 +7,7 @@ import {
   isLocationInList,
   normalizeLocation,
 } from "../lib/target-locations.js";
+import { createApiClient } from "../lib/api-client.js";
 
 async function waitForPageReady(page, timeout = 30000) {
   const startTime = Date.now();
@@ -32,64 +33,7 @@ async function safeEvaluate(page, fn) {
   }
 }
 
-async function withRetry(label, fn, maxRetries = 3) {
-  let backoff = 2000;
-  for (let i = 0; i < maxRetries; i++) {
-    try {
-      return await fn();
-    } catch (err) {
-      if (i < maxRetries - 1) {
-        console.error(
-          `  [${label}] 失败: ${err.message}，${backoff / 1000}s 后重试...`,
-        );
-        await new Promise((r) => setTimeout(r, backoff));
-        backoff *= 2;
-      } else {
-        throw err;
-      }
-    }
-  }
-}
-
-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),
-    });
-    if (!res.ok) {
-      const errText = await res.text();
-      throw new Error(`HTTP ${res.status}: ${errText.substring(0, 200)}`);
-    }
-    return res.json();
-  });
-}
 
-async function apiPut(url) {
-  return withRetry(`PUT ${url}`, async () => {
-    const res = await fetch(url, {
-      method: "PUT",
-      headers: { "Content-Type": "application/json" },
-    });
-    if (!res.ok) {
-      const errText = await res.text();
-      throw new Error(`HTTP ${res.status}: ${errText.substring(0, 200)}`);
-    }
-    return res.json();
-  });
-}
-
-async function apiGet(url) {
-  return withRetry(`GET ${url}`, async () => {
-    const res = await fetch(url);
-    if (!res.ok) {
-      const errText = await res.text();
-      throw new Error(`HTTP ${res.status}: ${errText.substring(0, 200)}`);
-    }
-    return res.json();
-  });
-}
 
 function isBrowserClosedError(err) {
   if (!err) return false;
@@ -110,6 +54,12 @@ function isBrowserClosedError(err) {
  */
 async function runAutoMode(options) {
   const { serverUrl, parallel, interval, maxComments } = options;
+  const { apiGet, apiPost, apiPut } = createApiClient({
+    checkStatus: true,
+    maxRetries: 2,
+    backoff: 2000,
+    log: true,
+  });
   const actualParallel = Math.max(1, parallel || 1);
   const actualInterval = interval || 10;
   const actualMaxComments = maxComments || 200;
@@ -478,6 +428,12 @@ export async function handleComments(options) {
 
       const guessedLocation = normalizeLocation(videoInfo?.locationCreated);
       const serverUrl = commentsServer || defaultServer;
+      const { apiPost } = createApiClient({
+        checkStatus: true,
+        maxRetries: 2,
+        backoff: 2000,
+        log: true,
+      });
 
       if (
         guessedLocation &&

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(
@@ -269,140 +254,116 @@ export async function handleExplore(options) {
           ? `${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;
-      }
+        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,
@@ -411,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,
@@ -449,127 +398,167 @@ 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} 次`);
+
+          await withRetry("report captcha", () =>
+            apiPost(`${serverUrl}/api/error-report`, {
+              userId,
+              username,
+              errorType: "captcha",
+              errorMessage: result.captchaMessage || "页面出现验证码",
+              stage: result.captchaStage || "video-page",
+              errorStack: "",
+            }),
+          ).catch(() => {});
 
-      // 更新关注/粉丝成功时间（仅登录状态下）
-      if (result.hasFollowData && result.keepFollow) {
-        const totalFollows =
-          (result.discoveredFollowing || []).length +
-          (result.discoveredFollowers || []).length;
-        if (totalFollows > 0) {
-          lastFollowSuccessTime = Date.now();
+          // 累计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;
 
-      console.error("  已提交");
+        // 更新关注/粉丝成功时间（仅登录状态下）
+        if (result.hasFollowData && result.keepFollow) {
+          const totalFollows =
+            (result.discoveredFollowing || []).length +
+            (result.discoveredFollowers || []).length;
+          if (totalFollows > 0) {
+            lastFollowSuccessTime = Date.now();
+          }
+        }
 
-      if (exploreMaxUsers > 0 && processedCount >= exploreMaxUsers) {
-        console.error(`\n已达上限 ${exploreMaxUsers} 个用户，停止处理`);
-        break;
-      }
+        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("  已提交");
+
+        if (exploreMaxUsers > 0 && processedCount >= exploreMaxUsers) {
+          console.error(`\n已达上限 ${exploreMaxUsers} 个用户，停止处理`);
+          break;
+        }
       } catch (e) {
         // 浏览器关闭错误：自动重建 browser + page，然后重试当前轮次
         if (isBrowserClosedError(e)) {

package/src/cli/refresh.js

@@ -23,6 +23,7 @@ import {
   switchAccount,
 } from "../lib/browser/cdp.js";
 import { HealthChecker } from "../lib/browser/health-checker.js";
+import { createApiClient } from "../lib/api-client.js";
 import path from "path";
 import os from "os";
 
@@ -45,24 +46,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 handleRefresh(options) {
   const {
     explorePreset,
@@ -116,9 +99,6 @@ export async function handleRefresh(options) {
 
     setDelayConfig(explorePreset);
 
-    // 连接服务器验证
-    await apiGet(`${serverUrl}/api/stats`);
-
     console.error(`\n=== Refresh 模式（基于 explore） ===`);
     console.error(`服务器: ${serverUrl}`);
     console.error(`视频采集: ${exploreMaxVideos || 16}`);
@@ -175,6 +155,11 @@ export async function handleRefresh(options) {
       );
     }
 
+    const { apiGet, apiPost } = createApiClient({ meta: { port: cdpOptions.port } });
+
+    // 连接服务器验证
+    await apiGet(`${serverUrl}/api/stats`);
+
     browser = await ensureBrowserReadyCDP(cdpOptions);
     const { processExplore } = await import("../scraper/explore-core.js");
     const { isLoggedIn } = await import("../lib/browser/page.js");

package/src/lib/api-client.js

@@ -0,0 +1,101 @@
+import crypto from "node:crypto";
+
+const MAX_RETRY_WAIT = 5 * 60 * 1000;
+
+async function withRetry(label, fn, opts = {}) {
+  const { maxRetries, backoff: initialBackoff = 1000, log = true } = opts;
+
+  let backoff = initialBackoff;
+  let i = 0;
+
+  while (true) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (maxRetries !== undefined && i >= maxRetries) {
+        throw err;
+      }
+      if (log) {
+        console.error(
+          `[连接] ${label} 失败: ${err.message}，${backoff / 1000}秒后重试...`,
+        );
+      }
+      await new Promise((r) => setTimeout(r, backoff));
+      if (backoff < MAX_RETRY_WAIT) backoff *= 2;
+      i++;
+    }
+  }
+}
+
+function buildHeaders(baseHeaders, clientId, meta) {
+  return {
+    ...baseHeaders,
+    "X-Client-Id": clientId,
+    "X-Client-Info": JSON.stringify(meta),
+  };
+}
+
+export function createApiClient(opts = {}) {
+  const clientId = crypto.randomUUID();
+  const {
+    checkStatus = false,
+    maxRetries,
+    backoff = 1000,
+    log = true,
+    meta = {},
+  } = opts;
+  const retryOpts = { maxRetries, backoff, log };
+
+  async function apiGet(url) {
+    return withRetry(`GET ${url}`, async () => {
+      const res = await fetch(url, {
+        headers: buildHeaders({}, clientId, meta),
+      });
+      if (checkStatus && !res.ok) {
+        const errText = await res.text();
+        throw new Error(`HTTP ${res.status}: ${errText.substring(0, 200)}`);
+      }
+      return res.json();
+    }, retryOpts);
+  }
+
+  async function apiPost(url, body) {
+    return withRetry(`POST ${url}`, async () => {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: buildHeaders(
+          { "Content-Type": "application/json" },
+          clientId,
+          meta,
+        ),
+        body: JSON.stringify(body),
+      });
+      if (checkStatus && !res.ok) {
+        const errText = await res.text();
+        throw new Error(`HTTP ${res.status}: ${errText.substring(0, 200)}`);
+      }
+      return res.json();
+    }, retryOpts);
+  }
+
+  async function apiPut(url, body) {
+    return withRetry(`PUT ${url}`, async () => {
+      const res = await fetch(url, {
+        method: "PUT",
+        headers: buildHeaders(
+          { "Content-Type": "application/json" },
+          clientId,
+          meta,
+        ),
+        body: body ? JSON.stringify(body) : undefined,
+      });
+      if (checkStatus && !res.ok) {
+        const errText = await res.text();
+        throw new Error(`HTTP ${res.status}: ${errText.substring(0, 200)}`);
+      }
+      return res.json();
+    }, retryOpts);
+  }
+
+  return { apiGet, apiPost, apiPut };
+}

package/src/watch/data-store.js

@@ -1951,6 +1951,8 @@ export function createStore(filePath, options = {}) {
   let clientErrors = new Map();
   // 客户端登录状态：userId → boolean
   let clientLoginStatus = new Map();
+  // 活跃客户端追踪：clientId → { type, ip, port, userId, lastSeen }
+  let activeClients = new Map();
   // refill 锁：防止多个 claimNextJob 同时触发 LLM refill
   let refillLock = null; // Promise | null
   // LLM 采样偏移量记忆：按猜测国家记录上次查询位置，避免重复采样
@@ -3928,6 +3930,38 @@ Standards: 90-100=clear match, 70-89=likely, 50-69=possible, 20-49=low, 0-19=unl
     return Object.fromEntries(clientLoginStatus);
   }
 
+  function trackClient(clientId, info) {
+    const existing = activeClients.get(clientId);
+    if (existing) {
+      if (info.type) existing.type = info.type;
+      if (info.userId) existing.userId = info.userId;
+      if (info.ip) existing.ip = info.ip;
+      if (info.port !== undefined) existing.port = info.port;
+      existing.lastSeen = Date.now();
+    } else {
+      activeClients.set(clientId, {
+        ...info,
+        lastSeen: Date.now(),
+      });
+    }
+  }
+
+  function getActiveClients() {
+    const now = Date.now();
+    const stale = 2 * 60 * 1000;
+    for (const [id, info] of activeClients) {
+      if (now - info.lastSeen > stale) activeClients.delete(id);
+    }
+    return Array.from(activeClients.entries()).map(([clientId, info]) => ({
+      clientId,
+      type: info.type || "unknown",
+      ip: info.ip || "",
+      port: info.port || 0,
+      userId: info.userId || "",
+      lastSeen: info.lastSeen,
+    }));
+  }
+
   function getPendingUserUpdateTasks(limit, countries) {
     const targetCountries = countries
       ? countries.map((c) => String(c).trim().toUpperCase())
@@ -4493,6 +4527,8 @@ Standards: 90-100=clear match, 70-89=likely, 50-69=possible, 20-49=low, 0-19=unl
     deleteClientError,
     getClientErrors,
     getClientLoginStatus,
+    trackClient,
+    getActiveClients,
     registerVideos,
     getVideo,
     getVideos,

package/src/watch/public/app.js

@@ -221,6 +221,7 @@ function renderStats() {
   renderCountryChart(d.countryStats);
   renderSourceChart(d.sourceStats);
   renderTargetLocationFilter(d.targetCountryStats);
+  renderActiveClients(d.activeClients || []);
 }
 
 function renderTargetLocationFilter(targetCountryStats) {
@@ -237,6 +238,100 @@ function renderTargetLocationFilter(targetCountryStats) {
       .join("");
 }
 
+function formatRelativeTime(ts) {
+  const diff = Math.max(0, Date.now() - ts);
+  if (diff < 5000) return "刚刚";
+  const s = Math.round(diff / 1000);
+  if (s < 60) return s + " 秒前";
+  const m = Math.round(s / 60);
+  if (m < 60) return m + " 分钟前";
+  return Math.round(m / 60) + " 小时前";
+}
+
+function renderActiveClients(clients) {
+  const section = document.getElementById("activeClientsSection");
+  const bar = document.getElementById("activeClientsBar");
+  const table = document.getElementById("activeClientsTable");
+  const tbody = document.getElementById("activeClientsBody");
+  if (!section || !bar) return;
+
+  const types = ["explore", "refresh", "attach", "comments"];
+  const labels = { explore: "Explore", refresh: "Refresh", attach: "Attach", comments: "Comments" };
+  const grouped = {};
+  for (const c of clients) {
+    if (!grouped[c.type]) grouped[c.type] = [];
+    grouped[c.type].push(c);
+  }
+
+  const counts = {};
+  for (const t of types) counts[t] = (grouped[t] || []).length;
+  const total = clients.length;
+
+  if (total === 0) {
+    section.style.display = "none";
+    return;
+  }
+  section.style.display = "";
+
+  // 清除之前的选择状态
+  let selectedType = bar.dataset.selectedType || "";
+
+  const parts = ['<span class="bar-label">活跃客户端</span>'];
+  for (const t of types) {
+    const count = counts[t] || 0;
+    const cls = count > 0 ? "active" : "inactive";
+    const dot = count > 0 ? '<span class="dot"></span>' : "";
+    const sel = t === selectedType ? " selected" : "";
+    parts.push(
+      `<span class="client-badge ${cls}${sel}" data-type="${t}" onclick="toggleClientDetail('${t}')">${dot}${labels[t]}: ${count}</span>`,
+    );
+  }
+  bar.innerHTML = parts.join("\n");
+
+  // 如果有选中类型，刷新明细
+  if (selectedType && grouped[selectedType]) {
+    showClientDetail(selectedType, grouped[selectedType]);
+  } else {
+    table.style.display = "none";
+  }
+}
+
+function toggleClientDetail(type) {
+  const bar = document.getElementById("activeClientsBar");
+  if (bar.dataset.selectedType === type) {
+    bar.dataset.selectedType = "";
+    document.getElementById("activeClientsTable").style.display = "none";
+  } else {
+    bar.dataset.selectedType = type;
+  }
+  if (currentStats) renderActiveClients(currentStats.activeClients || []);
+}
+
+function showClientDetail(type, clients) {
+  const table = document.getElementById("activeClientsTable");
+  const tbody = document.getElementById("activeClientsBody");
+  table.style.display = "";
+  tbody.innerHTML = clients
+    .map((c) => {
+      const cid = c.clientId ? c.clientId.substring(0, 8) : "-";
+      const ipPort = c.ip
+        ? c.ip + (c.port ? ":" + c.port : "")
+        : "-";
+      const userId = c.userId || "-";
+      const last = formatRelativeTime(c.lastSeen);
+      return `<tr>
+        <td class="client-id">${cid}</td>
+        <td class="ip-port">${ipPort}</td>
+        <td class="ip-port">${c.port || "-"}</td>
+        <td class="user-id">${userId}</td>
+        <td class="last-seen">${last}</td>
+      </tr>`;
+    })
+    .join("");
+}
+
+window.toggleClientDetail = toggleClientDetail;
+
 function renderCountryChart(countries) {
   const el = document.getElementById("countryChart");
   const filtered = countries.filter((c) => c.country !== "未知");

package/src/watch/public/index.html

@@ -58,6 +58,21 @@
         <div class="value target" id="statTarget">0</div>
       </div>
     </div>
+    <div id="activeClientsSection" class="active-clients-section" style="display:none">
+      <div class="active-clients-bar" id="activeClientsBar"></div>
+      <table class="active-clients-table" id="activeClientsTable" style="display:none">
+        <thead>
+          <tr>
+            <th>Client ID</th>
+            <th>IP</th>
+            <th>端口</th>
+            <th>用户编号</th>
+            <th>最后活跃</th>
+          </tr>
+        </thead>
+        <tbody id="activeClientsBody"></tbody>
+      </table>
+    </div>
     <div class="client-errors-section" id="clientErrorsSection" style="display:none">
       <div class="section-header">
         <h3>客户端异常</h3>

package/src/watch/public/style.css

@@ -118,6 +118,113 @@ body {
   background: rgba(167, 139, 250, 0.15);
 }
 
+.active-clients-section {
+  background: #1a1a24;
+  border-radius: 8px;
+  padding: 12px 16px;
+  margin-bottom: 16px;
+}
+
+.active-clients-bar {
+  display: flex;
+  gap: 16px;
+  align-items: center;
+  flex-wrap: wrap;
+}
+
+.active-clients-bar .bar-label {
+  font-size: 13px;
+  color: #888;
+  margin-right: 4px;
+}
+
+.active-clients-bar .client-badge {
+  font-size: 13px;
+  padding: 3px 10px;
+  border-radius: 12px;
+  cursor: pointer;
+  transition: background 0.2s;
+  white-space: nowrap;
+}
+
+.active-clients-bar .client-badge .dot {
+  display: inline-block;
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  margin-right: 4px;
+}
+
+.active-clients-bar .client-badge.active {
+  background: #1a2e1a;
+  color: #4ade80;
+}
+
+.active-clients-bar .client-badge.active:hover {
+  background: #224422;
+}
+
+.active-clients-bar .client-badge.active .dot {
+  background: #4ade80;
+}
+
+.active-clients-bar .client-badge.inactive {
+  background: #252536;
+  color: #64748b;
+}
+
+.active-clients-bar .client-badge.selected {
+  outline: 2px solid #60a5fa;
+}
+
+.active-clients-table {
+  width: 100%;
+  border-collapse: collapse;
+  margin-top: 12px;
+  font-size: 13px;
+}
+
+.active-clients-table th {
+  text-align: left;
+  color: #888;
+  font-weight: 500;
+  padding: 6px 12px;
+  border-bottom: 1px solid #2a2a3a;
+}
+
+.active-clients-table td {
+  padding: 8px 12px;
+  border-bottom: 1px solid #1e1e2e;
+  color: #ccc;
+}
+
+.active-clients-table td.client-id {
+  font-family: monospace;
+  font-size: 12px;
+  color: #60a5fa;
+}
+
+.active-clients-table td.ip-port {
+  font-family: monospace;
+  font-size: 12px;
+  color: #facc15;
+}
+
+.active-clients-table td.user-id {
+  font-family: monospace;
+  font-size: 12px;
+  color: #c084fc;
+}
+
+.active-clients-table td.last-seen {
+  color: #94a3b8;
+  font-size: 12px;
+}
+
+.active-clients-table tr:hover td {
+  background: #1e1e2e;
+}
+
 .charts {
   display: grid;
   grid-template-columns: 1fr 1fr;

package/src/watch/server.js

@@ -89,6 +89,14 @@ function sendCSV(res, columns, rows) {
   res.end(body);
 }
 
+function inferClientType(routePath) {
+  if (routePath.startsWith("/api/redo-job")) return "refresh";
+  if (routePath.startsWith("/api/user-update-tasks")) return "attach";
+  if (routePath.startsWith("/api/comment-task")) return "comments";
+  if (routePath.startsWith("/api/job") || routePath.startsWith("/api/explore-new")) return "explore";
+  return null;
+}
+
 export function startWatchServer(
   dataAnchor,
   port = 3000,
@@ -112,6 +120,19 @@ export function startWatchServer(
     const server = http.createServer(async (req, res) => {
       const { path: routePath, params } = parseQuery(req.url);
 
+      // 客户端追踪：从 header 提取 clientId 和元数据，根据路由推断类型
+      const clientId = req.headers["x-client-id"] || "";
+      if (clientId) {
+        let meta = {};
+        try {
+          meta = JSON.parse(req.headers["x-client-info"] || "{}");
+        } catch {}
+        const ip = req.socket.remoteAddress || "";
+        const userId = params.userId || "";
+        const type = inferClientType(routePath);
+        store.trackClient(clientId, { ip, port: meta.port, userId, type });
+      }
+
       if (req.method === "POST" && routePath === "/api/users") {
         try {
           const { usernames, sources, guessedLocation } = await readBody(req);
@@ -382,6 +403,7 @@ export function startWatchServer(
         const stats = computeStatsIncremental(store);
         stats.targetLocations = DEFAULT_TARGET_LOCATIONS;
         stats.clientLoginStatus = store.getClientLoginStatus();
+        stats.activeClients = store.getActiveClients();
         stats.llmSampleOffsets = store.getLlmSampleOffsets(); // 添加偏移量状态
         sendJSON(res, 200, stats);
         return;