tt-help-cli-ycl 1.4.136 → 1.4.140

package/src/webserver/server.mjs

@@ -3,6 +3,13 @@ import os from "os";
 import { TikTokScraper } from "../lib/tiktok-scraper.mjs";
 import { getProductInfo } from "../lib/shop-scraper.mjs";
 import { userId as configUserId } from "../lib/constants.js";
+import { killListeningOnPort } from "../lib/port.js";
+import {
+  getCurrentNode,
+  listGroupNodes,
+  getProxyDelay,
+  switchProxy,
+} from "../clash/api.js";
 
 // ---- 工具函数 ----
 
@@ -64,6 +71,83 @@ function readBody(req) {
   });
 }
 
+/**
+ * 请求错误分类，返回 { kind, status, retryable, countConsecutive }。
+ * countConsecutive=false 的错误不会累计 consecutiveErrors（不会触发浏览器重启）：
+ * - cdn：IP/节点被 TikTok 风控，重启 scraper 无效 → 走 CDN 冷却自愈链路
+ * - shutdown：服务关闭中（restart 竞态）→ 503，等待/重试即可
+ * - browser：浏览器/页面崩溃或重启竞态产物（Target closed / ERR_ABORTED /
+ *   newPage null 等）。竞态产物本身是重启的结果而非原因，若计入连续错误会
+ *   形成"重启→竞态错误→再重启"的死亡螺旋，故不计。
+ * - timeout/unknown：真实故障 → 计入，达阈值触发重启。
+ */
+export function classifyError(e) {
+  const msg = e?.message || "";
+  if (e?.name === "CDNBlockedError") {
+    return {
+      kind: "cdn",
+      status: 503,
+      retryable: true,
+      countConsecutive: false,
+    };
+  }
+  if (e?.name === "TikTokStatusError" && e?.statusCode) {
+    // TikTok 明确 HTTP 状态码（404 不存在等）：业务结果，返回 200 带 statusCode，
+    // 不计连续错误、不触发重启、nginx 不 failover（与 handleTiktokUser 业务结果一致）
+    return {
+      kind: "business",
+      status: 200,
+      retryable: false,
+      countConsecutive: false,
+      statusCode: e.statusCode,
+    };
+  }
+  if (msg.includes("Server is shutting down")) {
+    return {
+      kind: "shutdown",
+      status: 503,
+      retryable: true,
+      countConsecutive: false,
+    };
+  }
+  if (
+    msg.includes("Timeout") ||
+    msg.includes("timeout") ||
+    e?.name === "TimeoutError"
+  ) {
+    return {
+      kind: "timeout",
+      status: 504,
+      retryable: true,
+      countConsecutive: true,
+    };
+  }
+  if (
+    msg.includes("Protocol error") ||
+    msg.includes("Target closed") ||
+    msg.includes("Browser closed") ||
+    msg.includes("Session closed") ||
+    msg.includes("has been closed") ||
+    msg.includes("ERR_ABORTED") ||
+    msg.includes("frame was detached") ||
+    msg.includes("Execution context was destroyed") ||
+    msg.includes("Cannot read properties of null")
+  ) {
+    return {
+      kind: "browser",
+      status: 503,
+      retryable: true,
+      countConsecutive: false,
+    };
+  }
+  return {
+    kind: "unknown",
+    status: 500,
+    retryable: false,
+    countConsecutive: true,
+  };
+}
+
 // ---- Scraper 生命周期 ----
 
 const SCRAPER_CONFIG = {
@@ -71,6 +155,8 @@ const SCRAPER_CONFIG = {
   wafTTL: 120000,
   maxRequestsPerPage: 50,
   proxyServer: null,
+  requestRatePerSecond: 0, // 0 = 不限制对 TikTok 的请求速率（默认安全值由 CLI 注入）
+  requestBurst: 8,
   captchaNotifyUrl: null,
   enableLog: false,
 };
@@ -121,6 +207,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 +249,11 @@ function recordRequest(success) {
   }
   recentTotal++;
   if (!success) recentErrors++;
-  if (success) consecutiveErrors = 0;
+  if (success) {
+    consecutiveErrors = 0;
+    // 注意：成功请求不影响 CDN 限流窗口计数（计数只由限流事件驱动，
+    // 由 handleCdnLimit 的 5 分钟窗口结算清零），避免交错限流下被反复打回。
+  }
 }
 
 function isDegraded() {
@@ -181,6 +279,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 +295,175 @@ async function restartScraper(reason) {
   }
 }
 
