tt-help-cli-ycl 1.4.98 → 1.4.99

package/package.json

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

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

@@ -0,0 +1,113 @@
+/**
+ * product-fill 服务端数据层集成测试
+ *
+ * 用临时 SQLite 库验证：
+ *  - getPendingProductTasks：只领取"有 seoUrl 且缺商品详情"的商家，已补全/无 seoUrl 的不领
+ *  - updateProductInfo：回写 product_* 字段到 jobs 表，成功后移出候选
+ *
+ * 运行: TMPDIR=$(mktemp -d) node scripts/test-product-fill-db.mjs
+ */
+import { createStore } from "../src/watch/data-store.js";
+import { getDb } from "../src/watch/db-schema.js";
+import { join } from "node:path";
+
+const tmp = process.env.TMPDIR || "/tmp";
+const dbPath = join(tmp, `tt-test-product-${Date.now()}.db`);
+
+const store = createStore(dbPath);
+const db = getDb();
+if (!db) {
+  console.error("❌ db 未初始化");
+  process.exit(1);
+}
+
+const now = Date.now();
+// A: 有 seoUrl、无商品 → 应被领取
+db.prepare(
+  `INSERT INTO jobs (unique_id, status, tt_seller, top_video_seo_url, product_name, updated_at)
+   VALUES ('sellerA', 'done', 1, 'https://www.tiktok.com/shop/pdp/a1', NULL, ?)`,
+).run(now);
+// B: 有 seoUrl、已有商品 → 不应被领取
+db.prepare(
+  `INSERT INTO jobs (unique_id, status, tt_seller, top_video_seo_url, product_name, updated_at)
+   VALUES ('sellerB', 'done', 1, 'https://www.tiktok.com/shop/pdp/b1', '已有商品', ?)`,
+).run(now);
+// C: 无 seoUrl → 不应被领取
+db.prepare(
+  `INSERT INTO jobs (unique_id, status, tt_seller, top_video_seo_url, product_name, updated_at)
+   VALUES ('sellerC', 'done', 1, NULL, NULL, ?)`,
+).run(now);
+
+let passed = 0;
+function check(name, fn) {
+  try {
+    fn();
+    passed++;
+    console.log(`  ✅ ${name}`);
+  } catch (e) {
+    console.error(`  ❌ ${name}\n     ${e.message}`);
+    process.exitCode = 1;
+  }
+}
+
+console.log("===== product-fill 服务端数据层测试 =====");
+
+console.log("\n[1] getPendingProductTasks：只领缺商品的");
+const tasks = store.getPendingProductTasks(5);
+check("返回 1 条（仅 sellerA）", () => {
+  const ids = tasks.map((t) => t.uniqueId);
+  assert(ids.length === 1 && ids[0] === "sellerA", `实际: ${ids.join(",")}`);
+});
+check("任务带 seoUrl / productId / productTitle", () => {
+  assert(tasks[0].seoUrl === "https://www.tiktok.com/shop/pdp/a1");
+  assert("productId" in tasks[0] && "productTitle" in tasks[0]);
+});
+check("limit=1 只取 1 条", () => {
+  assert(store.getPendingProductTasks(1).length === 1);
+});
+
+console.log("\n[2] updateProductInfo：回写商品详情");
+const ret = store.updateProductInfo("sellerA", {
+  rating: 4.7,
+  reviewCount: 3303,
+  soldCount: 296,
+  productName: "测试商品A",
+});
+check("返回 ok", () => assert(ret.ok === true, JSON.stringify(ret)));
+const rowA = db
+  .prepare("SELECT * FROM jobs WHERE unique_id = ?")
+  .get("sellerA");
+check("jobs 表已写入 product_* 字段", () => {
+  assert(rowA.product_rating === 4.7);
+  assert(rowA.product_review_count === 3303);
+  assert(rowA.product_sold_count === 296);
+  assert(rowA.product_name === "测试商品A");
+});
+check("未增加 user_update_count", () => {
+  assert((rowA.user_update_count || 0) === 0);
+});
+
+console.log("\n[3] 补全后移出候选");
+const tasksAfter = store.getPendingProductTasks(5);
+check("sellerA 不再出现在候选", () => {
+  assert(!tasksAfter.some((t) => t.uniqueId === "sellerA"));
+});
+
+console.log("\n[4] 异常输入");
+check("缺 productDetail → error", () => {
+  const r = store.updateProductInfo("sellerB", null);
+  assert(r.ok !== true && r.error);
+});
+check("不存在的用户 → error", () => {
+  const r = store.updateProductInfo("ghostUser", { rating: 1 });
+  assert(r.ok !== true && r.error);
+});
+
+store.stopBackup?.();
+console.log(
+  `\n结果: ${passed} 通过${process.exitCode ? ", 有失败" : ", 0 失败"}`,
+);
+
+function assert(cond, msg = "断言失败") {
+  if (!cond) throw new Error(msg);
+}

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

