tt-help-cli-ycl 1.4.184 → 1.4.185

package/src/cli/explore.js

@@ -39,6 +39,10 @@ import {
   ensurePoolLogin,
   crashBackoffMs,
   retryRestoreOnNavFailure,
+  CANDIDATE_INJECT_MAX_RETRIES,
+  CANDIDATE_INJECT_DELAY_MS,
+  decideCandidateInjectAction,
+  isRetryableInjectFailure,
 } from "../lib/login-pool-client.js";
 import { getClientConfig } from "../watchdog/reporter.js";
 import { createApiClient } from "../lib/api-client.js";
@@ -390,8 +394,10 @@ export async function handleExplore(options) {
 
     /**
      * 换号（以号为主键）：先取新号（旧号仍在手，无空窗）→ 注入验证 → 还旧号。
-     * 候选最多试 5 个（注入失败的释放回池）；池空/服务器不可达 → 保旧号返回 false，
-     * 由主循环「无在手账号」补取逻辑兑底。
+     * 候选最多试 5 个；注入失败按类型分流（decideCandidateInjectAction）：
+     * 浏览器级崩溃 → 熔断重启；确定性号死（会话过期/身份不符）→ 立即释放回池换下一个；
+     * 瞬态/环境失败 → 同一候选原号重试（共 3 次尝试，间隔 15s）全败才释放；
+     * 池空/服务器不可达 → 保旧号返回 false，由主循环「无在手账号」补取逻辑兑底。
      * @param code 受控换号原因（SWITCH_REASON，上报服务端 switchStats；可选）；
      *             首选按外层 call site 上报，候选注入失败后的再取号 = inject_fail
      */
@@ -405,6 +411,33 @@ export async function handleExplore(options) {
         );
         if (!(await sleepSliced(backoffWaitMs))) return false;
       }