+// ---- CDN 限流自愈（限流窗口计数 + 5 分钟结算 + 切节点 + 躺平）----
+// 模型（用户定稿）：只数"限流窗口"，成功请求完全不参与计数。
+// 每次限流（403/429）→ 计一个限流窗口 + 进入 100s 冷却（静默，请求直接 503）；
+// 5 分钟窗口内累计 2 个限流窗口 → 立即切换 Clash 节点；
+// 窗口到期（距第一个限流窗口超过 5 分钟）时结算：限流窗口 ≥2 → 切换并重新计数；<2 → 重新计数。
+// 切节点成功 → 重新计数；连切 CDN_MAX_SWITCHES 个节点仍限流 → 躺平（持续 503 靠 nginx failover）。
+let cdnCooling = false; // 当前是否处于冷却静默期
+let cdnCooldownUntil = 0; // 冷却结束时间戳；0 = 从未进入冷却
+let cdnCooldownCount = 0; // 5 分钟窗口内累计的限流窗口数
+let cdnWindowStartAt = 0; // 当前 5 分钟窗口起点（第一个限流窗口的时间戳）；0 = 无窗口
+let cdnSwitchCount = 0; // 累计切换节点次数（防无限切节点循环）
+let cdnSwitching = false; // 节点切换进行中（防重入）
+let cdnGiveUp = false; // 判定 IP/账号级，躺平不再自动动作
+let CDN_COOLDOWN_MS = 100000; // 单次冷却时长，默认 100 秒（可被 startWebserver 覆盖）
+const CDN_SWITCH_COOLDOWN_COUNT = 2; // 5 分钟窗口内限流窗口数阈值，达到即切换节点
+const CDN_SWITCH_WINDOW_MS = 5 * 60 * 1000; // 统计窗口：5 分钟
+const CDN_MAX_SWITCHES = 3; // 连续切换节点次数上限，超过躺平
+const CLASH_GROUP_NAME = "GLOBAL"; // Clash 选择器组名（与 clash/checker.js CONFIG 一致）
+
+/**
+ * 5 分钟窗口结算（纯函数，便于单测）：
+ * - 窗口未到期 → 原样返回
+ * - 窗口到期且限流窗口数 ≥ 阈值 → 应切换，并重新计数
+ * - 窗口到期但未达阈值 → 重新计数（重新计算）
+ */
+export function settleCooldownWindow(
+  count,
+  windowStartAt,
+  now,
+  windowMs,
+  threshold,
+) {
+  if (windowStartAt && now - windowStartAt > windowMs) {
+    if (count >= threshold) {
+      return { shouldSwitch: true, count: 0, windowStartAt: 0 };
+    }
+    return { shouldSwitch: false, count: 0, windowStartAt: 0 };
+  }
+  return { shouldSwitch: false, count, windowStartAt };
+}
+
+function startCdnCooldown(reason = "") {
+  cdnCooling = true;
+  cdnCooldownUntil = Date.now() + CDN_COOLDOWN_MS;
+  console.error(
+    `[webserver] CDN 冷却开始${reason ? ` (${reason})` : ""}：持续 ${Math.round(CDN_COOLDOWN_MS / 1000)}s，期间请求直接 503`,
+  );
+}
+
+// 冷却期是否生效；到期后自动解除静默
+function shouldFailFast() {
+  if (cdnGiveUp) return false; // 躺平后不再拦截，让请求尝试（成功即可自然恢复）
+  if (cdnSwitching) return true; // 切节点期间直接 503，避免继续打风控节点
+  if (!cdnCooling) return false;
+  if (Date.now() >= cdnCooldownUntil) {
+    cdnCooling = false; // 冷却期满，解除静默
+    console.error(
+      `[webserver] CDN 冷却期满，解除静默（限流窗口累计 ${cdnCooldownCount}/${CDN_SWITCH_COOLDOWN_COUNT}）`,
+    );
+    return false;
+  }
+  return true;
+}
+
+/**
+ * webserver 自己发起的节点 fallback：切换 Clash 组到第一个 delay 探测通过的候选节点。
+ * 由 CDN 自愈状态机在"5 分钟内累计 2 个完整限流窗口"后调用，不依赖看门狗/daemon。
+ */
+export async function switchClashNode(reason) {
+  const current = await getCurrentNode(CLASH_GROUP_NAME).catch(() => "?");
+  const nodes = await listGroupNodes(CLASH_GROUP_NAME);
+  const candidates = nodes.filter((n) => n !== current);
+  if (!candidates.length) {
+    throw new Error(
+      `切节点失败：组 ${CLASH_GROUP_NAME} 无候选节点 (当前 ${current})`,
+    );
+  }
+  for (const cand of candidates) {
+    const d = await getProxyDelay(cand, "https://www.tiktok.com", 5000);
+    if (d.delay > 0 && !d.timeout) {
+      await switchProxy(CLASH_GROUP_NAME, cand);
+      console.error(
+        `[webserver] 已切换 Clash 节点: ${current} → ${cand} (delay=${d.delay}ms) [${reason}]`,
+      );
+      return cand;
+    }
+    console.error(
+      `[webserver] 候选节点探测不通，跳过: ${cand} (delay=${d.delay}ms)`,
+    );
+  }
+  throw new Error(`切节点失败：${candidates.length} 个候选均探测不通`);
+}
+
+// 触发切换 Clash 节点（防重入；连切上限；成功重置计数）
+function startCdnSwitch() {
+  if (cdnSwitching || cdnGiveUp) return;
+  if (cdnSwitchCount >= CDN_MAX_SWITCHES) {
+    cdnGiveUp = true;
+    console.error(
+      `[webserver] 已连切 ${cdnSwitchCount} 个节点仍 CDN 限流，躺平不再自动动作（需人工处理）`,
+    );
+    return;
+  }
+  console.error(
+    `[webserver] 触发切换节点: 限流窗口 ${cdnCooldownCount}/${CDN_SWITCH_COOLDOWN_COUNT} 个，开始第 ${cdnSwitchCount + 1}/${CDN_MAX_SWITCHES} 次切节点...`,
+  );
+  cdnSwitching = true;
+  cdnSwitchCount++;
+  switchClashNode(
+    `5 分钟内累计 ${cdnCooldownCount} 个完整限流窗口，触发第 ${cdnSwitchCount} 次切节点`,
+  )
+    .then((node) => {
+      // 切换成功：重新计数（窗口起点与限流窗口数都清零），新节点重新累计
+      cdnCooldownCount = 0;
+      cdnWindowStartAt = 0;
+      consecutiveErrors = 0;
+      console.error(
+        `[webserver] 节点切换完成 (${node})，重新计数，进入冷却观察新节点`,
+      );
+    })
+    .catch((e) => {
+      cdnGiveUp = true;
+      console.error(`[webserver] 切节点失败，躺平: ${e.message}`);
+    })
+    .finally(() => {
+      cdnSwitching = false;
+      if (!cdnGiveUp) {
+        startCdnCooldown("观察新节点");
+      }
+    });
+}
+
+// 处理一次 CDN 限流（在 isCdnBlocked 分支调用）
+function handleCdnLimit() {
+  if (cdnGiveUp || cdnSwitching) return;
+  const now = Date.now();
+  // 冷却窗口未到期（含并发到达）：持续静默，不重复计数
+  if (cdnCooling && now < cdnCooldownUntil) return;
+
+  // 5 分钟窗口结算：距窗口起点超过 5 分钟 → 检查是否达标
+  const settled = settleCooldownWindow(
+    cdnCooldownCount,
+    cdnWindowStartAt,
+    now,
+    CDN_SWITCH_WINDOW_MS,
+    CDN_SWITCH_COOLDOWN_COUNT,
+  );
+  cdnCooldownCount = settled.count;
+  cdnWindowStartAt = settled.windowStartAt;
+  if (settled.shouldSwitch) {
+    console.error(`[webserver] 5 分钟窗口到期，限流窗口数达标，触发切换节点`);
+    startCdnSwitch();
+    return;
+  }
+
+  // 本次限流计一个窗口
+  if (cdnCooldownCount === 0) cdnWindowStartAt = now;
+  cdnCooldownCount++;
+  startCdnCooldown(`限流窗口 ${cdnCooldownCount}/${CDN_SWITCH_COOLDOWN_COUNT}`);
+  console.error(
+    `[webserver] 触发 CDN 限流自愈：限流窗口 ${cdnCooldownCount}/${CDN_SWITCH_COOLDOWN_COUNT} 个（5 分钟窗口），进入冷却`,
+  );
+
+  // 窗口内攒够阈值 → 立即切换
+  if (cdnCooldownCount >= CDN_SWITCH_COOLDOWN_COUNT) {
+    startCdnSwitch();
+  }
+}
+
 async function warmScraper() {
   if (scraperClosing || !scraperInstance) return;
   const now = Date.now();
@@ -227,8 +501,17 @@ function logHealth() {
   const scraperState = scraperInstance && !scraperClosing ? "运行中" : "未就绪";
   const windowRate =
     recentTotal > 0 ? Math.round((recentErrors / recentTotal) * 100) : 0;
+  const cdnState = cdnGiveUp
+    ? "躺平"
+    : cdnSwitching
+      ? "切节点中"
+      : cdnCooling
+        ? `冷却中(窗口${cdnCooldownCount}/${CDN_SWITCH_COOLDOWN_COUNT})`
+        : cdnCooldownCount > 0
+          ? `窗口累计${cdnCooldownCount}/${CDN_SWITCH_COOLDOWN_COUNT}`
+          : "正常";
   console.error(
-    `[webserver] 健康: scraper=${scraperState} | 连续错误=${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS} | 近1min=${recentErrors}/${recentTotal} (${windowRate}%)`,
+    `[webserver] 健康: scraper=${scraperState} | CDN=${cdnState} | 连续错误=${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS} | 近1min=${recentErrors}/${recentTotal} (${windowRate}%)`,
   );
 }
 
@@ -519,6 +802,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 +837,9 @@ export async function startWebserver(
   proxyServer = null,
   captchaNotifyUrl = null,
   enableLog = false,
+  requestRatePerSecond = 0,
+  requestBurst = 8,
+  cdnCooldownSec = 100,
 ) {
   if (poolSize > 0) {
     SCRAPER_CONFIG.poolSize = poolSize;
@@ -560,6 +851,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（毫秒）> 默认 100s
+  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 = 100000;
+  }
   const server = http.createServer(async (req, res) => {
     const url = new URL(req.url, `http://127.0.0.1:${port}`);
 
@@ -582,48 +893,47 @@ 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) {
-      // 错误分类：CDN 限流是环境问题（代理/IP 被 TikTok CDN 拦截），重启 scraper 无法解决，
-      // 故不累计 consecutiveErrors、不触发重启；但仍计入 recentErrors（/health 展示错误率）。
-      const isCdnBlocked = e.name === "CDNBlockedError";
-      if (!isCdnBlocked) consecutiveErrors++;
+      // 错误分类（详见 classifyError）：
+      // - cdn/shutdown/browser（含重启竞态产物）不计 consecutiveErrors，不触发重启；
+      //   否则会形成"重启→竞态错误→再重启"的死亡螺旋，且重启对 IP 风控无效。
+      // - timeout/unknown 才算真实故障，累计达阈值才触发 scraper 重启。
+      const cls = classifyError(e);
+      if (cls.countConsecutive) consecutiveErrors++;
       recordRequest(false);
 
-      // 区分错误类型，返回正确的 HTTP 状态码供 nginx 判断
-      let status = 500;
-      let retryable = false;
-
-      if (isCdnBlocked) {
-        // CDN 限流（Akamai Access Denied）→ 503 临时不可用（节点级，nginx 可 failover 到其他节点）
-        status = 503;
-        retryable = true;
+      if (cls.kind === "cdn") {
+        // CDN 限流（Akamai Access Denied / goto 非2xx）→ 503 临时不可用（节点级，nginx 可 failover）
         logErrorThrottled("request CDN限流", e.message);
-      } else if (e.message?.includes("Server is shutting down")) {
-        // 服务正在关闭 → 503
-        status = 503;
-        retryable = true;
+        // 触发自愈：冷却 → 到期探活 → 仍限流则单次重启 → 再限流则躺平
+        handleCdnLimit();
+      } else if (cls.kind === "shutdown") {
         console.error(`[webserver] request 服务关闭中: ${e.message}`);
-      } else if (
-        e.message?.includes("Timeout") ||
-        e.message?.includes("timeout") ||
-        e.name === "TimeoutError"
-      ) {
-        // 超时 → 504
-        status = 504;
-        retryable = true;
+      } else if (cls.kind === "timeout") {
         console.error(`[webserver] request 超时: ${e.message}`);
-      } else if (
-        e.message?.includes("Protocol error") ||
-        e.message?.includes("Target closed") ||
-        e.message?.includes("Browser closed") ||
-        e.message?.includes("Session closed")
-      ) {
-        // 浏览器/页面崩溃 → 503
-        status = 503;
-        retryable = true;
+      } else if (cls.kind === "browser") {
         console.error(`[webserver] request 浏览器异常: ${e.message}`);
+      } else if (cls.kind === "business") {
+        logErrorThrottled("request 业务状态码", e.message);
       } else {
         console.error(`[webserver] request 未知错误: ${e.message}`);
       }
@@ -633,10 +943,12 @@ export async function startWebserver(
       }
 
       if (!res.headersSent) {
-        return sendJSON(res, status, {
-          error: e.message,
-          retryable,
-        });
+        const payload = { error: e.message, retryable: cls.retryable };
+        if (cls.statusCode) {
+          payload.statusCode = cls.statusCode;
+          payload.tiktokStatusCode = cls.statusCode;
+        }
+        return sendJSON(res, cls.status, payload);
       }
       // 响应已发送（流式等场景），记录日志并销毁 socket
       console.error(
@@ -660,6 +972,9 @@ export async function startWebserver(
   // 启动健康心跳日志（每 10 分钟一行，防假死误判）
   startHealthTimer();
 
+  // 启动前清理端口占用（旧孤儿 webserver 等直接杀掉），避免 EADDRINUSE
+  await killListeningOnPort(port);
+
   return new Promise((resolve, reject) => {
     server.listen(port, () => {
       const localIP = getLocalIP();