@@ -0,0 +1,117 @@
+/**
+ * product-fill HTTP 端到端测试
+ *
+ * 起真实 watch server（临时库），验证两个端点：
+ *  - GET  /api/product-tasks?limit=        → 领取缺商品任务
+ *  - POST /api/product-fill/:uniqueId      → 回写商品详情
+ *
+ * 运行: TMPDIR=$(mktemp -d) node scripts/test-product-fill-http.mjs
+ */
+import { startWatchServer } from "../src/watch/server.js";
+import { createStore } from "../src/watch/data-store.js";
+import { getDb } from "../src/watch/db-schema.js";
+import { join } from "node:path";
+
+const tmp = process.env.TMPDIR || "/tmp";
+const dbPath = join(tmp, `tt-test-http-${Date.now()}.db`);
+
+const store = createStore(dbPath);
+const db = getDb();
+const now = Date.now();
+db.prepare(
+  `INSERT INTO jobs (unique_id, status, tt_seller, top_video_seo_url, product_name, updated_at)
+   VALUES ('sellerA', 'done', 1, 'https://www.tiktok.com/shop/pdp/a1', NULL, ?)`,
+).run(now);
+db.prepare(
+  `INSERT INTO jobs (unique_id, status, tt_seller, top_video_seo_url, product_name, updated_at)
+   VALUES ('sellerB', 'done', 1, 'https://www.tiktok.com/shop/pdp/b1', '已有', ?)`,
+).run(now);
+
+let passed = 0;
+function check(name, fn) {
+  try {
+    fn();
+    passed++;
+    console.log(`  ✅ ${name}`);
+  } catch (e) {
+    console.error(`  ❌ ${name}\n     ${e.message}`);
+    process.exitCode = 1;
+  }
+}
+function assert(cond, msg = "断言失败") {
+  if (!cond) throw new Error(msg);
+}
+
+const { server } = await startWatchServer(dbPath, 0, store, {
+  llmDiscover: false,
+});
+const port = server.address().port;
+const base = `http://127.0.0.1:${port}`;
+
+console.log("===== product-fill HTTP 端到端测试 =====");
+try {
+  console.log("\n[1] GET /api/product-tasks");
+  const res = await fetch(`${base}/api/product-tasks?limit=5`);
+  const data = await res.json();
+  check("返回 200 + total/tasks", () => {
+    assert(
+      res.ok && typeof data.total === "number" && Array.isArray(data.tasks),
+    );
+  });
+  check("只返回缺商品的 sellerA", () => {
+    const ids = data.tasks.map((t) => t.uniqueId);
+    assert(ids.length === 1 && ids[0] === "sellerA", `实际: ${ids.join(",")}`);
+    assert(data.tasks[0].seoUrl === "https://www.tiktok.com/shop/pdp/a1");
+  });
+
+  console.log("\n[2] POST /api/product-fill/:uniqueId");
+  const fill = await fetch(`${base}/api/product-fill/sellerA`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      productDetail: {
+        rating: 4.7,
+        reviewCount: 3303,
+        soldCount: 296,
+        productName: "HTTP测试商品",
+      },
+    }),
+  });
+  const fillData = await fill.json();
+  check("回传 ok", () =>
+    assert(fillData.ok === true, JSON.stringify(fillData)),
+  );
+
+  console.log("\n[3] 补全后任务消失");
+  const res2 = await fetch(`${base}/api/product-tasks?limit=5`);
+  const data2 = await res2.json();
+  check("sellerA 不再出现", () =>
+    assert(!data2.tasks.some((t) => t.uniqueId === "sellerA")),
+  );
+
+  console.log("\n[4] 无效回传（缺 body）");
+  const bad = await fetch(`${base}/api/product-fill/sellerB`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({}),
+  });
+  const badData = await bad.json();
+  check("返回 error", () =>
+    assert(bad.status === 400 && badData.error, JSON.stringify(badData)),
+  );
+} finally {
+  // 强制关闭连接 + 超时兜底，避免 keep-alive/定时器拖住进程
+  try {
+    server.closeAllConnections?.();
+  } catch {}
+  await Promise.race([
+    new Promise((r) => server.close(r)),
+    new Promise((r) => setTimeout(r, 1000)),
+  ]);
+  store.stopBackup?.();
+}
+
+console.log(
+  `\n结果: ${passed} 通过${process.exitCode ? ", 有失败" : ", 0 失败"}`,
+);
+process.exit(process.exitCode || 0);

