tt-help-cli-ycl 1.4.144 → 1.4.146

package/src/cli/comments.js

@@ -5,17 +5,11 @@
 //   手动模式: tt-help comments <URL> [N] [--save]            单视频评论提取
 // ────────────────────────────────────────
 
-import {
-  getBrowserMemory,
-  formatMemoryWithBrowser,
-} from "../lib/browser-memory.js";
-import { reportConsecutiveTaskErrors } from "../lib/client-error-report.js";
+import { formatMemoryWithBrowser } from "../lib/browser-memory.js";
+import { reportClientErrorAndFailover } from "../lib/client-error-report.js";
 
 import { fetchUserCommentsAPI } from "../lib/api-interceptor-comment.js";
-import {
-  closeCommentPanel,
-  isBrowserClosedError,
-} from "../lib/browser/page.js";
+import { closeCommentPanel, getOrCreatePage } from "../lib/browser/page.js";
 import {
   server as defaultServer,
   proxy as configuredProxy,
@@ -43,78 +37,16 @@ import { parseVideoInfo } from "../lib/parse-ssr.mjs";
 // ────────────────────────────────────────
 
 const CFG = {
-  /** 默认 CDP 端口池起点 */
-  portPoolStart: 6222,
-  /** 端口池大小 */
-  portPoolSize: 10,
+  /** 默认 CDP 端口（固定：一次会话一个浏览器，不换端口、不重启） */
+  defaultPort: 6222,
   /** 每视频最大评论数 */
   maxComments: 200,
   /** 空闲间隔上限（秒） */
   interval: 10,
   /** 并行数 */
   parallel: 1,
-  /** 连续 403 后重启浏览器 */
-  consecutive403Blocked: 3,
-  /** 连续验证码后重启浏览器 */
-  maxConsecutiveCaptcha: 3,
-  /** 内存回收 — 触发回收的 RSS(MB) 阈值 */
-  recycleRssMb: 2000,
-  /** 内存回收 — 触发回收的 Heap(MB) 阈值 */
-  recycleHeapMb: 2000,
-  /** 内存回收 — 触发回收的 Edge 进程(MB) 阈值 */
-  recycleEdgeMb: 2000,
-  /** 内存回收 — 两次回收最小间隔(ms) */
-  recycleCooldownMs: 180000,
-  /** 内存回收 — 每 N 个任务强制回收（0=禁用） */
-  periodicRecycleEvery: 0,
-  /** 内存回收 — 回收时是否切换端口（默认关闭：只重启浏览器不换端口） */
-  switchPortOnRecycle: false,
-  /** 连续任务处理错误阈值（达到后上报服务端） */
-  consecutiveTaskErrorsMax: 20,
-  /** 单端口最大运行时间(ms)，超时自动重启浏览器（默认 48 分钟） */
-  maxSessionRunTimeMs: 48 * 60 * 1000,
 };
 
-/** 从环境变量覆写配置 */
-function loadEnvConfig() {
-  const int = (key, def) => {
-    const v = parseInt(process.env[key], 10);
-    return Number.isFinite(v) ? v : def;
-  };
-  CFG.portPoolStart = int("COMMENTS_PORT_POOL_START", CFG.portPoolStart);
-  CFG.portPoolSize = int("COMMENTS_PORT_POOL_SIZE", CFG.portPoolSize);
-  CFG.recycleRssMb = Math.max(
-    256,
-    int("COMMENTS_RECYCLE_RSS_MB", CFG.recycleRssMb),
-  );
-  CFG.recycleHeapMb = Math.max(
-    128,
-    int("COMMENTS_RECYCLE_HEAP_MB", CFG.recycleHeapMb),
-  );
-  CFG.recycleEdgeMb = Math.max(
-    500,
-    int("COMMENTS_RECYCLE_EDGE_MB", CFG.recycleEdgeMb),
-  );
-  CFG.recycleCooldownMs = Math.max(
-    0,
-    int("COMMENTS_RECYCLE_COOLDOWN_MS", CFG.recycleCooldownMs),
-  );
-  CFG.periodicRecycleEvery = Math.max(
-    0,
-    int("COMMENTS_PERIODIC_RECYCLE_EVERY", CFG.periodicRecycleEvery),
-  );
-  CFG.switchPortOnRecycle =
-    String(process.env.COMMENTS_SWITCH_PORT_ON_RECYCLE || "0") !== "0";
-  CFG.consecutiveTaskErrorsMax = Math.max(
-    1,
-    int("COMMENTS_CONSECUTIVE_TASK_ERRORS_MAX", CFG.consecutiveTaskErrorsMax),
-  );
-  CFG.maxSessionRunTimeMs = Math.max(
-    60000,
-    int("COMMENTS_MAX_SESSION_RUN_TIME_MS", CFG.maxSessionRunTimeMs),
-  );
-}
-
 // ────────────────────────────────────────
 // Section 3: 页面辅助
 // ────────────────────────────────────────
@@ -191,184 +123,6 @@ async function setupPageBlocking(page) {
   _blockedPages.add(page);
 }
 
-// ────────────────────────────────────────
-// Section 5: CDP 会话管理（端口池/浏览器/页面/内存回收）
-// ────────────────────────────────────────
-
-class CdpSessionManager {
-  constructor({ portPoolStart, portPoolSize, proxy }) {
-    this.port = portPoolStart;
-    this.portPoolStart = portPoolStart;
-    this.portPoolSize = portPoolSize;
-    this.proxy = proxy;
-    this.browser = null;
-    this.page = null;
-    this.lastRecycleAt = 0;
-    this.sessionStartTime = Date.now();
-    this._lastMemCheck = 0;
-    this._shuttingDown = false;
-  }
-
-  pickNextPort() {
-    const candidates = [];
-    for (let i = 0; i < this.portPoolSize; i++) {
-      const p = this.portPoolStart + i;
-      if (p !== this.port) candidates.push(p);
-    }
-    if (candidates.length === 0) return this.port;
-    return candidates[Math.floor(Math.random() * candidates.length)];
-  }
-
-  /** 启动：连接浏览器 + 获取页面 */
-  async init() {
-    const opts = { port: this.port };
-    if (this.proxy) opts.proxyServer = this.proxy;
-    this.browser = await ensureBrowserReady(opts);
-    this.page = await this._ensurePage();
-  }
-
-  /** 获取或恢复 page */
-  async _ensurePage() {
-    let p = getPage(this.browser);
-    if (p) await setupPageBlocking(p);
-    return p;
-  }
-
-  async ensurePage() {
-    if (!this.page || this.page.isClosed()) {
-      this.page = await this._ensurePage();
-    }
-    return this.page;
-  }
-
-  /** 轻量回收：清空当前 tab */
-  async recyclePage() {
-    if (!this.page || this.page.isClosed()) {
-      this.page = await this._ensurePage();
-      return;
-    }
-    try {
-      await this.page.goto("about:blank", {
-        waitUntil: "domcontentloaded",
-        timeout: 5000,
-      });
-    } catch {
-      await this.page.close().catch(() => {});
-      this.page = await this._ensurePage();
-    }
-  }
-
-  /** 深度回收：关闭浏览器，可选切换端口 */
-  async recycleSession(reason, { switchPort = true } = {}) {
-    const oldPort = this.port;
-    const doSwitch = switchPort && CFG.switchPortOnRecycle;
-    if (doSwitch) this.port = this.pickNextPort();
-    const hint =
-      oldPort === this.port
-        ? `port=${this.port}`
-        : `port ${oldPort}→${this.port}`;
-    console.error(`  ♻️ 重建 CDP 会话 (${reason}; ${hint})...`);
-
-    if (this.page) {
-      await this.page.close().catch(() => {});
-      this.page = null;
-    }
-    await this.browser?.close().catch(() => {});
-
-    if (oldPort !== this.port) {
-      await killEdgeProcesses(null, oldPort).catch(() => {});
-    }
-
-    const opts = { port: this.port };
-    if (this.proxy) opts.proxyServer = this.proxy;
-    this.browser = await ensureBrowserReady(opts);
-    this.page = await this._ensurePage();
-    this.lastRecycleAt = Date.now();
-    // 重建会话后重置运行计时（无论是否换端口）。
-    // 旧逻辑只在换端口时重置，而默认 switchPortOnRecycle=false，
-    // 导致 48min 定时轮换触发后计时不归零，之后每次内存采样（30s）
-    // 都再次满足超时条件 → 每 30s 反复重建会话（“一直在切换”）
-    this.sessionStartTime = Date.now();
-  }
-
-  /** 内存检查 + 定时轮换 + 按需回收（每 30s 最多采样一次） */
-  async maybeRecycleForMemory(processedCount) {
-    const now = Date.now();
-    if (now - this._lastMemCheck < 30000) return;
-    this._lastMemCheck = now;
-
-    // 定时轮换：单端口运行超时自动重启浏览器
-    const sessionElapsed = now - this.sessionStartTime;
-    if (sessionElapsed >= CFG.maxSessionRunTimeMs) {
-      const mins = Math.round(sessionElapsed / 60000);
-      await this.recycleSession(`定时轮换 (运行 ${mins} 分钟)`, {
-        switchPort: true,
-      });
-      return;
-    }
-
-    const mem = process.memoryUsage();
-    const rssMB = mem.rss / 1024 / 1024;
-    const heapMB = mem.heapUsed / 1024 / 1024;
-    const edgeMB = getBrowserMemory(this.port);
-
-    const nodeOver = rssMB >= CFG.recycleRssMb || heapMB >= CFG.recycleHeapMb;
-    const edgeOver = edgeMB !== null && edgeMB >= CFG.recycleEdgeMb;
-
-    if (nodeOver || edgeOver) {
-      if (
-        CFG.recycleCooldownMs > 0 &&
-        Date.now() - this.lastRecycleAt < CFG.recycleCooldownMs
-      )
-        return;
-
-      const parts = [];
-      if (rssMB >= CFG.recycleRssMb)
-        parts.push(`rss=${rssMB.toFixed(0)}≥${CFG.recycleRssMb}`);
-      if (heapMB >= CFG.recycleHeapMb)
-        parts.push(`heap=${heapMB.toFixed(0)}≥${CFG.recycleHeapMb}`);
-      if (edgeOver)
-        parts.push(`edge:${this.port}=${edgeMB}≥${CFG.recycleEdgeMb}`);
-
-      await this.recycleSession(`mem ${parts.join("+")}`, {
-        switchPort: edgeOver,
-      });
-      return;
-    }
-
-    if (
-      CFG.periodicRecycleEvery > 0 &&
-      processedCount > 0 &&
-      processedCount % CFG.periodicRecycleEvery === 0
-    ) {
-      await this.recycleSession(`periodic #${processedCount}`, {
-        switchPort: false,
-      });
-    }
-  }
-
-  /** 重启浏览器（不切换端口，用于浏览器异常断开） */
-  async restartBrowser() {
-    try {
-      await this.browser?.close();
-    } catch {}
-    this.browser = null;
-    this.page = null;
-    const opts = { port: this.port };
-    if (this.proxy) opts.proxyServer = this.proxy;
-    this.browser = await ensureBrowserReady(opts);
-    this.page = await this._ensurePage();
-  }
-
-  async shutdown() {
-    if (this._shuttingDown) return;
-    this._shuttingDown = true;
-    if (this.page) await this.page.close().catch(() => {});
-    await this.browser?.close().catch(() => {});
-    killEdgeProcesses(null, this.port);
-  }
-}
-
 // ────────────────────────────────────────
 // Section 6: 共享操作（视频页准备 & 评论提取 & 保存）
 // ────────────────────────────────────────
@@ -498,11 +252,10 @@ async function runAutoMode(options) {
   const actualInterval = interval || CFG.interval;
   const actualMaxComments = maxComments || CFG.maxComments;
   const effectiveProxy = proxyOption || configuredProxy;
-  const portPoolStart = basePort || CFG.portPoolStart;
+  // 固定端口：一次会话一个浏览器，全程不换端口、不重启浏览器（错误只打印，不自愈）
+  const cdpPort = basePort || CFG.defaultPort;
   const jobLocations = locations || null;
 
-  loadEnvConfig();
-
   // ── 设备标识 ──
   let userId = configuredUserId;
   if (!userId) {
@@ -521,28 +274,129 @@ async function runAutoMode(options) {
   let shuttingDown = false;
   let processedCount = 0,
     skippedCount = 0,
-    errorCount = 0,
-    browserRestartCount = 0;
-  let consecutiveErrors = 0,
-    consecutive403 = 0,
-    consecutiveCaptchaCount = 0,
-    consecutiveTaskErrors = 0;
-
-  // ── CDP 会话 ──
-  const session = new CdpSessionManager({
-    portPoolStart,
-    portPoolSize: CFG.portPoolSize,
-    proxy: effectiveProxy,
-  });
+    errorCount = 0;
+
+  // ── 错误计数（纯观察，不做任何自愈） ──
+  // 阈值语义：连续超过 N 次触发动作（即第 N+1 次）
+  //   403      连续 >2 次 → 上报服务端 + 强制 fallback（daemon 换节点），清零后继续跑
+  //   网络错误 连续 >10 次 → 触发 daemon fallback 换节点（本地 IPC，不依赖服务端可达）+ 退出
+  //   验证码   连续 >3 次（人工一直未解决）→ 打印退出
+  //   其他错误 连续 >10 次 → 打印退出
+  // 清零规则：成功提交一个任务 → 全部清零；fallback 触发 → 对应计数清零；
+  //           人工点掉验证码 → 验证码计数清零；领取任务成功 → 网络计数清零
+  const errorCounts = { http403: 0, network: 0, captcha: 0, other: 0 };
+  const ERROR_LIMITS = { http403: 2, network: 10, captcha: 3, other: 10 };
+  const resetAllErrorCounts = () => {
+    errorCounts.http403 = 0;
+    errorCounts.network = 0;
+    errorCounts.captcha = 0;
+    errorCounts.other = 0;
+  };
+  const bumpErrorCount = (type) => {
+    errorCounts[type]++;
+    return errorCounts[type] > ERROR_LIMITS[type];
+  };
+
+  // 浏览器是否真的已断开（用户手动关窗口 / CDP 断开）。
+  // 网络层 net::ERR_* 是代理抖动/连接重置，浏览器进程还活着，不算关闭。
+  function isBrowserDisconnected(browser, e) {
+    try {
+      if (
+        browser &&
+        typeof browser.isConnected === "function" &&
+        !browser.isConnected()
+      ) {
+        return true;
+      }
+    } catch {}
+    if (!e) return false;
+    const msg = e.message || "";
+    if (msg.includes("net::ERR_")) return false;
+    return (
+      msg.includes("Target closed") ||
+      msg.includes("Browser has been closed") ||
+      msg.includes("Target page, context or browser has been closed")
+    );
+  }
+
+  // 网络错误判定（代理抖动 net::ERR_* 归为网络错误）
+  function isNetworkError(e) {
+    return (
+      e.code === "ECONNREFUSED" ||
+      e.code === "ENOTFOUND" ||
+      e.code === "ECONNRESET" ||
+      (e.message &&
+        (e.message.includes("ECONNREFUSED") ||
+          e.message.includes("fetch failed") ||
+          e.message.includes("network") ||
+          e.message.includes("net::ERR_")))
+    );
+  }
+
+  // 网络错误超限 → 触发 daemon fallback 换节点（本地 IPC，不依赖服务端可达）+ 退出
+  const networkErrorExit = async () => {
+    console.error(
+      `  ❌ 连续网络错误超过 ${ERROR_LIMITS.network} 次 → 触发 daemon fallback 换节点后退出`,
+    );
+    await reportClientErrorAndFailover({
+      post: apiPost,
+      baseUrl: serverUrl,
+      userId,
+      errorType: "network_failure",
+      message: `连续 ${ERROR_LIMITS.network + 1} 次网络错误 (port=${cdpPort})`,
+      stage: "comments",
+    });
+    await shutdown("连续网络错误");
+  };
+
+  // ── CDP 浏览器（固定端口） ──
+  const cdpOpts = { port: cdpPort };
+  if (effectiveProxy) cdpOpts.proxyServer = effectiveProxy;
+  let browser;
+  try {
+    browser = await ensureBrowserReady(cdpOpts);
+  } catch (err) {
+    console.error(`× 浏览器启动失败: ${err.message}`);
+    process.exit(1);
+  }
+  let page = await getOrCreatePage(browser);
+  await setupPageBlocking(page);
+
+  // 轻量回收：只清空当前 tab（不重启浏览器）
+  async function recyclePage() {
+    if (!page || page.isClosed()) {
+      page = await getOrCreatePage(browser);
+      await setupPageBlocking(page);
+      return;
+    }
+    try {
+      await page.goto("about:blank", {
+        waitUntil: "domcontentloaded",
+        timeout: 5000,
+      });
+    } catch {
+      await page.close().catch(() => {});
+      page = await getOrCreatePage(browser);
+      await setupPageBlocking(page);
+    }
+  }
 
   // ── 生命周期 ──
+  let closing = false;
+  const closeResources = async () => {
+    if (closing) return;
+    closing = true;
+    if (page) await page.close().catch(() => {});
+    await browser?.close().catch(() => {});
+    killEdgeProcesses(null, cdpPort);
+  };
   const shutdown = async (signal) => {
     if (shuttingDown) return;
     shuttingDown = true;
     console.error(
-      `\n── ${signal} ── 处理=${processedCount} 跳过=${skippedCount} 错误=${errorCount} 重启=${browserRestartCount}`,
+      `\n── ${signal} ── 处理=${processedCount} 跳过=${skippedCount} 错误=${errorCount}`,
     );
-    await session.shutdown();
+    await closeResources();
     console.error("已退出");
     process.exit(0);
   };
@@ -567,37 +421,26 @@ async function runAutoMode(options) {
   if (jobLocations) console.error(`║  任务过滤: ${jobLocations}`);
   console.error(`║  服务端:   ${serverUrl}`);
   console.error(
-    `║  CDP 端口池: ${portPoolStart}-${portPoolStart + CFG.portPoolSize - 1}（当前: ${session.port}）`,
+    `║  CDP 端口: ${cdpPort}${effectiveProxy ? "  代理: " + effectiveProxy : ""}`,
   );
   console.error(`║  并行: ${actualParallel}, 间隔: ${actualInterval}s`);
   console.error(`║  每视频最大评论: ${actualMaxComments}`);
-  if (effectiveProxy) console.error(`║  代理: ${effectiveProxy}`);
   console.error(`╚══════════════════════════════════════════╝`);
-  console.error(`📊 启动内存: ${formatMemoryWithBrowser(session.port)}`);
+  console.error(`📊 启动内存: ${formatMemoryWithBrowser(cdpPort)}`);
   console.error("开始循环接收任务...\n");
 
-  // ── 启动浏览器 ──
-  try {
-    await session.init();
-  } catch (err) {
-    console.error(`× 浏览器启动失败: ${err.message}`);
-    process.exit(1);
-  }
-
   // ════════════════════════════════════════
   // 主循环
   // ════════════════════════════════════════
   try {
     while (!shuttingDown) {
+      // 浏览器窗口被手动关闭（CDP 断开）→ 自动退出
+      if (isBrowserDisconnected(browser)) {
+        console.error("🚪 检测到浏览器窗口已关闭，自动退出");
+        await shutdown("浏览器已关闭");
+        return;
+      }
       try {
-        // 确保页面可用
-        await session.ensurePage();
-        if (!session.page) {
-          console.error("  ⚠ 无可用页面 → 重建会话");
-          await session.recycleSession("page missing", { switchPort: false });
-          continue;
-        }
-
         // ── 领取任务 ──
         let tasks;
         try {
@@ -607,18 +450,19 @@ async function runAutoMode(options) {
           const resp = await apiGet(apiUrl);
           tasks = resp.tasks || [];
         } catch (err) {
-          console.error(`  × 获取任务失败: ${err.message}`);
-          consecutiveErrors++;
-          if (consecutiveErrors > 0 && consecutiveErrors % 30 === 0) {
-            console.error(
-              `  ⚠ 已连续获取失败 ${consecutiveErrors} 次，继续等待服务恢复...`,
-            );
+          // 领取失败计入网络错误（服务端不可达 / 代理不通都算）
+          const over = bumpErrorCount("network");
+          console.error(
+            `  × 获取任务失败: ${err.message}（连续网络错误 ${errorCounts.network} 次），15 秒后重试...`,
+          );
+          if (over) {
+            await networkErrorExit();
+            return;
           }
-          const waitMs = Math.min(consecutiveErrors * 1000, 60000);
-          await delay(waitMs, waitMs + 1000);
+          await new Promise((r) => setTimeout(r, 15000));
           continue;
         }
-        consecutiveErrors = 0;
+        errorCounts.network = 0; // 领取成功 → 网络计数清零
 
         if (tasks.length === 0) {
           console.error(`  … 无任务，${actualInterval}s 内重试`);
@@ -648,18 +492,20 @@ async function runAutoMode(options) {
             console.error(`【${taskNum}】${href.substring(0, 60)}…`);
 
             // 确保页面可用
-            await session.ensurePage();
-            if (!session.page) throw new Error("未找到可用页面");
+            if (!page || page.isClosed()) {
+              page = await getOrCreatePage(browser);
+              await setupPageBlocking(page);
+            }
 
             // ── 登录弹窗检测（任务前）──
             try {
-              const modals = await detectModals(session.page);
+              const modals = await detectModals(page);
               const loginModal = modals.find(
                 (m) => m.type === "login-modal" || m.type === "modal-container",
               );
               if (loginModal) {
                 console.error(`        🔔 检测到登录弹窗，正在关闭...`);
-                const { closed, failed } = await closeAllModals(session.page, {
+                const { closed, failed } = await closeAllModals(page, {
                   waitMs: 300,
                 });
                 console.error(
@@ -672,11 +518,11 @@ async function runAutoMode(options) {
             }
 
             // 导航到视频页
-            await prepareVideoPage(session.page, href);
+            await prepareVideoPage(page, href);
 
             // ── 提取视频 tag（仅 ttSeller 视频）──
             if (ttSeller && loc) {
-              const { tagNames } = await extractVideoTags(session.page);
+              const { tagNames } = await extractVideoTags(page);
               if (tagNames.length > 0) {
                 const { inserted } = await saveVideoTags(
                   apiPost,
@@ -693,13 +539,13 @@ async function runAutoMode(options) {
             }
 
             // 获取评论
-            const result = await fetchUserCommentsAPI(session.page, {
+            const result = await fetchUserCommentsAPI(page, {
               maxComments: actualMaxComments,
               log: () => {},
             });
 
             // 关闭评论面板
-            await closeCommentPanel(session.page);
+            await closeCommentPanel(page);
 
             // ── 处理结果 ──
             let resultNote = "";
@@ -713,17 +559,16 @@ async function runAutoMode(options) {
 
               // ── 先检测并关闭登录弹窗（避免被误判为验证码导致长时间等待）──
               try {
-                const modalsBefore = await detectModals(session.page);
+                const modalsBefore = await detectModals(page);
                 const loginModal = modalsBefore.find(
                   (m) =>
                     m.type === "login-modal" || m.type === "modal-container",
                 );
                 if (loginModal) {
                   console.error("        🔔 检测到登录弹窗，正在关闭...");
-                  const { closed, failed } = await closeAllModals(
-                    session.page,
-                    { waitMs: 300 },
-                  );
+                  const { closed, failed } = await closeAllModals(page, {
+                    waitMs: 300,
+                  });
                   console.error(
                     `        🔔 弹窗关闭: closed=${JSON.stringify(closed)} failed=${JSON.stringify(failed)}`,
                   );
@@ -737,7 +582,7 @@ async function runAutoMode(options) {
               await new Promise((r) =>
                 setTimeout(r, 3000 + Math.random() * 2000),
               );
-              const captchaResult = await waitAndGetCaptcha(session.page, {
+              const captchaResult = await waitAndGetCaptcha(page, {
                 waitMs: 180000,
                 pollInterval: 5000,
                 log: () => {},
@@ -756,28 +601,25 @@ async function runAutoMode(options) {
 
                 if (captchaResult.resolved) {
                   resultNote = "验证码已解决";
-                  consecutiveCaptchaCount = 0;
+                  errorCounts.captcha = 0; // 人工点掉 → 验证码计数清零
                 } else {
-                  consecutiveCaptchaCount++;
-                  resultNote = `验证码未解决(${consecutiveCaptchaCount}/${CFG.maxConsecutiveCaptcha})`;
-                  await closeCaptcha(session.page).catch(() => {});
+                  const over = bumpErrorCount("captcha");
+                  resultNote = `验证码未解决(连续第 ${errorCounts.captcha} 次)`;
+                  await closeCaptcha(page).catch(() => {});
                   await new Promise((r) => setTimeout(r, 1000));
-                }
-
-                if (consecutiveCaptchaCount >= CFG.maxConsecutiveCaptcha) {
-                  console.error(
-                    `  ♻️ 连续${CFG.maxConsecutiveCaptcha}次验证码 → 重启浏览器`,
-                  );
-                  await session.recycleSession("连续验证码", {
-                    switchPort: true,
-                  });
-                  consecutiveCaptchaCount = 0;
+                  if (over) {
+                    console.error(
+                      `  ❌ 连续验证码超过 ${ERROR_LIMITS.captcha} 次且未解决 → 打印并退出`,
+                    );
+                    await shutdown("连续验证码未解决");
+                    return;
+                  }
                 }
               } else {
-                consecutiveCaptchaCount = 0;
+                errorCounts.captcha = 0;
               }
             } else {
-              consecutiveCaptchaCount = 0;
+              errorCounts.captcha = 0;
               const authors = extractUniqueAuthors(result.comments);
               const discovered = authors.length;
               let added = 0,
@@ -806,105 +648,140 @@ async function runAutoMode(options) {
             // commit 任务
             await apiPut(`${serverUrl}/api/comment-task/${id}`);
             processedCount++;
-            consecutive403 = 0;
-            consecutiveTaskErrors = 0;
+            resetAllErrorCounts(); // 成功一个任务 → 所有错误计数清零
 
             // 每 10 个任务输出内存汇总
             if (totalTasks() % 10 === 0) {
-              const remainingMs =
-                session.sessionStartTime + CFG.maxSessionRunTimeMs - Date.now();
-              const remainingMins =
-                remainingMs > 0 ? Math.round(remainingMs / 60000) : 0;
               console.error(
-                `── #${totalTasks()} ── ${formatMemoryWithBrowser(session.port)}  处理=${processedCount} 跳过=${skippedCount} 错误=${errorCount}  距轮换≈${remainingMins}min`,
+                `── #${totalTasks()} ── ${formatMemoryWithBrowser(cdpPort)}  处理=${processedCount} 跳过=${skippedCount} 错误=${errorCount}`,
               );
             }
           } catch (err) {
             errorCount++;
-            consecutiveTaskErrors++;
-            const isBrowserClosed = isBrowserClosedError(err);
+            // 浏览器窗口被手动关闭 → 退出
+            if (isBrowserDisconnected(browser, err)) {
+              console.error(
+                `🚪 浏览器窗口已关闭 (${err.message || ""})，自动退出`,
+              );
+              await shutdown("浏览器已关闭");
+              return;
+            }
+            // 网络错误（含代理抖动 net::ERR_*）
+            if (isNetworkError(err)) {
+              const over = bumpErrorCount("network");
+              console.error(
+                `  ⚠️ 网络错误 (${err.message})，15 秒后重试（连续网络错误 ${errorCounts.network} 次）...`,
+              );
+              if (over) {
+                await networkErrorExit();
+                return;
+              }
+              await new Promise((r) => setTimeout(r, 15000));
+              continue;
+            }
             const is403 =
               err.message &&
               (err.message.includes("403") ||
                 err.message.includes("status 403") ||
                 err.message.includes("status code 403"));
-
             if (is403) {
-              consecutive403++;
+              const over = bumpErrorCount("http403");
               console.error(
-                `        403 (${consecutive403}/${CFG.consecutive403Blocked})`,
+                `        🚫 HTTP 403（连续第 ${errorCounts.http403} 次）`,
               );
-              if (consecutive403 >= CFG.consecutive403Blocked) {
-                console.error("  🚫 连续403 → 等2min重启浏览器");
-                await new Promise((r) => setTimeout(r, 120000));
-                await session.recycleSession("连续 403 封禁");
-                consecutive403 = 0;
+              if (over) {
+                console.error(
+                  `  ⚠️ 连续 403 超过 ${ERROR_LIMITS.http403} 次 → 上报服务端 + 触发 daemon fallback`,
+                );
+                await reportClientErrorAndFailover({
+                  post: apiPost,
+                  baseUrl: serverUrl,
+                  userId,
+                  errorType: "consecutive_blocked",
+                  message: `连续 ${ERROR_LIMITS.http403 + 1} 次 403 (port=${cdpPort})`,
+                  stage: "comments",
+                });
+                errorCounts.http403 = 0; // fallback 触发后清零
               }
-            } else if (isBrowserClosed) {
-              console.error("        浏览器断开 → 重启");
-              browserRestartCount++;
-              await session.restartBrowser();
-            } else {
-              console.error(`        ${err.message}`);
+              await recyclePage();
+              continue;
             }
-
-            // 连续任务错误达到阈值，汇报服务端 + 触发 daemon fallback 换节点
-            if (consecutiveTaskErrors >= CFG.consecutiveTaskErrorsMax) {
+            console.error(`        ${err.message}`);
+            const over = bumpErrorCount("other");
+            if (over) {
               console.error(
-                `  ⚠️ 连续任务错误 ${consecutiveTaskErrors}/${CFG.consecutiveTaskErrorsMax} → 汇报服务端 + 触发 fallback`,
+                `  ❌ 连续其他错误超过 ${ERROR_LIMITS.other} 次 → 打印并退出`,
               );
-              await reportConsecutiveTaskErrors({
-                post: apiPost,
-                baseUrl: serverUrl,
-                userId,
-                message: `连续 ${consecutiveTaskErrors} 个任务处理失败 (port=${session.port})`,
-                stage: "comments",
-              });
-              consecutiveTaskErrors = 0;
+              await shutdown("连续其他错误");
+              return;
             }
           }
-
-          // 任务间内存检查
-          await session.maybeRecycleForMemory(processedCount);
         }
       } catch (err) {
         errorCount++;
-        consecutiveTaskErrors++;
-        if (isBrowserClosedError(err)) {
-          browserRestartCount++;
-          console.error(`  ⚠ 浏览器断开 (#${browserRestartCount}) → 重启`);
-          await session.restartBrowser();
-        } else {
-          console.error(`  × ${err.message}`);
+        if (isBrowserDisconnected(browser, err)) {
+          console.error(`🚪 浏览器窗口已关闭 (${err.message || ""})，自动退出`);
+          await shutdown("浏览器已关闭");
+          return;
         }
-
-        // 连续轮间错误达到阈值，汇报服务端 + 触发 daemon fallback 换节点
-        if (consecutiveTaskErrors >= CFG.consecutiveTaskErrorsMax) {
+        if (isNetworkError(err)) {
+          const over = bumpErrorCount("network");
           console.error(
-            `  ⚠️ 连续轮间错误 ${consecutiveTaskErrors}/${CFG.consecutiveTaskErrorsMax} → 汇报服务端 + 触发 fallback`,
+            `  ⚠️ 网络错误 (${err.message})，15 秒后重试（连续网络错误 ${errorCounts.network} 次）...`,
           );
-          await reportConsecutiveTaskErrors({
-            post: apiPost,
-            baseUrl: serverUrl,
-            userId,
-            message: `连续 ${consecutiveTaskErrors} 个轮次处理失败 (port=${session.port})`,
-            stage: "comments",
-          });
-          consecutiveTaskErrors = 0;
+          if (over) {
+            await networkErrorExit();
+            return;
+          }
+          await new Promise((r) => setTimeout(r, 15000));
+          continue;
+        }
+        const is403 =
+          err.message &&
+          (err.message.includes("403") ||
+            err.message.includes("status 403") ||
+            err.message.includes("status code 403"));
+        if (is403) {
+          const over = bumpErrorCount("http403");
+          console.error(`  🚫 HTTP 403（连续第 ${errorCounts.http403} 次）`);
+          if (over) {
+            console.error(
+              `  ⚠️ 连续 403 超过 ${ERROR_LIMITS.http403} 次 → 上报服务端 + 触发 daemon fallback`,
+            );
+            await reportClientErrorAndFailover({
+              post: apiPost,
+              baseUrl: serverUrl,
+              userId,
+              errorType: "consecutive_blocked",
+              message: `连续 ${ERROR_LIMITS.http403 + 1} 次 403 (port=${cdpPort})`,
+              stage: "comments",
+            });
+            errorCounts.http403 = 0;
+          }
+          await new Promise((r) => setTimeout(r, 15000));
+          continue;
+        }
+        console.error(`  × ${err.message}`);
+        const over = bumpErrorCount("other");
+        if (over) {
+          console.error(
+            `  ❌ 连续其他错误超过 ${ERROR_LIMITS.other} 次 → 打印并退出`,
+          );
+          await shutdown("连续其他错误");
+          return;
         }
       }
 
-      // 轮间内存检查 + 等待
-      await session.maybeRecycleForMemory(processedCount);
+      // 轮间等待
       await delay(1000, actualInterval * 1000);
     }
   } finally {
     process.removeListener("SIGINT", onSigint);
     process.removeListener("SIGTERM", onSigterm);
     console.error(
-      `\n── 统计 ── 处理=${processedCount} 跳过=${skippedCount} 错误=${errorCount} 重启=${browserRestartCount}`,
+      `\n── 统计 ── 处理=${processedCount} 跳过=${skippedCount} 错误=${errorCount}`,
     );
-    await session.shutdown();
+    await closeResources();
   }
 }