tt-help-cli-ycl 1.3.32 → 1.3.34

package/src/cli/watch.js

@@ -1,31 +1,31 @@
-import { existsSync } from 'fs';
-import { createStore } from '../watch/data-store.js';
-import { startWatchServer, openBrowser } from '../watch/server.js';
-
-export async function handleWatch(options) {
-  const { outputFile, watchPort } = options;
-
-  if (!outputFile) {
-    console.error('用法: tt-help watch -o <数据文件> [-p 端口]');
-    console.error('示例: tt-help watch -o data.json');
-    console.error('      tt-help watch -o data.json -p 8080');
-    process.exit(1);
-  }
-
-  if (!existsSync(outputFile)) {
-    console.error(`文件不存�? ${outputFile}`);
-    process.exit(1);
-  }
-
-  const store = createStore(outputFile);
-  const { server, port } = await startWatchServer(outputFile, watchPort, store);
-  openBrowser(port);
-
-  process.once('SIGINT', () => {
-    store.stopBackup();
-    server.close();
-    process.exit(0);
-  });
-
-  console.error('�?Ctrl+C 停止监控服务');
-}
+import { existsSync } from 'fs';
+import { createStore } from '../watch/data-store.js';
+import { startWatchServer, openBrowser } from '../watch/server.js';
+
+export async function handleWatch(options) {
+  const { outputFile, watchPort } = options;
+
+  if (!outputFile) {
+    console.error('用法: tt-help watch -o <数据文件> [-p 端口]');
+    console.error('示例: tt-help watch -o data.json');
+    console.error('      tt-help watch -o data.json -p 8080');
+    process.exit(1);
+  }
+
+  if (!existsSync(outputFile)) {
+    console.error(`文件不存�? ${outputFile}`);
+    process.exit(1);
+  }
+
+  const store = createStore(outputFile);
+  const { server, port } = await startWatchServer(outputFile, watchPort, store);
+  openBrowser(port);
+
+  process.once('SIGINT', () => {
+    store.stopBackup();
+    server.close();
+    process.exit(0);
+  });
+
+  console.error('�?Ctrl+C 停止监控服务');
+}

package/src/lib/api-interceptor.js

@@ -1,14 +1,10 @@
 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,