package/src/cli/product-fill.js

@@ -0,0 +1,205 @@
+/**
+ * product-fill 命令 — 循环到服务端领取"缺商品详情"任务，补全商品信息
+ *
+ * 与 attach 类似的多用户循环客户端：
+ *   1. 通过 webserver（集中式）抓取商品详情（PDP 评分/销量/评论）
+ *   2. 循环 GET /api/product-tasks 领取任务
+ *   3. 对每个任务 POST webserver /api/tiktok/product 抓取商品详情
+ *   4. 成功 → POST /api/product-fill/:uniqueId 回写 jobs 表
+ *
+ * 用法: tt-help product-fill [-s 服务端] [-w webserver] [-i 间隔秒] [-l 每批上限]
+ */
+import { getMacOrUuid } from "../lib/mac-or-uuid.js";
+import { createApiClient } from "../lib/api-client.js";
+import { userId as configuredUserId, saveUserId } from "../lib/constants.js";
+
+const CAPTCHA_BACKOFF_MS = 30_000; // 验证码后冷却时长
+
+function formatNow() {
+  return new Date().toLocaleString("zh-CN", { hour12: false });
+}
+
+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.status === 503) {
+    const err = new Error(
+      `captcha: ${(await res.json().catch(() => ({}))).error || "Blocked"}`,
+    );
+    err.retryable = true;
+    throw err;
+  }
+  if (!res.ok) {
+    const err = new Error(`HTTP ${res.status}`);
+    err.status = res.status;
+    throw err;
+  }
+  return res.json();
+}
+
+export async function handleProductFill(options) {
+  const {
+    productFillLimit,
+    productFillInterval,
+    serverUrl,
+    productFillWebserver,
+    showHelp,
+  } = options;
+  const webserverUrl = productFillWebserver || null;
+
+  if (showHelp) {
+    log(
+      "用法: tt-help product-fill [-s 服务端] [-w webserver地址] [-i 间隔秒] [-l 每批上限]",
+    );
+    log("");
+    log("参数:");
+    log("  -s, --server <URL>      服务端地址（默认: http://127.0.0.1:3001）");
+    log(
+      "  -w, --webserver <URL>   商品详情 webserver 地址（必填，如 http://127.0.0.1:3000）",
+    );
+    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("");
+    log("示例:");
+    log(
+      "  tt-help product-fill -s http://127.0.0.1:3001 -w http://127.0.0.1:3000",
+    );
+    log("  tt-help product-fill -w http://117.71.53.99:17300 -i 5 -l 10");
+    return;
+  }
+
+  if (!webserverUrl) {
+    log(
+      "错误: 缺少 webserver 地址，请用 -w/--webserver 指定（如 http://127.0.0.1:3000）",
+    );
+    return;
+  }
+
+  // ── 设备标识 ──
+  let userId = configuredUserId;
+  if (!userId) {
+    userId = await getMacOrUuid();
+    saveUserId(userId);
+    log(`[ProductFill] 未检测到本地用户编号，已生成并使用: ${userId}`);
+  }
+  log(
+    `[ProductFill] 用户编号: ${userId} | 服务端: ${serverUrl} | webserver: ${webserverUrl}`,
+  );
+  log(
+    `[ProductFill] 每批上限: ${productFillLimit} | 空闲间隔: ${productFillInterval}秒`,
+  );
+
+  const { apiGet, apiPost } = createApiClient({ log: false });
+
+  let shuttingDown = false;
+  const shutdown = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    log(`\n[ProductFill] 收到退出信号，完成当前批次后退出...`);
+  };
+  process.on("SIGINT", () => shutdown());
+  process.on("SIGTERM", () => shutdown());
+
+  let loopCount = 0;
+  let totalSuccess = 0;
+  let totalFailed = 0;
+  let totalSkipped = 0;
+  let captchaBackoffUntil = 0; // 验证码后冷却到的时间戳
+
+  try {
+    while (!shuttingDown) {
+      loopCount++;
+      if (shuttingDown) break;
+
+      const { tasks = [] } = await apiGet(
+        `${serverUrl}/api/product-tasks?limit=${productFillLimit}&userId=${encodeURIComponent(userId)}`,
+      );
+
+      if (!tasks || tasks.length === 0) {
+        if (loopCount === 1) {
+          log(
+            `[ProductFill] 当前无缺商品任务，${productFillInterval}秒后重试...`,
+          );
+        }
+        await new Promise((r) => setTimeout(r, productFillInterval * 1000));
+        continue;
+      }
+
+      log(`\n[ProductFill] 获取到 ${tasks.length} 个补商品任务...`);
+
+      // 验证码冷却期间整批跳过（避免反复触发 webserver 限流）
+      const now = Date.now();
+      if (now < captchaBackoffUntil) {
+        const waitSec = Math.ceil((captchaBackoffUntil - now) / 1000);
+        log(`  ⏳ 验证码冷却中（剩余 ${waitSec}s），本批跳过`);
+        await new Promise((r) => setTimeout(r, captchaBackoffUntil - now));
+        continue;
+      }
+
+      for (const task of tasks) {
+        const uniqueId = task.uniqueId;
+        const seoUrl = task.seoUrl;
+        if (!seoUrl) {
+          log(`  ✗ @${uniqueId} 无 seoUrl，跳过`);
+          totalSkipped++;
+          continue;
+        }
+        log(`  → 补商品 @${uniqueId} ...`);
+        try {
+          const detail = await fetchProductDetail(webserverUrl, seoUrl);
+          const post = await apiPost(
+            `${serverUrl}/api/product-fill/${encodeURIComponent(uniqueId)}`,
+            { productDetail: detail },
+          );
+          if (post && post.ok) {
+            totalSuccess++;
+            log(
+              `  ✓ @${uniqueId} 商品已补全 (评分${detail.rating ?? "-"} | 销量${detail.soldCount ?? "-"} | 评论${detail.reviewCount ?? "-"})`,
+            );
+          } else {
+            totalFailed++;
+            log(`  ✗ @${uniqueId} 回传失败: ${post?.error || "未知"}`);
+          }
+        } catch (e) {
+          if (e.retryable) {
+            totalSkipped++;
+            captchaBackoffUntil = Date.now() + CAPTCHA_BACKOFF_MS;
+            log(
+              `  ⏳ @${uniqueId} 验证码拦截，冷却 ${CAPTCHA_BACKOFF_MS / 1000} 秒`,
+            );
+          } else {
+            totalFailed++;
+            log(`  ✗ @${uniqueId} 商品详情失败: ${e.message || "未知错误"}`);
+          }
+        }
+      }
+
+      log(
+        `  本批结果: 成功 ${totalSuccess} | 失败 ${totalFailed} | 跳过 ${totalSkipped}\n`,
+      );
+      await new Promise((r) => setTimeout(r, 300));
+    }
+  } catch (err) {
+    log(`[ProductFill] 运行异常: ${err.message}`);
+    throw err;
+  } finally {
+    log(
+      `[ProductFill] 已退出。总计: 成功 ${totalSuccess} | 失败 ${totalFailed} | 跳过 ${totalSkipped}`,
+    );
+  }
+}

