tt-help-cli-ycl 1.4.169 → 1.4.172

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

@@ -284,6 +284,7 @@ export class WatchdogAgent {
     this.loginReport = null; // 最近一次登录检测结果（随心跳上报）
     this._loginChecking = false; // 防重入
     this._lastLoginCheckAt = 0; // 上次检测时间戳
+    this._loginRecheckPending = false; // 服务端下发的手动重检待执行标记
     this.loginCheckTimer = null;
     this.running = false;
     this.heartbeatTimer = null;
@@ -915,6 +916,15 @@ export class WatchdogAgent {
           );
         }
       }
+      // 服务端下发「立即重检」：标记待重检 + 清零上次检测时间，60s 调度器下一跳执行
+      // （重检只检上次未通过的端口，范围在调度器消费时按最新 loginReport 计算）
+      if (data.loginRecheck) {
+        this._loginRecheckPending = true;
+        this._lastLoginCheckAt = 0;
+        console.error(
+          "[watchdog] 服务端下发登录重检，下一跳立即执行（仅上次未通过的端口）",
+        );
+      }
 
       // 心跳日志：仅状态变化或每 10 次打印一次
       this._heartbeatSeq++;
@@ -975,18 +985,102 @@ export class WatchdogAgent {
     if (!this.running || this._loginChecking) return;
     if (!Array.isArray(this.loginPorts) || this.loginPorts.length === 0) return;
     if (Date.now() - this._lastLoginCheckAt < this.loginCheckIntervalMs) return;
+
+    // 手动重检：只检上次未通过的端口；无有效历史结果退化为全量，全部已登录则跳过
+    let ports = this.loginPorts;
+    if (this._loginRecheckPending) {
+      this._loginRecheckPending = false;
+      const resolved = this._resolveRecheckPorts();
+      if (resolved) {
+        if (resolved.length === 0) {
+          console.error("[watchdog] 重检跳过: 上次全部已登录，无需重检");
+          return; // 不占位，2h 周期照常
+        }
+        ports = resolved;
+        console.error(
+          `[watchdog] 手动重检: 仅检测上次未通过的端口 (${ports.join(",")})`,
+        );
+      }
+      // resolved === null → 无有效历史结果，保持全量
+    }
+
     this._lastLoginCheckAt = Date.now(); // 先占位，防 60s tick 重入
-    this._runLoginCheck().catch((e) => {
+    this._runLoginCheck(ports).catch((e) => {
       console.error(`[watchdog] 登录检测执行失败: ${e.message}`);
     });
   }
 
+  /**
+   * 计算手动重检端口范围：上次检测未通过（status !== "logged_in"）的端口，
+   * 含配置了但上次没检到的端口（同样视为未通过）。
+   * @returns {number[]|null} 端口子集；null = 无有效历史结果（调用方退化为全量）
+   */
+  _resolveRecheckPorts() {
+    const report = this.loginReport;
+    if (
+      !report ||
+      report.error ||
+      !Array.isArray(report.ports) ||
+      report.ports.length === 0
+    ) {
+      return null;
+    }
+    const last = new Map(report.ports.map((r) => [Number(r.port), r.status]));
+    return this.loginPorts.filter((p) => last.get(Number(p)) !== "logged_in");
+  }
+
+  /**
+   * 合并登录检测结果：本次检测过的端口用新结果，未检端口保留上次结果。
+   * 全量检测时未检端口为空，行为等同整体替换（与合并前一致）。
+   * @param {Array|null} results 本次端口级结果（null = 无结果，仅保留旧数据）
+   * @param {number[]} checkedPorts 本次实际检测的端口
+   * @param {string} [error] 本次检测的整级错误（可选）
+   */
+  _mergeLoginReport(results, checkedPorts, error) {
+    const prev =
+      this.loginReport && Array.isArray(this.loginReport.ports)
+        ? this.loginReport.ports
+        : [];
+    const checked = new Set(checkedPorts.map(Number));
+    const order = this.loginPorts.map(Number);
+    const byPort = new Map();
+    // 未被本次覆盖的配置端口保留旧结果（配置外残留丢弃，全量检测时行为等同整体替换）
+    for (const r of prev) {
+      const key = Number(r.port);
+      if (!checked.has(key) && order.includes(key)) byPort.set(key, r);
+    }
+    if (Array.isArray(results)) {
+      for (const r of results) byPort.set(Number(r.port), r);
+    }
+    const ports = [...byPort.values()].sort((a, b) => {
+      const ia = order.indexOf(Number(a.port));
+      const ib = order.indexOf(Number(b.port));
+      return (ia < 0 ? order.length : ia) - (ib < 0 ? order.length : ib);
+    });
+    const report = { ports, checkedAt: Date.now() };
+    if (error) report.error = error;
+    return report;
+  }
+
+  /**
+   * 整级失败时的 loginReport：子集重检失败保留未检端口历史结果，全量检测失败整体记错（原行为）
+   */
+  _failedLoginReport(checkedPorts, error) {
+    if (checkedPorts.length < this.loginPorts.length) {
+      return this._mergeLoginReport(null, checkedPorts, error);
+    }
+    return { error, checkedAt: Date.now() };
+  }
+
   /**
    * 执行一次登录检测：spawn 子进程跑 tt-help login-check（一次性短任务，不进 ProcessManager）
    */
-  async _runLoginCheck() {
+  async _runLoginCheck(portsOverride) {
     this._loginChecking = true;
-    const ports = this.loginPorts;
+    const ports =
+      Array.isArray(portsOverride) && portsOverride.length > 0
+        ? portsOverride
+        : this.loginPorts;
     console.error(`[watchdog] 开始登录检测 (端口: ${ports.join(",")})...`);
     try {
       // 全局安装用 tt-help 命令；源码模式用 node cli.js
@@ -1045,7 +1139,7 @@ export class WatchdogAgent {
           // stdout 不是 JSON → 走错误分支
         }
         if (partial) {
-          this.loginReport = { ports: partial, checkedAt: Date.now() };
+          this.loginReport = this._mergeLoginReport(partial, ports);
           console.error(
             `[watchdog] 登录检测完成(部分失败): ${
               String(stderr)
@@ -1058,16 +1152,16 @@ export class WatchdogAgent {
           );
           return;
         }
-        this.loginReport = {
-          error: `exit ${code}: ${String(stderr).slice(-500)}`,
-          checkedAt: Date.now(),
-        };
+        this.loginReport = this._failedLoginReport(
+          ports,
+          `exit ${code}: ${String(stderr).slice(-500)}`,
+        );
         console.error(`[watchdog] 登录检测失败: ${this.loginReport.error}`);
         return;
       }
       const parsed = JSON.parse(String(stdout).trim());
       if (!Array.isArray(parsed)) throw new Error("结果不是数组");
-      this.loginReport = { ports: parsed, checkedAt: Date.now() };
+      this.loginReport = this._mergeLoginReport(parsed, ports);
       const summary = parsed
         .map(
           (r) =>
@@ -1076,7 +1170,7 @@ export class WatchdogAgent {
         .join(" ");
       console.error(`[watchdog] 登录检测完成: ${summary}`);
     } catch (e) {
-      this.loginReport = { error: e.message, checkedAt: Date.now() };
+      this.loginReport = this._failedLoginReport(ports, e.message);
       console.error(`[watchdog] 登录检测异常: ${e.message}`);
     } finally {
       this._loginChecking = false;

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);