+      // 候选注入失败命中浏览器级崩溃签名时的处置（首判与重试中途重判共用）：
+      // crashStreak++ 按轮退避 + 释放候选 + 上报 + 转同号重启；返回值由调用方直接 return
+      async function abortCandidateLoopOnCrash(crashReason, candidate, fromRecovery) {
+        // 浏览器级崩溃：不怪账号，立即中止候选循环（不消耗 inject_fail/recover_fail 口径），
+        // 已取候选照常 release，转同号重启（与内存超限路径同语义）；按轮熔断退避
+        crashStreak++;
+        const backoffMs = crashBackoffMs(crashStreak);
+        crashBackoffUntil = Date.now() + backoffMs;
+        console.error(
+          `[换号] @${candidate.username} 注入失败为浏览器级崩溃（${crashReason}），中止候选循环（第 ${crashStreak} 轮，熔断 ${Math.round(backoffMs / 1000)}s），释放候选...`,
+        );
+        await poolClient.release(candidate).catch(() => {});
+        await errorReporter.report({
+          username: poolAccount ? poolAccount.username : "unknown",
+          errorType: "account_switch_failed",
+          errorMessage: `注入失败为浏览器级崩溃，中止候选循环转同号重启（第${crashStreak}轮，熔断${Math.round(backoffMs / 1000)}s）: ${crashReason}`,
+          stage: "account-switch",
+        }).catch(() => {});
+        if (fromRecovery) {
+          // 恢复链中（重启后恢复失败触发的换号）不再递归重启，保留现场等熔断窗口
+          console.error(`[换号] 恢复链中不再递归重启浏览器，保留现场等待熔断窗口`);
+          return false;
+        }
+        return await restartPoolBrowser(
+          `注入验证遭遇浏览器级崩溃（${crashReason}）`,
+        );
+      }
       for (let attempt = 0; attempt < 5; attempt++) {
         let next = null;
         try {
@@ -415,40 +448,71 @@ export async function handleExplore(options) {
           );
           return false;
         }
-        const r = await injectPoolAccount(page, next, {
+        let r = await injectPoolAccount(page, next, {
           verifyUsername: next.username,
         }).catch((e) => ({ ok: false, reason: e.message }));
         if (!r.ok) {
-          if (isBrowserClosedError(new Error(r.reason))) {
-            // 浏览器级崩溃：不怪账号，立即中止候选循环（不消耗 inject_fail/recover_fail 口径），
-            // 已取候选照常 release，转同号重启（与内存超限路径同语义）；按轮熔断退避
-            crashStreak++;
-            const backoffMs = crashBackoffMs(crashStreak);
-            crashBackoffUntil = Date.now() + backoffMs;
-            console.error(
-              `[换号] @${next.username} 注入失败为浏览器级崩溃（${r.reason}），中止候选循环（第 ${crashStreak} 轮，熔断 ${Math.round(backoffMs / 1000)}s），释放候选...`,
+          // 注入失败三路分流（f11 48h 实测：~17% 瞬态环境失败曾连烧 5 候选全死于同一环境）：
+          // 崩溃 → 既有熔断（中止候选循环）；确定性号死 → 立即弃号换下一个候选（现状行为）；
+          // 瞬态/环境失败 → 同一候选原号重试（共 3 次尝试，间隔 15s），重试期间租约保持在手
+          let action = decideCandidateInjectAction(r.reason, isBrowserClosedError);
+          if (action === "circuit-break") {
+            return await abortCandidateLoopOnCrash(r.reason, next, opts.fromRecovery);
+          }
+          if (action === "retry") {
+            // 瞬态/环境失败（超时/AbortError/net::ERR_*/Execution context destroyed/无账号数据/导航类）：
+            // 原号重试最多 2 次（共 3 次尝试），间隔 15s，重试期间不 release（租约保持在手）；
+            // 确定性号死（会话过期/身份不符）不进此分支，直接弃号换下一个候选
+            r = await retryRestoreOnNavFailure(
+              () =>
+                injectPoolAccount(page, next, { verifyUsername: next.username }),
+              r.reason,
+              {
+                isRetryable: isRetryableInjectFailure,
+                maxRetries: CANDIDATE_INJECT_MAX_RETRIES,
+                delayMs: CANDIDATE_INJECT_DELAY_MS,
+                sleep: (ms) => sleepSliced(ms),
+                shouldAbort: () => shuttingDown,
+                onRetry: (n, delayMs, why) =>
+                  console.error(
+                    `[换号] @${next.username} 第${n}次注入失败（瞬态，${why}），${Math.round(delayMs / 1000)}s 后原号重试`,
+                  ),
+              },
             );
-            await poolClient.release(next).catch(() => {});
-            await errorReporter.report({
-              username: poolAccount ? poolAccount.username : "unknown",
-              errorType: "account_switch_failed",
-              errorMessage: `注入失败为浏览器级崩溃，中止候选循环转同号重启（第${crashStreak}轮，熔断${Math.round(backoffMs / 1000)}s）: ${r.reason}`,
-              stage: "account-switch",
-            }).catch(() => {});
-            if (opts.fromRecovery) {
-              // 恢复链中（重启后恢复失败触发的换号）不再递归重启，保留现场等熔断窗口
-              console.error(`[换号] 恢复链中不再递归重启浏览器，保留现场等待熔断窗口`);
+            if (r.aborted) {
+              // shuttingDown 中断：释放候选退出（租约主动还干净，服务端 TTL 兑底）
+              console.error(`[换号] @${next.username} 原号重试等待中被关闭信号中断，释放候选`);
+              await poolClient.release(next).catch(() => {});
               return false;
             }
-            return await restartPoolBrowser(
-              `注入验证遭遇浏览器级崩溃（${r.reason}）`,
-            );
+            if (r.ok && r.attempts > 1) {
+              console.error(
+                `[换号] @${next.username} 原号重试成功（第 ${r.attempts} 次尝试）`,
+              );
+            }
+            if (!r.ok) {
+              // 重试中途失败签名可能升级为浏览器级崩溃（如首败 timeout、再败 Page crashed）：
+              // 对最终原因重判，命中熔断则中止候选循环（不弃号给下一候选——坏浏览器再吃一个号），
+              // 升级为确定性号死则 fall through 到下方弃号分支换候选
+              action = decideCandidateInjectAction(r.reason, isBrowserClosedError);
+              if (action === "circuit-break") {
+                return await abortCandidateLoopOnCrash(r.reason, next, opts.fromRecovery);
+              }
+            }
+          }
+          if (!r.ok) {
+            if (r.attempts > 1) {
+              console.error(
+                `[换号] @${next.username} 原号重试 ${r.attempts - 1} 次后仍失败（共 ${r.attempts} 次尝试，${r.reason}），释放候选换下一个...`,
+              );
+            } else {
+              console.error(
+                `[换号] @${next.username} 注入验证失败（${r.reason}），释放候选换下一个...`,
+              );
+            }
+            await poolClient.release(next).catch(() => {});
+            continue;
           }
-          console.error(
-            `[换号] @${next.username} 注入验证失败（${r.reason}），释放候选换下一个...`,
-          );
-          await poolClient.release(next).catch(() => {});
-          continue;
         }
         // 新号验证通过：切换在手状态，再还旧号（谁持账号谁还）
         const prev = poolAccount;

package/src/cli/search.js

@@ -51,6 +51,10 @@ import {
   ensurePoolLogin,
   crashBackoffMs,
   retryRestoreOnNavFailure,
+  CANDIDATE_INJECT_MAX_RETRIES,
+  CANDIDATE_INJECT_DELAY_MS,
+  decideCandidateInjectAction,
+  isRetryableInjectFailure,
 } from "../lib/login-pool-client.js";
 import { getClientConfig } from "../watchdog/reporter.js";
 import {
@@ -476,6 +480,33 @@ export async function handleSearch(parsed) {
         );
         if (!(await sleepSliced(backoffWaitMs))) return false;
       }
+      // 候选注入失败命中浏览器级崩溃签名时的处置（首判与重试中途重判共用）：
+      // crashStreak++ 按轮退避 + 释放候选 + 上报 + 转同号重启；返回值由调用方直接 return
+      async function abortCandidateLoopOnCrash(crashReason, candidate, fromRecovery) {
+        // 浏览器级崩溃：不怪账号，立即中止候选循环（不消耗 inject_fail 口径），
+        // 已取候选照常 release，转同号重启（与内存超限路径同语义）；按轮熔断退避
+        crashStreak++;
+        const backoffMs = crashBackoffMs(crashStreak);
+        crashBackoffUntil = Date.now() + backoffMs;
+        log(
+          `[换号] @${candidate.username} 注入失败为浏览器级崩溃（${crashReason}），中止候选循环（第 ${crashStreak} 轮，熔断 ${Math.round(backoffMs / 1000)}s），释放候选...`,
+        );
+        await poolClient.release(candidate).catch(() => {});
+        await errorReporter.report({
+          username: poolAccount ? poolAccount.username : "unknown",
+          errorType: "account_switch_failed",
+          errorMessage: `注入失败为浏览器级崩溃，中止候选循环转同号重启（第${crashStreak}轮，熔断${Math.round(backoffMs / 1000)}s）: ${crashReason}`,
+          stage: "account-switch",
+        }).catch(() => {});
+        if (fromRecovery) {
+          // 恢复链中（重启后恢复失败触发的换号）不再递归重启，保留现场等熔断窗口
+          log(`[换号] 恢复链中不再递归重启浏览器，保留现场等待熔断窗口`);
+          return false;
+        }
+        return await restartPoolBrowser(
+          `注入验证遭遇浏览器级崩溃（${crashReason}）`,
+        );
+      }
       for (let attempt = 0; attempt < 5; attempt++) {
         let next = null;
         try {
@@ -486,40 +517,71 @@ export async function handleSearch(parsed) {
           );
           return false;
         }
-        const r = await injectPoolAccount(page, next, {
+        let r = await injectPoolAccount(page, next, {
           verifyUsername: next.username,
         }).catch((e) => ({ ok: false, reason: e.message }));
         if (!r.ok) {
-          if (isBrowserClosedError(new Error(r.reason))) {
-            // 浏览器级崩溃：不怪账号，立即中止候选循环（不消耗 inject_fail 口径），
-            // 已取候选照常 release，转同号重启（与内存超限路径同语义）；按轮熔断退避
-            crashStreak++;
-            const backoffMs = crashBackoffMs(crashStreak);
-            crashBackoffUntil = Date.now() + backoffMs;
-            log(
-              `[换号] @${next.username} 注入失败为浏览器级崩溃（${r.reason}），中止候选循环（第 ${crashStreak} 轮，熔断 ${Math.round(backoffMs / 1000)}s），释放候选...`,
+          // 注入失败三路分流（与 explore.js 镜像）：崩溃 → 既有熔断（中止候选循环）；
+          // 确定性号死 → 立即弃号换下一个候选（现状行为）；
+          // 瞬态/环境失败 → 同一候选原号重试（共 3 次尝试，间隔 15s），重试期间租约保持在手
+          let action = decideCandidateInjectAction(r.reason, isBrowserClosedError);
+          if (action === "circuit-break") {
+            return await abortCandidateLoopOnCrash(r.reason, next, opts.fromRecovery);
+          }
+          if (action === "retry") {
+            // 瞬态/环境失败（超时/AbortError/net::ERR_*/Execution context destroyed/无账号数据/导航类）：
+            // 原号重试最多 2 次（共 3 次尝试），间隔 15s，重试期间不 release（租约保持在手）；
+            // 确定性号死（会话过期/身份不符）不进此分支，直接弃号换下一个候选
+            r = await retryRestoreOnNavFailure(
+              () =>
+                injectPoolAccount(page, next, { verifyUsername: next.username }),
+              r.reason,
+              {
+                isRetryable: isRetryableInjectFailure,
+                maxRetries: CANDIDATE_INJECT_MAX_RETRIES,
+                delayMs: CANDIDATE_INJECT_DELAY_MS,
+                sleep: (ms) => sleepSliced(ms),
+                shouldAbort: () => shuttingDown,
+                onRetry: (n, delayMs, why) =>
+                  log(
+                    `[换号] @${next.username} 第${n}次注入失败（瞬态，${why}），${Math.round(delayMs / 1000)}s 后原号重试`,
+                  ),
+              },
             );
-            await poolClient.release(next).catch(() => {});
-            await errorReporter.report({
-              username: poolAccount ? poolAccount.username : "unknown",
-              errorType: "account_switch_failed",
-              errorMessage: `注入失败为浏览器级崩溃，中止候选循环转同号重启（第${crashStreak}轮，熔断${Math.round(backoffMs / 1000)}s）: ${r.reason}`,
-              stage: "account-switch",
-            }).catch(() => {});
-            if (opts.fromRecovery) {
-              // 恢复链中（重启后恢复失败触发的换号）不再递归重启，保留现场等熔断窗口
-              log(`[换号] 恢复链中不再递归重启浏览器，保留现场等待熔断窗口`);
+            if (r.aborted) {
+              // shuttingDown 中断：释放候选退出（租约主动还干净，服务端 TTL 兑底）
+              log(`[换号] @${next.username} 原号重试等待中被关闭信号中断，释放候选`);
+              await poolClient.release(next).catch(() => {});
               return false;
             }
-            return await restartPoolBrowser(
-              `注入验证遭遇浏览器级崩溃（${r.reason}）`,
-            );
+            if (r.ok && r.attempts > 1) {
+              log(
+                `[换号] @${next.username} 原号重试成功（第 ${r.attempts} 次尝试）`,
+              );
+            }
+            if (!r.ok) {
+              // 重试中途失败签名可能升级为浏览器级崩溃（如首败 timeout、再败 Page crashed）：
+              // 对最终原因重判，命中熔断则中止候选循环（不弃号给下一候选——坏浏览器再吃一个号），
+              // 升级为确定性号死则 fall through 到下方弃号分支换候选
+              action = decideCandidateInjectAction(r.reason, isBrowserClosedError);
+              if (action === "circuit-break") {
+                return await abortCandidateLoopOnCrash(r.reason, next, opts.fromRecovery);
+              }
+            }
+          }
+          if (!r.ok) {
+            if (r.attempts > 1) {
+              log(
+                `[换号] @${next.username} 原号重试 ${r.attempts - 1} 次后仍失败（共 ${r.attempts} 次尝试，${r.reason}），释放候选换下一个...`,
+              );
+            } else {
+              log(
+                `[换号] @${next.username} 注入验证失败（${r.reason}），释放候选换下一个...`,
+              );
+            }
+            await poolClient.release(next).catch(() => {});
+            continue;
           }
-          log(
-            `[换号] @${next.username} 注入验证失败（${r.reason}），释放候选换下一个...`,
-          );
-          await poolClient.release(next).catch(() => {});
-          continue;
         }
         const prev = poolAccount;
         poolAccount = next;

package/src/lib/login-pool-client.js

@@ -238,6 +238,8 @@ export async function retryRestoreOnNavFailure(attemptFn, firstFailure, opts = {
   let reason = firstFailure;
   let attempts = 1; // 首次尝试已发生
   while (typeof isRetryable === "function" && attempts <= maxRetries && isRetryable(reason)) {
+    // 每轮重试前回调（可选）：attempts=当前已失败次数，供调用方打「第N次失败→间隔后重试」日志
+    if (typeof opts.onRetry === "function") opts.onRetry(attempts, delayMs, reason);
     await sleep(delayMs);
     if (shouldAbort()) return { ok: false, reason, attempts, aborted: true };
     attempts++;
@@ -249,3 +251,68 @@ export async function retryRestoreOnNavFailure(attemptFn, firstFailure, opts = {
   }
   return { ok: false, reason, attempts };
 }
+
+// ── 候选注入失败原号重试（纯函数/纯常量，2026-11-05 f11 48h 实测驱动）──
+// 背景：注入验证失败 82.8% 为浏览器级崩溃（走既有崩溃熔断），~17% 为瞬态环境失败
+// （page.goto 超时 / AbortError / net::ERR_* / Execution context destroyed / 无账号数据），
+// 0 条会话过期。现状对非崩溃失败一律立即弃号换下一个候选，网络劣化窗口会连续烧掉
+// 5 个候选且全死于同一环境。改造：瞬态失败同一候选原号重试（共 3 次尝试，间隔 15s），
+// 重试期间租约保持在手；确定性号死（会话过期/身份不符）维持立即弃号；
+// 浏览器级崩溃维持熔断路径（决策上崩溃优先，见 decideCandidateInjectAction）。
+// 本组函数保持零依赖（崩溃签名判定由调用方注入 isBrowserClosedError，勿拖 playwright 链）。
+
+/** 候选注入瞬态失败原号重试：追加次数（共 3 次尝试，全败才弃号换下一个候选） */
+export const CANDIDATE_INJECT_MAX_RETRIES = 2;
+/** 候选注入重试间隔 */
+export const CANDIDATE_INJECT_DELAY_MS = 15 * 1000;
+
+/**
+ * 确定性号死：会话过期 / 身份不符（injectPoolAccount 的账号级失败文案）。
+ * 重试无意义（号本身死了，换环境也救不活），立即弃号换下一个候选。
+ */
+export function isDeterministicAccountFailure(reason) {
+  if (!reason) return false;
+  const msg = String(reason);
+  return msg.includes("会话过期") || msg.includes("身份不符");
+}
+
+/**
+ * 候选注入失败是否可原号重试（瞬态/环境失败白名单，f11 实测清单）：
+ * - 可重试：超时 / net::ERR_*（导航层） / AbortError / Execution context destroyed /
+ *   无账号数据 / 导航失败前缀
+ * - 不可重试：确定性号死（会话过期/身份不符）；浏览器级崩溃签名（Page/Target crashed 等
+ *   由调用方决策先行分流走熔断，此处对不含 net::ERR_CONNECTION 前缀的纯崩溃签名兜底排除）；
+ *   未知失败（既非号死也非已知瞬态签名）→ 不重试，维持现状立即弃号（保守兜底）
+ */
+export function isRetryableInjectFailure(reason) {
+  if (!reason) return false;
+  const msg = String(reason);
+  if (isDeterministicAccountFailure(msg)) return false;
+  if (msg.includes("net::ERR_")) return true;
+  if (/timed?\s*out|timeout/i.test(msg)) return true;
+  if (/AbortError/i.test(msg)) return true;
+  if (/Execution context (was )?destroyed/i.test(msg)) return true;
+  if (msg.includes("无账号数据")) return true;
+  if (msg.includes("导航失败")) return true;
+  return false;
+}
+
+/**
+ * 候选注入失败处置决策（纯函数，候选循环内按返回值三路分流）：
+ * 返回 "circuit-break" | "retry" | "discard"
+ * - circuit-break：浏览器级崩溃（isBrowserClosedError 命中，含 Page/Target crashed、
+ *   net::ERR_CONNECTION_* 等）→ 既有崩溃熔断路径（中止候选循环，已取候选照常 release）
+ * - discard：确定性号死（会话过期/身份不符）或未知失败 → 立即弃号换下一个候选（现状行为）
+ * - retry：瞬态/环境失败 → 同一候选原号重试（共 3 次尝试，间隔 15s，租约保持在手）
+ * @param {string} reason 注入失败原因
+ * @param {(error: Error) => boolean} [isBrowserClosedFn] 崩溃签名判定（客户端传
+ *        page.js 的 isBrowserClosedError，SSOT 留 page.js；测试可注入假谓词）
+ */
+export function decideCandidateInjectAction(reason, isBrowserClosedFn) {
+  const msg = String(reason ?? "");
+  if (typeof isBrowserClosedFn === "function" && isBrowserClosedFn(new Error(msg))) {
+    return "circuit-break";
+  }
+  if (isRetryableInjectFailure(msg)) return "retry";
+  return "discard";
+}