tt-help-cli-ycl 1.4.136 → 1.4.139

package/src/lib/browser/page.js

@@ -228,14 +228,42 @@ export async function isLoggedInByDom(page) {
 
 export async function closeCommentPanel(page) {
   await page.evaluate(() => {
-    const rightPanel = document.querySelector('[class*="RightPanelContainer"]');
-    if (rightPanel) {
-      const tabContainer = rightPanel.querySelector('[class*="TabContainer"]');
-      if (tabContainer) {
-        const closeOverlay = tabContainer.querySelector("div:last-child");
-        if (closeOverlay) closeOverlay.click();
+    // 覆盖新版短视频面板容器（DivVideoDetailContainer）与旧版容器
+    const panels = document.querySelectorAll(
+      '[class*="RightPanelContainer"], [class*="VideoDetailContainer"]',
+    );
+    if (panels.length === 0) return;
+
+    // 明确的关闭按钮选择器（按优先级）——绝不点击任何 tab 子元素，避免误开"商品"等 tab
+    const closeSelectors = [
+      '[data-e2e="comment-close"]',
+      '[data-e2e="close"]',
+      '[data-e2e="modal-close"]',
+      '[class*="CloseButton"]',
+      '[class*="close-button"]',
+    ];
+
+    for (const panel of panels) {
+      for (const sel of closeSelectors) {
+        const btn = panel.querySelector(sel);
+        if (btn && btn.offsetParent !== null) {
+          btn.dispatchEvent(new MouseEvent("mousedown", { bubbles: true }));
+          btn.dispatchEvent(new MouseEvent("mouseup", { bubbles: true }));
+          btn.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+          return;
+        }
       }
     }
+
+    // 无明确关闭按钮时：只点面板外的遮罩层，避免误点 tab
+    const mask = document.querySelector(
+      '[class*="DivModalMask"], [class*="modal-mask"], [class*="ModalMask"]',
+    );
+    if (mask && mask.offsetParent !== null) {
+      mask.dispatchEvent(new MouseEvent("mousedown", { bubbles: true }));
+      mask.dispatchEvent(new MouseEvent("mouseup", { bubbles: true }));
+      mask.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+    }
   });
 }
 

package/src/lib/browser-memory.js

@@ -0,0 +1,95 @@
+/**
+ * 浏览器 / Node 内存统计 helper（tag / comments 等业务命令共享）。
+ * 跨平台：macOS / Linux 用 ps RSS，Windows 用 PowerShell 查 msedge 工作集。
+ */
+import { writeFileSync, unlinkSync } from "fs";
+import { execSync } from "child_process";
+import os from "os";
+import path from "path";
+
+export function formatMemoryUsage(mem = process.memoryUsage()) {
+  const mb = (n) => (n / 1024 / 1024).toFixed(0);
+  return `rss:${mb(mem.rss)}MB heap:${mb(mem.heapUsed)}MB ext:${mb(mem.external)}MB ab:${mb(mem.arrayBuffers)}MB`;
+}
+
+/**
+ * 获取 Edge 浏览器进程的内存占用（跨平台：macOS/Linux/Windows）。
+ * @param {number|null} [port] - 按 CDP 端口筛选；不传则统计全部 msedge 进程
+ * @returns {number|null} 内存 MB，获取失败返回 null
+ */
+export function getBrowserMemory(port = null) {
+  try {
+    const platform = os.platform();
+    let cmd;
+    if (platform === "darwin") {
+      if (port) {
+        cmd = `ps aux | grep "[M]icrosoft Edge" | grep "remote-debugging-port=${port}" | awk '{sum += $6} END {printf "%d", sum/1024}'`;
+      } else {
+        cmd =
+          'ps aux | grep "[M]icrosoft Edge" | awk \'{sum += $6} END {printf "%d", sum/1024}\'';
+      }
+      const result = execSync(cmd, { timeout: 5000 }).toString().trim();
+      const mb = parseInt(result, 10);
+      return mb > 0 ? mb : null;
+    } else if (platform === "linux") {
+      if (port) {
+        cmd = `ps aux | grep "[m]sedge" | grep "remote-debugging-port=${port}" | awk '{sum += $6} END {printf "%d", sum/1024}'`;
+      } else {
+        cmd =
+          'ps aux | grep "[m]sedge" | awk \'{sum += $6} END {printf "%d", sum/1024}\'';
+      }
+      const result = execSync(cmd, { timeout: 5000 }).toString().trim();
+      const mb = parseInt(result, 10);
+      return mb > 0 ? mb : null;
+    } else if (platform === "win32") {
+      // 用临时 .ps1 文件避免命令行转义问题
+      const ps1Path = path.join(os.tmpdir(), `edge-mem-${Date.now()}.ps1`);
+      try {
+        let ps1Content;
+        if (port) {
+          ps1Content =
+            `$procs = Get-CimInstance Win32_Process -Filter "Name LIKE 'msedge%'" -ErrorAction SilentlyContinue; ` +
+            `$sum = 0; ` +
+            `foreach ($p in $procs) { ` +
+            `  if ($p.CommandLine -and $p.CommandLine -like "*--remote-debugging-port=${port}*") { ` +
+            `    $sum += $p.WorkingSetSize ` +
+            `  } ` +
+            `}; ` +
+            `Write-Output $sum`;
+        } else {
+          // 无端口场景：Get-Process（.NET API，不依赖 WMI）统计全部 msedge 工作集
+          ps1Content =
+            `$procs = Get-Process msedge -ErrorAction SilentlyContinue; ` +
+            `$sum = 0; ` +
+            `foreach ($p in $procs) { $sum += $p.WorkingSet64 }; ` +
+            `Write-Output $sum`;
+        }
+        writeFileSync(ps1Path, ps1Content);
+        cmd = `powershell.exe -NoProfile -ExecutionPolicy Bypass -File "${ps1Path}"`;
+        const result = execSync(cmd, { timeout: 5000 }).toString().trim();
+        try {
+          unlinkSync(ps1Path);
+        } catch {}
+        const bytes = parseInt(result, 10);
+        const mb = bytes > 0 ? Math.round(bytes / 1048576) : 0;
+        return mb > 0 ? mb : null;
+      } catch {
+        try {
+          unlinkSync(ps1Path);
+        } catch {}
+        return null;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function formatMemoryWithBrowser(port = null) {
+  const nodeMem = formatMemoryUsage();
+  const edgeMB = getBrowserMemory(port);
+  if (!edgeMB) return nodeMem;
+  const portLabel = port ? `:${port}` : "";
+  return `${nodeMem} edge${portLabel}:${edgeMB}MB`;
+}

package/src/lib/client-error-report.js

@@ -0,0 +1,82 @@
+/**
+ * 客户端错误上报 + Clash daemon 故障切换 的共享 helper。
+ * 供 tag / comments 等业务命令复用，避免重复实现。
+ */
+
+/**
+ * 触发 Clash daemon 的故障切换（换出口节点），与 watchdog 的 failover 一致。
+ * 复用 ../clash/ipc.js 现成的 writeCommand 接口，不改动 daemon/ipc 模块。
+ * @param {string} reason - failover 原因（会写入 daemon 日志）
+ * @param {(s: string) => void} [log] - 日志函数，默认 console.error
+ */
+export async function triggerClashFailover(reason, log = console.error) {
+  try {
+    const ipc = await import("../clash/ipc.js");
+    ipc.writeCommand({ action: "failover", reason });
+    log(`  🔀 已触发 daemon failover (${reason})`);
+  } catch (e) {
+    log(`  ⚠️ 触发 daemon failover 失败: ${e.message}`);
+  }
+}
+
+/**
+ * 上报单条客户端错误到服务端，并触发 daemon fallback 换节点。
+ * @param {object} opts
+ * @param {(url: string, body: object) => Promise} opts.post - 发 POST 的函数（返回 promise）
+ * @param {string} opts.baseUrl - 服务端地址
+ * @param {string} opts.userId
+ * @param {string} opts.errorType - 错误类型（如 consecutive_task_errors / consecutive_blocked）
+ * @param {string} opts.message - 用作 errorMessage 与 failover reason
+ * @param {string} opts.stage - stage 标识（如 tag-scoring / comments）
+ * @param {(s: string) => void} [opts.log] - 日志函数，默认 console.error
+ */
+export async function reportClientErrorAndFailover({
+  post,
+  baseUrl,
+  userId,
+  errorType,
+  message,
+  stage,
+  log = console.error,
+}) {
+  try {
+    await post(`${baseUrl}/api/error-report`, {
+      userId,
+      username: "",
+      errorType,
+      errorMessage: message,
+      stage,
+      errorStack: "",
+    });
+  } catch {}
+  await triggerClashFailover(message, log);
+}
+
+/**
+ * 连续任务错误达到阈值后：上报服务端 + 触发 daemon fallback 换节点。
+ * @param {object} opts
+ * @param {(url: string, body: object) => Promise} opts.post - 发 POST 的函数（返回 promise）
+ * @param {string} opts.baseUrl - 服务端地址
+ * @param {string} opts.userId
+ * @param {string} opts.message - 用作 errorMessage 与 failover reason
+ * @param {string} opts.stage - stage 标识（如 tag-scoring / comments）
+ * @param {(s: string) => void} [opts.log] - 日志函数，默认 console.error
+ */
+export async function reportConsecutiveTaskErrors({
+  post,
+  baseUrl,
+  userId,
+  message,
+  stage,
+  log = console.error,
+}) {
+  return reportClientErrorAndFailover({
+    post,
+    baseUrl,
+    userId,
+    errorType: "consecutive_task_errors",
+    message,
+    stage,
+    log,
+  });
+}

package/src/lib/constants.js

@@ -289,6 +289,9 @@ const HELP_TEXT = [
   "      -p, --port <端口号>    监听端口，默认 3000",
   "      --pool-size <数量>     浏览器页面池大小，默认 8",
   "      --proxy <地址>         HTTP 代理（如 127.0.0.1:7897）",
+  "      --rate <请求/秒>       对 TikTok 的全局请求速率限制，默认 3（0=不限制）",
+  "                            （限速突发容量自动跟随 --pool-size，无需单独设置）",
+  "      --cooldown <秒>        CDN 限流自动冷却时长：首次限流后冷却，到期仍限流则单次重启，默认 180",
   "      --log                   显示 API 成功日志（默认不显示，错误日志始终输出）",
   "      --notify [地址]         验证码通知，默认 http://117.71.53.99:17301",
   "    API:",
@@ -470,6 +473,7 @@ const HELP_TEXT = [
   "        tt-help explore --webserver http://127.0.0.1:3000 --location DE,ES,FR",
   "        tt-help refresh --server http://127.0.0.1:3001 --port 9222",
   "        tt-help webserver -p 3000 --pool-size 8 --proxy 127.0.0.1:7897",
+  "        tt-help webserver -p 3000 --pool-size 8 --proxy 127.0.0.1:7897 --rate 3",
   "        tt-help webserver -p 3000 --log",
   "        tt-help config set server http://127.0.0.1:3001",
   "        tt-help attach -p 5 -i 10",

package/src/lib/tiktok-scraper.mjs

@@ -18,6 +18,38 @@ function delay(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
+// 令牌桶：平均 rate 个请求/秒，允许最多 capacity 个突发。
+// rate <= 0 表示不限流（兼容旧行为）。用于限制对 TikTok 的全局 QPS，
+// 避免 8 页并行时短时间高频访问触发 Akamai CDN 限流（Access Denied）。
+class TokenBucket {
+  constructor({ ratePerSecond, capacity }) {
+    this.rate = ratePerSecond;
+    this.capacity = capacity;
+    this.tokens = capacity;
+    this.lastRefill = Date.now();
+  }
+  _refill() {
+    const now = Date.now();
+    const elapsed = (now - this.lastRefill) / 1000;
+    this.tokens = Math.min(this.capacity, this.tokens + elapsed * this.rate);
+    this.lastRefill = now;
+    if (this.tokens < 0) this.tokens = 0;
+  }
+  async acquire() {
+    if (this.rate <= 0) return; // 不限流
+    while (true) {
+      this._refill();
+      if (this.tokens >= 1) {
+        this.tokens -= 1;
+        return;
+      }
+      // 距下一个令牌可用还需多少毫秒
+      const waitMs = Math.ceil(((1 - this.tokens) / this.rate) * 1000);
+      await delay(Math.max(waitMs, 40));
+    }
+  }
+}
+
 class PageSlot {
   constructor(page) {
     this.page = page;
@@ -60,12 +92,18 @@ export class TikTokScraper {
     warmUrl = DEFAULT_WARM_URL,
     maxRequestsPerPage = DEFAULT_MAX_REQUESTS_PER_PAGE,
     proxyServer = null,
+    requestRatePerSecond = 0, // 0 = 不限制对 TikTok 的请求速率
+    requestBurst = 8, // 限速器突发容量（允许一次小突发热身/单次重试）
   } = {}) {
     this.poolSize = poolSize;
     this.wafTtl = wafTtl;
     this.warmUrl = warmUrl;
     this.maxRequestsPerPage = maxRequestsPerPage;
     this.proxyServer = proxyServer;
+    this.rateLimiter = new TokenBucket({
+      ratePerSecond: requestRatePerSecond,
+      capacity: requestBurst,
+    });
     this.browser = null;
     this.context = null;
     this.slots = [];
@@ -190,6 +228,10 @@ export class TikTokScraper {
   }
 
   async _fetchViewSource(url, slot) {
+    // 全局限速：所有对外请求（含重试路径）统一在这里节流，
+    // 避免 8 页并行时短时间高频访问触发 TikTok CDN 限流。
+    await this.rateLimiter.acquire();
+
     const page = await this._ensurePage(slot);
 
     await page.goto("view-source:" + url, {

package/src/webserver/server.mjs

@@ -71,6 +71,8 @@ const SCRAPER_CONFIG = {
   wafTTL: 120000,
   maxRequestsPerPage: 50,
   proxyServer: null,
+  requestRatePerSecond: 0, // 0 = 不限制对 TikTok 的请求速率（默认安全值由 CLI 注入）
+  requestBurst: 8,
   captchaNotifyUrl: null,
   enableLog: false,
 };
@@ -121,6 +123,14 @@ let recentWindowStart = Date.now();
 const RECENT_WINDOW_MS = 60000; // 60 秒滑动窗口
 
 async function getScraper() {
+  // 重启进行中：等待重启完成，避免拿到 context 已被关闭的半死实例
+  if (restartPromise) {
+    try {
+      await restartPromise;
+    } catch (e) {
+      console.error(`[webserver] 等待重启失败: ${e.message}`);
+    }
+  }
   if (scraperInstance && !scraperClosing) {
     return scraperInstance;
   }
@@ -155,7 +165,11 @@ function recordRequest(success) {
   }
   recentTotal++;
   if (!success) recentErrors++;
-  if (success) consecutiveErrors = 0;
+  if (success) {
+    consecutiveErrors = 0;
+    // 请求成功（含探活）→ 视为 CDN 已恢复，清除自愈状态
+    resetCdnRecovered();
+  }
 }
 
 function isDegraded() {
@@ -181,6 +195,13 @@ async function restartScraper(reason) {
     }
     scraperInitPromise = null;
     consecutiveErrors = 0;
+    // 真正重建：init 全新 scraper 实例，而非仅清空（否则重启期间并发请求会拿到
+    // context 为 null 的半死实例，抛 "Cannot read properties of null (reading 'newPage')"）
+    console.error(`[webserver] 重建 scraper 实例...`);
+    const scraper = new TikTokScraper(SCRAPER_CONFIG);
+    await scraper.init();
+    scraperInstance = scraper;
+    lastWarmTime = Date.now();
     console.error(`[webserver] 重启 scraper 完成`);
   })();
   try {
@@ -190,6 +211,70 @@ async function restartScraper(reason) {
   }
 }
 
+// ---- CDN 限流自愈（冷却窗口 + 单次重启 + 躺平）----
+// 首次限流 → 进入冷却期，期间业务请求直接 503（让 IP 静默冷却，Akamai 窗口自动解除）；
+// 冷却期满后由下一个请求"探活"：成功 → 恢复；仍限流 → 重启一次 scraper 再冷却；
+// 重启后再限流 → 判定 IP/账号级，躺平（不再自动重启，持续 503 靠 nginx failover + 人工换 IP）。
+let cdnCooling = false; // 当前是否处于冷却静默期
+let cdnCooldownUntil = 0; // 冷却结束时间戳；0 = 从未进入冷却
+let cdnRestartedThisWindow = false; // 最近一个冷却窗口是否已执行过重启
+let cdnGiveUp = false; // 判定 IP/账号级，躺平不再自动重启
+let CDN_COOLDOWN_MS = 180000; // 冷却时长，默认 3 分钟（可被 startWebserver 覆盖）
+
+function startCdnCooldown() {
+  cdnCooling = true;
+  cdnCooldownUntil = Date.now() + CDN_COOLDOWN_MS;
+}
+
+// 冷却期是否生效；到期后自动解除静默，交给下一个请求探活
+function shouldFailFast() {
+  if (cdnGiveUp) return false; // 躺平后不再拦截，让请求尝试（成功即可自然恢复）
+  if (!cdnCooling) return false;
+  if (Date.now() >= cdnCooldownUntil) {
+    cdnCooling = false; // 冷却期满，解除静默
+    return false;
+  }
+  return true;
+}
+
+// 成功恢复：清空自愈状态，下次限流重新走完整流程
+function resetCdnRecovered() {
+  cdnCooling = false;
+  cdnCooldownUntil = 0;
+  cdnRestartedThisWindow = false;
+  cdnGiveUp = false;
+}
+
+// 处理一次 CDN 限流（在 isCdnBlocked 分支调用）
+function handleCdnLimit() {
+  if (cdnGiveUp) return;
+  const now = Date.now();
+  // 冷却窗口未到期（含并发到达）：持续冷却，不重启
+  if (cdnCooling && now < cdnCooldownUntil) return;
+  // 从未进入冷却：首次限流
+  if (!cdnCooling && cdnCooldownUntil === 0) {
+    startCdnCooldown();
+    console.error(
+      `[webserver] 触发 CDN 限流自愈：进入 ${Math.round(CDN_COOLDOWN_MS / 1000)}s 冷却期，期间请求直接 503，到期后探活`,
+    );
+    return;
+  }
+  // 冷却已结束（探活失败）
+  if (!cdnRestartedThisWindow) {
+    cdnRestartedThisWindow = true;
+    console.error(
+      `[webserver] 冷却期后仍 CDN 限流，第 1 次重启 scraper 并再次冷却...`,
+    );
+    restartScraper("CDN 限流冷却后仍限流").catch(() => {});
+    startCdnCooldown();
+  } else {
+    cdnGiveUp = true;
+    console.error(
+      `[webserver] 冷却+重启后仍 CDN 限流，判定 IP/账号级，躺平不再自动重启（需人工换 IP/代理）`,
+    );
+  }
+}
+
 async function warmScraper() {
   if (scraperClosing || !scraperInstance) return;
   const now = Date.now();
@@ -519,6 +604,11 @@ function handleHealth(req, res) {
     lastWarmSec: lastWarmTime
       ? Math.round((Date.now() - lastWarmTime) / 1000)
       : null,
+    cdnCooling: cdnCooling,
+    cdnCooldownSec: cdnCooling
+      ? Math.max(0, Math.ceil((cdnCooldownUntil - Date.now()) / 1000))
+      : 0,
+    cdnGiveUp,
     uptime: process.uptime(),
   });
 }
@@ -549,6 +639,9 @@ export async function startWebserver(
   proxyServer = null,
   captchaNotifyUrl = null,
   enableLog = false,
+  requestRatePerSecond = 0,
+  requestBurst = 8,
+  cdnCooldownSec = 180,
 ) {
   if (poolSize > 0) {
     SCRAPER_CONFIG.poolSize = poolSize;
@@ -560,6 +653,26 @@ export async function startWebserver(
     SCRAPER_CONFIG.captchaNotifyUrl = captchaNotifyUrl;
   }
   SCRAPER_CONFIG.enableLog = !!enableLog;
+  // 限速参数：显式传入才覆盖，否则用 SCRAPER_CONFIG 默认值（0=不限速）。
+  if (requestRatePerSecond > 0) {
+    SCRAPER_CONFIG.requestRatePerSecond = requestRatePerSecond;
+  }
+  // 突发容量：显式传入则使用；否则自动跟随最终生效的 poolSize。
+  if (requestBurst > 0) {
+    SCRAPER_CONFIG.requestBurst = requestBurst;
+  } else {
+    SCRAPER_CONFIG.requestBurst = SCRAPER_CONFIG.poolSize;
+  }
+  // CDN 冷却时长：优先 CLI 传入（秒）> 环境变量 WEBSERVER_CDN_COOLDOWN_MS（毫秒）> 默认 180s
+  const envCooldownMs =
+    parseInt(process.env.WEBSERVER_CDN_COOLDOWN_MS || "0", 10) || 0;
+  if (cdnCooldownSec > 0) {
+    CDN_COOLDOWN_MS = cdnCooldownSec * 1000;
+  } else if (envCooldownMs > 0) {
+    CDN_COOLDOWN_MS = envCooldownMs;
+  } else {
+    CDN_COOLDOWN_MS = 180000;
+  }
   const server = http.createServer(async (req, res) => {
     const url = new URL(req.url, `http://127.0.0.1:${port}`);
 
@@ -582,6 +695,23 @@ export async function startWebserver(
       });
     }
 
+    // CDN 冷却期：业务 API 直接 503，不真正去抓（让 IP 静默冷却，Akamai 窗口可自动解除）
+    if (route.path.startsWith("/api/tiktok") && shouldFailFast()) {
+      const remainSec = Math.max(
+        0,
+        Math.ceil((cdnCooldownUntil - Date.now()) / 1000),
+      );
+      logErrorThrottled(
+        "request CDN冷却",
+        `冷却中，直接返回 503 (剩余 ${remainSec}s)`,
+      );
+      return sendJSON(res, 503, {
+        error: "CDN cooldown active, cooling IP",
+        retryable: true,
+        cdnCooldownSec: remainSec,
+      });
+    }
+
     try {
       return await route.handler(req, res);
     } catch (e) {
@@ -600,6 +730,8 @@ export async function startWebserver(
         status = 503;
         retryable = true;
         logErrorThrottled("request CDN限流", e.message);
+        // 触发自愈：冷却 → 到期探活 → 仍限流则单次重启 → 再限流则躺平
+        handleCdnLimit();
       } else if (e.message?.includes("Server is shutting down")) {
         // 服务正在关闭 → 503
         status = 503;