tt-help-cli-ycl 1.4.145 → 1.4.147

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 {
+  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,
+} 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"; // 未配置任何代理时，出口探测按本机 Clash 默认端口尝试
 
 function formatNow() {
   return new Date().toLocaleString("zh-CN", { hour12: false });
@@ -38,26 +47,84 @@ 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)" : ""}`,
+/**
+ * 判断浏览器是否真的已断开（用户手动关窗口 / 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 },
     );
-    err.status = res.status;
-    // webserver 约定：503=验证码；504/502 响应体带 retryable=true 表示可重试
-    err.captcha = res.status === 503;
-    err.retryable = !!body.retryable || res.status === 503;
-    throw err;
+    try {
+      await body.dump();
+    } catch {}
+    return statusCode === 200;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 通过代理探测出口 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,
+      },
+    );
+    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 +132,63 @@ export async function handleProductFill(options) {
     productFillLimit,
     productFillInterval,
     serverUrl,
-    productFillWebserver,
     productFillProxy,
+    productFillTaskDelay,
+    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;
+
+  // 与其他命令口径一致：--proxy 参数 > 配置文件 ~/.tt-help.json 的 proxy；
+  // 均未配置则不注入 proxyServer，浏览器走系统默认代理（explore/attach 同款）
+  const resolvedProxy = productFillProxy || configuredProxy || 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>           浏览器启动代理及出口探测（未指定时用配置文件 ~/.tt-help.json 的 proxy；均未配置则浏览器走系统默认代理）",
     );
     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 会自动拉起（验证码时弹浏览器，人工解决后继续）。",
+      "  --task-delay <N>        每个任务处理完后的随机延迟上限，秒（默认: 5，实际等待 N/2~N 秒随机）",
     );
     log("");
+    log("说明:");
+    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 +200,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 +210,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 +224,6 @@ export async function handleProductFill(options) {
     // 兜底：卡在网络重试/等待中时 10 秒后强制退出
     forceExitTimer = setTimeout(() => {
       log("[ProductFill] 等待超时，强制退出");
-      killLocalWebserver();
       process.exit(0);
     }, 10_000);
     forceExitTimer.unref?.();
@@ -157,57 +231,49 @@ 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 launchedPorts = new Set();
+  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 (resolvedProxy) cdpOptions.proxyServer = resolvedProxy;
+    const wasReady = await isCDPPortReady(profile.port);
+    log(
+      `[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()}）`);
+  };
+
+  // ── 代理出口国家探测 ──
+  // 与浏览器启动通道保持一致；未配置任何代理时按本机 Clash 默认端口探测
+  const effectiveProxyUrl = resolvedProxy || 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) =>
@@ -222,18 +288,160 @@ 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;
   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, country) => {
+    let detail;
+    try {
+      detail = await fetchViaCDP(seoUrl);
+    } catch (e) {
+      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);
+      } else if (isNetworkError(e)) {
+        // 网络层错误：代理断连/Clash 切节点，浏览器没死，不杀浏览器，
+        // 记为可重试错误跳过本轮，下轮代理探测自然跟上
+        const err = new Error(`网络层错误（浏览器未重启）: ${e.message}`);
+        err.retryable = true;
+        throw err;
+      } else {
+        throw e;
+      }
+    }
+    // 空数据防御：回写字段全空，不回写（防止假成功死循环）
+    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 +452,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 +477,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, profile.country);
           const post = await apiPost(
             `${serverUrl}/api/product-fill/${encodeURIComponent(uniqueId)}`,
             { productDetail: detail },
@@ -283,6 +500,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 +508,7 @@ export async function handleProductFill(options) {
             batchFailed++;
             totalFailed++;
             log(`  ✗ @${uniqueId} 回传失败: ${post?.error || "未知"}`);
+            await noteFail(uniqueId);
           }
         } catch (e) {
           if (e.captcha) {
@@ -299,8 +518,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 +540,15 @@ export async function handleProductFill(options) {
             batchFailed++;
             totalFailed++;
             log(`  ✗ @${uniqueId} 商品详情失败: ${e.message || "未知错误"}`);
+            await noteFail(uniqueId);
           }
         }
+        // 每个任务处理完后随机延迟（防风控）：N/2 ~ N 秒，Ctrl+C 可中断
+        if (!shuttingDown) await taskRandomDelay();
       }
 
       log(
-        `  本批: 成功 ${batchSuccess} | 失败 ${batchFailed} | 跳过 ${batchSkipped}（累计: 成功 ${totalSuccess} | 失败 ${totalFailed} | 跳过 ${totalSkipped}）\n`,
+        `  本批: 成功 ${batchSuccess} | 失败 ${batchFailed} | 跳过 ${batchSkipped} | 标记 ${batchMarked}（累计: 成功 ${totalSuccess} | 失败 ${totalFailed} | 跳过 ${totalSkipped} | 标记 ${totalMarked}）\n`,
       );
       await interruptibleSleep(300);
     }
@@ -322,12 +557,28 @@ export async function handleProductFill(options) {
     throw err;
   } finally {
     if (forceExitTimer) clearTimeout(forceExitTimer);
-    if (localWebserverChild && !localWebserverChild.killed) {
-      log("[ProductFill] 关闭自动拉起的本地 webserver...");
-      localWebserverChild.kill("SIGTERM");
+    // 退出清理：关闭本进程启动的浏览器实例。
+    // 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}`,
+      `[ProductFill] 已退出。总计: 成功 ${totalSuccess} | 失败 ${totalFailed} | 跳过 ${totalSkipped} | 标记不可售 ${totalMarked}`,
     );
   }
 }