tt-help-cli-ycl 1.4.169 → 1.4.171

package/src/watch/watchdog-server.js

@@ -19,6 +19,17 @@ import {
 } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+import {
+  initSubscriptionCenter,
+  ensureWorker,
+  getSubscriptionView,
+  ingestNodeReport,
+  addSubscription,
+  updateSubscription,
+  deleteSubscription,
+  probeSubscription,
+} from "./subscription-center.js";
+import { reconcileAutoAlloc, ALLOC_MAX_INSTANCES } from "./subscription-allocator.js";
 
 const homeDir = homedir() || process.env.HOME || process.env.USERPROFILE || "";
 const WATCHDOG_CONFIG_PATH = join(homeDir, ".tt-help-watchdog.json");
@@ -44,6 +55,9 @@ const LLM_CACHE_TTL = 15 * 60 * 1000; // 15 分钟过期
 // 看门狗客户端下次心跳时取走，取走后清空
 const clashCmdQueue = new Map();
 
+// 登录检测手动重检队列：clientId → true（后台页面点「重检」下发，随心跳取走即清空，一次性）
+const loginRecheckQueue = new Map();
+
 // 国家过滤配置幂等下发记录：userId → JSON.stringify(countries)
 // 仅当配置变化时才入队，避免每次心跳都触发 daemon 刷新候选集
 const lastSentCountries = new Map();
@@ -495,6 +509,22 @@ async function handleHeartbeat(params, body, res) {
   // 按 userId 返回该客户端的专属命令列表（先处理到点自动恢复）
   const userId = (body.config && body.config.userId) || "";
   autoResumeCommands(userId);
+
+  // 订阅中心: 被动采集节点上报的 provider 快照（探测 worker 的兜底数据源）+ 惰性启动 worker
+  // （单写者: worker 只在接收心跳的进程运行，见 subscription-center.js 头注释）
+  try {
+    ingestNodeReport(userId, body.clashHealth || null, body.clashHealthChannels || []);
+    ensureWorker();
+  } catch (e) {
+    console.error(`[watchdog] 订阅中心采集异常: ${e.message}`);
+  }
+  // 订阅自动分配（Phase 2）: auto 模式节点惰性重算 alloc，变化才写回；
+  // 必须在下方构造响应（读取 proxySettings）之前执行，同一个心跳就把新 alloc 下发
+  try {
+    reconcileAutoAlloc(userId);
+  } catch (e) {
+    console.error(`[watchdog] 订阅自动分配异常: ${e.message}`);
+  }
   const commands = getClientCommands(userId);
 
   // 幂等下发节点国家配置（默认 US）
@@ -524,6 +554,10 @@ async function handleHeartbeat(params, body, res) {
   );
   if (logReqQueue.has(clientId)) logReqQueue.delete(clientId);
 
+  // 取出待下发的登录重检请求（一次性，取走即清空）
+  const loginRecheck = loginRecheckQueue.get(clientId) || false;
+  if (loginRecheck) loginRecheckQueue.delete(clientId);
+
   const ts = new Date().toLocaleTimeString("zh-CN", { hour12: false });
   console.error(
     `[watchdog ${ts}] 心跳: ${clientId} (${body.hostname || "?"}, user=${userId || "?"}) ${body.processes?.length || 0}进程, 返回${commands.length}条命令${clashCommands.length ? ", " + clashCommands.length + "条Clash命令" : ""}`,
@@ -540,6 +574,7 @@ async function handleHeartbeat(params, body, res) {
     proxySettings: getProxySettingsStored(userId),
     autoUpgrade: getAutoUpgradeStored(userId),
     loginPorts: getLoginPortsStored(userId),
+    loginRecheck: loginRecheck || undefined,
     serverTime: Date.now(),
   });
 }
@@ -558,9 +593,56 @@ async function handleGetClients(params, body, res) {
     autoUpgrades: getAllAutoUpgrades(),
     loginPorts: getAllLoginPorts(),
     configPath: WATCHDOG_CONFIG_PATH,
+    // 订阅中心视图（探测/代报快照 + 状态推导 + 引用关系；独立文件，读多写少）
+    subscriptions: getSubscriptionViewSafe(),
   });
 }
 
