tt-help-cli-ycl 1.3.26 → 1.3.27

package/package.json

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

package/src/cli/explore.js

@@ -125,9 +125,14 @@ export async function handleExplore(options) {
 
   let 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);
 
+  // 检测登录状态（启动时只检测一次）
+  let loggedIn = await isLoggedIn(page);
+  console.error(`登录状态: ${loggedIn ? "已登录" : "未登录"}`);
+
   // 全局拦截图片资源，减少内存占用和加载时间
   await page.route("**/*", (route) => {
     const resourceType = route.request().resourceType();
@@ -169,16 +174,22 @@ export async function handleExplore(options) {
       userDataDir: nextAccount.userDataDir,
     });
     console.error(`[健康检查] 已切换到端口 ${nextAccount.port}`);
+    // 切换账户后重新检测登录状态
+    loggedIn = await isLoggedIn(page);
+    console.error(
+      `[健康检查] 新账户登录状态: ${loggedIn ? "已登录" : "未登录"}`,
+    );
     lastFollowSuccessTime = Date.now(); // 切换账户后重置
+    captchaCount = 0; // 重置验证码计数
+    consecutiveNetworkErrors = 0; // 重置网络错误计数
   }
 
   let processedCount = 0;
   let errorCount = 0;
   let consecutiveNetworkErrors = 0;
   let captchaCount = 0; // 验证码累计计数
-  let followBlockedCount = 0; // 关注/粉丝封禁计数
   let lastFollowSuccessTime = Date.now(); // 最近一次成功获取关注/粉丝的时间
-  const FOLLOW_BLOCK_THRESHOLD = 30 * 60 * 1000; // 30分钟
+  const FOLLOW_BLOCK_THRESHOLD = 10 * 60 * 1000; // 10分钟
 
   while (true) {
     const job = await apiGet(
@@ -196,6 +207,20 @@ export async function handleExplore(options) {
     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}`);
     }
 
     // 切换任务前检测验证码
@@ -235,18 +260,16 @@ export async function handleExplore(options) {
       }
     }
 
-    // 关注/粉丝功能封禁检测（仅登录状态下）
-    if (
-      exploreEnableFollow &&
-      Date.now() - lastFollowSuccessTime > FOLLOW_BLOCK_THRESHOLD
-    ) {
-      followBlockedCount++;
-      const minutes = Math.round((Date.now() - lastFollowSuccessTime) / 60000);
-      console.error(
-        `\n[封禁检测] 关注/粉丝功能已 ${minutes} 分钟未成功获取，切换到下一个账户...`,
-      );
-      await handleAccountSwitch(`关注/粉丝功能被封 (${followBlockedCount})`);
-      lastFollowSuccessTime = Date.now();
+    // 关注/粉丝封禁检测移到健康检查中（仅登录状态下）
+    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) {
@@ -275,6 +298,7 @@ export async function handleExplore(options) {
       {
         maxVideos: exploreMaxVideos,
         enableFollow: exploreEnableFollow,
+        loggedIn, // 传入登录状态，避免每次调用 isLoggedIn(page)
         maxFollowing: exploreMaxFollowing,
         maxFollowers: exploreMaxFollowers,
         location: exploreLocation,
@@ -299,6 +323,7 @@ export async function handleExplore(options) {
         {
           maxVideos: exploreMaxVideos,
           enableFollow: exploreEnableFollow,
+          loggedIn, // 传入登录状态
           maxFollowing: exploreMaxFollowing,
           maxFollowers: exploreMaxFollowers,
           location: exploreLocation,

package/src/lib/api-interceptor.js

@@ -1,11 +1,23 @@
-import { delay } from './delay.js';
-import { retryWithBackoff } from './retry.js';
-import { assertPageUrl } from './browser/page.js';
+import { delay } from "./delay.js";
+import { retryWithBackoff } from "./retry.js";
+import { assertPageUrl } from "./browser/page.js";
+import {
+  detectPageError,
+  detectPageErrorWithWait,
+} from "./page-error-detector.js";
 
 /**
  * 处理 API 响应数据：提取首页视频 + 翻页
  */
-async function processAPIResponse(data, username, maxVideos, items, page, apiRequestUrl, log) {
+async function processAPIResponse(
+  data,
+  username,
+  maxVideos,
+  items,
+  page,
+  apiRequestUrl,
+  log,
+) {
   // 提取首页视频
   const firstPageItems = data.itemList || [];
   for (const item of firstPageItems) {
@@ -23,7 +35,7 @@ async function processAPIResponse(data, username, maxVideos, items, page, apiReq
   while (hasMore && cursor && items.length < maxVideos) {
     const reqUrl = apiRequestUrl || data.apiRequestUrl;
     if (!reqUrl) {
-      log('  [API拦截] 未捕获到 API 请求 URL，无法翻页');
+      log("  [API拦截] 未捕获到 API 请求 URL，无法翻页");
       break;
     }
 
@@ -41,7 +53,9 @@ async function processAPIResponse(data, username, maxVideos, items, page, apiReq
           const href = `https://www.tiktok.com/@${username}/video/${item.id}`;
           items.push({ id: item.id, href });
         }
-        log(`  [API拦截] 翻页 cursor=${cursor}，获取 ${pageData.itemList.length} 条，累计 ${items.length}`);
+        log(
+          `  [API拦截] 翻页 cursor=${cursor}，获取 ${pageData.itemList.length} 条，累计 ${items.length}`,
+        );
       }
 
       cursor = pageData.cursor;
