tt-help-cli-ycl 1.4.139 → 1.4.142

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 = {
@@ -167,8 +251,8 @@ function recordRequest(success) {
   if (!success) recentErrors++;
   if (success) {
     consecutiveErrors = 0;
-    // 请求成功（含探活）→ 视为 CDN 已恢复，清除自愈状态
-    resetCdnRecovered();
+    // 注意：成功请求不影响 CDN 限流窗口计数（计数只由限流事件驱动，
+    // 由 handleCdnLimit 的 5 分钟窗口结算清零），避免交错限流下被反复打回。
   }
 }
 
@@ -211,67 +295,172 @@ async function restartScraper(reason) {
   }
 }
 
-// ---- CDN 限流自愈（冷却窗口 + 单次重启 + 躺平）----
-// 首次限流 → 进入冷却期，期间业务请求直接 503（让 IP 静默冷却，Akamai 窗口自动解除）；
-// 冷却期满后由下一个请求"探活"：成功 → 恢复；仍限流 → 重启一次 scraper 再冷却；
-// 重启后再限流 → 判定 IP/账号级，躺平（不再自动重启，持续 503 靠 nginx failover + 人工换 IP）。
+// ---- 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 cdnRestartedThisWindow = false; // 最近一个冷却窗口是否已执行过重启
-let cdnGiveUp = false; // 判定 IP/账号级，躺平不再自动重启
-let CDN_COOLDOWN_MS = 180000; // 冷却时长，默认 3 分钟（可被 startWebserver 覆盖）
+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() {
+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;
 }
 
-// 成功恢复：清空自愈状态，下次限流重新走完整流程
-function resetCdnRecovered() {
-  cdnCooling = false;
-  cdnCooldownUntil = 0;
-  cdnRestartedThisWindow = false;
-  cdnGiveUp = false;
+/**
+ * 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) return;
+  if (cdnGiveUp || cdnSwitching) 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，到期后探活`,
-    );
+
+  // 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 (!cdnRestartedThisWindow) {
-    cdnRestartedThisWindow = true;
-    console.error(
-      `[webserver] 冷却期后仍 CDN 限流，第 1 次重启 scraper 并再次冷却...`,
-    );
-    restartScraper("CDN 限流冷却后仍限流").catch(() => {});
-    startCdnCooldown();
-  } else {
-    cdnGiveUp = true;
-    console.error(
-      `[webserver] 冷却+重启后仍 CDN 限流，判定 IP/账号级，躺平不再自动重启（需人工换 IP/代理）`,
-    );
+
+  // 本次限流计一个窗口
+  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();
   }
 }
 
@@ -312,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}%)`,
   );
 }
 
@@ -543,6 +741,7 @@ async function notifyCaptchaToWatch(url, maxRetries = 3) {
             "TikTok Shop captcha detected, browser opened - manual intervention required",
           stage: "product_info",
           errorStack: url,
+          hostname: os.hostname(),
         }),
       });
       console.error("[webserver] Captcha alert sent to watch server");
@@ -641,7 +840,7 @@ export async function startWebserver(
   enableLog = false,
   requestRatePerSecond = 0,
   requestBurst = 8,
-  cdnCooldownSec = 180,
+  cdnCooldownSec = 100,
 ) {
   if (poolSize > 0) {
     SCRAPER_CONFIG.poolSize = poolSize;
@@ -663,7 +862,7 @@ export async function startWebserver(
   } else {
     SCRAPER_CONFIG.requestBurst = SCRAPER_CONFIG.poolSize;
   }
-  // CDN 冷却时长：优先 CLI 传入（秒）> 环境变量 WEBSERVER_CDN_COOLDOWN_MS（毫秒）> 默认 180s
+  // CDN 冷却时长：优先 CLI 传入（秒）> 环境变量 WEBSERVER_CDN_COOLDOWN_MS（毫秒）> 默认 100s
   const envCooldownMs =
     parseInt(process.env.WEBSERVER_CDN_COOLDOWN_MS || "0", 10) || 0;
   if (cdnCooldownSec > 0) {
@@ -671,7 +870,7 @@ export async function startWebserver(
   } else if (envCooldownMs > 0) {
     CDN_COOLDOWN_MS = envCooldownMs;
   } else {
-    CDN_COOLDOWN_MS = 180000;
+    CDN_COOLDOWN_MS = 100000;
   }
   const server = http.createServer(async (req, res) => {
     const url = new URL(req.url, `http://127.0.0.1:${port}`);
@@ -715,47 +914,27 @@ export async function startWebserver(
     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);
         // 触发自愈：冷却 → 到期探活 → 仍限流则单次重启 → 再限流则躺平
         handleCdnLimit();
-      } else if (e.message?.includes("Server is shutting down")) {
-        // 服务正在关闭 → 503
-        status = 503;
-        retryable = true;
+      } 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}`);
       }
@@ -765,10 +944,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(
@@ -792,6 +973,9 @@ export async function startWebserver(
   // 启动健康心跳日志（每 10 分钟一行，防假死误判）
   startHealthTimer();
 
+  // 启动前清理端口占用（旧孤儿 webserver 等直接杀掉），避免 EADDRINUSE
+  await killListeningOnPort(port);
+
   return new Promise((resolve, reject) => {
     server.listen(port, () => {
       const localIP = getLocalIP();