+function getSubscriptionViewSafe() {
+  try {
+    return getSubscriptionView();
+  } catch (e) {
+    console.error(`[watchdog] 订阅视图构建失败: ${e.message}`);
+    return [];
+  }
+}
+
+// ── 订阅中心 API（Phase 1: 池子 CRUD + 主动探测 + 只读引用展示，不改任何节点行为） ──
+
+async function handleSubscriptionsList(params, body, res) {
+  sendJSON(res, 200, { ok: true, subscriptions: getSubscriptionViewSafe() });
+}
+
+async function handleSubscriptionsAdd(params, body, res) {
+  const r = addSubscription(body || {});
+  sendJSON(res, r.ok ? 200 : 400, r);
+}
+
+async function handleSubscriptionsUpdate(params, body, res) {
+  const r = updateSubscription(body || {});
+  sendJSON(res, r.ok ? 200 : 400, r);
+}
+
+async function handleSubscriptionsDelete(params, body, res) {
+  const r = deleteSubscription((body || {}).id, { force: !!(body || {}).force });
+  sendJSON(res, r.ok ? 200 : r.needForce ? 409 : 400, r);
+}
+
+async function handleSubscriptionsProbe(params, body, res) {
+  const id = (body || {}).id;
+  if (!id) {
+    sendJSON(res, 400, { ok: false, error: "缺少 id" });
+    return;
+  }
+  const r = await probeSubscription(id, { manual: true });
+  if (r.ok) {
+    const view = getSubscriptionViewSafe().find((s) => s.id === id) || null;
+    sendJSON(res, 200, { ok: true, subscription: view });
+  } else {
+    sendJSON(res, 400, r);
+  }
+}
+
 // ── 按需日志拉取（点"日志"按钮 → 入队 → 心跳下发 → 客户端回传 → 覆盖写盘） ──
 
 /** 后台页面请求某客户端日志：请求入队，等该客户端下次心跳取走 */
