tt-help-cli-ycl 1.4.169 → 1.4.172

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

@@ -1,216 +0,0 @@
-/**
- * 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);
-// D: 有 seoUrl、name 空但 rating 有值 → 已抓到数据，不应被领取（防死循环）
-db.prepare(
-  `INSERT INTO jobs (unique_id, status, tt_seller, top_video_seo_url, product_name, product_rating, updated_at)
-   VALUES ('sellerD', 'done', 1, 'https://www.tiktok.com/shop/pdp/d1', NULL, 4.5, ?)`,
-).run(now);
-// E: 有 seoUrl、name 空但 sold_count 有值 → 已抓到数据，不应被领取（防死循环）
-db.prepare(
-  `INSERT INTO jobs (unique_id, status, tt_seller, top_video_seo_url, product_name, product_sold_count, updated_at)
-   VALUES ('sellerE', 'done', 1, 'https://www.tiktok.com/shop/pdp/e1', '', 120, ?)`,
-).run(now);
-// F: 有 seoUrl、无商品 → 与 A 一起验证 claim 防重复领取
-db.prepare(
-  `INSERT INTO jobs (unique_id, status, tt_seller, top_video_seo_url, product_name, updated_at)
-   VALUES ('sellerF', 'done', 1, 'https://www.tiktok.com/shop/pdp/f1', NULL, ?)`,
-).run(now + 1);
-
-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("只返回缺商品的（sellerA/sellerF，不含 B/C/D/E）", () => {
-  const ids = tasks.map((t) => t.uniqueId);
-  assert(ids.length === 2, `实际: ${ids.join(",")}`);
-  assert(
-    ids.includes("sellerA") && ids.includes("sellerF"),
-    `实际: ${ids.join(",")}`,
-  );
-});
-check("任务带 seoUrl / productId / productTitle", () => {
-  const a = tasks.find((t) => t.uniqueId === "sellerA");
-  assert(a.seoUrl === "https://www.tiktok.com/shop/pdp/a1");
-  assert("productId" in a && "productTitle" in a);
-});
-check("limit=1 只取 1 条", () => {
-  db.prepare(
-    "UPDATE jobs SET claimed_at = NULL, claimed_by = NULL WHERE unique_id IN ('sellerA','sellerF')",
-  ).run();
-  assert(store.getPendingProductTasks(1).length === 1);
-  db.prepare(
-    "UPDATE jobs SET claimed_at = NULL, claimed_by = NULL WHERE unique_id IN ('sellerA','sellerF')",
-  ).run();
-});
-check("领取即锁定：写入 claimed_by/claimed_at", () => {
-  const claimed = store.getPendingProductTasks(5, "testerA");
-  assert(claimed.length === 2, `实际: ${claimed.length}`);
-  const row = db
-    .prepare(
-      "SELECT claimed_by, claimed_at FROM jobs WHERE unique_id = 'sellerA'",
-    )
-    .get();
-  assert(row.claimed_by === "testerA", JSON.stringify(row));
-  assert(row.claimed_at !== null && row.claimed_at !== undefined);
-});
-check("锁定期间不重复领取（多客户端防重复）", () => {
-  const again = store.getPendingProductTasks(5, "testerB");
-  assert(
-    again.length === 0,
-    `实际领到: ${again.map((t) => t.uniqueId).join(",")}`,
-  );
-});
-check("TTL 过期后自动回收", () => {
-  db.prepare("UPDATE jobs SET claimed_at = ? WHERE unique_id = 'sellerF'").run(
-    Date.now() - 6 * 60 * 1000,
-  );
-  const recycled = store.getPendingProductTasks(5, "testerC");
-  assert(
-    recycled.some((t) => t.uniqueId === "sellerF"),
-    `实际: ${recycled.map((t) => t.uniqueId).join(",")}`,
-  );
-});
-check("name 空但 rating 有值 → 不进候选", () => {
-  assert(!tasks.some((t) => t.uniqueId === "sellerD"));
-});
-check("name 空但 soldCount 有值 → 不进候选", () => {
-  assert(!tasks.some((t) => t.uniqueId === "sellerE"));
-});
-
-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[3b] skus 入库（product_skus JSON 列）");
-const skuRet = store.updateProductInfo("sellerB", {
-  rating: 4.8,
-  reviewCount: 174,
-  soldCount: 962,
-  productName: "Sku Product",
-  skus: [
-    {
-      skuId: "1731140428076257811",
-      specs: "Shade: Wanderlust",
-      stock: 106,
-      stockStatus: 1,
-      warehouseId: "7676336681096611597",
-    },
-    {
-      skuId: "1729888889849549331",
-      specs: "Shade: Ballerina",
-      stock: 2017,
-      stockStatus: 1,
-      warehouseId: "7676336681096611597",
-    },
-  ],
-});
-check("带 skus 回写返回 ok", () => assert(skuRet.ok === true));
-check("product_skus 列已写入 JSON（读回可解析）", () => {
-  const rowB = db
-    .prepare("SELECT product_skus FROM jobs WHERE unique_id = ?")
-    .get("sellerB");
-  const parsed = JSON.parse(rowB.product_skus);
-  assert(parsed.length === 2);
-  assert(parsed[0].skuId === "1731140428076257811");
-  assert(parsed[1].stock === 2017);
-});
-check("无 skus 回写（老客户端）不报错", () => {
-  const ret = store.updateProductInfo("sellerB", {
-    rating: 4.0,
-    soldCount: 10,
-    productName: "Old",
-    reviewCount: 5,
-  });
-  assert(ret.ok === true);
-});
-
-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

@@ -1,117 +0,0 @@
-/**
- * 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/scripts/test-proxy-switch-restart.mjs

@@ -1,198 +0,0 @@
-/**
- * 代理切换 → watchdog 强制重启命令 链路测试（2026-08-28，先打通路版本）
- *
- * 验证：
- *   T1  daemon _markSwitchTime 递增 restartSeq（首次为 1，连续递增）
- *   T2  daemon _writeHealth 把 restartSeq 带进 health 文件
- *   T3  daemon 未切换时 restartSeq 保持 0
- *   T4  ProcessManager.restartAll 先停后起（真实子进程，pid 变化、数量恢复）
- *   T5  restartAll 跳过 stopped / 无 child 的命令
- *   T6  无运行命令时 restartAll 返回 {restarted:0}
- *   T7  Agent._checkProxySwitch 首次读取仅建基线不触发
- *   T8  health.restartSeq 变大 → 触发强制重启（真实子进程 pid 变化）
- *   T9  health.restartSeq 变小（daemon 重启归零）→ 不触发
- *   T10 通道重启：主文件 seq 不变时不触发
- *
- * 运行: node --test scripts/test-proxy-switch-restart.mjs
- */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { writeFileSync, rmSync, existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-
-const HEALTH_FILE = join(tmpdir(), "clash-health.json");
-
-/** 清理并写 health 文件（模拟 daemon 写入） */
-function writeHealthFile(extra) {
-  writeFileSync(
-    HEALTH_FILE,
-    JSON.stringify(
-      {
-        node: "🇺🇸 美国01",
-        healthy: true,
-        lastCheck: new Date().toISOString(),
-        ...extra,
-      },
-      null,
-      2,
-    ),
-  );
-}
-
-/** 生成一个常驻假命令（测试业务进程） */
-function fakeCmd(id) {
-  return {
-    id,
-    name: id,
-    command: process.execPath,
-    args: ["-e", "setInterval(()=>{},1000)"],
-    enabled: true,
-  };
-}
-
-function cleanup() {
-  try {
-    rmSync(HEALTH_FILE, { force: true });
-  } catch {}
-}
-
-test("T1-T3: daemon 切换信号（_markSwitchTime 递增 + _writeHealth 带出）", async () => {
-  const { ClashDaemon } = await import("../src/clash/daemon.js");
-  const ipc = await import("../src/clash/ipc.js");
-  cleanup();
-  try {
-    const d = new ClashDaemon({ dryRun: true });
-    const c = { proxyPort: 0 };
-
-    // T3: 未切换 → restartSeq = 0
-    d._writeHealth(c, { node: "A", healthy: true });
-    let h = ipc.readHealth(0);
-    assert.equal(h.restartSeq, 0, "未切换时 restartSeq 应为 0");
-
-    // T1: 首次切换 → 1
-    d._markSwitchTime(c);
-    assert.equal(c._restartSeq, 1, "首次切换 restartSeq 应为 1");
-    d._markSwitchTime(c);
-    assert.equal(c._restartSeq, 2, "连续切换 restartSeq 递增");
-
-    // T2: _writeHealth 带出 restartSeq
-    d._writeHealth(c, { node: "B", healthy: true, lastSwitch: "A → B" });
-    h = ipc.readHealth(0);
-    assert.equal(h.restartSeq, 2, "health 文件应携带 restartSeq=2");
-    assert.equal(h.lastSwitch, "A → B");
-  } finally {
-    cleanup();
-  }
-});
-
-test("T4-T6: ProcessManager.restartAll 先停后起", async () => {
-  const { ProcessManager } = await import("../src/watchdog/process-manager.js");
-  const pm = new ProcessManager();
-  try {
-    // T6: 空集
-    const empty = await pm.restartAll("测试");
-    assert.deepEqual(empty, { restarted: 0 }, "无运行命令应返回 0");
-
-    pm.startCommand(fakeCmd("proc-a"));
-    await new Promise((r) => setTimeout(r, 500));
-    assert.equal(pm.runningCount, 1);
-    const oldPid = pm.processes.get("proc-a").child.pid;
-
-    // T4: 先停后起，pid 变化、数量恢复
-    const r = await pm.restartAll("代理切换(测试)");
-    assert.equal(r.restarted, 1, "应重启 1 个命令");
-    assert.equal(pm.runningCount, 1, "重启后数量恢复");
-    const newPid = pm.processes.get("proc-a").child.pid;
-    assert.notEqual(newPid, oldPid, "重启后应是新进程（pid 不同）");
-
-    // T5: stopped 的命令不参与重启
-    pm.startCommand(fakeCmd("proc-b"));
-    await new Promise((r) => setTimeout(r, 500));
-    pm.stopCommand("proc-b");
-    const r2 = await pm.restartAll("二次重启");
-    assert.equal(r2.restarted, 1, "只重启 running 的 1 个，stopped 的不算");
-    assert.equal(pm.runningCount, 1);
-    assert.ok(!pm.processes.has("proc-b"), "proc-b 保持停止状态");
-  } finally {
-    pm.stopAll();
-  }
-});
-
-test("T7-T13: Agent._checkProxySwitch 感知切换（默认禁用，开启后才重启）", async () => {
-  const { WatchdogAgent } = await import("../src/watchdog/agent.js");
-  cleanup();
-  const agent = new WatchdogAgent({
-    serverUrl: "http://127.0.0.1:9",
-    clientId: "test-switch",
-    intervalMs: 60000,
-    spawnDaemon: false,
-  });
-  try {
-    // 准备一个运行中的假业务命令
-    agent.processManager.startCommand(fakeCmd("proc-c"));
-    await new Promise((r) => setTimeout(r, 500));
-    const pid0 = agent.processManager.processes.get("proc-c").child.pid;
-
-    // T7: 首次读取建基线，不触发
-    writeHealthFile({ restartSeq: 0, lastSwitch: "初始化" });
-    await agent._checkProxySwitch();
-    assert.equal(
-      agent.processManager.processes.get("proc-c").child.pid,
-      pid0,
-      "首次读取仅建基线，不应重启",
-    );
-
-    // T10: seq 不变不触发
-    writeHealthFile({ restartSeq: 0, lastSwitch: "初始化" });
-    await agent._checkProxySwitch();
-    assert.equal(
-      agent.processManager.processes.get("proc-c").child.pid,
-      pid0,
-      "seq 不变不应重启",
-    );
-
-    // T11: 默认禁用时 seq 变大 → 不触发（但基线已跟随更新）
-    writeHealthFile({ restartSeq: 1, lastSwitch: "禁用期间切换: A → B" });
-    await agent._checkProxySwitch();
-    assert.equal(
-      agent.processManager.processes.get("proc-c").child.pid,
-      pid0,
-      "默认禁用时检测到切换也不应重启",
-    );
-
-    // T12: 开启开关后，seq 仍为 1（无新切换）→ 不补触发历史切换
-    agent._applySwitchRestartConfig({ enabled: true });
-    await agent._checkProxySwitch();
-    assert.equal(
-      agent.processManager.processes.get("proc-c").child.pid,
-      pid0,
-      "开启开关后不应补触发开启前的历史切换",
-    );
-
-    // T8: 开启后 seq 1→2 → 触发强制重启
-    writeHealthFile({ restartSeq: 2, lastSwitch: "开启后切换: B → C" });
-    await agent._checkProxySwitch();
-    const pid1 = agent.processManager.processes.get("proc-c").child.pid;
-    assert.notEqual(pid1, pid0, "开启后检测到切换应强制重启（pid 变化）");
-    assert.equal(agent.processManager.runningCount, 1, "重启后数量恢复");
-
-    // T9: seq 变小（daemon 重启归零）→ 不触发
-    writeHealthFile({ restartSeq: 0, lastSwitch: "daemon 重启" });
-    await agent._checkProxySwitch();
-    assert.equal(
-      agent.processManager.processes.get("proc-c").child.pid,
-      pid1,
-      "seq 变小（daemon 重启归零）不应触发",
-    );
-
-    // T13: 归零后再次真实切换（0 → 1）应重新触发
-    writeHealthFile({ restartSeq: 1, lastSwitch: "再次切换: C → D" });
-    await agent._checkProxySwitch();
-    const pid2 = agent.processManager.processes.get("proc-c").child.pid;
-    assert.notEqual(pid2, pid1, "归零后再次切换应重新触发");
-  } finally {
-    await agent.stop();
-    cleanup();
-  }
-});