tt-help-cli-ycl 1.4.146 → 1.4.148

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tt-help-cli-ycl",
-  "version": "1.4.146",
+  "version": "1.4.148",
   "description": "TikTok user & video data scraper - extract ttSeller, verified, locationCreated from HTML source",
   "type": "module",
   "bin": {

package/scripts/test-product-fill-cdp.mjs

@@ -138,6 +138,37 @@ try {
     assert.strictEqual(parsed.subcommand, "product-fill"),
   );
   check("-l 3 生效", () => assert.strictEqual(parsed.productFillLimit, 3));
+  check("--task-delay 未传时默认 5", () =>
+    assert.strictEqual(parsed.productFillTaskDelay, 5),
+  );
+
+  process.argv = [
+    "node",
+    "tt-help",
+    "product-fill",
+    "--profiles",
+    "US/9223",
+    "--task-delay",
+    "30",
+  ];
+  const parsedDelay = parseArgs();
+  check("--task-delay 30 生效", () =>
+    assert.strictEqual(parsedDelay.productFillTaskDelay, 30),
+  );
+
+  process.argv = [
+    "node",
+    "tt-help",
+    "product-fill",
+    "--profiles",
+    "US/9223",
+    "--task-delay",
+    "0",
+  ];
+  const parsedDelayZero = parseArgs();
+  check("--task-delay 0 生效（关闭任务间延迟）", () =>
+    assert.strictEqual(parsedDelayZero.productFillTaskDelay, 0),
+  );
 
   process.argv = [
     "node",
@@ -163,6 +194,99 @@ try {
   process.argv = origArgv;
 }
 
+console.log("\n[6] 浏览器断连判定（网络层错误不重启，防误杀 Edge）");
+const { isBrowserDisconnected, isNetworkError, isCDPPortReady } =
+  await import("../src/cli/product-fill.js");
+
+const onlineBrowser = { isConnected: () => true };
+const offlineBrowser = { isConnected: () => false };
+
+check("net::ERR_CONNECTION_CLOSED + 浏览器在线 → 不断连", () => {
+  assert.strictEqual(
+    isBrowserDisconnected(
+      onlineBrowser,
+      new Error("page.goto: net::ERR_CONNECTION_CLOSED at https://..."),
+    ),
+    false,
+  );
+});
+check("net::ERR_CONNECTION_RESET + 浏览器在线 → 不断连", () => {
+  assert.strictEqual(
+    isBrowserDisconnected(
+      onlineBrowser,
+      new Error("net::ERR_CONNECTION_RESET"),
+    ),
+    false,
+  );
+});
+check("net::ERR_PROXY_CONNECTION_FAILED + 浏览器在线 → 不断连", () => {
+  assert.strictEqual(
+    isBrowserDisconnected(
+      onlineBrowser,
+      new Error("net::ERR_PROXY_CONNECTION_FAILED"),
+    ),
+    false,
+  );
+});
+check("isConnected()=false → 断连", () => {
+  assert.strictEqual(
+    isBrowserDisconnected(offlineBrowser, new Error("any error")),
+    true,
+  );
+});
+check("Target closed + 在线 → 断连", () => {
+  assert.strictEqual(
+    isBrowserDisconnected(onlineBrowser, new Error("Target closed")),
+    true,
+  );
+});
+check("Browser has been closed + 在线 → 断连", () => {
+  assert.strictEqual(
+    isBrowserDisconnected(onlineBrowser, new Error("Browser has been closed")),
+    true,
+  );
+});
+check("Target page... closed + 在线 → 断连", () => {
+  assert.strictEqual(
+    isBrowserDisconnected(
+      onlineBrowser,
+      new Error("Target page, context or browser has been closed"),
+    ),
+    true,
+  );
+});
+check("Protocol error + 在线 → 不断连（交给错误计数处理）", () => {
+  assert.strictEqual(
+    isBrowserDisconnected(onlineBrowser, new Error("Protocol error")),
+    false,
+  );
+});
+check("无错误参数 → 不断连", () => {
+  assert.strictEqual(isBrowserDisconnected(onlineBrowser, null), false);
+});
+check("isNetworkError(net::ERR_*) → true", () => {
+  assert.strictEqual(
+    isNetworkError(new Error("net::ERR_CONNECTION_CLOSED")),
+    true,
+  );
+});
+check("isNetworkError(普通错误) → false", () => {
+  assert.strictEqual(isNetworkError(new Error("Timeout")), false);
+});
+
+console.log("\n[7] CDP 端口就绪探测（isCDPPortReady）");
+// 未监听端口应快速返回 false（本机无 Edge 监听该端口）
+const probeResult = await isCDPPortReady(65531);
+if (probeResult === false) {
+  passed++;
+  console.log("  ✅ 未监听端口 → false");
+} else {
+  console.error(
+    "  ❌ 未监听端口 → false\n     期望 false，实得 " + probeResult,
+  );
+  process.exitCode = 1;
+}
+
 console.log(
   `\n结果: ${passed} 通过${process.exitCode ? ", 有失败" : ", 0 失败"}`,
 );

package/src/cli/attach.js

@@ -143,12 +143,17 @@ export async function handleAttach(options) {
 
   if (webserverUrl) {
     attachLog(`[Attach] webserver 模式: ${webserverUrl}`);
+    // webserver 端共享 scraper（poolSize 默认 8，每 slot 串行），当 -p 并发数大于
+    // poolSize 时，请求会在 webserver 内排队，端到端耗时可达数分钟（实测 270~310s）。
+    // 30s 超时太短会让整批任务被误判失败（aborted due to timeout），故放宽到 10 分钟
+    // 作为兜底——webserver 进程若真的挂了，连接会立即断开报错，不会真的空等 10 分钟。
+    const WEBSERVER_FETCH_TIMEOUT_MS = 600000;
     getUserInfo = async (uniqueId) => {
       const res = await fetch(`${webserverUrl}/api/tiktok/user`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ uniqueId }),
-        signal: AbortSignal.timeout(30000),
+        signal: AbortSignal.timeout(WEBSERVER_FETCH_TIMEOUT_MS),
       });
       let data = null;
       try {

package/src/cli/product-fill.js

@@ -17,13 +17,13 @@
 import { ProxyAgent, request } from "undici";
 import { getMacOrUuid } from "../lib/mac-or-uuid.js";
 import { createApiClient } from "../lib/api-client.js";
-import { userId as configuredUserId, saveUserId } from "../lib/constants.js";
-import { ensureBrowserReady } from "../lib/browser/cdp.js";
 import {
-  getOrCreatePage,
-  isBrowserClosedError,
-  relaunchBrowser,
-} from "../lib/browser/page.js";
+  userId as configuredUserId,
+  saveUserId,
+  proxy as configuredProxy,
+} from "../lib/constants.js";
+import { ensureBrowserReady, killEdgeProcesses } from "../lib/browser/cdp.js";
+import { getOrCreatePage, relaunchBrowser } from "../lib/browser/page.js";
 import {
   getProductInfoCDP,
   isEmptyProductDetail,
@@ -37,7 +37,7 @@ const CAPTCHA_BACKOFF_MS = 30_000; // 验证码后冷却时长
 const CDP_CAPTCHA_WAIT_MS = 180_000; // CDP 模式人工解验证码最长等待
 const FAIL_MARK_LIMIT = 3; // 连续失败达到该次数后哨兵放弃
 const SENTINEL_RATING = -1; // 哨兵：商品不可售/已下架（正常评分 0-5，-1 不会冲突）
-const DEFAULT_PROXY = "http://127.0.0.1:7897"; // 未传 --proxy 时按本机 Clash 默认端口探测
+const DEFAULT_PROXY = "http://127.0.0.1:7897"; // 未配置任何代理时，出口探测按本机 Clash 默认端口尝试
 
 function formatNow() {
   return new Date().toLocaleString("zh-CN", { hour12: false });
@@ -47,6 +47,62 @@ function log(message = "") {
   console.error(`[${formatNow()}] ${message}`);
 }
 
+/**
+ * 判断浏览器是否真的已断开（用户手动关窗口 / CDP 断连）。
+ * 网络层错误（net::ERR_CONNECTION_CLOSED/RESET/REFUSED...）是代理断连/节点切换，
+ * 浏览器进程还活着，不算断连 —— 只认两种确凿信号：
+ *   1. browser.isConnected() === false（CDP 连接已断）
+ *   2. 明确的关闭消息（Target closed / Browser has been closed）
+ * 参考 tag.js 的 isBrowserDisconnected；page.js 的 isBrowserClosedError
+ * 会把 net::ERR_CONNECTION_* 误判为浏览器关闭，进而误杀共用端口的 Edge。
+ */
+export function isBrowserDisconnected(browser, error) {
+  try {
+    if (
+      browser &&
+      typeof browser.isConnected === "function" &&
+      !browser.isConnected()
+    ) {
+      return true;
+    }
+  } catch {}
+  if (!error) return false;
+  const msg = error.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_*）：代理断连/节点切换，浏览器没死，不应触发重启 */
+export function isNetworkError(error) {
+  if (!error) return false;
+  const msg = error.message || "";
+  return msg.includes("net::ERR_");
+}
+
+/**
+ * 探测 CDP 端口是否已有浏览器在监听（连接前调用，
+ * 用于区分"本进程启动的浏览器"和"复用的已存在实例"，
+ * 退出时只关闭前者，不误杀用户自己开着的 Edge）。
+ */
+export async function isCDPPortReady(port) {
+  try {
+    const { statusCode, body } = await request(
+      `http://127.0.0.1:${port}/json`,
+      { method: "GET", headersTimeout: 2000, bodyTimeout: 2000 },
+    );
+    try {
+      await body.dump();
+    } catch {}
+    return statusCode === 200;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * 通过代理探测出口 IP 国家码（ip-api.com 免费接口）。
  * 探测失败（超时/代理未开/接口异常）返回 null。
@@ -77,10 +133,15 @@ export async function handleProductFill(options) {
     productFillInterval,
     serverUrl,
     productFillProxy,
+    productFillTaskDelay,
     productFillProfiles,
     showHelp,
   } = options;
 
+  // 与其他命令口径一致：--proxy 参数 > 配置文件 ~/.tt-help.json 的 proxy；
+  // 均未配置则不注入 proxyServer，浏览器走系统默认代理（explore/attach 同款）
+  const resolvedProxy = productFillProxy || configuredProxy || null;
+
   if (showHelp) {
     log(
       "用法: tt-help product-fill --profiles <国家/端口>[,<国家/端口>...] [-s 服务端] [-i 间隔秒] [-l 每批上限] [--proxy URL]",
@@ -95,10 +156,13 @@ export async function handleProductFill(options) {
     );
     log("  -s, --server <URL>      服务端地址（默认: http://127.0.0.1:3001）");
     log(
-      "  --proxy <URL>           浏览器启动代理及出口探测（默认: http://127.0.0.1:7897）",
+      "  --proxy <URL>           浏览器启动代理及出口探测（未指定时用配置文件 ~/.tt-help.json 的 proxy；均未配置则浏览器走系统默认代理）",
     );
     log("  -i, --interval <N>      无任务时轮询间隔，单位秒（默认: 10）");
     log("  -l, --limit <N>         每批领取任务数上限（默认: 5）");
+    log(
+      "  --task-delay <N>        每个任务处理完后的随机延迟上限，秒（默认: 5，实际等待 N/2~N 秒随机）",
+    );
     log("");
     log("说明:");
     log("  循环向服务端 /api/product-tasks?country=XX 领取缺商品详情任务；");
@@ -171,6 +235,9 @@ export async function handleProductFill(options) {
   let browser = null;
   let page = null;
   let currentPort = null;
+  // 本进程启动（或断连重启拉起）的浏览器端口：退出时按端口关闭；
+  // 连接前端口已有浏览器（用户自己开的）→ 不记录，退出时不杀
+  const launchedPorts = new Set();
   const connectProfile = async (profile) => {
     if (currentPort === profile.port && browser) return;
     if (browser) {
@@ -179,18 +246,21 @@ export async function handleProductFill(options) {
       page = null;
     }
     const cdpOptions = { port: profile.port };
-    if (productFillProxy) cdpOptions.proxyServer = productFillProxy;
+    if (resolvedProxy) cdpOptions.proxyServer = resolvedProxy;
+    const wasReady = await isCDPPortReady(profile.port);
     log(
-      `[ProductFill] 切换浏览器端口 ${currentPort ?? "-"} → ${profile.port}（country=${profile.country}${productFillProxy ? `，代理 ${productFillProxy}` : ""}）`,
+      `[ProductFill] 切换浏览器端口 ${currentPort ?? "-"} → ${profile.port}（country=${profile.country}${resolvedProxy ? `，代理 ${resolvedProxy}` : ""}）`,
     );
     browser = await ensureBrowserReady(cdpOptions);
+    if (!wasReady) launchedPorts.add(profile.port);
     page = await getOrCreatePage(browser);
     currentPort = profile.port;
     log(`[ProductFill] CDP 浏览器已就绪（当前页: ${page.url()}）`);
   };
 
   // ── 代理出口国家探测 ──
-  const effectiveProxyUrl = productFillProxy || DEFAULT_PROXY;
+  // 与浏览器启动通道保持一致；未配置任何代理时按本机 Clash 默认端口探测
+  const effectiveProxyUrl = resolvedProxy || DEFAULT_PROXY;
   let proxyCountry = null;
   const refreshProxyCountry = async () => {
     const prev = proxyCountry;
@@ -218,6 +288,18 @@ export async function handleProductFill(options) {
       tick();
     });
 
+  /**
+   * 任务间随机延迟（可被退出信号中断）：--task-delay 为最大秒数 N，
+   * 实际等待 N/2 ~ N 秒随机（随机口径与 delay.js 的 delay(min, max) 一致）。
+   * N=0 时立即返回（关闭任务间延迟）。
+   */
+  const taskRandomDelay = () => {
+    const maxMs = (productFillTaskDelay ?? 0) * 1000;
+    const minMs = Math.floor(maxMs / 2);
+    const ms = Math.floor(Math.random() * (maxMs - minMs + 1)) + minMs;
+    return interruptibleSleep(ms);
+  };
+
   let loopCount = 0;
   let totalSuccess = 0;
   let totalFailed = 0;
@@ -260,29 +342,68 @@ export async function handleProductFill(options) {
   };
 
   /** CDP 直抓：验证码在已登录浏览器中弹出时，等待人工解决后自动重试 */
-  const fetchViaCDP = async (seoUrl) => {
+  const fetchViaCDP = async (seoUrl, uniqueId) => {
     try {
       return await getProductInfoCDP(page, seoUrl);
     } catch (e) {
       if (!e.message?.includes("Blocked by TikTok")) throw e;
-      // 验证码：优先检测可见容器并等待人工解决（浏览器就在本机屏幕上）
-      const cap = await detectCaptcha(page);
-      if (cap?.exists) {
-        log("  ⏳ 检测到验证码，请在已登录的浏览器窗口中手动解决...");
+      // 撞码即向服务端报一次（errorType: captcha），之后无论人工解决、
+      // 自动放行还是超时冷却，本任务流程不再重复上报
+      await apiPost(`${serverUrl}/api/error-report`, {
+        userId,
+        username: uniqueId,
+        errorType: "captcha",
+        errorMessage: e.message,
+        stage: "product-fill",
+      }).catch(() => {});
+      // 验证码拦截统一等待（上限 3 分钟）：容器可能稍后才渲染（HTML 已含
+      // 标记、DOM 未挂载），也可能全程不出现（风控软拦/结构变化）。
+      // 轮询期间容器出现 → 交人工解决；容器未出现但页面恢复出商品数据 →
+      // 直接重试；到点仍拦截 → 抛 captcha 错误走 30s 冷却
+      log(
+        `  ⏳ 验证码拦截，等待处理（上限 ${CDP_CAPTCHA_WAIT_MS / 1000}s，可在浏览器中人工解决）...`,
+      );
+      const deadline = Date.now() + CDP_CAPTCHA_WAIT_MS;
+      let cap = await detectCaptcha(page);
+      while (!cap && Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 5000));
+        cap = await detectCaptcha(page);
+        if (!cap) {
+          // 容器始终没出现：探测页面是否已自动放行
+          const html = await page.content().catch(() => "");
+          if (
+            html.includes('"product_model"') ||
+            html.includes('"review_ratings"')
+          ) {
+            log("  ✓ 拦截已自动解除，重新抓取...");
+            return getProductInfoCDP(page, seoUrl);
+          }
+        }
+      }
+      if (cap) {
+        log("  ⏳ 请在已登录的浏览器窗口中手动解决验证码...");
         const r = await waitAndGetCaptcha(page, {
-          waitMs: CDP_CAPTCHA_WAIT_MS,
+          waitMs: Math.max(0, deadline - Date.now()),
           pollInterval: 5000,
           log,
         });
         if (r.resolved) {
           log("  ✓ 验证码已解决，重新抓取...");
-          return getProductInfoCDP(page, seoUrl);
+          try {
+            return await getProductInfoCDP(page, seoUrl);
+          } catch (retryErr) {
+            // 重试又撞码：仍标记 captcha 走冷却，避免误计 noteFail 哨兵
+            if (retryErr.message?.includes("Blocked by TikTok")) {
+              retryErr.captcha = true;
+            }
+            throw retryErr;
+          }
         }
       }
       const err = new Error(
-        cap?.exists
+        cap
           ? "验证码等待人工解决超时"
-          : "验证码拦截（无可见验证码容器）",
+          : "验证码拦截（3 分钟内未出现容器且未自动解除）",
       );
       err.captcha = true;
       throw err;
@@ -290,23 +411,43 @@ export async function handleProductFill(options) {
   };
 
   /** 抓取商品详情，带浏览器断连恢复与空数据防御 */
-  const getTaskDetail = async (seoUrl) => {
+  const getTaskDetail = async (seoUrl, country, uniqueId) => {
     let detail;
     try {
-      detail = await fetchViaCDP(seoUrl);
+      detail = await fetchViaCDP(seoUrl, uniqueId);
     } catch (e) {
-      if (!isBrowserClosedError(e)) throw e;
-      log("  ↻ 浏览器断连，重启浏览器后重试...");
-      try {
-        const cdpOptions = { port: currentPort };
-        if (productFillProxy) cdpOptions.proxyServer = productFillProxy;
-        browser = await relaunchBrowser(cdpOptions, currentPort);
-        page = await getOrCreatePage(browser);
-      } catch (relaunchErr) {
-        relaunchErr.retryable = true;
-        throw relaunchErr;
+      if (isBrowserDisconnected(browser, e)) {
+        // 确凿断连（CDP 断开 / 明确关闭消息）才重启浏览器
+        log("  ↻ 浏览器断连，重启浏览器后重试...");
+        try {
+          const cdpOptions = { port: currentPort };
+          if (resolvedProxy) cdpOptions.proxyServer = resolvedProxy;
+          browser = await relaunchBrowser(cdpOptions, currentPort);
+          page = await getOrCreatePage(browser);
+          launchedPorts.add(currentPort); // 重启拉起的实例归本进程管，退出时关闭
+        } catch (relaunchErr) {
+          relaunchErr.retryable = true;
+          throw relaunchErr;
+        }
+        // 重启后先确认代理出口恢复正常，避免刚拉起又撞上代理断连窗口
+        await refreshProxyCountry();
+        if (!proxyCountry || (country && proxyCountry !== country)) {
+          const err = new Error(
+            `浏览器重启后代理出口异常（${proxyCountry || "探测失败"}），本轮跳过`,
+          );
+          err.retryable = true;
+          throw err;
+        }
+        detail = await fetchViaCDP(seoUrl, uniqueId);
+      } else if (isNetworkError(e)) {
+        // 网络层错误：代理断连/Clash 切节点，浏览器没死，不杀浏览器，
+        // 记为可重试错误跳过本轮，下轮代理探测自然跟上
+        const err = new Error(`网络层错误（浏览器未重启）: ${e.message}`);
+        err.retryable = true;
+        throw err;
+      } else {
+        throw e;
       }
-      detail = await fetchViaCDP(seoUrl);
     }
     // 空数据防御：回写字段全空，不回写（防止假成功死循环）
     if (isEmptyProductDetail(detail)) {
@@ -390,7 +531,7 @@ export async function handleProductFill(options) {
         }
         log(`  → 补商品 @${uniqueId} ...`);
         try {
-          const detail = await getTaskDetail(seoUrl);
+          const detail = await getTaskDetail(seoUrl, profile.country, uniqueId);
           const post = await apiPost(
             `${serverUrl}/api/product-fill/${encodeURIComponent(uniqueId)}`,
             { productDetail: detail },
@@ -416,6 +557,9 @@ export async function handleProductFill(options) {
             log(
               `  ⏳ @${uniqueId} 验证码拦截，冷却 ${CAPTCHA_BACKOFF_MS / 1000} 秒`,
             );
+            // 验证码是全局风控：立即终止本批次剩余任务，避免批次内
+            // 继续 goto 顶着风控连刷；30s 冷却在 while 顶部领取前生效
+            break;
           } else if (e.delisted) {
             // 壳页/下架：seller_id 为空且无销售数据 → 立即哨兵放弃
             batchSkipped++;
@@ -441,6 +585,8 @@ export async function handleProductFill(options) {
             await noteFail(uniqueId);
           }
         }
+        // 每个任务处理完后随机延迟（防风控）：N/2 ~ N 秒，Ctrl+C 可中断
+        if (!shuttingDown) await taskRandomDelay();
       }
 
       log(
@@ -453,6 +599,26 @@ export async function handleProductFill(options) {
     throw err;
   } finally {
     if (forceExitTimer) clearTimeout(forceExitTimer);
+    // 退出清理：关闭本进程启动的浏览器实例。
+    // CDP 的 browser.close() 只断开连接不关浏览器进程，需按端口 kill；
+    // 只杀 launchedPorts 里的端口（本进程拉起的），用户自己开着的 Edge 不动
+    if (browser) {
+      await browser.close().catch(() => {});
+    }
+    if (launchedPorts.size > 0) {
+      log(
+        `[ProductFill] 正在关闭浏览器（端口 ${[...launchedPorts].join(", ")}）...`,
+      );
+      await Promise.all(
+        [...launchedPorts].map((port) =>
+          Promise.race([
+            killEdgeProcesses(undefined, port),
+            new Promise((r) => setTimeout(r, 5000)),
+          ]),
+        ),
+      );
+      log(`[ProductFill] 浏览器已关闭`);
+    }
     log(
       `[ProductFill] 已退出。总计: 成功 ${totalSuccess} | 失败 ${totalFailed} | 跳过 ${totalSkipped} | 标记不可售 ${totalMarked}`,
     );

package/src/lib/args.js

@@ -895,6 +895,7 @@ function parseProductFillArgs(args) {
   let interval = 10;
   let serverUrl = defaultServer;
   let proxyUrl = null;
+  let taskDelay = 5; // --task-delay：每个任务处理完后的随机延迟上限，秒
   /** 端口/国家配置：--profiles US/9223,JP/1222 → [{country:"US",port:9223},...] */
   let profiles = [];
 
@@ -919,6 +920,10 @@ function parseProductFillArgs(args) {
       interval = parseInt(args[++i], 10) || 10;
     } else if (arg === "-l" || arg === "--limit") {
       limit = parseInt(args[++i], 10) || 5;
+    } else if (arg === "--task-delay") {
+      // 允许 0（关闭任务间延迟），非法值回退默认 5
+      const v = parseInt(args[++i], 10);
+      taskDelay = Number.isFinite(v) && v >= 0 ? v : 5;
     }
   }
 
@@ -928,6 +933,7 @@ function parseProductFillArgs(args) {
     productFillInterval: interval,
     serverUrl,
     productFillProxy: proxyUrl,
+    productFillTaskDelay: taskDelay,
     productFillProfiles: profiles,
     urls: [],
     outputFormat: "json",

package/src/lib/constants.js

@@ -227,9 +227,10 @@ const HELP_TEXT = [
   "    --profiles 国家/端口对绑定（端口 profile 区域需与商品国家一致，如 US/9223,JP/1222）；",
   "    每轮探测代理出口，在配置中匹配端口领取对应国家任务，出口不在配置范围则跳过",
   "    -s, --server <URL>     服务端地址（默认: http://127.0.0.1:3001）",
-  "    --proxy <URL>          浏览器启动代理及出口探测（默认: http://127.0.0.1:7897）",
+  "    --proxy <URL>          浏览器启动代理及出口探测（未指定时用配置文件 proxy；均未配置则浏览器走系统默认代理）",
   "    -i, --interval <N>     无任务时轮询间隔，单位秒（默认: 10）",
   "    -l, --limit <N>        每批领取任务数上限（默认: 5）",
+  "    --task-delay <N>       每个任务处理完后的随机延迟上限，秒（默认: 5，实际 N/2~N 秒随机）",
   "    下架壳页/连续失败3次/无效URL → 回写 rating=-1 哨兵永久移出候选",
   "    示例: tt-help product-fill --profiles US/9223",
   "          tt-help product-fill --profiles US/9223,JP/1222 -s http://117.71.53.99:17301 -i 5",

package/src/watch/db-schema.js

@@ -103,6 +103,9 @@ export function initDb(filePath) {
   db = new Database(dbPath);
   db.pragma("journal_mode = WAL");
   db.pragma("busy_timeout = 5000");
+  // 调大 SQLite 页缓存：主库 7.3GB，task_queue 等热表的回表若走磁盘 I/O 会非常慢
+  // （实测同规模数据 16MB 缓存 1.5s → 256MB 1.1s）。512MB 足以让 task_queue 全量驻留内存。
+  db.pragma("cache_size = -524288");
 
   // ===== users 表 =====
   db.exec(`
@@ -423,10 +426,11 @@ export function initDb(filePath) {
     `CREATE INDEX IF NOT EXISTS idx_jobs_list_done ON jobs(pinned, processed_at, follower_count, unique_id) WHERE status = 'done'`,
     `CREATE INDEX IF NOT EXISTS idx_jobs_list_error ON jobs(pinned, processed_at, follower_count, unique_id) WHERE status = 'error'`,
     `CREATE INDEX IF NOT EXISTS idx_jobs_list_restricted ON jobs(pinned, processed_at, follower_count, unique_id) WHERE status = 'restricted'`,
-    // jobs_done 冷归档表索引（done 列表 / 国家统计 / 重检）
+    // jobs_done 冷归档表索引（done 列表 / 国家统计 / 重检 / no_video 计数）
     `CREATE INDEX IF NOT EXISTS idx_jobs_done_list ON jobs_done(pinned, processed_at, follower_count, unique_id) WHERE status = 'done'`,
     `CREATE INDEX IF NOT EXISTS idx_jobs_done_loc ON jobs_done(location_created)`,
     `CREATE INDEX IF NOT EXISTS idx_jobs_done_status_updated ON jobs_done(status, updated_at) WHERE status = 'done' AND (tt_seller IS NULL OR tt_seller != 1)`,
+    `CREATE INDEX IF NOT EXISTS idx_jobs_done_novideo ON jobs_done(no_video) WHERE no_video = 1`,
   ];
   for (const sql of indexes) {
     db.exec(sql);

package/src/watch/public/app.js

@@ -5286,21 +5286,20 @@ function renderCmdRows(myCmds, userId, procs, isOnline, llmAnalysis, clientId) {
         styled(
           "span",
           "display:flex;gap:2px",
-          (isOnline
-            ? tag(
-                "button",
-                {
-                  onclick:
-                    "wdToggleClientCmd('" + esc(userId) + "'," + idx + ")",
-                  style:
-                    "padding:1px 5px;font-size:11px;background:" +
-                    (c.enabled ? "#f59e0b" : "#4ade80") +
-                    ";color:#000;border:none;border-radius:2px;cursor:pointer",
-                  title: c.enabled ? "停止" : "启动",
-                },
-                c.enabled ? "⏹" : "▶",
-              )
-            : "") +
+          tag(
+            "button",
+            {
+              onclick: "wdToggleClientCmd('" + esc(userId) + "'," + idx + ")",
+              style:
+                "padding:1px 5px;font-size:11px;background:" +
+                (c.enabled ? "#f59e0b" : "#4ade80") +
+                ";color:#000;border:none;border-radius:2px;cursor:pointer",
+              title:
+                (c.enabled ? "停止" : "启动") +
+                (isOnline ? "" : "（设备离线，上线后生效）"),
+            },
+            c.enabled ? "⏹" : "▶",
+          ) +
             tag(
               "button",
               {

package/src/watch/server.js

@@ -104,14 +104,16 @@ const STAT_GROUPS = {
             SUM(CASE WHEN no_video = 1 THEN 1 ELSE 0 END) as noVideo
           FROM jobs
           UNION ALL
+          -- jobs_done 冷归档表：全部是 done 且只增不改。改用覆盖索引/部分索引计数，
+          -- 避免对 147 万行全表回表（原 SUM(CASE WHEN no_video=1) 无法匹配索引）
           SELECT
-            COUNT(*) as jobsTotal,
-            COUNT(*) as done,
+            c.cnt as jobsTotal,
+            c.cnt as done,
             0 as error,
             0 as restricted,
             0 as targetUsers,
-            SUM(CASE WHEN no_video = 1 THEN 1 ELSE 0 END) as noVideo
-          FROM jobs_done
+            (SELECT COUNT(*) FROM jobs_done WHERE no_video = 1) as noVideo
+          FROM (SELECT COUNT(*) as cnt FROM jobs_done) c
         )`,
       },
       {
@@ -389,8 +391,15 @@ function computeStatsIncremental(st) {
   };
 }
 
-// 快项失效：任务领取/提交后调用，下一次 /api/stats 请求即触发 fast 组后台刷新
+// 快项失效：任务领取/提交后调用，下一次 /api/stats 请求即触发 fast 组后台刷新。
+// 节流：53 个采集进程高频领/交任务，若每次都失效会导致 fast 组几乎每 10s 全量重算，
+// 把失效限制为至少间隔 FAST_DIRTY_MIN_INTERVAL，重算节奏由 fast TTL(30s) 主导。
+let lastFastDirtyTime = 0;
+const FAST_DIRTY_MIN_INTERVAL = 30 * 1000;
 function markFastStatsDirty() {
+  const now = Date.now();
+  if (now - lastFastDirtyTime < FAST_DIRTY_MIN_INTERVAL) return;
+  lastFastDirtyTime = now;
   groupState.fast.cacheTime = 0;
 }
 
@@ -579,6 +588,7 @@ export function startWatchServer(
         "CREATE INDEX IF NOT EXISTS idx_task_queue_status ON task_queue(status)",
         "CREATE INDEX IF NOT EXISTS idx_jobs_done_list ON jobs_done(pinned, processed_at, follower_count, unique_id) WHERE status = 'done'",
         "CREATE INDEX IF NOT EXISTS idx_jobs_done_loc ON jobs_done(location_created)",
+        "CREATE INDEX IF NOT EXISTS idx_jobs_done_novideo ON jobs_done(no_video) WHERE no_video = 1",
         "CREATE INDEX IF NOT EXISTS idx_videos_user_update ON videos(user_update_count)",
         // product-fill 领任务查询的部分索引：只索引候选行，避免全表扫描 164 万行
         "CREATE INDEX IF NOT EXISTS idx_jobs_product_fill ON jobs(claimed_at, updated_at) WHERE top_video_seo_url IS NOT NULL AND top_video_seo_url != '' AND (product_name IS NULL OR product_name = '') AND product_rating IS NULL AND product_sold_count IS NULL",