@@ -836,6 +918,7 @@ async function handleSetErrorTrigger(params, body, res) {
  * 允许同一订阅地址配置多行（每行一个独立实例，可各自使用不同节点）
  * 上限 8 条: 与 discover.js RUNTIME_MAX_INSTANCES=8 对齐（第 9 条实例端口会超出
  * 巡检枚举段 9097-9104，永远进不了 daemon 巡检列表）
+ * 手动模式语义: 整体覆写（无 mode 字段）——存量 auto 节点在此编辑列表即回到手动模式
  */
 async function handleSetProxySettings(params, body, res) {
   const { userId, subscriptions } = body || {};
@@ -866,6 +949,86 @@ async function handleSetProxySettings(params, body, res) {
   sendJSON(res, 200, { ok: true, subscriptions: cleaned });
 }
 
+/**
+ * 订阅自动分配（Phase 2）: 切换/配置 auto 模式。
+ * 迁移 = 方案 A: 存量手动列表原样转成 alloc（count 默认 = 现状条数），
+ * 切换瞬间分配结果 = 现状节点无感；之后心跳惰性重算（死订阅换血/跨机器摊开）。
+ * 已在 auto 模式时传 count = 调整数量（粘性重分配，砍尾部/补尾部）。
+ */
+async function handleSetProxyAuto(params, body, res) {
+  const { userId, count } = body || {};
+  if (!userId) {
+    sendJSON(res, 400, { error: "缺少 userId" });
+    return;
+  }
+  const cur = getProxySettingsStored(userId);
+  const curList =
+    cur && Array.isArray(cur.subscriptions)
+      ? cur.subscriptions.filter((s) => s && (typeof s === "string" || s.url))
+      : [];
+  let n;
+  let capped = false;
+  if (count !== undefined && count !== null && count !== "") {
+    n = parseInt(count, 10);
+    if (!Number.isInteger(n) || n <= 0) {
+      sendJSON(res, 400, { error: "count 须为正整数" });
+      return;
+    }
+    if (n > ALLOC_MAX_INSTANCES) {
+      n = ALLOC_MAX_INSTANCES; // 超上限截断 + 标红（实例端口段只有 8 个）
+      capped = true;
+    }
+  } else {
+    // 迁移 Plan A: count = 现状条数（切换瞬间分配 = 现状，节点无感）
+    n = Math.min(Math.max(1, curList.length || 1), ALLOC_MAX_INSTANCES);
+    capped = curList.length > ALLOC_MAX_INSTANCES;
+  }
+  setProxySettingsStored(userId, {
+    mode: "auto",
+    count: n,
+    subscriptions: curList.slice(0, n).map((s) =>
+      typeof s === "string" ? { name: "", url: s } : { name: s.name || "", url: s.url },
+    ),
+    // count-capped 由 countCapped 标志持久化（落盘 count 已截断为 8，若按 count>MAX
+    // 判断，下轮 reconcile 会立刻丢失标红）
+    countCapped: capped ? true : undefined,
+    allocWarn: capped ? "count-capped" : null,
+    allocatedAt: Date.now(),
+    updatedAt: new Date().toISOString(),
+  });
+  // 立即跑一遍分配器（死订阅换血/从池子补齐），客户端经下个心跳拿到
+  let reconciled = null;
+  try {
+    reconciled = reconcileAutoAlloc(userId);
+  } catch (e) {
+    console.error(`[watchdog] 订阅自动分配异常: ${e.message}`);
+  }
+  const ts = new Date().toLocaleTimeString("zh-CN", { hour12: false });
+  console.error(
+    `[watchdog ${ts}] ${userId} 订阅切换为自动分配: count=${n}${capped ? `（超上限截断为 ${ALLOC_MAX_INSTANCES}）` : ""}`,
+  );
+  sendJSON(res, 200, {
+    ok: true,
+    proxySettings: getProxySettingsStored(userId),
+    changed: !!(reconciled && reconciled.changed),
+  });
+}
+
+/** 切回手动模式: 丢弃 mode/count/allocWarn，当前 alloc 原样变成手动列表（分配器不再触碰） */
+async function handleSetProxyManual(params, body, res) {
+  const { userId } = body || {};
+  if (!userId) {
+    sendJSON(res, 400, { error: "缺少 userId" });
+    return;
+  }
+  const cur = getProxySettingsStored(userId);
+  const list = cur && Array.isArray(cur.subscriptions) ? cur.subscriptions : [];
+  setProxySettingsStored(userId, { subscriptions: list });
+  const ts = new Date().toLocaleTimeString("zh-CN", { hour12: false });
+  console.error(`[watchdog ${ts}] ${userId} 订阅切换为手动模式: ${list.length} 条`);
+  sendJSON(res, 200, { ok: true, proxySettings: { subscriptions: list } });
+}
+
 /** 配置某 agent 的代理切换重启（代理切换后强制重启全部命令；默认不启用） */
 async function handleSetSwitchRestart(params, body, res) {
   const { userId, config } = body || {};
@@ -942,6 +1105,19 @@ async function handleSetLoginPorts(params, body, res) {
   });
 }
 
+/** 后台页面手动触发某客户端立即重检一次登录状态（一次性队列随心跳下发，无冷却限频） */
+async function handleRecheckLogin(params, body, res) {
+  const { clientId } = body || {};
+  if (!clientId || !clients.has(clientId)) {
+    sendJSON(res, 400, { error: "clientId 不存在或客户端未连接" });
+    return;
+  }
+  loginRecheckQueue.set(clientId, true);
+  const ts = new Date().toLocaleTimeString("zh-CN", { hour12: false });
+  console.error(`[watchdog ${ts}] 登录重检请求: clientId=${clientId}`);
+  sendJSON(res, 200, { ok: true, message: "已下发重检，客户端下次心跳时执行" });
+}
+
 // ── 公开 ──
 
 export function registerWatchdogRoutes(httpServer) {
@@ -950,6 +1126,8 @@ export function registerWatchdogRoutes(httpServer) {
   console.error(`[watchdog] 日志目录: ${LOGS_DIR}`);
   // 自动迁移：为已有命令补充唯一 ID
   migrateCommandIds();
+  // 订阅中心: 仅加载订阅池（worker 由心跳惰性启动，保证单进程探测）
+  initSubscriptionCenter();
 }
 
 // 为现有命令中未分配 ID 的自动补充 ID
@@ -1028,6 +1206,14 @@ export async function tryHandleWatchdogRoute(
     await handleSetProxySettings(params, body, res);
     return true;
   }
+  if (method === "POST" && routePath === "/api/watchdog/set-proxy-auto") {
+    await handleSetProxyAuto(params, body, res);
+    return true;
+  }
+  if (method === "POST" && routePath === "/api/watchdog/set-proxy-manual") {
+    await handleSetProxyManual(params, body, res);
+    return true;
+  }
   if (method === "POST" && routePath === "/api/watchdog/set-auto-upgrade") {
     await handleSetAutoUpgrade(params, body, res);
     return true;
@@ -1036,6 +1222,10 @@ export async function tryHandleWatchdogRoute(
     await handleSetLoginPorts(params, body, res);
     return true;
   }
+  if (method === "POST" && routePath === "/api/watchdog/recheck-login") {
+    await handleRecheckLogin(params, body, res);
+    return true;
+  }
   if (method === "POST" && routePath === "/api/watchdog/request-logs") {
     await handleRequestLogs(params, body, res);
     return true;
@@ -1044,6 +1234,26 @@ export async function tryHandleWatchdogRoute(
     await handleReportLogs(params, body, res);
     return true;
   }
+  if (method === "GET" && routePath === "/api/watchdog/subscriptions") {
+    await handleSubscriptionsList(params, body, res);
+    return true;
+  }
+  if (method === "POST" && routePath === "/api/watchdog/subscriptions") {
+    await handleSubscriptionsAdd(params, body, res);
+    return true;
+  }
+  if (method === "POST" && routePath === "/api/watchdog/subscriptions/update") {
+    await handleSubscriptionsUpdate(params, body, res);
+    return true;
+  }
+  if (method === "POST" && routePath === "/api/watchdog/subscriptions/delete") {
+    await handleSubscriptionsDelete(params, body, res);
+    return true;
+  }
+  if (method === "POST" && routePath === "/api/watchdog/subscriptions/probe") {
+    await handleSubscriptionsProbe(params, body, res);
+    return true;
+  }
   if (method === "GET" && routePath === "/api/watchdog/logs-file") {
     await handleGetLogsFile(params, body, res);
     return true;

package/src/watchdog/agent.js

@@ -915,6 +915,11 @@ export class WatchdogAgent {
           );
         }
       }
+      // 服务端下发「立即重检」：清零上次检测时间，60s 调度器下一跳即执行
+      if (data.loginRecheck) {
+        this._lastLoginCheckAt = 0;
+        console.error("[watchdog] 服务端下发登录重检，下一跳立即执行");
+      }
 
       // 心跳日志：仅状态变化或每 10 次打印一次
       this._heartbeatSeq++;

package/scripts/test-api-interceptor-429.mjs

@@ -1,122 +0,0 @@
-// 临时验证：fetchUserVideosAPI 对 HTTP 429 / ratelimit triggered 判定为"被封"
-// 运行：RM_BLOCKED_WAIT_MS=1 node scripts/test-api-interceptor-429.mjs
-import { fetchUserVideosAPI } from "../src/lib/api-interceptor.js";
-
-// 构造一个可被 waitForResponse 返回的 429 响应
-function make429Response() {
-  return {
-    url: () => "https://www.tiktok.com/api/post/item_list/?...",
-    status: () => 429,
-    headers: () => ({ "content-length": "19" }),
-    json: async () => {
-      throw new Error("Unexpected token 'r'...");
-    },
-    body: async () => Buffer.from("ratelimit triggered"),
-  };
-}
-
-// 构造一个正常响应（itemList 非空）
-function make200Response(username) {
-  const itemList = [
-    { id: "111", stats: { playCount: 1 }, isECVideo: 0, isAd: 0 },
-  ];
-  return {
-    url: () => "https://www.tiktok.com/api/post/item_list/?...",
-    status: () => 200,
-    headers: () => ({}),
-    json: async () => ({ itemList, cursor: 0, hasMore: false }),
-    body: async () => Buffer.from(JSON.stringify({ itemList })),
-    username,
-  };
-}
-
-// 构造 mock page：封禁场景时 waitForResponse 返回 429 响应
-function makePage(username, respFactory) {
-  const page = {
-    _handlers: {},
-    on(event, fn) {
-      (page._handlers[event] ||= []).push(fn);
-      return page;
-    },
-    off(event) {
-      delete page._handlers[event];
-      return page;
-    },
-    url: () => `https://www.tiktok.com/@${username}`,
-    goto: async () => {},
-    // checkCdpHealth 用 () => document.readyState（fn.length===0）→ 返回 "complete"；
-    // detectPageError 用 (patterns)=>...（fn.length===1）→ 返回 null（页面无错误文案）
-    evaluate: async (fn) => (fn.length === 1 ? null : "complete"),
-    reload: async () => {},
-    waitForFunction: async () => null,
-    waitForResponse: async (pred, opts) => {
-      const resp = respFactory();
-      if (!pred(resp)) throw new Error("response 不匹配 item_list");
-      return resp;
-    },
-  };
-  return page;
-}
-
-let pass = 0;
-let fail = 0;
-
-async function expectReject(name, fn, expectedMsg) {
-  try {
-    await fn();
-    fail++;
-    console.error(`✗ ${name}: 未抛错（期望 "${expectedMsg}"）`);
-  } catch (e) {
-    if (e.message === expectedMsg || e.message.includes(expectedMsg)) {
-      pass++;
-      console.log(`✓ ${name}: 抛错 "${e.message}"`);
-    } else {
-      fail++;
-      console.error(
-        `✗ ${name}: 抛错 "${e.message}"（期望含 "${expectedMsg}"）`,
-      );
-    }
-  }
-}
-
-async function expectResolve(name, fn) {
-  try {
-    const r = await fn();
-    if (r instanceof Map && r.size === 1) {
-      pass++;
-      console.log(`✓ ${name}: 正常返回 ${r.size} 个视频`);
-    } else {
-      fail++;
-      console.error(`✗ ${name}: 返回异常 ${JSON.stringify(r)}`);
-    }
-  } catch (e) {
-    fail++;
-    console.error(`✗ ${name}: 抛错 ${e.message}`);
-  }
-}
-
-// 用例1：429 + ratelimit triggered → 判定为"被封"
-await expectReject(
-  "HTTP 429 ratelimit triggered 判为被封",
-  () =>
-    fetchUserVideosAPI(
-      makePage("fumolbbf08o", make429Response),
-      "fumolbbf08o",
-      5,
-      () => {},
-    ),
-  "被封: fumolbbf08o",
-);
-
-// 用例2：正常 200 itemList → 不误判，正常返回视频
-await expectResolve("HTTP 200 正常 itemList 不被误伤", () =>
-  fetchUserVideosAPI(
-    makePage("fumolbbf08o", make200Response),
-    "fumolbbf08o",
-    5,
-    () => {},
-  ),
-);
-
-console.log(`\n结果: ${pass} 通过, ${fail} 失败`);
-process.exit(fail > 0 ? 1 : 0);

package/scripts/test-api-interceptor-captcha.mjs

@@ -1,176 +0,0 @@
-// 临时验证：被判重试期间弹出验证码 → fetchUserVideosAPI 立即抛 "验证码:"，不再空转重试
-// 运行：RM_BLOCKED_WAIT_MS=1 node scripts/test-api-interceptor-captcha.mjs
-import { fetchUserVideosAPI } from "../src/lib/api-interceptor.js";
-
-let pass = 0;
-let fail = 0;
-
-function check(name, ok, detail = "") {
-  if (ok) {
-    pass++;
-    console.log(`✓ ${name}${detail ? `: ${detail}` : ""}`);
-  } else {
-    fail++;
-    console.error(`✗ ${name}${detail ? `: ${detail}` : ""}`);
-  }
-}
-
-// 429 + 页面有验证码容器
-// captchaPhase 控制验证码何时出现：
-//   "instant"  → 首次检测时已渲染（进分支 5s 检测命中）
-//   "delayed"  → 首次检测时未渲染，进入重试等待后才出现（sleep 醒来后 3s 检测命中）
-//   "never"    → 不出现（走正常被封重试）
-function make429CaptchaPage(username, captchaPhase = "instant") {
-  let gotoCount = 0;
-  let captchaDelayElapsed = false;
-  const page = {
-    _handlers: {},
-    on(event, fn) {
-      (page._handlers[event] ||= []).push(fn);
-      return page;
-    },
-    off(event) {
-      delete page._handlers[event];
-      return page;
-    },
-    url: () => `https://www.tiktok.com/@${username}`,
-    goto: async () => {
-      gotoCount++;
-    },
-    // checkCdpHealth 用 () => document.readyState（fn.length===0）→ "complete"
-    // detectCaptcha/detectCaptchaWithWait 通过 captchaDelayElapsed 开关控制
-    _captchaVisible() {
-      if (captchaPhase === "never") return false;
-      if (captchaPhase === "instant") return true;
-      return captchaDelayElapsed; // delayed：等待后才可见
-    },
-    evaluate: async (fn) => {
-      if (
-        fn.toString().includes("captcha-verify-container") &&
-        page._captchaVisible()
-      ) {
-        return {
-          exists: true,
-          visible: true,
-          rect: { x: 0, y: 0, w: 100, h: 100 },
-        };
-      }
-      // detectPageError（fn.length===1）→ null
-      if (fn.length === 1) return null;
-      return "complete";
-    },
-    waitForFunction: async (fn, opts) => {
-      // 带等待检测：轮询语义——可见即返回 handle，否则等满 timeout 返回 null
-      const deadline = Date.now() + (opts?.timeout || 5000);
-      while (Date.now() < deadline) {
-        if (page._captchaVisible()) {
-          return { jsonValue: async () => true };
-        }
-        await new Promise((r) => setTimeout(r, 5));
-      }
-      return null;
-    },
-    reload: async () => {},
-    waitForResponse: async (pred) => {
-      const resp = {
-        url: () => "https://www.tiktok.com/api/post/item_list/?...",
-        status: () => 429,
-        headers: () => ({ "content-length": "19" }),
-        json: async () => {
-          throw new Error("Unexpected token 'r'...");
-        },
-        body: async () => Buffer.from("ratelimit triggered"),
-      };
-      if (!pred(resp)) throw new Error("response 不匹配 item_list");
-      return resp;
-    },
-    get gotoCount() {
-      return gotoCount;
-    },
-    // 测试钩子：标记 delayed 验证码已出现
-    _markCaptchaDelayed() {
-      captchaDelayElapsed = true;
-    },
-  };
-  return page;
-}
-
-// 用例1：429 + 验证码立即可见 → 首次检测命中，只 goto 1 次（无重试）
-{
-  const page = make429CaptchaPage("fumolbbf08o", "instant");
-  try {
-    await fetchUserVideosAPI(page, "fumolbbf08o", 5, () => {});
-    check("429+验证码(即时) 立即转验证码", false, "未抛错");
-  } catch (e) {
-    check(
-      "429+验证码(即时) 立即转验证码",
-      e.message === "验证码: fumolbbf08o",
-      `抛错 "${e.message}"`,
-    );
-  }
-  check(
-    "429+验证码(即时) 不再重试（仅 1 次 goto）",
-    page.gotoCount === 1,
-    `goto 次数 = ${page.gotoCount}`,
-  );
-}
-
-// 用例2（核心场景）：429 首检时验证码未渲染 → 重试等待期间弹出
-// → sleep 醒来后的检测必须抓住它（下次 goto 冲掉前），抛 "验证码:"
-{
-  const page = make429CaptchaPage("fumolbbf08o", "delayed");
-  // 在 waitForFunction 轮询到 captchaDelayElapsed=false 一轮后标记出现，
-  // 模拟"等待期渲染"：用 setTimeout 在重试 sleep 期间触发
-  setTimeout(() => page._markCaptchaDelayed(), 50);
-  try {
-    await fetchUserVideosAPI(page, "fumolbbf08o", 5, () => {});
-    check("等待期间弹出的验证码 被醒来检测抓住", false, "未抛错");
-  } catch (e) {
-    check(
-      "等待期间弹出的验证码 被醒来检测抓住",
-      e.message === "验证码: fumolbbf08o",
-      `抛错 "${e.message}"，goto ${page.gotoCount} 次`,
-    );
-  }
-  check(
-    "醒来检测抓住时未再发起下一轮 goto（goto ≤ 2）",
-    page.gotoCount <= 2,
-    `goto 次数 = ${page.gotoCount}`,
-  );
-}
-
-// 用例3：429 + 验证码始终不出现 → 走正常被封重试，最终抛 "被封:"
-{
-  const page = make429CaptchaPage("fumolbbf08o", "never");
-  try {
-    await fetchUserVideosAPI(page, "fumolbbf08o", 5, () => {});
-    check("429无验证码 仍按被封重试", false, "未抛错");
-  } catch (e) {
-    check(
-      "429无验证码 仍按被封重试",
-      e.message === "被封: fumolbbf08o",
-      `抛错 "${e.message}"，goto ${page.gotoCount} 次`,
-    );
-  }
-}
-
-// 用例4：429 + waitForFunction/检测本身抛异常（上下文销毁）→ 忽略，按被封重试
-{
-  const page = make429CaptchaPage("fumolbbf08o", "never");
-  page.waitForFunction = async () => {
-    throw new Error("Execution context was destroyed");
-  };
-  try {
-    await fetchUserVideosAPI(page, "fumolbbf08o", 5, () => {});
-    check("检测异常时忽略按被封重试", false, "未抛错");
-  } catch (e) {
-    check(
-      "检测异常时忽略按被封重试",
-      e.message === "被封: fumolbbf08o",
-      `抛错 "${e.message}"`,
-    );
-  }
-}
-
-console.error(`\n结果: ${pass} 通过, ${fail} 失败`);
-process.exit(fail > 0 ? 1 : 0);