@@ -18,7 +14,6 @@ async function processAPIResponse(
   apiRequestUrl,
   log,
 ) {
-  // 提取首页视频
   const firstPageItems = data.itemList || [];
   for (const item of firstPageItems) {
     if (items.length >= maxVideos) break;
@@ -26,7 +21,6 @@ async function processAPIResponse(
     items.push({ id: item.id, href });
   }
 
-  // 翻页获取后续视频
   let cursor = data.cursor;
   let hasMore = data.hasMore;
 
@@ -61,7 +55,6 @@ async function processAPIResponse(
 
   log(`  [API拦截] 共 ${items.length} 条视频`);
 
-  // 转成 Map 返回，与 collectVideos 一致
   const videoMap = new Map();
   for (const v of items) {
     if (!videoMap.has(v.id)) videoMap.set(v.id, v);
@@ -70,159 +63,80 @@ async function processAPIResponse(
   return videoMap;
 }
 
-/**
- * 单次 API 拦截尝试：注册拦截器 → 导航 → 用 waitForResponse 精确等待 API
- * @param {number} apiTimeout - API 响应超时时间（ms），默认 15000
- * @returns {{data: object|null, apiRequestUrl: string|null, elapsed: number}}
- */
-async function tryInterceptAPI(page, username, log, apiTimeout = 15000) {
-  const url = `https://www.tiktok.com/@${username}`;
-  let apiRequestUrl = null;
+async function fetchUserVideosAPI(page, username, maxVideos, log) {
+  log(`  [API拦截] 获取 @${username} 视频 ...`);
 
-  const responseHandler = async (response) => {
-    if (response.url().includes("/api/post/item_list/")) {
-      // 只记录 URL，数据通过 waitForResponse 获取
-    }
-  };
+  let apiRequestUrl = null;
+  let sawApiRequest = false;
 
   const requestHandler = (request) => {
-    if (request.url().includes("/api/post/item_list/") && !apiRequestUrl) {
-      apiRequestUrl = request.url();
+    if (request.url().includes("/api/post/item_list/")) {
+      sawApiRequest = true;
+      if (!apiRequestUrl) apiRequestUrl = request.url();
     }
   };
 
-  page.on("response", responseHandler);
   page.on("request", requestHandler);
 
   const t0 = Date.now();
+  let data = null;
+  let interceptionError = null;
 
   try {
-    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
+    await page.goto(
+      `https://www.tiktok.com/@${username}`,
+      { waitUntil: "domcontentloaded", timeout: 30000 },
+    );
     await assertPageUrl(page, `@${username}`);
 
-    // 用 waitForResponse 精确等待 API 响应（超时时间可配置）
     const response = await page.waitForResponse(
       (res) => res.url().includes("/api/post/item_list/"),
-      { timeout: apiTimeout },
+      { timeout: 30000 },
     );
 
-    const data = await response.json();
-    const elapsed = Date.now() - t0;
-    return { data, apiRequestUrl, elapsed };
+    data = await response.json();
   } catch (e) {
-    const elapsed = Date.now() - t0;
-    return { data: null, apiRequestUrl, elapsed, error: e.message };
+    interceptionError = e.message;
   } finally {
-    page.off("response", responseHandler);
     page.off("request", requestHandler);
   }
-}
 
-/**
- * 通过拦截 TikTok 内部 API 获取用户视频列表
- * 比 DOM 滚动解析快 5-10 倍
- *
- * 弱网优化：
- * - 使用 waitForResponse 精确等待 API 响应（而非固定超时）
- * - 最多重试 3 次，递增等待 + 递增超时：
- *   - 第 1 次：等待 0s，   超时 15s  → 正常尝试
- *   - 第 2 次：等待 3s，   超时 20s  → 短暂波动恢复
- *   - 第 3 次：等待 10s，  超时 30s  → 网络缓慢给更多时间
- * - 每次重试前清理拦截器
- *
- * @param {import('playwright').Page} page - Playwright page (CDP 连接)
- * @param {string} username - TikTok 用户名
- * @param {number} maxVideos - 最大视频数
- * @param {Function} log - 日志函数
- * @returns {Map<string, {id: string, href: string}>} 与 collectVideos 返回格式一致
- * @throws {Error} API 超时或网络异常时抛出
- */
-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",
-    "region_blocked",
-    "login_required",
-  ]);
-
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    const [, apiTimeout] = retryStrategy[attempt - 1];
-    if (attempt > 1) {
-      log(
-        `  [API拦截] 重试 ${attempt}/${maxRetries} (超时 ${apiTimeout / 1000}s)`,
-      );
-    } else {
-      log(`  [API拦截] 获取 @${username} 视频 ...`);
-    }
+  const elapsed = Date.now() - t0;
 
-    const { data, apiRequestUrl, elapsed, error } = await tryInterceptAPI(
-      page,
+  if (data && Array.isArray(data.itemList) && data.itemList.length > 0) {
+    log(`  [API拦截] 成功，耗时 ${elapsed}ms`);
+    return await processAPIResponse(
+      data,
       username,
+      maxVideos,
+      [],
+      page,
+      apiRequestUrl,
       log,
-      apiTimeout,
     );
+  }
 
-    if (data && Array.isArray(data.itemList) && data.itemList.length > 0) {
-      // 成功拦截且拿到了视频，处理数据
-      return await processAPIResponse(
-        data,
-        username,
-        maxVideos,
-        items,
-        page,
-        apiRequestUrl,
-        log,
-      );
-    }
-
-    // API 已返回但没有视频时，优先判定是否是确定性的页面错误。
-    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}`);
-    }
-
-    if (data && Array.isArray(data.itemList) && data.itemList.length === 0) {
-      if (noRetryErrors.has(pageError)) {
-        return new Map();
-      }
-
-      return new Map();
-    }
+  let pageError = await detectPageError(page);
+  if (!pageError) {
+    pageError = await detectPageErrorWithWait(page, 5000);
+  }
 
-    if (noRetryErrors.has(pageError)) {
-      return new Map();
-    }
+  if (pageError === "service_error") {
+    throw new Error(`被封: ${username}`);
+  }
 
-    // 最后一次重试也失败了
-    if (attempt === maxRetries) {
-      if (!pageError) {
-        throw new Error(
-          `@${username} 页面异常（${maxRetries} 次重试均未拦截到 API）`,
-        );
-      }
-      return new Map();
-    }
+  if (pageError) {
+    log(`  [API拦截] 数据为空，识别到页面错误: ${pageError}`);
+    return new Map();
+  }
 
-    // 还有重试次数，等待后重试
-    const [waitTime] = retryStrategy[attempt - 1];
-    log(`  [API拦截] 失败，${waitTime / 1000}s 后重试...`);
-    await new Promise((r) => setTimeout(r, waitTime));
+  if (interceptionError) {
+    log(`  [API拦截] 超时/拦截失败: ${interceptionError}，耗时 ${elapsed}ms`);
+    throw new Error(`@${username} 页面异常（API拦截超时，未识别到错误类型）`);
   }
+
+  log(`  [API拦截] 数据为空，未识别到错误类型，当作无视频处理`);
+  return new Map();
 }
 
-export { fetchUserVideosAPI };
+export { fetchUserVideosAPI };