package/src/lib/args.js

@@ -761,6 +761,44 @@ function parseAttachArgs(args) {
   };
 }
 
+function parseProductFillArgs(args) {
+  let limit = 5;
+  let interval = 10;
+  let serverUrl = defaultServer;
+  let webserverUrl = null;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-s" || arg === "--server") {
+      serverUrl = args[++i];
+    } else if (arg === "-w" || arg === "--webserver") {
+      webserverUrl = args[++i];
+    } else if (arg === "-i" || arg === "--interval") {
+      interval = parseInt(args[++i], 10) || 10;
+    } else if (arg === "-l" || arg === "--limit") {
+      limit = parseInt(args[++i], 10) || 5;
+    }
+  }
+
+  return {
+    subcommand: "product-fill",
+    productFillLimit: limit,
+    productFillInterval: interval,
+    serverUrl,
+    productFillWebserver: webserverUrl,
+    urls: [],
+    outputFormat: "json",
+    exploreCount: 0,
+    showConfig: false,
+    showHelp: false,
+    customProxy: null,
+    configAction: null,
+    configValue: null,
+    pipeMode: false,
+    filterStr: null,
+  };
+}
+
 function parseRecheckArgs(args) {
   let parallel = 1;
   let interval = 10;
@@ -1384,6 +1422,10 @@ export function parseArgs() {
     return parseAttachArgs(args.slice(1));
   }
 
+  if (args.length > 0 && args[0] === "product-fill") {
+    return parseProductFillArgs(args.slice(1));
+  }
+
   if (args.length > 0 && args[0] === "recheck") {
     return parseRecheckArgs(args.slice(1));
   }

package/src/lib/constants.js

@@ -198,6 +198,15 @@ const HELP_TEXT = [
   "    示例: tt-help attach -p 5 -i 10",
   "          tt-help attach -c PL,DE,FR -p 5",
   "",
+  "  tt-help product-fill [-s 服务端地址] [-w webserver地址] [-i 间隔秒数] [-l 每批上限]",
+  "    循环领取缺商品详情任务，通过 webserver 抓取评分/销量/评论并回写 jobs 表",
+  "    -s, --server <URL>     服务端地址（默认: http://127.0.0.1:3001）",
+  "    -w, --webserver <URL>  商品详情 webserver 地址（必填）",
+  "    -i, --interval <N>     无任务时轮询间隔，单位秒（默认: 10）",
+  "    -l, --limit <N>        每批领取任务数上限（默认: 5）",
+  "    示例: tt-help product-fill -w http://127.0.0.1:3000",
+  "          tt-help product-fill -s http://127.0.0.1:3001 -w http://117.71.53.99:17300 -i 5 -l 10",
+  "",
   "  tt-help recheck [-p 并行数] [-i 间隔秒数] [-s 服务端地址] [-c 国家列表]",
   "    重检 jobs 表中 done 非商家用户（tt_seller!=1），7 天未更新才检测",
   "    重新抓取用户基本信息（重点检查 tt_seller），更新回 jobs 表",

package/src/main.js

@@ -3,6 +3,7 @@ import { proxy, HELP_TEXT, getConfigText } from "./lib/constants.js";
 import { handleInfo } from "./cli/info.js";
 import { handleExplore } from "./cli/explore.js";
 import { handleAttach } from "./cli/attach.js";
+import { handleProductFill } from "./cli/product-fill.js";
 import { handleRecheck } from "./cli/recheck.js";
 import { handleWatch } from "./cli/watch.js";
 import { handleConfig, showConfig, showUsage, version } from "./cli/config.js";
@@ -35,6 +36,8 @@ async function main() {
       return handleInfo(parsed);
     case "attach":
       return handleAttach(parsed);
+    case "product-fill":
+      return handleProductFill(parsed);
     case "recheck":
       return handleRecheck(parsed);
     case "watch":

package/src/npm-main.js

@@ -3,6 +3,7 @@ import { PUBLIC_HELP_TEXT } from "./lib/constants.js";
 import { handleInfo } from "./cli/info.js";
 import { handleExplore } from "./cli/explore.js";
 import { handleAttach } from "./cli/attach.js";
+import { handleProductFill } from "./cli/product-fill.js";
 import { handleRecheck } from "./cli/recheck.js";
 import { handleConfig, showConfig, showUsage, version } from "./cli/config.js";
 import { handleOpen } from "./cli/open.js";
@@ -38,6 +39,8 @@ async function main() {
       return handleInfo(parsed);
     case "attach":
       return handleAttach(parsed);
+    case "product-fill":
+      return handleProductFill(parsed);
     case "recheck":
       return handleRecheck(parsed);
     case "webserver":

package/src/watch/data-store.js

@@ -2598,6 +2598,69 @@ export function createStore(filePath, options = {}) {
     return pending;
   }
 
+  // ===== product-fill：给缺商品详情的商家补商品信息（jobs 表） =====
+
+  /**
+   * 领取缺商品详情任务：jobs 表中有 top_video_seo_url 但未补过商品信息（product_name 为空）
+   * 补全是幂等的（同一 seoUrl 补出相同详情），成功回写后自动移出候选，无需额外锁定
+   * @param {number|string} limit
+   * @returns {{uniqueId:string, nickname:string|null, seoUrl:string, productId:string|null, productTitle:string|null}[]}
+   */
+  function getPendingProductTasks(limit) {
+    if (getDb()) {
+      const l = Math.max(1, parseInt(limit) || 5);
+      const rows = getDb()
+        .prepare(
+          `
+          SELECT unique_id, nickname, top_video_seo_url, top_video_product_id,
+                 top_video_product_title
+          FROM jobs
+          WHERE top_video_seo_url IS NOT NULL AND top_video_seo_url != ''
+            AND (product_name IS NULL OR product_name = '')
+          ORDER BY updated_at DESC
+          LIMIT ?
+        `,
+        )
+        .all(l);
+      return rows.map((row) => ({
+        uniqueId: row.unique_id,
+        nickname: row.nickname || null,
+        seoUrl: row.top_video_seo_url,
+        productId: row.top_video_product_id || null,
+        productTitle: row.top_video_product_title || null,
+      }));
+    }
+    // 内存模式无商品列，返回空
+    return [];
+  }
+
+  /**
+   * 回写商品详情到 jobs 表（product_* 列）
+   * @param {string} uniqueId
+   * @param {{rating?:number, reviewCount?:number, soldCount?:number, productName?:string}} productDetail
+   */
+  function updateProductInfo(uniqueId, productDetail) {
+    if (getDb()) {
+      if (!productDetail || typeof productDetail !== "object") {
+        return { ok: false, error: "productDetail 缺失" };
+      }
+      const ret = updateJobInfo(
+        uniqueId,
+        {
+          productRating: productDetail.rating ?? null,
+          productReviewCount: productDetail.reviewCount ?? null,
+          productSoldCount: productDetail.soldCount ?? null,
+          productName: productDetail.productName || null,
+        },
+        false, // 商品补全与用户刷新计数无关，不增加 user_update_count
+        "jobs",
+      );
+      if (ret.error) return ret;
+      return { ok: true };
+    }
+    return { ok: false, error: "db not initialized" };
+  }
+
   // ===== recheck-jobs：重检 jobs 表中 done 非商家用户 =====
 
   function getRecheckJobs(limit, countries) {
@@ -3383,6 +3446,8 @@ export function createStore(filePath, options = {}) {
     getPrecheckCandidates,
     markPrecheckResult,
     getPendingUserUpdateTasks,
+    getPendingProductTasks,
+    updateProductInfo,
     getRecheckJobs,
     batchUpdateRecheckJobs,
     updateUserInfo,

package/src/watch/db-schema.js

@@ -49,6 +49,11 @@ export function resetDbConnection() {
  * @param {Object} requiredColumns - { columnName: columnType }
  */
 function migrateColumns(tableName, requiredColumns) {
+  // 表不存在则跳过（videos_old 等表仅在历史 rename 后才存在，全新库不建）
+  const tableExists = db
+    .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name = ?")
+    .get(tableName);
+  if (!tableExists) return;
   const existing = new Set(
     db
       .prepare(`PRAGMA table_info(${tableName})`)
@@ -493,7 +498,6 @@ export function initDb(filePath) {
     `CREATE INDEX IF NOT EXISTS idx_jobs_user_update_queue_expr ON jobs(created_at ASC, unique_id ASC) WHERE COALESCE(tt_seller, '') = '' AND COALESCE(user_update_count, 0) <= 0`,
     `CREATE INDEX IF NOT EXISTS idx_videos_comment_queue ON videos(user_update_count, tt_seller DESC, registered_at ASC)`,
     `CREATE INDEX IF NOT EXISTS idx_videos_comment_queue_pending ON videos(tt_seller DESC, registered_at ASC, id) WHERE user_update_count IS NULL OR user_update_count <= 0`,
-    `CREATE INDEX IF NOT EXISTS idx_videos_old_id ON videos_old(id)`,
     `CREATE INDEX IF NOT EXISTS idx_tags_status ON tags(status)`,
     `CREATE INDEX IF NOT EXISTS idx_tags_score ON tags(score DESC)`,
     `CREATE INDEX IF NOT EXISTS idx_discover_log_country ON discover_log(country, round DESC)`,
@@ -513,6 +517,16 @@ export function initDb(filePath) {
   for (const sql of indexes) {
     db.exec(sql);
   }
+  // videos_old 索引（该表仅历史 rename 后存在，全新库跳过）
+  if (
+    db
+      .prepare(
+        "SELECT 1 FROM sqlite_master WHERE type='table' AND name='videos_old'",
+      )
+      .get()
+  ) {
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_videos_old_id ON videos_old(id)`);
+  }
 
   // ===== task_queue 索引（对应 claimNextJob UNION 查询的 4 个部分索引） =====
   const tqIndexes = [

package/src/watch/server.js

@@ -155,6 +155,8 @@ function inferClientType(routePath) {
   if (routePath.startsWith("/api/precheck")) return "precheck";
   if (routePath.startsWith("/api/redo-job")) return "refresh";
   if (routePath.startsWith("/api/user-update-tasks")) return "attach";
+  if (routePath.startsWith("/api/product-tasks")) return "product-fill";
+  if (routePath.startsWith("/api/product-fill")) return "product-fill";
   if (routePath.startsWith("/api/recheck-jobs")) return "recheck";
   if (routePath.startsWith("/api/comment-task")) return "comments";
   if (routePath.startsWith("/api/tags/refresh")) return "tag-refresh";
@@ -952,6 +954,40 @@ export function startWatchServer(
         return;
       }
 
+      // ── product-fill 端点：补商品信息（缺商品详情的商家） ──
+      if (req.method === "GET" && routePath === "/api/product-tasks") {
+        const limit = params.limit;
+        const tasks = store.getPendingProductTasks(limit);
+        const ts = new Date().toLocaleTimeString("zh-CN", { hour12: false });
+        console.error(`[JOB ${ts}] PRODUCT-TASKS: ${tasks.length} tasks`);
+        sendJSON(res, 200, { total: tasks.length, tasks });
+        return;
+      }
+
+      const productFillMatch = routePath.match(
+        /^\/api\/product-fill\/([^/]+)$/,
+      );
+      if (req.method === "POST" && productFillMatch) {
+        const uniqueId = decodeURIComponent(productFillMatch[1]);
+        try {
+          const body = await readBody(req);
+          const ret = store.updateProductInfo(uniqueId, body.productDetail);
+          const ts = new Date().toLocaleTimeString("zh-CN", { hour12: false });
+          if (ret.ok) {
+            console.error(`[JOB ${ts}] PRODUCT-FILL: ${uniqueId} ok`);
+            sendJSON(res, 200, { ok: true });
+          } else {
+            console.error(
+              `[JOB ${ts}] PRODUCT-FILL: ${uniqueId} 失败: ${ret.error}`,
+            );
+            sendJSON(res, 400, { error: ret.error });
+          }
+        } catch (e) {
+          sendJSON(res, 400, { error: e.message });
+        }
+        return;
+      }
+
       // ── recheck-jobs 端点 ──
       if (req.method === "GET" && routePath === "/api/recheck-jobs") {
         const limit = params.limit;

package/src/watchdog/upgrader.js

@@ -197,9 +197,17 @@ function openLogFile(prefix, label, what) {
 }
 
 /**
- * spawn 子进程（升级器 / 新版 watchdog 共用）
- * interactive：继承控制台；否则 detached 后台运行，stdout/stderr 落到 logFd
+ * spawn 子进程（升级器 U / 新版 watchdog 共用）
+ *
+ * interactive（前端）：stdio inherit，继承 cmd /k 前端窗口。
+ * 用于 cmd /k 启动的 watchdog 升级链路——旧 watchdog 被杀后 cmd /k 窗口保持，
+ * U 与新版继承该窗口，运维可远程（RDP）在前端窗口看日志。
+ * 前提：watchdog 由 cmd /k 启动（保证窗口在杀旧后不关闭）。
+ *
+ * 非交互：detached 后台 + 独立日志（旧 watchdog 非交互启动时的兜底，保证升级不丢）。
+ *
  * @param {string[]} args 子进程完整参数（node 脚本路径 + 参数）
+ * @param {{interactive?: boolean, logFd?: number}} opts
  * @returns {import("child_process").ChildProcess}
  */
 function spawnChild(args, { interactive = false, logFd } = {}) {
@@ -300,7 +308,9 @@ export async function runUpgradeMode(argv) {
     await new Promise((r) => setTimeout(r, 1000)); // 给强杀一点生效时间
   }
 
-  // 4) 旧进程已退，启新版 watchdog（无并存窗口，一定能起来）
+  // 4) 旧进程已退，启新版 watchdog
+  //     interactive：继承 cmd /k 前端窗口（运维远程看日志）；
+  //     旧 watchdog 非交互启动时自动退化为 detached 后台 + 独立日志（保证不丢）
   console.error(`[upgrade-proc] 启动新版 watchdog ...`);
   const cliPath = join(__dirname, "..", "..", "cli.js");
   const args = buildWatchdogArgs({
@@ -314,13 +324,28 @@ export async function runUpgradeMode(argv) {
     "upgrade-proc",
     "新版 watchdog 日志",
   );
+  let child;
   try {
-    const child = spawnChild([cliPath, ...args], { interactive, logFd });
+    child = spawnChild([cliPath, ...args], { interactive, logFd });
     console.error(`[upgrade-proc] 新版 watchdog 已启动 (pid=${child.pid})`);
   } catch (e) {
     console.error(`[upgrade-proc] 新版 watchdog 启动失败: ${e.message}`);
     process.exit(1);
   }
+
+  // 5) 存活校验：3s 后确认新版进程存活；未存活则明确报错（可看日志定位），不静默
+  await new Promise((r) => setTimeout(r, 3000));
+  try {
+    process.kill(child.pid, 0);
+    console.error(
+      `[upgrade-proc] 新版 watchdog 存活确认 (pid=${child.pid})，升级完成`,
+    );
+  } catch {
+    console.error(
+      `[upgrade-proc] 新版 watchdog (pid=${child.pid}) 启动后未存活，请查看日志排障`,
+    );
+    process.exit(1);
+  }
   process.exit(0);
 }
 
@@ -348,6 +373,8 @@ export function spawnUpgrader({
 
   const logFd = openLogFile("tt-help-upgrader", "watchdog", "升级程序日志");
   try {
+    // U 按旧 watchdog 的 interactive 透传：cmd /k 前端窗口启动时 U 继承前端窗口（运维可看升级日志），
+    // 旧 watchdog 非交互启动时 U 自动 detached 后台 + 独立日志
     return spawnChild([upgraderPath, ...args], { interactive, logFd });
   } catch (e) {
     console.error(`[watchdog] 升级程序启动失败: ${e.message}`);