@@ -82,12 +96,14 @@ async function fetchUserVideosAPI(page, username, maxVideos, log) {
 
   // 1. 注册 response 拦截器 + request URL 捕获
   let apiResolve = null;
-  const apiPromise = new Promise(r => { apiResolve = r; });
+  const apiPromise = new Promise((r) => {
+    apiResolve = r;
+  });
 
   let apiRequestUrl = null;
 
   const responseHandler = async (response) => {
-    if (response.url().includes('/api/post/item_list/')) {
+    if (response.url().includes("/api/post/item_list/")) {
       try {
         apiResolve(await response.json());
       } catch (e) {
@@ -97,94 +113,69 @@ async function fetchUserVideosAPI(page, username, maxVideos, log) {
   };
 
   const requestHandler = (request) => {
-    if (request.url().includes('/api/post/item_list/') && !apiRequestUrl) {
+    if (request.url().includes("/api/post/item_list/") && !apiRequestUrl) {
       apiRequestUrl = request.url();
     }
   };
 
-  page.on('response', responseHandler);
-  page.on('request', requestHandler);
+  page.on("response", responseHandler);
+  page.on("request", requestHandler);
 
   try {
     // 2. 导航并等待 API 响应
-    log('  [API拦截] 导航到用户页，等待 /api/post/item_list/ ...');
+    log("  [API拦截] 导航到用户页，等待 /api/post/item_list/ ...");
     const t0 = Date.now();
 
-    await retryWithBackoff(async () => {
-      await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
-      await assertPageUrl(page, `@${username}`);
-    }, { maxRetries: 3, baseDelay: 3000, log });
+    await retryWithBackoff(
+      async () => {
+        await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
+        await assertPageUrl(page, `@${username}`);
+      },
+      { maxRetries: 3, baseDelay: 3000, log },
+    );
 
     const data = await Promise.race([
       apiPromise,
-      new Promise(r => setTimeout(() => r(null), 8000)),
+      new Promise((r) => setTimeout(() => r(null), 8000)),
     ]);
 
     const elapsed = Date.now() - t0;
 
     if (!data || !data.itemList) {
-      log(`  [API拦截] ${elapsed}ms 后未拿到 API 数据，重试...`);
-      // 清理后重试
-      page.off('response', responseHandler);
-      page.off('request', requestHandler);
-
-      // 重试：重新注册拦截器并导航
-      let apiResolve2 = null;
-      const apiPromise2 = new Promise(r => { apiResolve2 = r; });
-      let apiRequestUrl2 = null;
-
-      const responseHandler2 = async (response) => {
-        if (response.url().includes('/api/post/item_list/')) {
-          try {
-            const json = await response.json().catch(() => null);
-            apiResolve2(json);
-          } catch (e) {
-            apiResolve2(null);
-          }
-        }
-      };
-
-      const requestHandler2 = (request) => {
-        if (request.url().includes('/api/post/item_list/') && !apiRequestUrl2) {
-          apiRequestUrl2 = request.url();
-        }
-      };
-
-      page.on('response', responseHandler2);
-      page.on('request', requestHandler2);
-
-      try {
-        await retryWithBackoff(
-          async () => {
-            await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
-            assertPageUrl(page, url);
-          },
-          { retries: 1, log },
-        );
-
-        const data2 = await Promise.race([
-          apiPromise2,
-          new Promise(r => setTimeout(() => r(null), 8000)),
-        ]);
-        const elapsed2 = Date.now() - t0;
+      // 使用 waitForFunction 等待错误信息出现（最多 8 秒）
+      const pageError = await detectPageErrorWithWait(page, 8000);
 
-        if (!data2 || !data2.itemList) {
-          throw new Error(`[API拦截] ${elapsed2}ms 后仍未拿到 API 数据（含重试），请检查网络`);
-        }
+      if (pageError === "service_error") {
+        throw new Error(`被封: ${username}`);
+      }
 
-        return await processAPIResponse(data2, username, maxVideos, items, page, apiRequestUrl2, log);
-      } finally {
-        page.off('response', responseHandler2);
-        page.off('request', requestHandler2);
+      // API 超时了，页面肯定有问题
+      // 如果识别不出具体错误类型，抛异常（而不是静默返回空 Map）
+      if (!pageError) {
+        throw new Error(`@${username} 页面异常（无法识别错误类型）`);
       }
+
+      // 其他已知错误（login_required, captcha, rate_limited 等）返回空 Map
+      log(
+        `  [API拦截] ${elapsed}ms 后未拿到 API 数据，页面异常（${pageError}）`,
+      );
+      return new Map();
     }
 
-    // 3. 处理数据（提取首页 + 翻页）
-    return await processAPIResponse(data, username, maxVideos, items, page, apiRequestUrl, log);
+    // 处理数据（提取首页 + 翻页）
+    return await processAPIResponse(
+      data,
+      username,
+      maxVideos,
+      items,
+      page,
+      apiRequestUrl,
+      log,
+    );
   } finally {
     // 5. 必须清理拦截器，防止累积
-    page.off('response', responseHandler);
-    page.off('request', requestHandler);
+    page.off("response", responseHandler);
+    page.off("request", requestHandler);
   }
 }
 

package/src/lib/browser/health-checker.js

@@ -5,7 +5,7 @@ import { execSync } from "child_process";
 const TOTAL_ACCOUNTS = 10;
 const BASE_PORT = 9222;
 const MEMORY_THRESHOLD = 0.9;
-const ROTATE_INTERVAL_MS = 2 * 60 * 60 * 1000;
+const ROTATE_INTERVAL_MS = 1 * 60 * 60 * 1000; // 1小时
 
 class HealthChecker {
   constructor() {
@@ -34,6 +34,7 @@ class HealthChecker {
 
   getNextAccount() {
     this.currentIndex = (this.currentIndex + 1) % TOTAL_ACCOUNTS;
+    this.startTime = Date.now(); // 切换后重置运行时间
     return this.accounts[this.currentIndex];
   }
 
@@ -86,7 +87,15 @@ class HealthChecker {
       return { shouldSwitch: true, reason: `运行 ${mins} 分钟` };
     }
 
-    return { shouldSwitch: false };
+    // 计算预计切换时间
+    const remainingMs = ROTATE_INTERVAL_MS - elapsed;
+    const remainingMins = Math.round(remainingMs / 60000);
+    const memHeadroom = ((MEMORY_THRESHOLD - memUsage) * 100).toFixed(1);
+
+    return {
+      shouldSwitch: false,
+      info: `内存 ${memPercent}% (余量 ${memHeadroom}%) | 定时轮换 ${remainingMins} 分钟后`,
+    };
   }
 }
 

package/src/lib/page-error-detector.js

@@ -49,6 +49,7 @@ const PATTERNS = {
     "没有内容",
     "发起对话",
     "0 条评论",
+    "找不到此账号",
   ],
   service_error: ["出错了", "很抱歉"],
 };
@@ -69,3 +70,36 @@ export async function detectPageError(page) {
     return null;
   }, PATTERNS);
 }
+
+/**
+ * 等待页面错误信息出现（轮询检测，最多等待 timeout ms）
+ * @param {import('playwright').Page} page
+ * @param {number} timeout - 超时时间（毫秒），默认 8000
+ * @returns {Promise<string|null>} 错误类型或 null
+ */
+export async function detectPageErrorWithWait(page, timeout = 8000) {
+  try {
+    const handle = await page.waitForFunction(
+      (patterns) => {
+        const bodyText = document.body.innerText;
+        const lower = bodyText.toLowerCase();
+
+        for (const [type, phrases] of Object.entries(patterns)) {
+          for (const phrase of phrases) {
+            if (lower.includes(phrase.toLowerCase())) {
+              return type;
+            }
+          }
+        }
+
+        return null;
+      },
+      PATTERNS,
+      { timeout },
+    );
+    return await handle.jsonValue();
+  } catch {
+    // 超时或未检测到错误
+    return null;
+  }
+}

package/src/scraper/explore-core.js

@@ -1,9 +1,4 @@
-import {
-  ensureBrowserReady,
-  detectPageError,
-  isLoggedIn,
-  delay,
-} from "./modules/page-helpers.js";
+import { ensureBrowserReady, delay } from "./modules/page-helpers.js";
 import { detectCaptcha } from "./modules/captcha-handler.js";
 export { ensureBrowserReady };
 import { getUserInfo, collectVideos } from "../videos/core.js";
@@ -18,6 +13,7 @@ async function processExplore(page, username, options, log) {
   const {
     maxVideos = 16,
     enableFollow = true,
+    loggedIn = false, // 由外部传入登录状态，避免每次调用 isLoggedIn(page)
     maxFollowing = 50,
     maxFollowers = 50,
     location = "PL,NL,BE,DE,FR,IT,ES,IE",
@@ -63,23 +59,10 @@ async function processExplore(page, username, options, log) {
     result.collectedVideos = videoArray.length;
 
     if (videoArray.length <= 0) {
+      // 视频为空：可能是页面受限或用户真的没有视频
       result.processed = true;
       result.noVideo = true;
-      const pageError = await detectPageError(page);
-      if (pageError === "service_error") {
-        result.error = `被封: ${username}`;
-        result.errorStack = "";
-        result.processed = false;
-        result.noVideo = false;
-        log(`  @${username} 服务异常（service_error），标记被封`);
-      } else if (pageError) {
-        result.restricted = true;
-        result.processed = true;
-        result.noVideo = true;
-        log(`  @${username} 页面受限（${pageError}），标记跳过`);
-      } else {
-        log(`  @${username} 没有视频，标记已处理`);
-      }
+      log(`  @${username} 没有视频，标记已处理`);
       return result;
     }
 
@@ -111,7 +94,6 @@ async function processExplore(page, username, options, log) {
 
       // 提取关注/粉丝
       if (enableFollow) {
-        const loggedIn = await isLoggedIn(page);
         await delay(100, 1000);
         if (!loggedIn) {
           log("  [跳过] 获取关注/粉丝：未登录，请先登录 TikTok");
@@ -171,27 +153,11 @@ async function processExplore(page, username, options, log) {
     result.errorStack = e.stack || "";
     log(`  [错误] ${e.message}`);
 
-    // API 拦截失败时，复用 videoArray.length <= 0 的被封检测逻辑
-    if (e.message.includes("API拦截")) {
-      log(`  [被封检测] 检查页面状态...`);
-      const hasErrorPage = await page
-        .waitForFunction(
-          (keywords) => {
-            const text = document.body.innerText;
-            return keywords.some((k) => text.includes(k));
-          },
-          ["出错了", "很抱歉"],
-          { timeout: 5000 },
-        )
-        .then(() => true)
-        .catch(() => false);
-
-      if (hasErrorPage) {
-        result.error = `被封: ${username}`;
-        result.processed = false;
-        result.noVideo = false;
-        log(`  @${username} API 拦截失败且页面异常，认定为被封`);
-      }
+    // 被封会抛出 "被封: username" 异常
+    if (e.message.startsWith("被封:")) {
+      result.processed = false;
+      result.noVideo = false;
+      log(`  @${username} 认定为被封`);
     }
   }
 

package/src/videos/core.js

@@ -1,5 +1,10 @@
-import { delay, ensureBrowserReady, ensureTikTokPage, retryWithBackoff } from '../scraper/modules/page-helpers.js';
-import { fetchUserVideosAPI } from '../lib/api-interceptor.js';
+import {
+  delay,
+  ensureBrowserReady,
+  ensureTikTokPage,
+  retryWithBackoff,
+} from "../scraper/modules/page-helpers.js";
+import { fetchUserVideosAPI } from "../lib/api-interceptor.js";
 
 async function getUserInfo(page) {
   return await page.evaluate(() => {
@@ -23,15 +28,21 @@ async function getUserInfo(page) {
       region: /"region":"([^"]*)/,
     };
 
-    const boolKeys = ['ttSeller', 'verified'];
-    const numKeys = ['followerCount', 'videoCount', 'followingCount', 'heartCount'];
+    const boolKeys = ["ttSeller", "verified"];
+    const numKeys = [
+      "followerCount",
+      "videoCount",
+      "followingCount",
+      "heartCount",
+    ];
 
     for (const [key, pat] of Object.entries(patterns)) {
       const match = html.match(pat);
       if (match) {
-        if (boolKeys.includes(key)) result[key] = match[1] === 'true';
+        if (boolKeys.includes(key)) result[key] = match[1] === "true";
         else if (numKeys.includes(key)) result[key] = parseInt(match[1], 10);
-        else if (key === 'signature') result[key] = match[1].replace(/\\n/g, '\n').replace(/\\\\/g, '\\');
+        else if (key === "signature")
+          result[key] = match[1].replace(/\\n/g, "\n").replace(/\\\\/g, "\\");
         else result[key] = match[1];
       }
     }
@@ -41,16 +52,22 @@ async function getUserInfo(page) {
 }
 
 async function collectVideos(page, username, maxVideos, log) {
-  const apiResult = await fetchUserVideosAPI(page, username, maxVideos, log);
-  if (apiResult && apiResult.size > 0) {
-    log(`收集完成: ${apiResult.size} 个视频`);
-    return apiResult;
-  }
-  if (apiResult && apiResult.size === 0) {
+  try {
+    const apiResult = await fetchUserVideosAPI(page, username, maxVideos, log);
+    if (apiResult && apiResult.size > 0) {
+      log(`收集完成: ${apiResult.size} 个视频`);
+      return apiResult;
+    }
+    // apiResult 为空 Map 表示页面有其他异常（login_required, captcha 等）
     return new Map();
+  } catch (e) {
+    // 被封会抛出 "被封: username" 异常
+    if (e.message.startsWith("被封:")) {
+      throw e; // 向上抛出，由 explore-core 处理
+    }
+    // 其他异常也向上抛出
+    throw new Error(`API 拦截失败：@${username} ${e.message}`);
   }
-  // apiResult is null means timeout before refactor; now it should throw instead
-  throw new Error(`API 拦截失败：@${username} 获取视频列表超时，请检查网络`);
 }
 
 async function runGetUserVideos(options) {
@@ -61,7 +78,7 @@ async function runGetUserVideos(options) {
   log(`URL: ${url}`);
   log(`最大视频数: ${maxVideos}\n`);
 
-  log('连接浏览器...');
+  log("连接浏览器...");
   const browser = await ensureBrowserReady();
 
   let page;
@@ -72,15 +89,20 @@ async function runGetUserVideos(options) {
     throw e;
   }
 
-  await retryWithBackoff(() => page.goto(url, { waitUntil: 'load', timeout: 30000 }), { log });
+  await retryWithBackoff(
+    () => page.goto(url, { waitUntil: "load", timeout: 30000 }),
+    { log },
+  );
   await delay(3000, 5000);
-  await page.waitForSelector('[class*="DivVideoList"]', { timeout: 10000 }).catch(() => {});
+  await page
+    .waitForSelector('[class*="DivVideoList"]', { timeout: 10000 })
+    .catch(() => {});
 
-  log('获取用户信息...');
+  log("获取用户信息...");
   const userInfo = await getUserInfo(page);
-  log('用户信息: ' + JSON.stringify(userInfo, null, 2));
+  log("用户信息: " + JSON.stringify(userInfo, null, 2));
 
-  log('\n开始滚动收集视频...');
+  log("\n开始滚动收集视频...");
   const videos = await collectVideos(page, username, maxVideos, log);
   const allVideos = Array.from(videos.values());
 
@@ -89,9 +111,11 @@ async function runGetUserVideos(options) {
   const output = {
     user: userInfo,
     totalVideos: Math.min(allVideos.length, maxVideos),
-    videos: allVideos.slice(0, maxVideos).map(v => ({
+    videos: allVideos.slice(0, maxVideos).map((v) => ({
       id: v.id,
-      url: v.href.startsWith('http') ? v.href : `https://www.tiktok.com${v.href}`,
+      url: v.href.startsWith("http")
+        ? v.href
+        : `https://www.tiktok.com${v.href}`,
     })),
   };