tt-help-cli-ycl 1.4.145 → 1.4.146

package/src/cli/product-fill.js

@@ -1,34 +1,43 @@
 /**
  * product-fill 命令 — 循环到服务端领取"缺商品详情"任务，补全商品信息
  *
- * 与 attach 类似的多用户循环客户端：
- *   1. 通过 webserver（集中式）抓取商品详情（PDP 评分/销量/评论）
- *   2. 循环 GET /api/product-tasks 领取任务
- *   3. 对每个任务 POST webserver /api/tiktok/product 抓取商品详情
+ * 使用前提：--profiles 国家/端口对 配置端口与国家绑定（如 US/9223,JP/1222）。
+ * TikTok 区域判定 = 浏览器 profile 区域 + 代理出口，商品国家必须与两者
+ * 匹配才能抓到数据（如 9223=US profile、1222=JP profile）。
+ *
+ * 流程：
+ *   1. 每轮领取前探测代理出口国家，与配置不匹配则跳过本轮
+ *   2. GET /api/product-tasks?country=XX 领取该国家任务
+ *   3. CDP 直抓商品详情（评分/销量/评论），验证码弹浏览器人工解决
  *   4. 成功 → POST /api/product-fill/:uniqueId 回写 jobs 表
+ *   5. 下架壳页/连续失败/无效 URL → 回写 rating=-1 哨兵，永久移出候选
  *
- * 用法: tt-help product-fill [-s 服务端] [-w webserver] [-i 间隔秒] [-l 每批上限]
+ * 用法: tt-help product-fill --profiles <XX/port>[,<XX/port>...] [-s 服务端] [-i 间隔秒] [-l 每批上限] [--proxy URL]
  */
-import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
+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";
+import {
+  getProductInfoCDP,
+  isEmptyProductDetail,
+} from "../lib/shop-scraper.mjs";
+import {
+  detectCaptcha,
+  waitAndGetCaptcha,
+} from "../scraper/modules/captcha-handler.js";
 
 const CAPTCHA_BACKOFF_MS = 30_000; // 验证码后冷却时长
