tt-help-cli-ycl 1.4.182 → 1.4.184

package/src/lib/error-report.js

@@ -0,0 +1,119 @@
+/**
+ * 客户端错误上报封装（方案甲：客户端报错自带字段）
+ *
+ * 背景：/api/error-report 的旧 username 字段语义混乱（在手池号/"account-switch"
+ * 占位/被探索目标/"unknown" 四种混传），且代理节点完全没报。本封装统一附加：
+ *   - poolUsername：报错时在手池号（getState 注入，无在手号空串，不传 "unknown"）
+ *   - proxyNode：当前 clash 节点名（三级 fallback：端口匹配通道 → 主通道 → 空串）
+ * 旧 username 字段原样透传（兼容存量页面显示），语义不动。
+ *
+ * 用法：
+ *   const errorReporter = createErrorReporter({
+ *     apiPost, serverUrl, userId,
+ *     proxyUrl: resolvedProxy,                    // 可选，缺省用 ~/.tt-help.json 的 proxy
+ *     getState: () => ({ poolUsername: poolAccount?.username || "" }),
+ *   });
+ *   await errorReporter.report({ errorType, errorMessage, stage, errorStack, username });
+ *
+ * 单测：scripts/test-error-report.mjs
+ */
+
+import { proxy as configuredProxy } from "./constants.js";
+import {
+  getClashHealth,
+  getClashHealthChannels,
+} from "../watchdog/reporter.js";
+
+/** 从代理地址提取端口（http://127.0.0.1:7897 → 7897；解析不出返回 0） */
+export function parseProxyPort(url) {
+  if (!url) return 0;
+  try {
+    const u = new URL(url);
+    const p = parseInt(u.port, 10);
+    if (p > 0) return p;
+  } catch {
+    /* 非 URL 形态走正则兑底 */
+  }
+  const m = String(url).match(/:(\d+)/);
+  return m ? parseInt(m[1], 10) || 0 : 0;
+}
+
+/**
+ * 解析当前 clash 节点名（三级 fallback）：
+ *   1. 与业务代理端口匹配且非 stale 的通道（clash-health-{port}.json）的 node
+ *   2. 主通道（clash-health.json，daemon 对主控制端双写）非 stale 的 node
+ *   3. 读不到（无 clash daemon / 文件 stale / 无 node 字段）→ ""
+ *
+ * @param {string|null} proxyUrl - 业务代理地址（--proxy 或 ~/.tt-help.json 的 proxy）
+ * @param {{channels?: Array<object>, health?: object|null}} [deps] - 测试注入用
+ * @returns {string}
+ */
+export function resolveProxyNode(proxyUrl, deps = {}) {
+  const channels = deps.channels ?? getClashHealthChannels();
+  const health = deps.health !== undefined ? deps.health : getClashHealth();
+  const port = parseProxyPort(proxyUrl);
+  if (port > 0) {
+    const ch = channels.find((c) => c && c.port === port && !c.stale);
+    if (ch && ch.node) return String(ch.node);
+  }
+  if (health && !health.stale && health.node) return String(health.node);
+  return "";
+}
+
+/**
+ * 创建错误上报器
+ *
+ * @param {object} opts
+ * @param {(url: string, body: object) => Promise<any>} opts.apiPost - API 客户端 POST（createApiClient 产出）
+ * @param {string} opts.serverUrl - watch 服务端地址
+ * @param {string} opts.userId - 客户端用户编号（机器级；单次调用可用 userId 覆盖）
+ * @param {string|null} [opts.proxyUrl] - 业务代理地址（缺省读 ~/.tt-help.json 的 proxy）
+ * @param {() => {poolUsername?: string}} [opts.getState] - 报错时刻状态（CLI 闭包注入在手池号）
+ * @returns {{ report: (info: object) => Promise<any> }}
+ */
+export function createErrorReporter({
+  apiPost,
+  serverUrl,
+  userId,
+  proxyUrl,
+  getState,
+}) {
+  if (!apiPost || !serverUrl) {
+    throw new Error("createErrorReporter 需要 apiPost 与 serverUrl");
+  }
+  // proxyUrl 未显式传（undefined）才回退配置文件；显式传 null 表示确无代理
+  const effectiveProxyUrl = proxyUrl === undefined ? configuredProxy : proxyUrl;
+
+  return {
+    /**
+     * 上报一条客户端异常
+     * @param {object} info
+     * @param {string} [info.userId] - 单次覆盖（如 search 每轮标签搜索的随机 clientId）
+     * @param {string} info.errorType
+     * @param {string} [info.errorMessage]
+     * @param {string} [info.stage]
+     * @param {string} [info.errorStack]
+     * @param {string} [info.username] - 旧字段原样透传（兼容），语义不动
+     */
+    async report({
+      userId: callUserId,
+      errorType,
+      errorMessage,
+      stage,
+      errorStack,
+      username,
+    } = {}) {
+      const state = getState ? getState() || {} : {};
+      return apiPost(`${serverUrl}/api/error-report`, {
+        userId: callUserId || userId,
+        username: username || "",
+        errorType: errorType || "other",
+        errorMessage: errorMessage || "",
+        stage: stage || "",
+        errorStack: errorStack || "",
+        poolUsername: state.poolUsername || "",
+        proxyNode: resolveProxyNode(effectiveProxyUrl),
+      });
+    },
+  };
+}

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

