tt-help-cli-ycl 1.3.29 → 1.3.31

package/src/cli/explore.js

@@ -71,7 +71,8 @@ export async function handleExplore(options) {
     exploreMaxUsers,
     serverUrl,
     explorePort,
-    exploreProfile,
+    exploreBasePort,
+    explorePortCount,
     exploreUserId,
     exploreMaxVideos,
   } = options;
@@ -100,28 +101,35 @@ export async function handleExplore(options) {
   console.error(`服务器: ${serverUrl}（断开会自动重连）`);
   if (exploreMaxUsers > 0) console.error(`上限: ${exploreMaxUsers} 个用户`);
 
-  const healthChecker = new HealthChecker();
+  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_${exploreProfile}`,
+      `Microsoft Edge For Testing_p${explorePort}`,
     );
   } else {
     cdpOptions.port = currentAccount.port;
     cdpOptions.userDataDir = currentAccount.userDataDir;
   }
 
-  console.error(`CDP 端口: ${cdpOptions.port || 9222}, 用户编号: ${userId}`);
-  if (exploreProfile || cdpOptions.userDataDir)
+  console.error(`CDP 端口: ${cdpOptions.port}, 用户编号: ${userId}`);
+  console.error(`浏览器配置: ${path.basename(cdpOptions.userDataDir)}`);
+  if (!explorePort) {
+    const portRange = `${currentAccount.port}-${currentAccount.port + healthChecker.accounts.length - 1}`;
     console.error(
-      `浏览器配置: ${exploreProfile || path.basename(cdpOptions.userDataDir)}`,
+      `端口轮换范围: ${portRange}（共 ${healthChecker.accounts.length} 个）`,
     );
+  }
 
   let browser = await ensureBrowserReadyCDP(cdpOptions);
   const { processExplore } = await import("../scraper/explore-core.js");

package/src/cli/videostats.js

@@ -0,0 +1,81 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { TikTokScraper } from '../lib/tiktok-scraper.mjs';
+
+export async function handleVideoStats(options) {
+  const { statsFile, statsParallel } = options;
+
+  if (!statsFile) {
+    console.error('用法: tt-help videostats <文件路径> -p <并发数>');
+    console.error('示例: tt-help videostats data/result-videos.json -p 3');
+    console.error('');
+    console.error('选项: -p, --parallel <N>  并发数（默认: 3）');
+    process.exit(1);
+  }
+
+  // 读取文件
+  const videos = JSON.parse(readFileSync(statsFile, 'utf-8'));
+  if (!Array.isArray(videos) || videos.length === 0) {
+    console.error('[videostats] 文件为空或格式错误');
+    process.exit(1);
+  }
+
+  const poolSize = Math.min(statsParallel, videos.length);
+  console.error(`[videostats] 读取 ${statsFile}: ${videos.length} 个视频，并发: ${poolSize}`);
+
+  // 初始化 scraper
+  const scraper = new TikTokScraper({ poolSize });
+  await scraper.init();
+  console.error('[videostats] 浏览器初始化完成，开始刷新...');
+
+  let success = 0, failed = 0, skipped = 0;
+
+  try {
+    for (let i = 0; i < videos.length; i += poolSize) {
+      const batch = videos.slice(i, i + poolSize);
+
+      const results = await Promise.allSettled(
+        batch.map(async (v) => {
+          if (!v.href) return { video: v, error: 'no href' };
+          try {
+            const info = await scraper.getVideoInfo(v.href);
+            if (!info) return { video: v, error: 'no info' };
+            return { video: v, info };
+          } catch (err) {
+            return { video: v, error: err.message };
+          }
+        })
+      );
+
+      for (const result of results) {
+        if (result.status === 'fulfilled') {
+          const { video, info, error } = result.value;
+          if (info && info.stats) {
+            video.stats = info.stats;
+            success++;
+          } else {
+            failed++;
+            const id = video.id || video.href || '?';
+            console.error(`  [失败] ${id.substring(0, 30)} - ${error || '获取失败'}`);
+          }
+        } else {
+          failed++;
+        }
+      }
+
+      const processed = Math.min(i + poolSize, videos.length);
+      console.error(`[videostats] 进度: ${processed}/${videos.length} (成功: ${success}, 失败: ${failed})`);
+    }
+
+    // 写回文件
+    writeFileSync(statsFile, JSON.stringify(videos, null, 2), 'utf-8');
+    console.error(``);
+    console.error(`[videostats] 完成: 成功 ${success}, 失败 ${failed}`);
+    console.error(`[videostats] 已更新 ${statsFile}`);
+
+  } catch (err) {
+    console.error(`[videostats] 异常: ${err.message}`);
+    process.exit(1);
+  } finally {
+    await scraper.close();
+  }
+}

package/src/lib/api-interceptor-comment.js

@@ -0,0 +1,126 @@
+import { delay } from "./delay.js";
+
+/**
+ * 拦截 /api/comment/list/ API，获取评论数据
+ *
+ * 流程：注册拦截器 → 点击评论 tab → 捕获 API response → 翻页获取全部评论
+ *
+ * @param {Page} page - Playwright page
+ * @param {object} options
+ * @param {number} options.maxComments - 最大评论数
+ * @param {function} options.log - 日志函数
+ * @param {function} options.onCaptcha - 验证码检测回调 (page) => Promise<{detected: boolean}>
+ * @returns {Promise<{comments: Array, total: number, captchaDetected: boolean, error: string|null}>}
+ */
+async function fetchUserCommentsAPI(page, { maxComments = 100, log = console.log, onCaptcha } = {}) {
+  // 先注册 API 拦截器，再点 tab（顺序不能反）
+  let apiResolve = null;
+  let apiRequestUrl = null;
+  const apiPromise = new Promise(r => { apiResolve = r; });
+
+  const handler = async (response) => {
+    const url = response.url();
+    if (response.status() === 200 && url.includes('/api/comment/list/') && !apiRequestUrl) {
+      apiRequestUrl = url;
+      try {
+        apiResolve(await response.json());
+      } catch (e) {
+        apiResolve(null);
+      }
+    }
+  };
+
+  page.on('response', handler);
+
+  try {
+    // 点击评论 tab 触发 API
+    log('  [API拦截] 点击评论 tab...');
+    const tabs = page.locator('[class*="tabbar-item"]');
+    const commentTab = tabs.filter({ hasText: /评论|Comment/ });
+    const count = await commentTab.count();
+
+    if (count === 0) {
+      return { comments: [], total: 0, captchaDetected: false, error: '未找到评论 tab' };
+    }
+
+    await commentTab.first().click({ force: true });
+
+    // 等待 API 响应
+    const t0 = Date.now();
+    const data = await Promise.race([
+      apiPromise,
+      page.waitForTimeout(10000).then(() => null),
+    ]);
+    const elapsed = Date.now() - t0;
+
+    if (!data || !apiRequestUrl) {
+      log(`  [API拦截] 点击评论 tab 后 ${elapsed}ms 未拿到 API 响应`);
+      return { comments: [], total: 0, captchaDetected: false, error: 'API 超时或未响应' };
+    }
+
+    // 验证码检测（API 拿完后检测）
+    let captchaDetected = false;
+    if (onCaptcha) {
+      try {
+        const captchaResult = await onCaptcha(page);
+        captchaDetected = !!captchaResult.detected;
+        if (captchaDetected) {
+          log('  [API拦截] 检测到验证码');
+        }
+      } catch (e) {
+        log(`  [API拦截] 验证码检测异常: ${e.message}`);
+      }
+    }
+
+    const items = data.comments || [];
+    log(`  [API拦截] ${elapsed}ms 后拿到 ${items.length} 条评论 (total: ${data.total || '?'})`);
+
+    if (items.length >= maxComments) {
+      return { comments: items.slice(0, maxComments), total: data.total || 0, captchaDetected };
+    }
+
+    // 翻页
+    let cursor = data.cursor;
+    let hasMore = data.has_more;
+    let pageNum = 1;
+
+    while (hasMore && cursor && items.length < maxComments) {
+      pageNum++;
+      const pageUrl = apiRequestUrl.replace(/cursor=([^&]+)/, `cursor=${cursor}`);
+
+      const pageData = await page.evaluate(async (u) => {
+        try {
+          const res = await fetch(u);
+          return await res.json();
+        } catch (e) {
+          return { error: e.message };
+        }
+      }, pageUrl);
+
+      if (pageData.error) {
+        log(`  [API拦截] 翻页 ${pageNum} 失败: ${pageData.error}`);
+        break;
+      }
+
+      const pageComments = pageData.comments || [];
+      log(`  [API拦截] 翻页 ${pageNum}: ${pageComments.length} 条 (累计: ${items.length + pageComments.length})`);
+
+      items.push(...pageComments);
+      cursor = pageData.cursor;
+      hasMore = pageData.has_more;
+
+      if (items.length >= maxComments) break;
+
+      await delay(200, 500);
+    }
+
+    const result = items.slice(0, maxComments);
+    log(`  [API拦截] 共 ${result.length} 条评论, ${pageNum} 页`);
+
+    return { comments: result, total: data.total || 0, captchaDetected };
+  } finally {
+    page.off('response', handler);
+  }
+}
+
+export { fetchUserCommentsAPI };

package/src/lib/api-interceptor.js

@@ -1,7 +1,10 @@
 import { delay } from "./delay.js";
 import { retryWithBackoff } from "./retry.js";
 import { assertPageUrl } from "./browser/page.js";
-import { detectPageError } from "./page-error-detector.js";
+import {
+  detectPageError,
+  detectPageErrorWithWait,
+} from "./page-error-detector.js";
 
 /**
  * 处理 API 响应数据：提取首页视频 + 翻页
@@ -23,18 +26,13 @@ async function processAPIResponse(
     items.push({ id: item.id, href });
   }
 
-  log(`  [API拦截] 获取首页 ${firstPageItems.length} 条视频`);
-
   // 翻页获取后续视频
   let cursor = data.cursor;
   let hasMore = data.hasMore;
 
   while (hasMore && cursor && items.length < maxVideos) {
     const reqUrl = apiRequestUrl || data.apiRequestUrl;
-    if (!reqUrl) {
-      log("  [API拦截] 未捕获到 API 请求 URL，无法翻页");
-      break;
-    }
+    if (!reqUrl) break;
 
     const newUrl = reqUrl.replace(/cursor=\d+/, `cursor=${cursor}`);
 
@@ -50,22 +48,18 @@ async function processAPIResponse(
           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}`,
-        );
       }
 
       cursor = pageData.cursor;
       hasMore = pageData.hasMore;
