tt-help-cli-ycl 1.4.169 → 1.4.172

package/package.json

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

package/scripts/test-subscription-allocator.mjs

@@ -0,0 +1,220 @@
+/**
+ * 订阅自动分配器 — 纯函数单元测试
+ *
+ * 覆盖需求讨论拍板的规则卡 v0:
+ *   规则1 配满 / 规则2 可用集 / 规则3 粘性 / 规则4 节点内摊开 /
+ *   规则5 跨机器错开 / 规则6 重复合法 / 规则7 空保护 / 规则8 决定性
+ *
+ * 运行: node scripts/test-subscription-allocator.mjs
+ */
+import assert from "assert";
+import {
+  allocateSubscriptions,
+  isSubAvailable,
+  ALLOC_MAX_INSTANCES,
+} from "../src/watch/subscription-allocator.js";
+
+const GB = 1073741824;
+
+/** 构造池子视图（池子顺序 = 数组顺序） */
+function mkView(name, { code = "ok", enabled = true } = {}) {
+  const colors = {
+    ok: "#4ade80",
+    expiring: "#f87171",
+    "quota-critical": "#f87171",
+    "probe-failed": "#fbbf24",
+    unknown: "#6b7280",
+    expired: "#f87171",
+    exhausted: "#f87171",
+    disabled: "#6b7280",
+  };
+  return {
+    id: "sub_" + name,
+    name,
+    url: `https://${name.toLowerCase()}.airport.example/sub?token=${name}`,
+    enabled: code === "disabled" ? false : enabled, // 与服务端口径一致: 禁用订阅 enabled=false
+    status: { code, label: code, color: colors[code] || "#6b7280" },
+    used: 30 * GB,
+    total: 100 * GB,
+  };
+}
+
+/** 全局占用数: 各机器 alloc 里 URL 出现次数（现算口径，与 reconcileAutoAlloc 一致） */
+function usageOf(allocs, exceptIdx = -1) {
+  const usage = {};
+  allocs.forEach((a, i) => {
+    if (i === exceptIdx) return;
+    for (const it of a) usage[it.url] = (usage[it.url] || 0) + 1;
+  });
+  return usage;
+}
+
+/** 粘性可用性判定（与 isAllocUrlAvailable 同口径: byUrl 含全部池子视图，含死订阅） */
+function mkIsAvail(allViews) {
+  const byUrl = new Map(allViews.map((v) => [v.url, v]));
+  return (u) => {
+    const v = byUrl.get(u);
+    return !v || isSubAvailable(v);
+  };
+}
+
+const urls = (alloc) => alloc.map((s) => s.url.split("?token=")[1]);
+let passed = 0;
+function t(name, fn) {
+  fn();
+  passed++;
+  console.log(`  ✓ ${name}`);
+}
+
+console.log("\n[规则2] 可用性判定: 只排除 已禁用/已到期/已耗尽");
+t("禁用/到期/耗尽不可用；临期/告急/探测失败/未知都可用", () => {
+  assert.strictEqual(isSubAvailable(mkView("a", { code: "disabled" })), false);
+  assert.strictEqual(isSubAvailable(mkView("a", { code: "expired" })), false);
+  assert.strictEqual(isSubAvailable(mkView("a", { code: "exhausted" })), false);
+  assert.strictEqual(isSubAvailable(mkView("a", { code: "ok" })), true);
+  assert.strictEqual(isSubAvailable(mkView("a", { code: "expiring" })), true);
+  assert.strictEqual(isSubAvailable(mkView("a", { code: "quota-critical" })), true);
+  assert.strictEqual(isSubAvailable(mkView("a", { code: "probe-failed" })), true);
+  assert.strictEqual(isSubAvailable(mkView("a", { code: "unknown" })), true);
+});
+
+console.log("\n[规则1/4/5/6/8] 需求文档示例: 池子 [A,B,C,D] 全可用");
+const A = mkView("A");
+const B = mkView("B");
+const C = mkView("C");
+const D = mkView("D");
+const avail4 = [A, B, C, D];
+const isAvail4 = mkIsAvail(avail4);
+
+t("F-1 配 3 → [A,B,C]（全局占用全 0，按池序）", () => {
+  const f1 = allocateSubscriptions({ available: avail4, count: 3, prevAlloc: [], usage: {}, isAvailUrl: isAvail4 });
+  assert.deepStrictEqual(urls(f1.alloc), ["A", "B", "C"]);
+  assert.strictEqual(f1.warn, null);
+});
+
+const f1 = allocateSubscriptions({ available: avail4, count: 3, prevAlloc: [], usage: {}, isAvailUrl: isAvail4 }).alloc;
+
+t("F-2 配 2 → [D,A]（D 全局占用 0 优先；A 池序靠前）", () => {
+  const f2 = allocateSubscriptions({
+    available: avail4, count: 2, prevAlloc: [], usage: usageOf([f1]), isAvailUrl: isAvail4,
+  });
+  assert.deepStrictEqual(urls(f2.alloc), ["D", "A"]);
+});
+
+const f2 = allocateSubscriptions({
+  available: avail4, count: 2, prevAlloc: [], usage: usageOf([f1]), isAvailUrl: isAvail4,
+}).alloc;
+
+t("F-3 配 1 → [B]（当前占用最少之一，按池序）", () => {
+  const f3 = allocateSubscriptions({
+    available: avail4, count: 1, prevAlloc: [], usage: usageOf([f1, f2]), isAvailUrl: isAvail4,
+  });
+  assert.deepStrictEqual(urls(f3.alloc), ["B"]);
+});
+
+const f3 = allocateSubscriptions({
+  available: avail4, count: 1, prevAlloc: [], usage: usageOf([f1, f2]), isAvailUrl: isAvail4,
+}).alloc;
+
+console.log("\n[规则3] B 到期失效: 只有持 B 的槽位换血，其余纹丝不动");
+const availNoB = [A, C, D]; // 可用集（B 已到期出列）
+const isAvailNoB = mkIsAvail([A, mkView("B", { code: "expired" }), C, D]); // byUrl 含死的 B
+
+t("F-1 槽2(B) 换血 → [A,D,C]（补全局最少占用的 D）", () => {
+  const f1b = allocateSubscriptions({
+    available: availNoB, count: 3, prevAlloc: f1, usage: usageOf([f2]), isAvailUrl: isAvailNoB,
+  });
+  assert.deepStrictEqual(urls(f1b.alloc), ["A", "D", "C"]);
+});
+
+const f1b = allocateSubscriptions({
+  available: availNoB, count: 3, prevAlloc: f1, usage: usageOf([f2]), isAvailUrl: isAvailNoB,
+}).alloc;
+
+t("F-2 不含 B → 纹丝不动 [D,A]", () => {
+  const f2b = allocateSubscriptions({
+    available: availNoB, count: 2, prevAlloc: f2, usage: usageOf([f1b]), isAvailUrl: isAvailNoB,
+  });
+  assert.deepStrictEqual(urls(f2b.alloc), ["D", "A"]);
+});
+
+t("F-3 槽1(B) 换血 → [C]（C/D 占用并列，按池序取 C）", () => {
+  const f3b = allocateSubscriptions({
+    available: availNoB, count: 1, prevAlloc: f3, usage: usageOf([f1b, f2]), isAvailUrl: isAvailNoB,
+  });
+  assert.deepStrictEqual(urls(f3b.alloc), ["C"]);
+});
+
+console.log("\n[规则1/6] 极端: 可用只剩 A → 回绕重复配满");
+const availOnlyA = [A];
+// B/C/D 均确凿死亡（byUrl 含全量死视图）
+const isAvailOnlyA = mkIsAvail([
+  A,
+  mkView("B", { code: "expired" }),
+  mkView("C", { code: "exhausted" }),
+  mkView("D", { code: "disabled" }),
+]);
+t("F-1 = A,A,A；F-2 = A,A（死槽也回绕补满）", () => {
+  const x1 = allocateSubscriptions({ available: availOnlyA, count: 3, prevAlloc: f1, usage: usageOf([f2, f3]), isAvailUrl: isAvailOnlyA });
+  assert.deepStrictEqual(urls(x1.alloc), ["A", "A", "A"]);
+  const x2 = allocateSubscriptions({ available: availOnlyA, count: 2, prevAlloc: f2, usage: usageOf([x1.alloc, f3]), isAvailUrl: isAvailOnlyA });
+  assert.deepStrictEqual(urls(x2.alloc), ["A", "A"]);
+});
+
+console.log("\n[规则3] 存量 URL 不在池子（迁移无感）: 视为未知 → 原位保留");
+t("非池子 URL 粘性保留", () => {
+  const legacy = { name: "legacy", url: "https://legacy.example/sub?token=X" };
+  const r = allocateSubscriptions({
+    available: avail4, count: 1, prevAlloc: [legacy], usage: {}, isAvailUrl: (u) => u === legacy.url,
+  });
+  assert.deepStrictEqual(r.alloc, [legacy]); // 原对象字段原样保留
+  assert.strictEqual(r.warn, null);
+});
+
+console.log("\n[规则7] 空保护: 可用集为空 → alloc 原地不动 + 标黄");
+t("有空槽补不上 → 原样返回存量 + warn=pool-empty", () => {
+  const prev = [{ name: "x", url: "https://x.example/1" }, { name: "y", url: "https://y.example/2" }];
+  const r = allocateSubscriptions({ available: [], count: 3, prevAlloc: prev, usage: {}, isAvailUrl: () => false });
+  assert.deepStrictEqual(r.alloc, prev, "绝不换血也不下发空列表");
+  assert.strictEqual(r.warn, "pool-empty");
+});
+t("存量槽全部粘性可用（纯保留）→ 不算告警", () => {
+  const prev = [{ name: "x", url: "https://x.example/1" }];
+  const r = allocateSubscriptions({ available: [], count: 1, prevAlloc: prev, usage: {}, isAvailUrl: () => true });
+  assert.deepStrictEqual(r.alloc, prev);
+  assert.strictEqual(r.warn, null);
+});
+
+console.log("\n[规则1] count 缩小: 砍尾部实例");
+t("5 槽缩到 2 → 保留前 2 个槽位", () => {
+  const prev = ["v", "w", "x", "y", "z"].map((n) => ({ name: n, url: `https://${n}.example/sub?token=${n}` }));
+  const r = allocateSubscriptions({
+    available: avail4, count: 2, prevAlloc: prev, usage: {}, isAvailUrl: () => true,
+  });
+  assert.deepStrictEqual(urls(r.alloc), ["v", "w"]);
+});
+
+console.log("\n[规则8] 决定性: 输入不变 → 输出恒等（心跳重跑零写盘的前提）");
+t("重复计算结果一致；对结果再分配幂等", () => {
+  const args = { available: avail4, count: 4, prevAlloc: f1, usage: usageOf([f2, f3]), isAvailUrl: isAvail4 };
+  const r1 = allocateSubscriptions(args);
+  const r2 = allocateSubscriptions(args);
+  assert.deepStrictEqual(r1, r2, "同输入同输出");
+  const again = allocateSubscriptions({ ...args, prevAlloc: r1.alloc });
+  assert.deepStrictEqual(again.alloc, r1.alloc, "粘性: 对结果重算不再变化");
+});
+
+t("count 超上限钳制到 8（实例端口段上限）", () => {
+  const r = allocateSubscriptions({ available: [A], count: 99, prevAlloc: [], usage: {}, isAvailUrl: isAvail4 });
+  assert.strictEqual(r.alloc.length, ALLOC_MAX_INSTANCES);
+  assert.ok(r.alloc.every((s) => s.url === A.url));
+});
+
+t("空池 + 空存量 → 返回空列表 + pool-empty（无害兜底）", () => {
+  const r = allocateSubscriptions({ available: [], count: 2, prevAlloc: [], usage: {}, isAvailUrl: () => false });
+  assert.deepStrictEqual(r.alloc, []);
+  assert.strictEqual(r.warn, "pool-empty");
+});
+
+console.log(`\n订阅分配器单元测试通过 ✅ (${passed} 用例)\n`);
+process.exit(0);