@@ -3,7 +3,7 @@
  *
  * 与心跳命令通道无关：acquire 响应直接携带明文 cookies（POST 专属通道，与心跳下发同级），
  * 注入由业务进程在自己持有的浏览器实例上执行（POC 实证 SOP，见知识库 edge-login-transfer.md）:
- *   context.clearCookies() + addCookies → 导航 tiktok.com → passport/web/account/info 验证身份
+ *   context.clearCookies() + 挂载一次性设备档案清档 + addCookies → 导航 tiktok.com → passport/web/account/info 验证身份
  *
  * 语义约定（2026-10-26 定稿：以号为主键，无幂等/无端口键）:
  *   - acquire: 挑最久未用的空闲号 → 租约 → 响应带明文 cookies；池空/服务器不可达抛错
@@ -93,6 +93,34 @@ export async function gotoTiktok(page, timeout = 45000) {
   });
 }
 
+/**
+ * 挂载「下一次文档加载起点」的一次性设备档案清空（addInitScript + token 自限，无需拆卸）。
+ * token 不匹配才清，清后写入新 token：下一次导航起 token 相等直接跳过，不误伤账号正常续用。
+ * 为什么不在活页上直接清：活页的 TikTok JS 会在清理后数秒内把旧设备 id 写回（实测），
+ * 必须赶在「新文档自身 JS 运行前」清，新会话才以全新设备初始化（配对软封修复，2026-11-01 实验）。
+ * 挂载失败仅告警不阻断（退化为旧行为）。返回的函数为兼容保留的空操作。
+ */
+export async function armDeviceWipeOnNextLoad(context, page) {
+  try {
+    const token = `w${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    await page.addInitScript((t) => {
+      try {
+        if (localStorage.getItem("__tt_wipe_token") === t) return;
+        localStorage.clear();
+        sessionStorage.clear();
+        localStorage.setItem("__tt_wipe_token", t);
+      } catch (e) {}
+      try { if (window.caches && caches.keys) { caches.keys().then((ks) => Promise.all(ks.map((k) => caches.delete(k)))).catch(() => {}); } } catch (e) {}
+      try { if (navigator.serviceWorker && navigator.serviceWorker.getRegistrations) { navigator.serviceWorker.getRegistrations().then((rs) => Promise.all(rs.map((r) => r.unregister()))).catch(() => {}); } } catch (e) {}
+      try { if (window.indexedDB && indexedDB.databases) { indexedDB.databases().then((dbs) => (dbs || []).forEach((d) => { try { const rq = indexedDB.deleteDatabase(d.name); rq.onsuccess = rq.onerror = rq.onblocked = () => {}; } catch (e) {} })).catch(() => {}); } } catch (e) {}
+    }, token);
+    return async () => {};
+  } catch (e) {
+    console.error(`[登录池] 设备档案清理挂载失败（忽略，退化为旧行为）: ${String(e).slice(0, 120)}`);
+    return async () => {};
+  }
+}
+
 function toPlaywrightCookies(cookies) {
   return (cookies || []).map((c) => ({
     name: c.name,
@@ -107,7 +135,7 @@ function toPlaywrightCookies(cookies) {
 
 /**
  * 原地注入账号（同一 Edge 运行实例，不重启浏览器；POC T2 实证）
- * 清旧 cookie → 注入 → 导航 → passport 验证身份。
+ * 清旧 cookie → 挂载一次性清档 → 注入 → 导航（新文档起点清上一账号设备档案）→ passport 验证身份。
  * @returns {Promise<{ok: boolean, username?: string, reason?: string}>}
  */
 export async function injectPoolAccount(page, account, { verifyUsername } = {}) {
@@ -116,8 +144,14 @@ export async function injectPoolAccount(page, account, { verifyUsername } = {})
   }
   const context = page.context();
   await context.clearCookies();
-  await context.addCookies(toPlaywrightCookies(account.cookies));
-  await gotoTiktok(page);
+  // 换号配对软封修复（2026-11-01 实验）：新文档起点清上一账号设备档案，让新会话以全新设备初始化
+  const disarmWipe = await armDeviceWipeOnNextLoad(context, page);
+  try {
+    await context.addCookies(toPlaywrightCookies(account.cookies));
+    await gotoTiktok(page);
+  } finally {
+    await disarmWipe();
+  }
   const id = await whoAmI(page);
   if (!id.hasAccount) {
     return {
@@ -159,3 +193,59 @@ export async function ensurePoolLogin(page, account) {
   }));
   return { ...r, injected: true };
 }
+
+// ── 崩溃熔断与恢复重试（纯函数/纯常量，2026-11-04 F16 实录驱动）──
+// 背景：渲染进程崩溃（Target/Page crashed）曾被误判为「账号注入失败」→ 换号循环烧池
+// （单日 28 号）。浏览器级失败须熔断退避（不取号保护账号池），账号级失败才候选轮换。
+// 本组常量/函数保持零依赖（login-pool-client 同时被 watchdog 侧引用，勿引入 playwright 链）。
+
+/** 崩溃熔断退避基数：第 1 轮 60s */
+export const CRASH_BACKOFF_BASE_MS = 60 * 1000;
+/** 崩溃熔断退避上限：15 分钟 */
+export const CRASH_BACKOFF_MAX_MS = 15 * 60 * 1000;
+
+/**
+ * 崩溃熔断退避时长：第 n 轮 = base × 2^(n-1)，封顶 max；n 非正整数返回 0。
+ * 注入验证成功即清零轮数（清零由调用方闭包状态负责）。
+ */
+export function crashBackoffMs(crashStreak, base = CRASH_BACKOFF_BASE_MS, max = CRASH_BACKOFF_MAX_MS) {
+  if (!Number.isInteger(crashStreak) || crashStreak <= 0) return 0;
+  return Math.min(base * 2 ** (crashStreak - 1), max);
+}
+
+/** 登录态恢复首败后追加重试次数（共 3 次尝试，全败才弃号转 recover_fail） */
+export const RESTORE_RETRY_MAX_RETRIES = 2;
+/** 恢复重试间隔 */
+export const RESTORE_RETRY_DELAY_MS = 10 * 1000;
+
+/**
+ * 登录态恢复重试驱动（纯逻辑，I/O 与谓词均注入，可单测；本文件保持零依赖）：
+ * 首次尝试已失败（firstFailure 为其失败原因），谓词判定为导航类瞬态失败则再试
+ * maxRetries 次、间隔 delayMs；账号级失败不重试直接返回。
+ * 调用方须传入 isRetryable（客户端用 page.js 的 isRetryableRestoreFailure）。
+ * @param {() => Promise<{ok: boolean, reason?: string}>} attemptFn 重试尝试
+ * @param {string} firstFailure 首次失败原因
+ * @param {object} opts {isRetryable, maxRetries, delayMs, sleep, shouldAbort}
+ *        （sleep/shouldAbort 供调用方接入分片中断）
+ * @returns {Promise<{ok: boolean, reason?: string, attempts: number, aborted?: boolean}>}
+ */
+export async function retryRestoreOnNavFailure(attemptFn, firstFailure, opts = {}) {
+  const isRetryable = opts.isRetryable;
+  const maxRetries = opts.maxRetries ?? RESTORE_RETRY_MAX_RETRIES;
+  const delayMs = opts.delayMs ?? RESTORE_RETRY_DELAY_MS;
+  const sleep = opts.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const shouldAbort = opts.shouldAbort || (() => false);
+  let reason = firstFailure;
+  let attempts = 1; // 首次尝试已发生
+  while (typeof isRetryable === "function" && attempts <= maxRetries && isRetryable(reason)) {
+    await sleep(delayMs);
+    if (shouldAbort()) return { ok: false, reason, attempts, aborted: true };
+    attempts++;
+    const r = await Promise.resolve()
+      .then(attemptFn)
+      .catch((e) => ({ ok: false, reason: e?.message || String(e) }));
+    if (r.ok) return { ...r, attempts };
+    reason = r.reason;
+  }
+  return { ok: false, reason, attempts };
+}

package/src/watch/data-store.js

@@ -2391,6 +2391,23 @@ export function createStore(filePath, options = {}) {
     return { saved: true };
   }
 
+  /**
+   * 自动恢复候选：updated_at 早于 maxAgeMs 的 error 行（B 方案：无次数上限全自动回流）。
+   * 仅扫 jobs——commitJob 会把 error 行从 task_queue 搬到 jobs（与页面「批量重新处理」同口径），
+   * 回流本身交给 resetJob（三表迁移 + 空池缓存失效 + 统计置脏全复用）。
+   * @returns {string[]} unique_id 列表（无 DB 的 JSON 模式返回空）
+   */
+  function listStaleErrorJobs(maxAgeMs, limit = 500) {
+    if (!getDb()) return [];
+    const cutoff = Date.now() - maxAgeMs;
+    return getDb()
+      .prepare(
+        `SELECT unique_id FROM jobs WHERE status = 'error' AND updated_at < ? ORDER BY updated_at LIMIT ?`,
+      )
+      .all(cutoff, limit)
+      .map((r) => r.unique_id);
+  }
+
   function togglePin(uniqueId) {
     if (getDb()) {
       const user = getJob(uniqueId);
@@ -2686,6 +2703,8 @@ export function createStore(filePath, options = {}) {
     errorStack,
     hostname,
     clientId,
+    poolUsername,
+    proxyNode,
   ) {
     const existing = clientErrors.get(userId);
     if (existing) {
@@ -2708,6 +2727,9 @@ export function createStore(filePath, options = {}) {
         existing.reportCount = (existing.reportCount || 1) + 1;
       }
       if (username) existing.username = username;
+      // 在手池号/代理节点（方案甲新增）：非空才覆盖，同 username 语义
+      if (poolUsername) existing.poolUsername = poolUsername;
+      if (proxyNode) existing.proxyNode = proxyNode;
     } else {
       clientErrors.set(userId, {
         userId,
@@ -2718,6 +2740,8 @@ export function createStore(filePath, options = {}) {
         errorStack: errorStack || "",
         username,
         stage: stage || "",
+        poolUsername: poolUsername || "",
+        proxyNode: proxyNode || "",
         timestamp: Date.now(),
         reportCount: 1,
         captchaCount: errorType === "captcha" ? 1 : 0,
@@ -3816,6 +3840,7 @@ export function createStore(filePath, options = {}) {
     commitJob,
     commitNewExplore,
     resetJob,
+    listStaleErrorJobs,
     togglePin,
     getNextRedoJob,
     commitRedoJob,