tt-help-cli-ycl 1.4.136 → 1.4.140

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 限流自动冷却时长，默认 100（冷却→探活→最多2次重启→自动切 Clash 节点）",
   "      --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/parse-ssr.mjs

@@ -1,5 +1,5 @@
 /**
- * CDN 限流错误（Akamai Access Denied）
+ * CDN 限流错误（Akamai Access Denied / HTTP 非 2xx 风控）
  */
 export class CDNBlockedError extends Error {
   constructor(message = "CDN限流 (Access Denied)", reference) {
@@ -9,6 +9,18 @@ export class CDNBlockedError extends Error {
   }
 }
 
+/**
+ * TikTok 明确 HTTP 状态码错误（goto 阶段被非 2xx 拒绝，如 404 视频/用户不存在）。
+ * 与 CDNBlockedError 区分：业务结果而非风控，webserver 返回 200 + statusCode。
+ */
+export class TikTokStatusError extends Error {
+  constructor(statusCode, message) {
+    super(message || `TikTok HTTP ${statusCode}`);
+    this.name = "TikTokStatusError";
+    this.statusCode = statusCode;
+  }
+}
+
 /**
  * 检测 HTML 是否为 CDN Access Denied
  * 返回 { isBlocked: true, reference: "xxx" } 或 null

package/src/lib/port.js

@@ -0,0 +1,72 @@
+/**
+ * 端口占用清理：webserver 启动前检查目标端口，若被占用直接杀掉占用进程。
+ * Windows 走 netstat -ano + taskkill；macOS/Linux 走 lsof + SIGKILL。
+ */
+import { execSync } from "node:child_process";
+import { parseNetstatListeningPids } from "./browser/cdp.js";
+
+const KILL_WAIT_MS = 500; // 杀完等端口释放（Windows 进程退出有延迟，立即 listen 仍可能 EADDRINUSE）
+
+function delay(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+/** 返回监听指定端口的 PID 列表（字符串数组） */
+export function findListeningPids(port) {
+  if (process.platform === "win32") {
+    try {
+      const out = execSync("netstat -ano -p TCP", {
+        encoding: "utf-8",
+        timeout: 5000,
+        windowsHide: true,
+      });
+      return parseNetstatListeningPids(out, port);
+    } catch (e) {
+      console.error(`[port] netstat 查询失败: ${e.message}`);
+      return [];
+    }
+  }
+  // POSIX：lsof 找不到监听时退出码非 0 且无输出，属正常情况
+  try {
+    const out = execSync(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t`, {
+      encoding: "utf-8",
+      timeout: 5000,
+    });
+    return out
+      .split(/\r?\n/)
+      .map((s) => s.trim())
+      .filter((s) => /^\d+$/.test(s));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 杀掉监听指定端口的全部进程（排除自身 PID），供启动前清理端口占用。
+ * 不区分进程类型：谁占谁死（用户拍板）。
+ */
+export async function killListeningOnPort(port) {
+  const pids = findListeningPids(port).filter((p) => p !== String(process.pid));
+  if (!pids.length) return;
+  console.error(
+    `[webserver] 端口 ${port} 被占用，直接清理进程 PID: ${pids.join(", ")}`,
+  );
+  for (const pid of pids) {
+    try {
+      if (process.platform === "win32") {
+        execSync(`taskkill /F /T /PID ${pid}`, {
+          encoding: "buffer",
+          timeout: 15000,
+          windowsHide: true,
+        });
+      } else {
+        process.kill(parseInt(pid, 10), "SIGKILL");
+      }
+      console.error(`[webserver] 已杀 PID ${pid}`);
+    } catch (e) {
+      console.error(`[webserver] 杀 PID ${pid} 失败: ${e.message}`);
+    }
+  }
+  // 等待端口释放，避免立即 listen 仍 EADDRINUSE
+  await delay(KILL_WAIT_MS);
+}

package/src/lib/tiktok-scraper.mjs

@@ -5,6 +5,7 @@ import {
   parseVideoInfo,
   isRetryableFailure,
   CDNBlockedError,
+  TikTokStatusError,
   detectAccessDenied,
 } from "./parse-ssr.mjs";
 
@@ -18,6 +19,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;
@@ -26,6 +59,30 @@ class PageSlot {
   }
 }
 
+/**
+ * 对 page.goto 抛出的错误做分类（goto 阶段失败时拿不到 HTML，
+ * detectAccessDenied 无法执行，必须在这里拦截风控类错误）。
+ * status 为导航期间捕获的最后一个 tiktok 响应状态码（可能为 null）：
+ * - 404 → TikTokStatusError（视频/用户不存在，业务结果）
+ * - 403/429/未知 → CDNBlockedError，由 webserver 走 CDN 冷却自愈链路
+ *   （503 + 冷却 + 躺平 + nginx failover），而不是 consecutiveErrors
+ *   浏览器重启链——重启对 IP/节点风控无效，只会形成死亡螺旋。
+ * - 其余（ERR_ABORTED / Target closed 等重启竞态产物）→ 返回 null，
+ *   原样冒泡交由 webserver 分类（503 retryable 且不计连续错误）。
+ */
+export function classifyGotoError(message, status) {
+  if (typeof message !== "string") return null;
+  if (message.includes("ERR_HTTP_RESPONSE_CODE_FAILURE")) {
+    if (status === 404) {
+      return new TikTokStatusError(404, "TikTok HTTP 404 (视频/用户不存在)");
+    }
+    return new CDNBlockedError(
+      `goto 非2xx (疑似 IP/节点风控, status=${status ?? "unknown"}): ${message.split("\n")[0]}`,
+    );
+  }
+  return null;
+}
+
 class PromiseQueue {
   constructor() {
     this._queue = [];
@@ -60,21 +117,32 @@ 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 = [];
     this.slotIdx = 0;
     this.lastWarmTime = 0;
     this.warmPromise = null;
+    // 关闭中标记：restart 时旧实例先 close，在途请求凭此立即失败（503），
+    // 而不是打到已销毁的 context 上报 "Cannot read properties of null"。
+    this.closing = false;
   }
 
   async init() {
+    // restart() = close() + init()：重建后恢复可用状态
+    this.closing = false;
     const executablePath = detectBrowser();
     if (!executablePath) {
       throw new Error(
@@ -105,6 +173,8 @@ export class TikTokScraper {
   }
 
   async close() {
+    // 先置关闭标记：在途请求的入口检查会立即失败，避免与关闭流程竞态
+    this.closing = true;
     if (this.browser) {
       const browser = this.browser;
       let closeTimedOut = false;
@@ -175,6 +245,10 @@ export class TikTokScraper {
   }
 
   async _ensurePage(slot) {
+    // 实例正在关闭/已关闭（restart 竞态）→ 抛可识别错误，webserver 返回 503 且不计连续错误
+    if (this.closing || !this.context) {
+      throw new Error("Server is shutting down");
+    }
     try {
       if (
         !slot.page.isClosed() &&
@@ -190,12 +264,38 @@ 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, {
-      waitUntil: "domcontentloaded",
-      timeout: 15000,
-    });
+    // 捕获导航期间最后一个 tiktok 响应的真实状态码：
+    // Chromium 的 ERR_HTTP_RESPONSE_CODE_FAILURE 不携带状态码，
+    // 通过 response 事件补齐，用于区分 403/429 风控与 404 不存在。
+    let lastStatus = null;
+    const onResponse = (resp) => {
+      try {
+        if (resp.url().includes("tiktok.com")) lastStatus = resp.status();
+      } catch {}
+    };
+    page.on("response", onResponse);
+
+    try {
+      await page.goto("view-source:" + url, {
+        waitUntil: "domcontentloaded",
+        timeout: 15000,
+      });
+    } catch (e) {
+      // goto 阶段失败（HTTP 非 2xx 等）拿不到 HTML，detectAccessDenied 没机会执行。
+      // 分类后抛出：风控类 → CDNBlockedError（走 webserver 冷却自愈而非浏览器重启）；
+      // 404 → TikTokStatusError（业务结果）；其余（ERR_ABORTED 等竞态）→ 原样冒泡。
+      const classified = classifyGotoError(e?.message, lastStatus);
+      if (classified) throw classified;
+      throw e;
+    } finally {
+      page.off("response", onResponse);
+    }
 
     const content = await page.evaluate(() => {
       const rows = document.querySelectorAll("tr");