package/scripts/test-subscription-auto-alloc-ui.mjs

@@ -0,0 +1,208 @@
+/**
+ * 订阅自动分配 UI 冒烟测试 — 真实 watch 服务 + 无头 Edge
+ *
+ * 流程:
+ *   0. 临时 HOME + 预置订阅池（A/B/C/D）+ F-1(auto, count=3) / F-2(manual) 配置
+ *   1. 起 watch 服务（动态端口）+ 伪造两台客户端心跳上线
+ *   2. F-1 卡片「配置 ⚙️」→ 弹窗应为自动分配视图（数量输入 + alloc 端口映射表 + 徽标）
+ *   3. F-2 卡片 → 弹窗应为手动视图（textarea + 切换为自动入口）
+ *   4. 手动视图点「⚡ 切换为自动分配」→ 服务端迁移 + 弹窗切到自动视图
+ *   5. 截图落盘 /tmp/suballoc-ui-*.png
+ *
+ * 运行: node scripts/test-subscription-auto-alloc-ui.mjs（自行起停服务）
+ */
+import { spawn } from "child_process";
+import { mkdtempSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { chromium } from "playwright";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const HOME = mkdtempSync(join(tmpdir(), "suballoc-ui-"));
+const PORT = 3127;
+const BASE = `http://127.0.0.1:${PORT}`;
+const GB = 1073741824;
+
+// mock 机场（探测/代报都用不上，仅池子状态 unknown=可用即可分配）
+const subUrl = (n) => `https://${n.toLowerCase()}.airport.example/sub?token=${n}`;
+
+// ── 预置配置: F-1 auto count=3（alloc: LEGACY+A+C），F-2 手动 1 条 ──
+const now = Date.now();
+writeFileSync(
+  join(HOME, ".tt-help-watchdog-subs.json"),
+  JSON.stringify(
+    {
+      subscriptions: ["A", "B", "C", "D"].map((n, i) => ({
+        id: "sub_" + n.toLowerCase(),
+        name: `订阅${n}`,
+        url: subUrl(n),
+        note: "",
+        enabled: true,
+        addedAt: now,
+        updatedAt: now,
+        probe: {
+          at: now,
+          ok: true,
+          httpCode: 200,
+          error: null,
+          upload: 0,
+          download: 30 * GB,
+          total: 100 * GB,
+          expire: Math.floor(now / 1000) + 20 * 86400,
+          suspiciousBody: false,
+        },
+        lastNodeReport: null,
+        history: [],
+        resets: [],
+        _i: i,
+      })),
+    },
+    null,
+    2,
+  ),
+);
+writeFileSync(
+  join(HOME, ".tt-help-watchdog.json"),
+  JSON.stringify(
+    {
+      proxySettings: {
+        "F-1": {
+          mode: "auto",
+          count: 3,
+          subscriptions: [
+            { name: "", url: "https://legacy-airport.example/sub?token=OLD" },
+            { name: "", url: subUrl("A") },
+            { name: "", url: subUrl("C") },
+          ],
+          allocWarn: null,
+          allocatedAt: now,
+        },
+        "F-2": { subscriptions: [{ name: "", url: subUrl("B") }] },
+      },
+    },
+    null,
+    2,
+  ),
+);
+
+// ── 起 watch 服务 ──
+const srv = spawn("node", [join(root, "src", "main.js"), "watch", "-o", join(HOME, "t.db"), "-p", String(PORT)], {
+  cwd: root,
+  env: { ...process.env, HOME },
+  stdio: ["ignore", "pipe", "pipe"],
+});
+srv.stdout.on("data", () => {});
+srv.stderr.on("data", (d) => process.stderr.write(`[srv] ${d}`));
+const srvReady = new Promise((resolve, reject) => {
+  const timer = setTimeout(() => reject(new Error("服务 15s 未就绪")), 15000);
+  srv.stderr.on("data", (d) => {
+    if (String(d).includes("监控服务已启动")) {
+      clearTimeout(timer);
+      resolve();
+    }
+  });
+});
+await srvReady;
+console.log("✓ watch 服务已启动");
+
+// ── 伪造心跳上线（F-1 / F-2） ──
+for (const u of ["F-1", "F-2"]) {
+  const r = await fetch(`${BASE}/api/watchdog/heartbeat?clientId=${u}@host`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ hostname: "host-" + u, config: { userId: u }, processes: [] }),
+  });
+  if (!r.ok) throw new Error("心跳失败 " + r.status);
+}
+console.log("✓ F-1/F-2 心跳上线");
+// 触发 F-1 分配器重算（心跳路径）——顺便让服务端把池子状态应用一遍
+
+const browser = await chromium.launch({
+  executablePath: "/usr/bin/microsoft-edge",
+  headless: true,
+});
+const ctx = await browser.newContext({ viewport: { width: 1560, height: 1000 }, deviceScaleFactor: 1.5 });
+const page = await ctx.newPage();
+page.on("dialog", (d) => d.accept());
+const errors = [];
+page.on("pageerror", (e) => errors.push(String(e)));
+
+try {
+  // 登录
+  const pad = (n) => String(n).padStart(2, "0");
+  const d = new Date();
+  await page.goto(BASE + "/", { waitUntil: "domcontentloaded" });
+  await page.fill("#password", `tt@${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}`);
+  const loginResp = page.waitForResponse((r) => r.url().includes("/api/login"), { timeout: 15000 });
+  await page.locator("#login-form").evaluate((f) => f.submit());
+  await loginResp;
+  await page.waitForTimeout(600);
+  console.log("✓ 已登录");
+
+  // 看门狗页 → 等客户端卡片出现
+  await page.goto(BASE + "/#watchdog", { waitUntil: "domcontentloaded" });
+  await page.waitForFunction(
+    () => document.body.textContent.includes("F-1") && document.body.textContent.includes("⚡自动"),
+    { timeout: 20000 },
+  );
+  console.log("✓ 客户端卡片渲染，F-1 显示 ⚡自动 徽标");
+
+  // ── F-1: 自动分配视图 ──
+  const cards = page.locator("div", { hasText: "F-1" });
+  const f1Btn = page.locator('button[onclick*="wdShowProxyModal"]').first();
+  await f1Btn.click();
+  await page.waitForFunction(() => {
+    const v = document.getElementById("wdProxyAutoView");
+    return v && v.style.display === "block" && document.getElementById("wdProxyAllocTable").children.length > 0;
+  }, { timeout: 5000 });
+  const countVal = await page.inputValue("#wdProxyCountInput");
+  if (countVal !== "3") throw new Error("F-1 数量输入应为 3，实际 " + countVal);
+  const tableText = await page.textContent("#wdProxyAllocTable");
+  for (const expect of ["实例1", "实例2", "实例3", "7897", "7899", "LEGACY".replace("LEGACY", "legacy-airport"), "订阅A", "订阅C"]) {
+    if (!tableText.includes(expect)) throw new Error(`alloc 表缺少: ${expect}\n---\n${tableText}`);
+  }
+  if (!tableText.includes("未入池")) throw new Error("非池子存量 URL 应标注「未入池」");
+  const manualHidden = await page.isHidden("#wdProxySubsText");
+  if (!manualHidden) throw new Error("auto 模式下 textarea 应隐藏");
+  await page.screenshot({ path: "/tmp/suballoc-ui-1-auto.png" });
+  console.log("✓ F-1 自动分配视图: 数量输入=3，alloc 表含端口映射/订阅名/未入池标注（截图1）");
+
+  // 切回手动（确认弹窗自动接受）→ textarea 出现
+  await page.click("#wdProxySwitchManualBtn");
+  await page.waitForFunction(() => !document.getElementById("wdProxySubsText").hidden && document.getElementById("wdProxySubsText").style.display !== "none", { timeout: 5000 });
+  const taVal = await page.inputValue("#wdProxySubsText");
+  if (!taVal.includes("legacy-airport")) throw new Error("切回手动后列表应包含存量 URL");
+  console.log("✓ 切回手动视图: textarea 展示且包含当前 alloc");
+  await page.screenshot({ path: "/tmp/suballoc-ui-2-manual.png" });
+
+  // 切回自动（恢复初始状态供后续用例）— 用 API 直接切，避免 confirm 时序
+  await page.evaluate(() => fetch("/api/watchdog/set-proxy-auto", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ userId: "F-1" }) }));
+  await page.waitForTimeout(400);
+
+  // 关闭弹窗（取消按钮无 id，用 evaluate）
+  await page.evaluate(() => { document.getElementById("wdProxyModal").style.display = "none"; });
+
+  // ── F-2: 手动视图 + 切自动入口 ──
+  const f2Btn = page.locator('button[onclick*="wdShowProxyModal(\'' + "F-2" + '\')"]');
+  await f2Btn.click();
+  await page.waitForFunction(() => document.getElementById("wdProxySubsText").style.display !== "none", { timeout: 5000 });
+  const autoBtnVisible = await page.isVisible("#wdProxySwitchAutoBtn");
+  if (!autoBtnVisible) throw new Error("手动视图应有「切换为自动分配」入口");
+  await page.screenshot({ path: "/tmp/suballoc-ui-3-f2-manual.png" });
+  console.log("✓ F-2 手动视图 + 切自动入口（截图3）");
+
+  // 点切换 → confirm 自动接受 → 应变自动视图
+  await page.click("#wdProxySwitchAutoBtn");
+  await page.waitForFunction(() => document.getElementById("wdProxyAutoView").style.display === "block", { timeout: 5000 });
+  const f2ps = await (await fetch(`${BASE}/api/watchdog/clients`, { headers: { cookie: await ctx.cookies().then((cs) => cs.map((c) => `${c.name}=${c.value}`).join("; ")) } })).json();
+  if (f2ps.proxySettings["F-2"].mode !== "auto") throw new Error("F-2 应已迁移为 auto");
+  console.log("✓ F-2 一键迁移: 弹窗切到自动视图，服务端 mode=auto");
+
+  if (errors.length) throw new Error("页面 JS 错误: " + errors.join(" | "));
+  console.log("\n订阅自动分配 UI 冒烟测试通过 ✅\n");
+} finally {
+  await browser.close().catch(() => {});
+  srv.kill("SIGKILL");
+}
+process.exit(0);