-    } catch (e) {
-      log(`  [API拦截] 翻页失败: ${e.message}`);
+    } catch {
       break;
     }
 
     await delay(300, 600);
   }
 
-  log(`  [API拦截] 总计获取 ${items.length} 条视频`);
+  log(`  [API拦截] 共 ${items.length} 条视频`);
 
   // 转成 Map 返回，与 collectVideos 一致
   const videoMap = new Map();
@@ -78,9 +72,10 @@ async function processAPIResponse(
 
 /**
  * 单次 API 拦截尝试：注册拦截器 → 导航 → 用 waitForResponse 精确等待 API
+ * @param {number} apiTimeout - API 响应超时时间（ms），默认 15000
  * @returns {{data: object|null, apiRequestUrl: string|null, elapsed: number}}
  */
-async function tryInterceptAPI(page, username, log) {
+async function tryInterceptAPI(page, username, log, apiTimeout = 15000) {
   const url = `https://www.tiktok.com/@${username}`;
   let apiRequestUrl = null;
 
@@ -105,20 +100,17 @@ async function tryInterceptAPI(page, username, log) {
     await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
     await assertPageUrl(page, `@${username}`);
 
-    // 用 waitForResponse 精确等待 API 响应（15 秒超时，适合弱网）
+    // 用 waitForResponse 精确等待 API 响应（超时时间可配置）
     const response = await page.waitForResponse(
       (res) => res.url().includes("/api/post/item_list/"),
-      { timeout: 15000 },
+      { timeout: apiTimeout },
     );
 
     const data = await response.json();
     const elapsed = Date.now() - t0;
-    log(`  [API拦截] ${elapsed}ms 后成功拦截 API 响应`);
-
     return { data, apiRequestUrl, elapsed };
   } catch (e) {
     const elapsed = Date.now() - t0;
-    log(`  [API拦截] ${elapsed}ms 后拦截失败: ${e.message}`);
     return { data: null, apiRequestUrl, elapsed, error: e.message };
   } finally {
     page.off("response", responseHandler);
@@ -132,8 +124,11 @@ async function tryInterceptAPI(page, username, log) {
  *
  * 弱网优化：
  * - 使用 waitForResponse 精确等待 API 响应（而非固定超时）
- * - 最多重试 3 次，每次重试前清理拦截器
- * - 超时 15s，适合弱网环境
+ * - 最多重试 3 次，递增等待 + 递增超时：
+ *   - 第 1 次：等待 0s，   超时 15s  → 正常尝试
+ *   - 第 2 次：等待 3s，   超时 20s  → 短暂波动恢复
+ *   - 第 3 次：等待 10s，  超时 30s  → 网络缓慢给更多时间
+ * - 每次重试前清理拦截器
  *
  * @param {import('playwright').Page} page - Playwright page (CDP 连接)
  * @param {string} username - TikTok 用户名
@@ -145,6 +140,12 @@ async function tryInterceptAPI(page, username, log) {
 async function fetchUserVideosAPI(page, username, maxVideos, log) {
   const items = [];
   const maxRetries = 3;
+  // 重试策略：[等待时间(ms), API超时(ms)]
+  const retryStrategy = [
+    [0, 15000], // 第 1 次：不等待，15s 超时
+    [3000, 20000], // 第 2 次：等 3s，20s 超时（短暂波动）
+    [10000, 30000], // 第 3 次：等 10s，30s 超时（网络缓慢）
+  ];
   const noRetryErrors = new Set([
     "service_error",
     "not_found",
@@ -153,14 +154,20 @@ async function fetchUserVideosAPI(page, username, maxVideos, log) {
   ]);
 
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    log(
-      `  [API拦截] 导航到用户页，等待 /api/post/item_list/ ... (尝试 ${attempt}/${maxRetries})`,
-    );
+    const [, apiTimeout] = retryStrategy[attempt - 1];
+    if (attempt > 1) {
+      log(
+        `  [API拦截] 重试 ${attempt}/${maxRetries} (超时 ${apiTimeout / 1000}s)`,
+      );
+    } else {
+      log(`  [API拦截] 获取 @${username} 视频 ...`);
+    }
 
     const { data, apiRequestUrl, elapsed, error } = await tryInterceptAPI(
       page,
       username,
       log,
+      apiTimeout,
     );
 
     if (data && Array.isArray(data.itemList) && data.itemList.length > 0) {
@@ -177,7 +184,13 @@ async function fetchUserVideosAPI(page, username, maxVideos, log) {
     }
 
     // API 已返回但没有视频时，优先判定是否是确定性的页面错误。
-    const pageError = await detectPageError(page);
+    let pageError = await detectPageError(page);
+
+    // service_error 经常比 API 判定晚一点渲染，补一个短等待避免漏判“被封”。
+    if (!pageError) {
+      const delayedPageError = await detectPageErrorWithWait(page, 3000);
+      if (delayedPageError) pageError = delayedPageError;
+    }
 
     if (pageError === "service_error") {
       throw new Error(`被封: ${username}`);
@@ -185,20 +198,13 @@ async function fetchUserVideosAPI(page, username, maxVideos, log) {
 
     if (data && Array.isArray(data.itemList) && data.itemList.length === 0) {
       if (noRetryErrors.has(pageError)) {
-        log(
-          `  [API拦截] ${elapsed}ms 后 API 返回空列表，页面异常（${pageError}）`,
-        );
         return new Map();
       }
 
-      log(`  [API拦截] ${elapsed}ms 后 API 返回 0 条视频`);
       return new Map();
     }
 
     if (noRetryErrors.has(pageError)) {
-      log(
-        `  [API拦截] ${elapsed}ms 后未拿到 API 数据，页面异常（${pageError}）`,
-      );
       return new Map();
     }
 
@@ -206,20 +212,15 @@ async function fetchUserVideosAPI(page, username, maxVideos, log) {
     if (attempt === maxRetries) {
       if (!pageError) {
         throw new Error(
-          `@${username} 页面异常（${elapsed}ms，${maxRetries} 次重试均未拦截到 API）`,
+          `@${username} 页面异常（${maxRetries} 次重试均未拦截到 API）`,
         );
       }
-      log(
-        `  [API拦截] ${elapsed}ms 后未拿到 API 数据，页面异常（${pageError}），${maxRetries} 次重试已用尽`,
-      );
       return new Map();
     }
 
     // 还有重试次数，等待后重试
-    const waitTime = 2000 * attempt;
-    log(
-      `  [API拦截] 拦截失败（${error || "未拿到有效 API 数据"}），${waitTime / 1000}s 后重试...`,
-    );
+    const [waitTime] = retryStrategy[attempt - 1];
+    log(`  [API拦截] 失败，${waitTime / 1000}s 后重试...`);
     await new Promise((r) => setTimeout(r, waitTime));
   }
 }