-const WEBSERVER_READY_TIMEOUT_MS = 60_000; // 等待自动拉起的 webserver 就绪上限
-
-/** 探测 webserver /health 是否可用 */
-async function probeWebserverHealth(url, timeoutMs = 1500) {
-  try {
-    const res = await fetch(`${url}/health`, {
-      signal: AbortSignal.timeout(timeoutMs),
-    });
-    return res.ok;
-  } catch {
-    return false;
-  }
-}
+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 默认端口探测
 
 function formatNow() {
   return new Date().toLocaleString("zh-CN", { hour12: false });
@@ -38,26 +47,28 @@ function log(message = "") {
   console.error(`[${formatNow()}] ${message}`);
 }
 
-/** 抓取商品详情（webserver /api/tiktok/product）；503 验证码 → retryable 错误 */
-async function fetchProductDetail(webserverUrl, seoUrl) {
-  const res = await fetch(`${webserverUrl}/api/tiktok/product`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ url: seoUrl }),
-    signal: AbortSignal.timeout(30_000),
-  });
-  if (!res.ok) {
-    const body = await res.json().catch(() => ({}));
-    const err = new Error(
-      `${body.error || `HTTP ${res.status}`}${res.status === 503 ? " (captcha)" : ""}`,
+/**
+ * 通过代理探测出口 IP 国家码（ip-api.com 免费接口）。
+ * 探测失败（超时/代理未开/接口异常）返回 null。
+ */
+export async function detectProxyCountry(proxyUrl, timeoutMs = 8000) {
+  const dispatcher = proxyUrl ? new ProxyAgent(proxyUrl) : null;
+  try {
+    const { statusCode, body } = await request(
+      "http://ip-api.com/json?fields=countryCode",
+      {
+        method: "GET",
+        ...(dispatcher ? { dispatcher } : {}),
+        headersTimeout: timeoutMs,
+        bodyTimeout: timeoutMs,
+      },
     );
-    err.status = res.status;
-    // webserver 约定：503=验证码；504/502 响应体带 retryable=true 表示可重试
-    err.captcha = res.status === 503;
-    err.retryable = !!body.retryable || res.status === 503;
-    throw err;
+    if (statusCode !== 200) return null;
+    const data = JSON.parse(await body.text());
+    return data?.countryCode || null;
+  } catch {
+    return null;
   }
-  return res.json();
 }
 
 export async function handleProductFill(options) {
@@ -65,48 +76,55 @@ export async function handleProductFill(options) {
     productFillLimit,
     productFillInterval,
     serverUrl,
-    productFillWebserver,
     productFillProxy,
+    productFillProfiles,
     showHelp,
   } = options;
-  // 不指定 -w 时默认使用本地 webserver（http://127.0.0.1:3000），
-  // 且本地无响应时自动拉起（适合单独机器：验证码时弹浏览器人工处理）
-  const spawnLocalWebserver = !productFillWebserver;
-  const webserverUrl = productFillWebserver || "http://127.0.0.1:3000";
-  // 自动拉起 webserver 时透传的代理（默认本机 clash 7897）
-  const localWebserverProxy = productFillProxy || "http://127.0.0.1:7897";
-  let localWebserverChild = null;
 
   if (showHelp) {
     log(
-      "用法: tt-help product-fill [-s 服务端] [-w webserver地址] [-i 间隔秒] [-l 每批上限]",
+      "用法: tt-help product-fill --profiles <国家/端口>[,<国家/端口>...] [-s 服务端] [-i 间隔秒] [-l 每批上限] [--proxy URL]",
     );
     log("");
     log("参数:");
-    log("  -s, --server <URL>      服务端地址（默认: http://127.0.0.1:3001）");
     log(
-      "  -w, --webserver <URL>   商品详情 webserver 地址（默认: http://127.0.0.1:3000，本地未运行会自动拉起）",
+      "  --profiles <XX/port>   必填。国家/端口对，逗号分隔可传多个（如 US/9223,JP/1222）；",
+    );
+    log(
+      "                          每轮探测代理出口，在配置中匹配对应端口自动领取该国家任务",
     );
+    log("  -s, --server <URL>      服务端地址（默认: http://127.0.0.1:3001）");
     log(
-      "  --proxy <URL>           自动拉起 webserver 时使用的代理（默认: http://127.0.0.1:7897）",
+      "  --proxy <URL>           浏览器启动代理及出口探测（默认: http://127.0.0.1:7897）",
     );
     log("  -i, --interval <N>      无任务时轮询间隔，单位秒（默认: 10）");
     log("  -l, --limit <N>         每批领取任务数上限（默认: 5）");
     log("");
     log("说明:");
-    log("  循环向服务端 /api/product-tasks 领取缺商品详情的任务；");
-    log("  对每个任务调用 webserver /api/tiktok/product 抓取评分/销量/评论；");
-    log("  成功后回传 /api/product-fill/:uniqueId 写入 jobs 表。");
-    log("  商品详情验证码(503)自动冷却 30 秒后重试，其他失败计数后继续。");
-    log(
-      "  不传 -w 时本地无 webserver 会自动拉起（验证码时弹浏览器，人工解决后继续）。",
-    );
+    log("  循环向服务端 /api/product-tasks?country=XX 领取缺商品详情任务；");
+    log("  代理出口不在配置范围 → 本轮不领任务，下轮重新探测；");
+    log("  商品下架壳页立即标记不可售（rating=-1），连续失败 3 次同样标记；");
+    log("  验证码在浏览器中弹出时等待人工解决（最长 3 分钟）后自动重试。");
     log("");
     log("示例:");
+    log("  tt-help product-fill --profiles US/9223 -s http://127.0.0.1:3001");
     log(
-      "  tt-help product-fill -s http://127.0.0.1:3001 -w http://127.0.0.1:3000",
+      "  tt-help product-fill --profiles US/9223,JP/1222 -s http://117.71.53.99:17301 -i 5",
+    );
+    return;
+  }
+
+  // ── 参数校验：至少一个有效的国家/端口对；同端口重复保留最后一个 ──
+  const finalProfiles = [];
+  for (const p of productFillProfiles || []) {
+    const idx = finalProfiles.findIndex((x) => x.port === p.port);
+    if (idx >= 0) finalProfiles[idx] = p;
+    else finalProfiles.push(p);
+  }
+  if (finalProfiles.length === 0) {
+    log(
+      "[ProductFill] 错误: 请传 --profiles 国家/端口对（如 --profiles US/9223,JP/1222）",
     );
-    log("  tt-help product-fill -w http://117.71.53.99:17300 -i 5 -l 10");
     return;
   }
 
@@ -118,7 +136,7 @@ export async function handleProductFill(options) {
     log(`[ProductFill] 未检测到本地用户编号，已生成并使用: ${userId}`);
   }
   log(
-    `[ProductFill] 用户编号: ${userId} | 服务端: ${serverUrl} | webserver: ${webserverUrl}`,
+    `[ProductFill] 用户编号: ${userId} | 服务端: ${serverUrl} | 端口配置: ${finalProfiles.map((p) => `${p.port}=${p.country}`).join(", ")}`,
   );
   log(
     `[ProductFill] 每批上限: ${productFillLimit} | 空闲间隔: ${productFillInterval}秒`,
@@ -128,17 +146,10 @@ export async function handleProductFill(options) {
 
   let shuttingDown = false;
   let forceExitTimer = null;
-  /** 强制退出路径清理自动拉起的 webserver（防止孤儿进程） */
-  const killLocalWebserver = () => {
-    if (localWebserverChild && !localWebserverChild.killed) {
-      localWebserverChild.kill("SIGKILL");
-    }
-  };
   const shutdown = () => {
     if (shuttingDown) {
       // 第二次信号：立即强制退出（网络重试等场景可能无法优雅退出）
       log(`\n[ProductFill] 再次收到信号，强制退出...`);
-      killLocalWebserver();
       process.exit(1);
       return;
     }
@@ -149,7 +160,6 @@ export async function handleProductFill(options) {
     // 兜底：卡在网络重试/等待中时 10 秒后强制退出
     forceExitTimer = setTimeout(() => {
       log("[ProductFill] 等待超时，强制退出");
-      killLocalWebserver();
       process.exit(0);
     }, 10_000);
     forceExitTimer.unref?.();
@@ -157,57 +167,43 @@ export async function handleProductFill(options) {
   process.on("SIGINT", () => shutdown());
   process.on("SIGTERM", () => shutdown());
 
-  // ── 确保 webserver 可用：未指定 -w 且本地无响应时自动拉起 ──
-  if (await probeWebserverHealth(webserverUrl)) {
-    log(`[ProductFill] webserver 已就绪: ${webserverUrl}`);
-  } else {
-    if (!spawnLocalWebserver) {
-      log(
-        `[ProductFill] 警告: webserver ${webserverUrl} 无响应，任务将按失败重试`,
-      );
-    } else {
-      const portMatch = webserverUrl.match(/:(\d+)\/?$/);
-      const port = portMatch ? parseInt(portMatch[1], 10) : 3000;
-      // cli.js 在包根（源码与 npm 包结构一致），webserver 命令两者都支持
-      const cliJs = fileURLToPath(new URL("../../cli.js", import.meta.url));
-      log(
-        `[ProductFill] 本地 webserver 未运行，自动拉起（端口 ${port}，代理 ${localWebserverProxy}）...`,
-      );
-      localWebserverChild = spawn(
-        process.execPath,
-        [
-          cliJs,
-          "webserver",
-          "-p",
-          String(port),
-          "--proxy",
-          localWebserverProxy,
-        ],
-        {
-          stdio: ["ignore", "ignore", "inherit"], // webserver 日志（含验证码提示）透传到本终端
-          windowsHide: true,
-        },
-      );
-      localWebserverChild.on("exit", (code) => {
-        if (!shuttingDown && code !== null && code !== 0) {
-          log(`[ProductFill] ⚠ 本地 webserver 已退出 (code=${code})`);
-        }
-      });
-      // 等待就绪（最多 60 秒）
-      const deadline = Date.now() + WEBSERVER_READY_TIMEOUT_MS;
-      while (!shuttingDown && Date.now() < deadline) {
-        if (await probeWebserverHealth(webserverUrl, 1000)) break;
-        await new Promise((r) => setTimeout(r, 1000));
-      }
-      if (await probeWebserverHealth(webserverUrl, 1000)) {
-        log(`[ProductFill] webserver 已就绪: ${webserverUrl}`);
+  // ── 浏览器连接管理：按出口国家自动切换端口（只换 CDP 连接，Edge 实例不杀） ──
+  let browser = null;
+  let page = null;
+  let currentPort = null;
+  const connectProfile = async (profile) => {
+    if (currentPort === profile.port && browser) return;
+    if (browser) {
+      await browser.close().catch(() => {});
+      browser = null;
+      page = null;
+    }
+    const cdpOptions = { port: profile.port };
+    if (productFillProxy) cdpOptions.proxyServer = productFillProxy;
+    log(
+      `[ProductFill] 切换浏览器端口 ${currentPort ?? "-"} → ${profile.port}（country=${profile.country}${productFillProxy ? `，代理 ${productFillProxy}` : ""}）`,
+    );
+    browser = await ensureBrowserReady(cdpOptions);
+    page = await getOrCreatePage(browser);
+    currentPort = profile.port;
+    log(`[ProductFill] CDP 浏览器已就绪（当前页: ${page.url()}）`);
+  };
+
+  // ── 代理出口国家探测 ──
+  const effectiveProxyUrl = productFillProxy || DEFAULT_PROXY;
+  let proxyCountry = null;
+  const refreshProxyCountry = async () => {
+    const prev = proxyCountry;
+    proxyCountry = await detectProxyCountry(effectiveProxyUrl);
+    // 只在国家变化时打印，避免每轮探测刷屏
+    if (proxyCountry !== prev) {
+      if (proxyCountry) {
+        log(`[ProductFill] 代理出口国家: ${proxyCountry}`);
       } else {
-        log(
-          `[ProductFill] 警告: webserver 启动超时，继续运行（抓取失败将自动重试）`,
-        );
+        log(`[ProductFill] ⚠ 无法探测代理出口国家`);
       }
     }
-  }
+  };
 
   /** 可被退出信号中断的等待（500ms 粒度检查 shuttingDown） */
   const interruptibleSleep = (ms) =>
@@ -226,14 +222,124 @@ export async function handleProductFill(options) {
   let totalSuccess = 0;
   let totalFailed = 0;
   let totalSkipped = 0;
+  let totalMarked = 0; // 标记不可售/放弃数
   let captchaBackoffUntil = 0; // 验证码后冷却到的时间戳
+  let lastMismatchLogAt = 0; // 出口不一致日志节流
+  /** 连续失败计数：uniqueId → 次数，达到 FAIL_MARK_LIMIT 后哨兵放弃 */
+  const failCount = new Map();
+
+  /** 哨兵回写：product_rating = -1，任务永久移出候选（以后不再领取） */
+  const markUnavailable = async (uniqueId, reason) => {
+    try {
+      const post = await apiPost(
+        `${serverUrl}/api/product-fill/${encodeURIComponent(uniqueId)}`,
+        { productDetail: { rating: SENTINEL_RATING } },
+      );
+      if (post && post.ok) {
+        totalMarked++;
+        failCount.delete(uniqueId);
+        log(`  ⊘ @${uniqueId} 已标记不可售（${reason}）`);
+        return true;
+      }
+      log(`  ✗ @${uniqueId} 标记失败: ${post?.error || "未知"}`);
+    } catch (e) {
+      log(`  ✗ @${uniqueId} 标记异常: ${e.message || "未知"}`);
+    }
+    return false;
+  };
+
+  /** 记录抓取失败次数，达到上限后哨兵放弃（防止死任务无限轮转） */
+  const noteFail = async (uniqueId) => {
+    const n = (failCount.get(uniqueId) || 0) + 1;
+    if (n < FAIL_MARK_LIMIT) {
+      failCount.set(uniqueId, n);
+      return;
+    }
+    failCount.delete(uniqueId);
+    await markUnavailable(uniqueId, `连续失败 ${n} 次`);
+  };
+
+  /** CDP 直抓：验证码在已登录浏览器中弹出时，等待人工解决后自动重试 */
+  const fetchViaCDP = async (seoUrl) => {
+    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("  ⏳ 检测到验证码，请在已登录的浏览器窗口中手动解决...");
+        const r = await waitAndGetCaptcha(page, {
+          waitMs: CDP_CAPTCHA_WAIT_MS,
+          pollInterval: 5000,
+          log,
+        });
+        if (r.resolved) {
+          log("  ✓ 验证码已解决，重新抓取...");
+          return getProductInfoCDP(page, seoUrl);
+        }
+      }
+      const err = new Error(
+        cap?.exists
+          ? "验证码等待人工解决超时"
+          : "验证码拦截（无可见验证码容器）",
+      );
+      err.captcha = true;
+      throw err;
+    }
+  };
+
+  /** 抓取商品详情，带浏览器断连恢复与空数据防御 */
+  const getTaskDetail = async (seoUrl) => {
+    let detail;
+    try {
+      detail = await fetchViaCDP(seoUrl);
+    } 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;
+      }
+      detail = await fetchViaCDP(seoUrl);
+    }
+    // 空数据防御：回写字段全空，不回写（防止假成功死循环）
+    if (isEmptyProductDetail(detail)) {
+      const err = new Error("商品详情数据为空（页面被拦截或结构变化）");
+      err.retryable = true;
+      err.empty = true;
+      throw err;
+    }
+    return detail;
+  };
 
   try {
     while (!shuttingDown) {
       loopCount++;
       if (shuttingDown) break;
 
-      // 验证码冷却期间不领任务（避免反复触发 webserver 限流）
+      // 每轮领取前探测出口：在配置中找匹配端口，找不到则不领任务，
+      // 下轮重新探测（代理切换生效有窗口期，等生效即可）
+      await refreshProxyCountry();
+      const profile = finalProfiles.find((p) => p.country === proxyCountry);
+      if (!profile) {
+        if (loopCount === 1 || Date.now() - lastMismatchLogAt > 60_000) {
+          log(
+            `[ProductFill] ⏳ 出口 ${proxyCountry || "未知"} 不在配置范围（${finalProfiles.map((p) => p.country).join("/")}），本轮跳过（等待代理切换）`,
+          );
+          lastMismatchLogAt = Date.now();
+        }
+        await interruptibleSleep(productFillInterval * 1000);
+        continue;
+      }
+      await connectProfile(profile);
+
+      // 验证码冷却期间不领任务
       const now = Date.now();
       if (now < captchaBackoffUntil) {
         const waitMs = captchaBackoffUntil - now;
@@ -244,8 +350,14 @@ export async function handleProductFill(options) {
         continue;
       }
 
+      // 领任务：服务端按国家过滤，只发该国家任务
+      const taskQuery = new URLSearchParams({
+        limit: String(productFillLimit),
+        userId,
+        country: profile.country,
+      });
       const { tasks = [] } = await apiGet(
-        `${serverUrl}/api/product-tasks?limit=${productFillLimit}&userId=${encodeURIComponent(userId)}`,
+        `${serverUrl}/api/product-tasks?${taskQuery.toString()}`,
       );
 
       if (!tasks || tasks.length === 0) {
@@ -263,19 +375,22 @@ export async function handleProductFill(options) {
       let batchSuccess = 0;
       let batchFailed = 0;
       let batchSkipped = 0;
+      let batchMarked = 0;
 
       for (const task of tasks) {
         const uniqueId = task.uniqueId;
         const seoUrl = task.seoUrl;
-        if (!seoUrl) {
-          log(`  ✗ @${uniqueId} 无 seoUrl，跳过`);
+        if (!seoUrl || !String(seoUrl).startsWith("http")) {
+          // 残缺 URL（如仅 ?source=anchor）：永远无效，直接哨兵放弃，
+          // 避免进入 page.goto 触发 Protocol error 被误判为浏览器断连
           batchSkipped++;
           totalSkipped++;
+          if (await markUnavailable(uniqueId, "seoUrl 无效")) batchMarked++;
           continue;
         }
         log(`  → 补商品 @${uniqueId} ...`);
         try {
-          const detail = await fetchProductDetail(webserverUrl, seoUrl);
+          const detail = await getTaskDetail(seoUrl);
           const post = await apiPost(
             `${serverUrl}/api/product-fill/${encodeURIComponent(uniqueId)}`,
             { productDetail: detail },
@@ -283,6 +398,7 @@ export async function handleProductFill(options) {
           if (post && post.ok) {
             batchSuccess++;
             totalSuccess++;
+            failCount.delete(uniqueId);
             log(
               `  ✓ @${uniqueId} 商品已补全 (评分${detail.rating ?? "-"} | 销量${detail.soldCount ?? "-"} | 评论${detail.reviewCount ?? "-"})`,
             );
@@ -290,6 +406,7 @@ export async function handleProductFill(options) {
             batchFailed++;
             totalFailed++;
             log(`  ✗ @${uniqueId} 回传失败: ${post?.error || "未知"}`);
+            await noteFail(uniqueId);
           }
         } catch (e) {
           if (e.captcha) {
@@ -299,8 +416,21 @@ export async function handleProductFill(options) {
             log(
               `  ⏳ @${uniqueId} 验证码拦截，冷却 ${CAPTCHA_BACKOFF_MS / 1000} 秒`,
             );
+          } else if (e.delisted) {
+            // 壳页/下架：seller_id 为空且无销售数据 → 立即哨兵放弃
+            batchSkipped++;
+            totalSkipped++;
+            if (await markUnavailable(uniqueId, "商品下架/不可售")) {
+              batchMarked++;
+            }
+          } else if (e.empty) {
+            // 解析全空（回写字段全无）：计入熔断，连续 N 次后哨兵放弃
+            batchFailed++;
+            totalFailed++;
+            log(`  ✗ @${uniqueId} 商品详情数据为空: ${e.message}`);
+            await noteFail(uniqueId);
           } else if (e.retryable) {
-            // 504 超时等可重试错误：未回写，下轮自然重试，不触发全局冷却
+            // 超时等可重试错误：未回写，下轮自然重试，不触发全局冷却
             batchSkipped++;
             totalSkipped++;
             log(`  ⏳ @${uniqueId} 临时失败（可重试）: ${e.message}`);
@@ -308,12 +438,13 @@ export async function handleProductFill(options) {
             batchFailed++;
             totalFailed++;
             log(`  ✗ @${uniqueId} 商品详情失败: ${e.message || "未知错误"}`);
+            await noteFail(uniqueId);
           }
         }
       }
 
       log(
-        `  本批: 成功 ${batchSuccess} | 失败 ${batchFailed} | 跳过 ${batchSkipped}（累计: 成功 ${totalSuccess} | 失败 ${totalFailed} | 跳过 ${totalSkipped}）\n`,
+        `  本批: 成功 ${batchSuccess} | 失败 ${batchFailed} | 跳过 ${batchSkipped} | 标记 ${batchMarked}（累计: 成功 ${totalSuccess} | 失败 ${totalFailed} | 跳过 ${totalSkipped} | 标记 ${totalMarked}）\n`,
       );
       await interruptibleSleep(300);
     }
@@ -322,12 +453,8 @@ export async function handleProductFill(options) {
     throw err;
   } finally {
     if (forceExitTimer) clearTimeout(forceExitTimer);
-    if (localWebserverChild && !localWebserverChild.killed) {
-      log("[ProductFill] 关闭自动拉起的本地 webserver...");
-      localWebserverChild.kill("SIGTERM");
-    }
     log(
-      `[ProductFill] 已退出。总计: 成功 ${totalSuccess} | 失败 ${totalFailed} | 跳过 ${totalSkipped}`,
+      `[ProductFill] 已退出。总计: 成功 ${totalSuccess} | 失败 ${totalFailed} | 跳过 ${totalSkipped} | 标记不可售 ${totalMarked}`,
     );
   }
 }

package/src/cli/tag.js

@@ -9,7 +9,7 @@ import {
 import { reportClientErrorAndFailover } from "../lib/client-error-report.js";
 import { fetchTagData, enrichVideosWithLocation } from "../lib/tag-fetcher.js";
 import { killEdgeProcesses, ensureBrowserReady } from "../lib/browser/cdp.js";
-import { getOrCreatePage, isBrowserClosedError } from "../lib/browser/page.js";
+import { getOrCreatePage } from "../lib/browser/page.js";
 import { TikTokScraper } from "../lib/tiktok-scraper.mjs";
 import { isLocationInList } from "../lib/target-locations.js";
 import { getTargetLocations } from "../lib/app-config.js";
@@ -34,11 +34,17 @@ function resolveTargetCountries(countries) {
 }
 
 /**
- * 判断浏览器是否已断开（用户手动关窗口 / CDP 断开）。
+ * 判断浏览器是否真的已断开（用户手动关窗口 / CDP 断开）。
  * 用于让采集循环（score-all / refresh）在浏览器被关闭后自动退出，避免无限重试。
+ *
+ * 注意：page.js 的 isBrowserClosedError 会把 net::ERR_CONNECTION_* 等网络层错误
+ * 也判为“浏览器关闭”。实际上这类错误是代理掂断/连接重置，浏览器进程还活着，
+ * 属于网络错误而不是窗口关闭。此处只认两种确凿信号：
+ *   1. browser.isConnected() === false（CDP 连接已断）
+ *   2. 明确的关闭消息（Target closed / Browser has been closed）
+ * net::ERR_* 一律放行，交给错误计数处理，避免误退出循环。
  */
 function isBrowserDisconnected(browser, e) {
-  if (e && isBrowserClosedError(e)) return true;
   try {
     if (
       browser &&
@@ -48,7 +54,16 @@ function isBrowserDisconnected(browser, e) {
       return true;
     }
   } catch {}
-  return false;
+  if (!e) return false;
+  const msg = e.message || "";
+  // 网络层错误（net::ERR_CONNECTION_CLOSED/RESET/REFUSED...）不代表浏览器关闭
+  if (msg.includes("net::ERR_")) return false;
+  // 明确的 CDP 关闭信号
+  return (
+    msg.includes("Target closed") ||
+    msg.includes("Browser has been closed") ||
+    msg.includes("Target page, context or browser has been closed")
+  );
 }
 
 // 构建带客户端追踪 header 的 fetch 封装
@@ -851,10 +866,10 @@ export async function handleScoreAll(parsed) {
   // ── 错误计数（纯观察，不做任何自愈） ──
   // 阈值语义：连续超过 N 次触发动作（即第 N+1 次）
   //   403      连续 >2 次 → 上报服务端 + 强制 fallback（daemon 换节点），清零后继续跑
-  //   网络错误 连续 >10 次 → 打印退出（服务端不可达时 fallback 请求也发不出去）
+  //   网络错误 连续 >10 次 → 触发 daemon fallback 换节点（本地 IPC，不依赖服务端可达）+ 退出
   //   验证码   连续 >3 次（人工一直未解决）→ 打印退出
   //   其他错误 连续 >10 次 → 打印退出
-  // 清零规则：成功处理一个 tag → 全部清零；fallback 触发 → 403 计数清零；
+  // 清零规则：成功处理一个 tag → 全部清零；fallback 触发 → 对应计数清零；
   //           人工点掉验证码 → 验证码计数清零
   const errorCounts = { http403: 0, network: 0, captcha: 0, other: 0 };
   const ERROR_LIMITS = { http403: 2, network: 10, captcha: 3, other: 10 };
@@ -1207,16 +1222,35 @@ export async function handleScoreAll(parsed) {
           (e.message &&
             (e.message.includes("ECONNREFUSED") ||
               e.message.includes("fetch failed") ||
-              e.message.includes("network")));
+              e.message.includes("network") ||
+              e.message.includes("net::ERR_")));
         if (isNetworkError) {
           const over = bumpErrorCount("network");
           log(
-            `  ⚠️ 服务端连接失败 (${e.message})，15 秒后重试（连续网络错误 ${errorCounts.network} 次）...`,
+            `  ⚠️ 网络错误 (${e.message})，15 秒后重试（连续网络错误 ${errorCounts.network} 次）...`,
           );
           if (over) {
             log(
-              `  ❌ 连续网络错误超过 ${ERROR_LIMITS.network} 次 → 打印并退出（服务端不可达，fallback 发不出去）`,
+              `  ❌ 连续网络错误超过 ${ERROR_LIMITS.network} 次 → 触发 daemon fallback 换节点后退出`,
             );
+            // 网络错误多为代理节点问题：fallback 走本地 IPC 触发 daemon 换节点
+            // （不依赖服务端可达），上报失败会被内部忽略；随后退出由看门狗拉起
+            await reportClientErrorAndFailover({
+              post: (url, body) =>
+                fetch(url, {
+                  method: "POST",
+                  headers: buildClientHeaders(clientId, clientMeta, {
+                    "Content-Type": "application/json",
+                  }),
+                  body: JSON.stringify(body),
+                }),
+              baseUrl,
+              userId,
+              errorType: "network_failure",
+              message: `连续 ${ERROR_LIMITS.network + 1} 次网络错误 (port=${cdpPort})`,
+              stage: "tag-scoring",
+              log,
+            });
             await cleanup();
             return;
           }