tt-help-cli-ycl 1.4.112 → 1.4.114

package/src/cli/refresh-mini.js

@@ -0,0 +1,714 @@
+/**
+ * refresh-mini — 视频信息更新专用客户端
+ *
+ * 特性：
+ * - 固定 CDP 端口 4222（--port 可覆盖），不做登录检测、不做多账户轮换
+ * - 只做 mini 采集：视频列表 + 由视频推导的信息（EC视频、最新发布时间）
+ * - 代理切换采用「触发通知」模式（不自己选节点/验证）：
+ *   需要切换时向 clash-daemon 发 failover 命令（fire-and-forget），
+ *   选节点、内容验证、失败回滚均由 daemon 完成
+ *   触发条件：定时轮换（--rotate-min）/ 验证码超时 / 连续错误 ≥ 3 / CDN ≥ 3
+ *   被封（0 字节空响应，api-interceptor 内部按 30/40/50s 重试 3 次）→ 仍封才触发切换
+ * - --ensure-daemon：启动时检查 daemon 是否存活，未存活则自动拉起（默认关闭）
+ */
+
+import {
+  getOrCreatePage,
+  isBrowserClosedError,
+  relaunchBrowser,
+} from "../lib/browser/page.js";
+import {
+  delay,
+  getDelayConfig,
+  setDelayConfig,
+} from "../scraper/modules/page-helpers.js";
+import {
+  detectCaptcha,
+  closeCaptcha,
+} from "../scraper/modules/captcha-handler.js";
+import {
+  userId as configuredUserId,
+  proxy as configuredProxy,
+  saveUserId,
+} from "../lib/constants.js";
+import { getMacOrUuid } from "../lib/mac-or-uuid.js";
+import {
+  ensureBrowserReady as ensureBrowserReadyCDP,
+  killEdgeProcesses,
+} from "../lib/browser/cdp.js";
+import { createApiClient } from "../lib/api-client.js";
+import { requireClashOrExit } from "../clash/checker.js";
+import { readHealth, writeCommand } from "../clash/ipc.js";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import path from "path";
+import os from "os";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const DEFAULT_PORT = 4222;
+const STARTUP_TIKTOK_URL = "https://www.tiktok.com/@ycl5007";
+const PAGE_GOTO_TIMEOUT = 60000;
+const MAX_RETRY_WAIT = 5 * 60 * 1000;
+const ERROR_SWITCH_THRESHOLD = 3; // 连续任务错误达到该次数 → 触发切换通知
+const SWITCH_RECEIPT_TIMEOUT_MS = 90_000; // 等待 daemon 切换回执上限（10s 轮询 + 候选逐个验证）
+const JS_CACHE_MAX = 80; // 静态 JS 缓存条数上限（每条数百 KB，约数十 MB）
+
+// TikTok 静态 JS 内存缓存：URL（含版本 hash，天然失效）→ Buffer
+// 跨任务复用，第二次导航直接从本地回源，省去代理节点重复下载耗时。
+// 注意：CDP 复用场景下 route.fetch() 不走 Edge 的代理会超时，
+// 因此缓存来源用 page.on('response') 监听浏览器原生下载（走代理正常）
+const jsCache = new Map();
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function withRetry(label, fn) {
+  let backoff = 1000;
+  while (true) {
+    try {
+      return await fn();
+    } catch (err) {
+      console.error(
+        `[连接] ${label} 失败: ${err.message}，${backoff / 1000}秒后重试...`,
+      );
+      await sleep(backoff);
+      backoff = Math.min(backoff * 2, MAX_RETRY_WAIT);
+    }
+  }
+}
+
+/**
+ * 拉起 clash-daemon（后台分离进程，fire-and-forget）
+ * 记录 PID 供退出时清理（只清理自己拉起的）
+ */
+let spawnedDaemonPid = null;
+
+function spawnClashDaemon() {
+  try {
+    const mainJs = path.join(__dirname, "..", "main.js");
+    const child = spawn(process.execPath, [mainJs, "clash-daemon"], {
+      detached: true,
+      stdio: "ignore",
+      cwd: path.dirname(mainJs),
+    });
+    child.unref();
+    spawnedDaemonPid = child.pid;
+    return true;
+  } catch (e) {
+    console.error(`[daemon] 启动失败: ${e.message}`);
+    return false;
+  }
+}
+
+/** 关闭自己拉起的 daemon（daemon 原本就在跑则不碰） */
+function stopSpawnedDaemon() {
+  if (!spawnedDaemonPid) return;
+  try {
+    process.kill(spawnedDaemonPid, "SIGTERM");
+    console.error(
+      `[daemon] 已关闭本进程拉起的 clash-daemon (pid ${spawnedDaemonPid})`,
+    );
+  } catch {
+    /* 已退出或不存在 */
+  }
+  spawnedDaemonPid = null;
+}
+
+/**
+ * 用 daemon 的 IPC 健康状态判断其是否存活（黑盒接口：clash-health.json）
+ */
+function isDaemonAlive() {
+  const h = readHealth();
+  return !!(h && !h.stale);
+}
+
+export async function handleRefreshMini(options) {
+  const {
+    explorePreset,
+    exploreInterval,
+    exploreLocation,
+    exploreJobLocations,
+    exploreMaxUsers,
+    explorePort,
+    exploreUserId,
+    exploreMaxVideos,
+    exploreRedoMaxAge,
+    exploreProxy,
+    serverUrl,
+    rotateMin,
+    captchaWaitMin,
+    ensureDaemon,
+  } = options;
+
+  const effectiveProxy = exploreProxy || configuredProxy;
+  let resolvedProxy = effectiveProxy;
+  if (
+    !effectiveProxy ||
+    effectiveProxy.includes("127.0.0.1") ||
+    effectiveProxy.includes("localhost")
+  ) {
+    // refresh-mini 必须走本地 Clash：未配置代理时自动发现，节点轮换才有意义
+    resolvedProxy = await requireClashOrExit("refresh-mini");
+  } else {
+    console.error(
+      `[警告] 使用非本地代理 ${effectiveProxy}，Clash 节点轮换将无效`,
+    );
+  }
+
+  let userId = exploreUserId || configuredUserId;
+  let browser = null;
+  let cdpOptions = null;
+  let shuttingDown = false;
+
+  const shutdown = async (signal) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.error(`\n[refresh-mini] 收到 ${signal}，正在关闭浏览器...`);
+    stopSpawnedDaemon();
+    if (cdpOptions) {
+      await killEdgeProcesses(cdpOptions.userDataDir, cdpOptions.port);
+    }
+    await browser?.close().catch(() => {});
+    console.error("[refresh-mini] 已退出");
+    process.exit(0);
+  };
+
+  const onSigint = () => void shutdown("SIGINT");
+  const onSigterm = () => void shutdown("SIGTERM");
+  process.once("SIGINT", onSigint);
+  process.once("SIGTERM", onSigterm);
+
+  try {
+    if (!userId) {
+      userId = await getMacOrUuid();
+      saveUserId(userId);
+      console.error(`[初始化] 未检测到本地用户编号，已生成并使用: ${userId}`);
+    }
+
+    setDelayConfig(explorePreset);
+
+    console.error(`\n=== refresh-mini 模式（视频信息更新） ===`);
+    console.error(`服务器: ${serverUrl}`);
+    console.error(`CDP 端口: ${explorePort || DEFAULT_PORT}（固定）`);
+    console.error(`采集范围: mini（仅视频及视频相关信息）`);
+    console.error(`视频采集: ${exploreMaxVideos || 16}`);
+    console.error(`国家筛选: ${exploreLocation}`);
+    if (exploreJobLocations) console.error(`任务国家: ${exploreJobLocations}`);
+    console.error(`空闲间隔: ${exploreInterval || 30} 秒`);
+    console.error(
+      `代理: ${resolvedProxy || "无"}${
+        rotateMin > 0
+          ? `（每 ${rotateMin} 分钟轮换节点）`
+          : "（定时轮换已关闭）"
+      }`,
+    );
+    console.error(`验证码等待人工解决上限: ${captchaWaitMin || 10} 分钟`);
+    if (exploreMaxUsers > 0) console.error(`上限: ${exploreMaxUsers} 个用户`);
+
+    cdpOptions = {
+      port: explorePort || DEFAULT_PORT,
+      userDataDir: path.join(
+        os.homedir(),
+        "Library",
+        "Application Support",
+        `Microsoft Edge For Testing_p${explorePort || DEFAULT_PORT}`,
+      ),
+    };
+    if (resolvedProxy) cdpOptions.proxyServer = resolvedProxy;
+
+    const { apiGet, apiPost } = createApiClient({
+      meta: { port: cdpOptions.port, clientType: "refresh-mini" },
+    });
+
+    // 连接服务器验证
+    await apiGet(`${serverUrl}/api/stats`);
+
+    browser = await ensureBrowserReadyCDP(cdpOptions);
+    const { processExplore } = await import("../scraper/explore-core.js");
+
+    let page = await getOrCreatePage(browser);
+
+    // 视频资源拦截：
+    // 1) 资源类型：media / image / stylesheet 直接拦
+    // 2) 视频文件后缀：.mp4/.m3u8/.ts（fetch 拉流带扩展名的情况）
+    // 3) TikTok 视频流专用 CDN：v16/v19/v77 等「v数字开头」域名，路径无扩展名
+    //    （hover 预览、首页自动播放都是这类地址，fetch 类型，后缀规则拦不住）
+    //    注意不能拦 tiktokv.us / www.tiktok.com/api 等业务域名（webid/mcs 关键 API）
+    function isBlockableResource(route) {
+      const request = route.request();
+      const resourceType = request.resourceType();
+      if (
+        resourceType === "image" ||
+        resourceType === "stylesheet" ||
+        resourceType === "media"
+      ) {
+        return true;
+      }
+      const url = request.url();
+      if (/\.(mp4|m3u8|ts)(\?|$)/i.test(url)) {
+        return true;
+      }
+      return /^https?:\/\/v\d+[a-z0-9-]*\.(tiktokcdn(-us)?\.(com|net)|tiktok\.com)\//i.test(
+        url,
+      );
+    }
+
+    async function setupNewPage(newBrowser) {
+      const newPage = await getOrCreatePage(newBrowser);
+      // 源头兜底：让 video.play() 变为空操作，无论视频流走什么地址/加载方式都无法播放
+      // （采集数据全部来自 API 拦截，不依赖视频播放，此注入无副作用）
+      await newPage.addInitScript(() => {
+        HTMLMediaElement.prototype.play = function () {
+          try {
+            this.pause();
+          } catch {}
+          return Promise.resolve();
+        };
+      });
+      // script 下载完成后缓存 body（浏览器原生下载，走代理正常；
+      // 资源已释放时 getResponseBody 会失败，忽略即可，不影响功能）
+      newPage.on("response", async (res) => {
+        if (res.request().resourceType() !== "script") return;
+        const url = res.url();
+        if (jsCache.has(url) || jsCache.size >= JS_CACHE_MAX) return;
+        try {
+          jsCache.set(url, await res.body());
+        } catch {}
+      });
+      await newPage.route("**/*", (route) => {
+        const request = route.request();
+        if (isBlockableResource(route)) {
+          route.abort();
+          return;
+        }
+        // JS 静态资源内存缓存：命中直接本地回源
+        if (request.resourceType() === "script") {
+          const cached = jsCache.get(request.url());
+          if (cached) {
+            route.fulfill({
+              status: 200,
+              contentType: "application/javascript",
+              body: cached,
+            });
+            return;
+          }
+        }
+        route.continue();
+      });
+      return newPage;
+    }
+
+    page = await setupNewPage(browser);
+
+    // 导航到 TikTok 页面
+    await withRetry("启动页面导航", async () => {
+      await page.goto(STARTUP_TIKTOK_URL, {
+        waitUntil: "domcontentloaded",
+        timeout: PAGE_GOTO_TIMEOUT,
+      });
+    });
+
+    // --ensure-daemon：检查 clash-daemon 是否存活，未存活则拉起（默认不检测）
+    if (ensureDaemon) {
+      if (isDaemonAlive()) {
+        const h = readHealth();
+        console.error(
+          `[daemon] 已运行（上次巡检 ${h?.ageSeconds ?? "?"}s 前）`,
+        );
+      } else {
+        console.error(`[daemon] 未检测到运行中的 clash-daemon，正在拉起...`);
+        console.error(
+          spawnClashDaemon()
+            ? `[daemon] 已发送启动命令（后台分离进程）`
+            : `[daemon] 启动失败，切换通知将无人处理`,
+        );
+      }
+    }
+
+    let proxySwitchCount = 0;
+    let lastProxyTriggerTime = Date.now(); // 上次触发切换的时间（定时轮换节流用）
+    let consecutiveTaskErrors = 0; // 任务级连续错误计数（触发代理切换，成功或发通知后归零）
+
+    /**
+     * 触发代理切换：向 daemon 发 failover 命令，等待回执后再返回。
+     * 回执 = clash-health.json 的 lastSwitch 字段（含本次 reason），
+     * healthy 字段即 daemon 的内容验证结果（切换后是否真的可用）。
+     * 超时（daemon 未运行等）返回 null，不阻塞后续处理。
+     */
+    async function triggerProxySwitch(reason) {
+      proxySwitchCount++;
+      lastProxyTriggerTime = Date.now();
+      consecutiveTaskErrors = 0;
+      const before = readHealth()?.lastSwitch || "";
+      console.error(
+        `[代理] 触发切换通知（${reason}，累计 ${proxySwitchCount} 次），等待 daemon 回执...`,
+      );
+      writeCommand({ action: "failover", reason: `refresh-mini: ${reason}` });
+
+      const deadline = Date.now() + SWITCH_RECEIPT_TIMEOUT_MS;
+      while (Date.now() < deadline) {
+        await sleep(3000);
+        const h = readHealth();
+        if (
+          h &&
+          h.lastSwitch &&
+          h.lastSwitch !== before &&
+          h.lastSwitch.includes(reason)
+        ) {
+          console.error(
+            `[代理] 切换回执: ${h.lastSwitch}${h.healthy ? "（健康）" : "（异常）"}`,
+          );
+          return !!h.healthy;
+        }
+      }
+      console.error(
+        `[代理] 等待切换回执超时（${SWITCH_RECEIPT_TIMEOUT_MS / 1000}s），daemon 可能未运行，继续处理`,
+      );
+      return null;
+    }
+
+    /** 等待人工在浏览器中解决验证码，超时返回 false */
+    async function waitForCaptchaResolved() {
+      const deadline = Date.now() + (captchaWaitMin || 10) * 60000;
+      console.error(
+        `  [验证码] 等待人工在浏览器中解决（上限 ${captchaWaitMin || 10} 分钟）...`,
+      );
+      while (Date.now() < deadline) {
+        await sleep(15000);
+        let visible = true;
+        try {
+          const r = await detectCaptcha(page);
+          visible = !!(r && r.visible);
+        } catch {
+          visible = false;
+        }
+        if (!visible) {
+          console.error("  [验证码] 已解决，继续处理");
+          return true;
+        }
+        await closeCaptcha(page).catch(() => {});
+      }
+      console.error("  [验证码] 等待超时未解决");
+      return false;
+    }
+
+    let processedCount = 0;
+    let errorCount = 0;
+    let consecutiveNetworkErrors = 0; // 领取任务 API 失败计数（服务端问题，不切代理）
+    let captchaCount = 0;
+
+    const processOptions = () => ({
+      maxVideos: exploreMaxVideos || 16,
+      enableFollow: false,
+      loggedIn: false,
+      maxFollowing: 0,
+      maxFollowers: 0,
+      location: exploreLocation,
+      locationMode: "refresh",
+      browser,
+      proxyServer: cdpOptions.proxyServer || null,
+      webserverUrl: null,
+      noProduct: true,
+      mini: true,
+    });
+
+    const reportError = (
+      username,
+      errorType,
+      errorMessage,
+      stage,
+      errorStack,
+    ) =>
+      withRetry("report error", () =>
+        apiPost(`${serverUrl}/api/error-report`, {
+          userId,
+          username,
+          errorType,
+          errorMessage,
+          stage,
+          errorStack: errorStack || "",
+        }),
+      ).catch(() => {});
+
+    const checkMaxUsers = () => {
+      if (exploreMaxUsers > 0 && processedCount >= exploreMaxUsers) {
+        console.error(`\n已达上限 ${exploreMaxUsers} 个用户，停止处理`);
+        return true;
+      }
+      return false;
+    };
+
+    console.error(`\n开始循环刷新任务...\n`);
+
+    while (true) {
+      if (shuttingDown) break;
+
+      // 定时轮换（任务间隙，预防性换 IP，等回执后再继续）
+      if (rotateMin > 0) {
+        const elapsedMin = (Date.now() - lastProxyTriggerTime) / 60000;
+        if (elapsedMin >= rotateMin) {
+          await triggerProxySwitch(`定时轮换（满 ${rotateMin} 分钟）`);
+        }
+      }
+
+      if (processedCount % 10 === 0 && processedCount > 0) {
+        console.error(
+          `[统计] 已处理 ${processedCount}, 出错 ${errorCount}, 已触发切换 ${proxySwitchCount} 次`,
+        );
+      }
+
+      // 领取 redo 任务
+      let redoUrl = `${serverUrl}/api/redo-job?userId=${userId}`;
+      if (exploreRedoMaxAge > 0) {
+        redoUrl += `&maxAge=${exploreRedoMaxAge}`;
+      }
+      if (exploreJobLocations) {
+        redoUrl += `&locations=${encodeURIComponent(exploreJobLocations)}`;
+      }
+      let job = null;
+      try {
+        job = await apiGet(redoUrl);
+      } catch (e) {
+        consecutiveNetworkErrors++;
+        console.error(
+          `  [网络] 获取任务失败 (${consecutiveNetworkErrors}): ${e.message}`,
+        );
+        await sleep(10000);
+        continue;
+      }
+
+      if (!job.hasJob) {
+        console.error(
+          `\n[空闲] 暂无 redo 任务，${exploreInterval || 30}s 后重试...`,
+        );
+        await sleep((exploreInterval || 30) * 1000);
+        consecutiveNetworkErrors = 0;
+        continue;
+      }
+
+      consecutiveNetworkErrors = 0;
+      const username = job.user.uniqueId;
+      const nickname = job.user.nickname;
+      console.error(`\n[${processedCount}] 更新 @${username} 视频信息...`);
+
+      // 切换任务前检测验证码
+      const captchaResult = await detectCaptcha(page);
+      if (captchaResult && captchaResult.visible) {
+        captchaCount++;
+        console.error(
+          `\n[验证码] 切换任务前检测到验证码（累计 ${captchaCount} 次）`,
+        );
+        await reportError(
+          "unknown",
+          "captcha",
+          "切换任务前检测到验证码",
+          "between-tasks",
+        );
+        const resolved = await waitForCaptchaResolved();
+        if (!resolved) {
+          await triggerProxySwitch(
+            `验证码等待 ${captchaWaitMin || 10} 分钟未解决`,
+          );
+          captchaCount = 0;
+        }
+      }
+
+      const { switchMax } = getDelayConfig();
+      await delay(switchMax, switchMax * 3);
+
+      let result = await processExplore(
+        page,
+        username,
+        processOptions(),
+        console.error,
+      );
+
+      // 浏览器关闭检测 → 重启浏览器并重试
+      if (result.error && isBrowserClosedError(new Error(result.error))) {
+        console.error("  [恢复] 浏览器已关闭，重启浏览器...");
+        browser = await relaunchBrowser(cdpOptions, cdpOptions.port);
+        page = await setupNewPage(browser);
+        result = await processExplore(
+          page,
+          username,
+          processOptions(),
+          console.error,
+        );
+      }
+
+      if (result.restricted) {
+        consecutiveTaskErrors = 0;
+        await apiPost(`${serverUrl}/api/redo-job/${username}`, {
+          restricted: true,
+          userInfo: result.userInfo || {},
+        });
+        if (checkMaxUsers()) break;
+        continue;
+      }
+
+      // CDN 限流：渐进退避，连续达到阈值 → 触发切换通知
+      if (result.cdnBlocked) {
+        consecutiveTaskErrors++;
+        errorCount++;
+        const waitMs = Math.min(consecutiveTaskErrors * 30000, 120000);
+        console.error(
+          `  [CDN] 限流，${waitMs / 1000}s 后重试（连续 ${consecutiveTaskErrors} 次）...`,
+        );
+        await sleep(waitMs);
+        if (consecutiveTaskErrors >= ERROR_SWITCH_THRESHOLD) {
+          await triggerProxySwitch(`CDN 限流连续 ${consecutiveTaskErrors} 次`);
+        }
+        if (checkMaxUsers()) break;
+        continue;
+      }
+
+      if (result.error) {
+        const isBlocked = result.error.startsWith("被封:");
+        consecutiveTaskErrors++;
+        errorCount++;
+
+        // 临时性错误：自动重试一次
+        if (result.retryable) {
+          console.error(`  [临时错误] 等待 5 秒后重试 @${username}...`);
+          await sleep(5000);
+          result = await processExplore(
+            page,
+            username,
+            processOptions(),
+            console.error,
+          );
+          if (!result.error) {
+            consecutiveTaskErrors = 0;
+            errorCount--;
+          }
+        }
+
+        if (result.error) {
+          const stillBlocked = result.error.startsWith("被封:");
+          // 被封的 30/60/90s 重试确认已在 api-interceptor 内部完成，
+          // 到这里仍被封说明重试耗尽，直接回退任务并触发切换
+          // 任务回退给服务端，之后会被重新派发
+          await apiPost(`${serverUrl}/api/redo-job/${username}`, {
+            error: result.error,
+          });
+          await reportError(
+            username,
+            stillBlocked
+              ? "被封"
+              : consecutiveTaskErrors > 1
+                ? "network"
+                : "other",
+            result.error,
+            "process",
+            result.errorStack || "",
+          );
+
+          const shouldSwitch =
+            stillBlocked || consecutiveTaskErrors >= ERROR_SWITCH_THRESHOLD;
+          if (shouldSwitch) {
+            await triggerProxySwitch(
+              stillBlocked
+                ? "账号/IP 被封（api-interceptor 30/40/50s 重试 3 次仍封）"
+                : `连续任务错误 ${consecutiveTaskErrors} 次`,
+            );
+          }
+          if (checkMaxUsers()) break;
+          continue;
+        }
+      }
+
+      if (result.captchaDetected) {
+        captchaCount++;
+        console.error(`  [验证码] 累计 ${captchaCount} 次`);
+        await reportError(
+          username,
+          "captcha",
+          result.captchaMessage || "页面出现验证码",
+          result.captchaStage || "video-page",
+        );
+        const resolved = await waitForCaptchaResolved();
+        if (!resolved || captchaCount >= ERROR_SWITCH_THRESHOLD) {
+          await triggerProxySwitch(
+            resolved
+              ? `验证码累计 ${captchaCount} 次`
+              : `验证码等待 ${captchaWaitMin || 10} 分钟未解决`,
+          );
+          captchaCount = 0;
+        }
+      }
+
+      consecutiveTaskErrors = 0;
+      processedCount++;
+
+      // refresh 模式：confirmedLocation 是二次确认的国家，写入 confirmed_location 列
+      // locationCreated 保持原始值不变
+      const refreshLocation =
+        result.confirmedLocation || result.locationCreated;
+      const guessedLocation = refreshLocation || null;
+
+      // latestVideoTime 是视频推导的零成本信息，需更新服务端 latest_video_time
+      //（影响任务排序 ORDER BY latest_video_time DESC 与前端显示）
+      const refreshUserInfo = { ...(result.userInfo || {}) };
+      if (result.confirmedLocation) {
+        refreshUserInfo.confirmedLocation = result.confirmedLocation;
+      }
+      if (result.latestVideoTime) {
+        refreshUserInfo.latestVideoTime = result.latestVideoTime;
+      }
+
+      const payload = {
+        userInfo: refreshUserInfo,
+        recentEcVideos: result.recentEcVideos || null,
+        topRecentVideo: result.topRecentVideo || null,
+        productDetail: result.productDetail || null,
+        discoveredFollowing: (result.discoveredFollowing || []).map((f) => ({
+          handle: Array.isArray(f) ? f[0] : f,
+          displayName: Array.isArray(f) ? f[1] : null,
+          guessedLocation,
+        })),
+        discoveredFollowers: (result.discoveredFollowers || []).map((f) => ({
+          handle: Array.isArray(f) ? f[0] : f,
+          displayName: Array.isArray(f) ? f[1] : null,
+          guessedLocation,
+        })),
+        discoveredRecommended: (result.discoveredRecommended || []).map(
+          (f) => ({
+            handle: Array.isArray(f) ? f[0] : f,
+            displayName: Array.isArray(f) ? f[1] : null,
+            guessedLocation,
+          }),
+        ),
+        processed: result.processed,
+        hasFollowData: result.hasFollowData,
+        keepFollow: result.keepFollow,
+        noVideo: result.noVideo,
+        collectedVideos: result.collectedVideos,
+      };
+      await apiPost(`${serverUrl}/api/redo-job/${username}`, payload);
+      console.error("  已提交");
+
+      // 预防性重置：每 50 个任务刷新页面，避免 SPA 状态累积导致主线程死锁
+      //（卡死现象：日志停在"[API拦截] 获取..."，刷新页面才恢复）
+      if (processedCount > 0 && processedCount % 50 === 0) {
+        console.error("  [维护] 已处理 50 个任务，刷新页面防止累积卡死...");
+        await page
+          .reload({ waitUntil: "domcontentloaded", timeout: 30000 })
+          .catch(() => {});
+        console.error("  [维护] 页面刷新完成");
+      }
+
+      if (checkMaxUsers()) break;
+    }
+
+    const stats = await apiGet(`${serverUrl}/api/stats`);
+    console.error(`\n完成: ${processedCount} 个用户处理, ${errorCount} 个出错`);
+    console.error(
+      `  总用户: ${stats.totalUsers}, 已完成: ${stats.processedUsers}, 待处理: ${stats.pendingUsers}, 错误: ${stats.errorUsers}`,
+    );
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+    process.removeListener("SIGTERM", onSigterm);
+    stopSpawnedDaemon();
+    await browser?.close().catch(() => {});
+  }
+}