tt-help-cli-ycl 1.4.169 → 1.4.172

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

@@ -0,0 +1,259 @@
+/**
+ * 订阅自动分配（Phase 2）端到端测试 — 直接驱动 watchdog-server 路由
+ *
+ * 覆盖:
+ *   1. 迁移方案 A: 手动列表原样转 auto alloc（count=现状条数，切换无感，非池子 URL 保留）
+ *   2. 心跳惰性重算 + 同一心跳下发新 alloc（响应 proxySettings 即最新分配）
+ *   3. count 调整: 补槽从池子取（规则1/4/5）、缩槽砍尾（规则1）
+ *   4. 跨机器错开: F-2/F-3 按全局占用数选订阅（规则5，文档示例复刻）
+ *   5. 死订阅换血: 禁用后被粘性槽位自动替换（规则2/3）
+ *   6. 空保护: 池子可用为空 → alloc 原地不动 + allocWarn=pool-empty（规则7）
+ *   7. 决定性: 重复心跳不重写（allocatedAt 不变，规则8）
+ *   8. count>8 截断 + count-capped 标红持久
+ *   9. 切回手动: mode 丢弃，分配器不再触碰
+ *
+ * 运行: HOME=$(mktemp -d) node scripts/test-subscription-auto-alloc.mjs
+ */
+import http from "http";
+import assert from "assert";
+import { writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const HOME = process.env.HOME;
+if (!HOME || HOME === "/") {
+  console.error("请用隔离 HOME 运行: HOME=$(mktemp -d) node scripts/test-subscription-auto-alloc.mjs");
+  process.exit(1);
+}
+
+const GB = 1073741824;
+
+// ── mock 机场: 按订阅名返回不同 subscription-userinfo ──
+const mock = http.createServer((req, res) => {
+  const name = new URL(req.url, "http://x").searchParams.get("name") || "A";
+  const expire =
+    name === "B"
+      ? Math.floor(Date.now() / 1000) - 86400 // B: 已到期
+      : Math.floor(Date.now() / 1000) + 20 * 86400;
+  res.writeHead(200, {
+    "subscription-userinfo": `upload=0; download=${30 * GB}; total=${100 * GB}; expire=${expire}`,
+  });
+  res.end("proxies: []");
+});
+await new Promise((r) => mock.listen(0, "127.0.0.1", r));
+const mockBase = `http://127.0.0.1:${mock.address().port}/sub`;
+const subUrl = (n) => `${mockBase}?name=${n}&token=tok-${n}`;
+const LEGACY_URL = "https://legacy-airport.example/sub?token=OLD"; // 不入池的存量订阅
+
+// ── 路由驱动（不起真实 HTTP 服务，与订阅中心 e2e 同款） ──
+const wdMod = await import(
+  join(dirname(fileURLToPath(import.meta.url)), "..", "src", "watch", "watchdog-server.js")
+);
+
+function mockRes() {
+  return {
+    code: 0,
+    body: null,
+    writeHead(c) {
+      this.code = c;
+      return this;
+    },
+    end(b) {
+      this.body = b ? JSON.parse(b) : null;
+    },
+  };
+}
+async function route(method, path, params, body) {
+  const res = mockRes();
+  const handled = await wdMod.tryHandleWatchdogRoute(path, method, params || {}, body || {}, res);
+  assert.ok(handled, "路由应被处理: " + method + " " + path);
+  return res;
+}
+
+const urlsOf = (entry) => (entry.subscriptions || []).map((s) => s.url);
+const short = (u) => (u.includes("legacy") ? "LEGACY" : new URL(u).searchParams.get("name"));
+
+let passed = 0;
+async function t(name, fn) {
+  await fn();
+  passed++;
+  console.log(`  ✓ ${name}`);
+}
+
+// ── 准备: 池子入 4 条（A/B/C/D 池序），B 探测为已到期（退出可用集，规则2） ──
+for (const n of ["A", "B", "C", "D"]) {
+  const add = await route("POST", "/api/watchdog/subscriptions", {}, { name: `订阅${n}`, url: subUrl(n) });
+  assert.strictEqual(add.code, 200, `入池 ${n}`);
+}
+const clients0 = await route("GET", "/api/watchdog/clients", {}, {});
+const subB = clients0.body.subscriptions.find((s) => s.url === subUrl("B"));
+const probeB = await route("POST", "/api/watchdog/subscriptions/probe", {}, { id: subB.id });
+assert.strictEqual(probeB.code, 200);
+assert.strictEqual(probeB.body.subscription.status.code, "expired", "B 探测后应判定已到期");
+
+// ── 1. 迁移方案 A: F-1 手动 [LEGACY, A] → auto（count=2，原样保留，无感切换） ──
+await t("迁移: 手动列表原样转 auto alloc，非池子 URL 粘性保留", async () => {
+  const set = await route("POST", "/api/watchdog/set-proxy-settings", {}, {
+    userId: "F-1",
+    subscriptions: [LEGACY_URL, subUrl("A")],
+  });
+  assert.strictEqual(set.code, 200);
+  assert.strictEqual(set.body.subscriptions.length, 2, "手动模式写入");
+
+  const auto = await route("POST", "/api/watchdog/set-proxy-auto", {}, { userId: "F-1" });
+  assert.strictEqual(auto.code, 200);
+  const ps = auto.body.proxySettings;
+  assert.strictEqual(ps.mode, "auto");
+  assert.strictEqual(ps.count, 2, "count 默认 = 现状条数");
+  assert.deepStrictEqual(ps.subscriptions.map((s) => s.url), [LEGACY_URL, subUrl("A")], "切换瞬间 = 现状，无感");
+});
+
+// ── 2. 心跳惰性重算（存量全可用 → 恒等）+ 同心跳下发 ──
+async function heartbeat(userId) {
+  const hb = await route("POST", "/api/watchdog/heartbeat", { clientId: `${userId}@host` }, {
+    hostname: "host-" + userId,
+    config: { userId },
+    processes: [],
+  });
+  assert.strictEqual(hb.code, 200);
+  return hb.body.proxySettings;
+}
+
+await t("心跳: 存量可用 → alloc 恒等；响应即携带最新 alloc", async () => {
+  const ps = await heartbeat("F-1");
+  assert.strictEqual(ps.mode, "auto");
+  assert.deepStrictEqual(ps.subscriptions.map((s) => s.url), [LEGACY_URL, subUrl("A")]);
+});
+
+// ── 3. count 调整: 3 槽 → 空槽从池子按序取 C（B 已到期被排除） ──
+await t("扩容 3 槽: 粘性保留 + 空槽补池序可用订阅（跳过已到期 B）", async () => {
+  const r = await route("POST", "/api/watchdog/set-proxy-auto", {}, { userId: "F-1", count: 3 });
+  assert.strictEqual(r.code, 200);
+  assert.deepStrictEqual(
+    r.body.proxySettings.subscriptions.map((s) => short(s.url)),
+    ["LEGACY", "A", "C"],
+  );
+});
+
+// ── 4. 跨机器错开（规则5，文档示例复刻: F-2=[D,A]，F-3=[C]——B 已到期出列） ──
+await t("F-2 配 2 → [D,A]: D 全局占用 0 优先，A 池序靠前", async () => {
+  const r = await route("POST", "/api/watchdog/set-proxy-auto", {}, { userId: "F-2", count: 2 });
+  assert.strictEqual(r.code, 200);
+  assert.deepStrictEqual(
+    r.body.proxySettings.subscriptions.map((s) => short(s.url)),
+    ["D", "A"],
+    "文档示例: A/C 各占 1 次（F-1），D 占 0 次优先；再补一槽回绕到 A",
+  );
+});
+
+await t("F-3 配 1 → [C]: 全局占用最少之一按池序", async () => {
+  const r = await route("POST", "/api/watchdog/set-proxy-auto", {}, { userId: "F-3", count: 1 });
+  assert.strictEqual(r.code, 200);
+  assert.deepStrictEqual(
+    r.body.proxySettings.subscriptions.map((s) => short(s.url)),
+    ["C"],
+  );
+});
+
+// ── 5. F-1 扩到 5 槽: 回绕重复合法（规则1/6） ──
+await t("F-1 扩 5 槽 → [LEGACY,A,C,D,A]: 回绕按全局占用+池序", async () => {
+  const r = await route("POST", "/api/watchdog/set-proxy-auto", {}, { userId: "F-1", count: 5 });
+  assert.strictEqual(r.code, 200);
+  assert.deepStrictEqual(
+    r.body.proxySettings.subscriptions.map((s) => short(s.url)),
+    ["LEGACY", "A", "C", "D", "A"],
+  );
+});
+
+// ── 6. 缩槽砍尾（规则1） ──
+await t("F-1 缩到 2 槽 → 保留前 2 槽 [LEGACY,A]", async () => {
+  const r = await route("POST", "/api/watchdog/set-proxy-auto", {}, { userId: "F-1", count: 2 });
+  assert.strictEqual(r.code, 200);
+  assert.deepStrictEqual(
+    r.body.proxySettings.subscriptions.map((s) => short(s.url)),
+    ["LEGACY", "A"],
+  );
+});
+
+// ── 7. 死订阅换血（规则2/3）: 禁用 A → 所有持 A 死槽的机器各自换血，活槽纹丝不动 ──
+await t("禁用 A: F-1 死槽换血 → [LEGACY,C]；F-2 死槽换血 → [D,C]；F-3 不动", async () => {
+  const cl = await route("GET", "/api/watchdog/clients", {}, {});
+  const subA = cl.body.subscriptions.find((s) => s.url === subUrl("A"));
+  const dis = await route("POST", "/api/watchdog/subscriptions/update", {}, { id: subA.id, enabled: false });
+  assert.strictEqual(dis.code, 200);
+
+  const ps1 = await heartbeat("F-1");
+  assert.deepStrictEqual(ps1.subscriptions.map((s) => short(s.url)), ["LEGACY", "C"], "A 被禁用 → 心跳换血为 C（池序在 D 前）");
+  assert.strictEqual(ps1.allocWarn, null);
+
+  const ps2 = await heartbeat("F-2");
+  assert.deepStrictEqual(ps2.subscriptions.map((s) => short(s.url)), ["D", "C"], "F-2 的 A 死槽同样换血（全局占用算定: C 剩余占用最少）");
+
+  const ps3 = await heartbeat("F-3");
+  assert.deepStrictEqual(ps3.subscriptions.map((s) => short(s.url)), ["C"], "F-3 持活的 C → 纹丝不动");
+  assert.strictEqual(ps3.allocWarn, null);
+});
+
+// ── 8. 空保护（规则7）: C/D 也禁用 → 池子可用为空，alloc 原地不动 + 标黄 ──
+await t("池子可用为空: alloc 原地不动 + allocWarn=pool-empty", async () => {
+  const cl = await route("GET", "/api/watchdog/clients", {}, {});
+  for (const n of ["C", "D"]) {
+    const sub = cl.body.subscriptions.find((s) => s.url === subUrl(n));
+    const dis = await route("POST", "/api/watchdog/subscriptions/update", {}, { id: sub.id, enabled: false });
+    assert.strictEqual(dis.code, 200);
+  }
+  const ps2 = await heartbeat("F-2");
+  assert.deepStrictEqual(ps2.subscriptions.map((s) => short(s.url)), ["D", "C"], "死槽也原地不动（绝不下发空列表/不换血）");
+  assert.strictEqual(ps2.allocWarn, "pool-empty", "标黄");
+  const ps3 = await heartbeat("F-3");
+  assert.deepStrictEqual(ps3.subscriptions.map((s) => short(s.url)), ["C"]);
+  assert.strictEqual(ps3.allocWarn, "pool-empty");
+});
+
+// ── 9. 决定性（规则8）: 重复心跳不重写 ──
+await t("重复心跳: alloc/allocatedAt 恒等（零写盘）", async () => {
+  const before = (await heartbeat("F-3")).allocatedAt;
+  assert.ok(before, "已有 allocatedAt");
+  const mid = await heartbeat("F-3");
+  assert.strictEqual(mid.allocatedAt, before, "输入不变 → 不重写");
+  const cl = await route("GET", "/api/watchdog/clients", {}, {});
+  assert.strictEqual(cl.body.proxySettings["F-3"].allocatedAt, before, "落盘值一致");
+});
+
+// ── 10. count>8: 截断 + 标红持久（先启用 A 让池子有可用订阅） ──
+await t("count=12 截断为 8 + count-capped 标红（心跳不丢）", async () => {
+  const cl = await route("GET", "/api/watchdog/clients", {}, {});
+  const subA = cl.body.subscriptions.find((s) => s.url === subUrl("A"));
+  const en = await route("POST", "/api/watchdog/subscriptions/update", {}, { id: subA.id, enabled: true });
+  assert.strictEqual(en.code, 200);
+
+  const r = await route("POST", "/api/watchdog/set-proxy-auto", {}, { userId: "F-1", count: 12 });
+  assert.strictEqual(r.code, 200);
+  const ps = r.body.proxySettings;
+  assert.strictEqual(ps.count, 8, "截断为实例上限");
+  assert.strictEqual(ps.allocWarn, "count-capped", "标红");
+  assert.strictEqual(ps.subscriptions.length, 8, "配满规则: count=8 → 8 槽（C 死槽换血 + 空槽回绕补 A）");
+  assert.deepStrictEqual(
+    ps.subscriptions.map((s) => short(s.url)),
+    ["LEGACY", ...Array(7).fill("A")],
+  );
+  const ps2 = await heartbeat("F-1");
+  assert.strictEqual(ps2.count, 8);
+  assert.strictEqual(ps2.allocWarn, "count-capped", "下轮心跳标红不丢（countCapped 标志持久化）");
+});
+
+// ── 11. 切回手动 ──
+await t("切回手动: mode 丢弃，心跳不再触碰", async () => {
+  const before = await route("POST", "/api/watchdog/set-proxy-manual", {}, { userId: "F-1" });
+  assert.strictEqual(before.code, 200);
+  assert.strictEqual(before.body.proxySettings.mode, undefined);
+  assert.strictEqual(before.body.proxySettings.count, undefined);
+  assert.ok(Array.isArray(before.body.proxySettings.subscriptions), "alloc 原样变手动列表");
+  const ps = await heartbeat("F-1");
+  assert.strictEqual(ps.mode, undefined, "心跳不回写 mode");
+  assert.deepStrictEqual(ps.subscriptions, before.body.proxySettings.subscriptions);
+});
+
+mock.close();
+console.log(`\n订阅自动分配端到端测试通过 ✅ (${passed} 用例)\n`);
+process.exit(0);

package/scripts/test-subscription-center-e2e.mjs

@@ -0,0 +1,134 @@
+/**
+ * 订阅中心 API 端到端测试 — 直接驱动 watchdog-server 路由（不起真实 HTTP 服务）
+ *
+ * 覆盖:
+ *   1. POST /api/watchdog/heartbeat        → 节点代报采集 + worker 惰性启动
+ *   2. GET  /api/watchdog/clients          → 响应含 subscriptions 视图
+ *   3. POST /api/watchdog/subscriptions    → 新增
+ *   4. POST /api/watchdog/subscriptions/probe   → 手动探测
+ *   5. POST /api/watchdog/subscriptions/update  → 禁用/启用
+ *   6. POST /api/watchdog/subscriptions/delete  → 删除（含 force 保护）
+ *
+ * 运行: HOME=$(mktemp -d) node scripts/test-subscription-center-e2e.mjs
+ */
+import http from "http";
+import assert from "assert";
+import { writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const HOME = process.env.HOME;
+if (!HOME || HOME === "/") {
+  console.error("请用隔离 HOME 运行: HOME=$(mktemp -d) node scripts/test-subscription-center-e2e.mjs");
+  process.exit(1);
+}
+
+const usedMock = { v: 30 * 1073741824 };
+const mock = http.createServer((req, res) => {
+  res.writeHead(200, {
+    "subscription-userinfo": `upload=0; download=${usedMock.v}; total=${100 * 1073741824}; expire=${Math.floor(Date.now() / 1000) + 20 * 86400}`,
+  });
+  res.end("proxies: []");
+});
+await new Promise((r) => mock.listen(0, "127.0.0.1", r));
+const subUrl = `http://127.0.0.1:${mock.address().port}/sub?token=E2E`;
+
+// 预置节点订阅配置（供代报映射与引用计算）
+writeFileSync(
+  join(HOME, ".tt-help-watchdog.json"),
+  JSON.stringify({ proxySettings: { "F-1": { subscriptions: [{ name: "", url: subUrl }] } } }),
+);
+
+const wdMod = await import(
+  join(dirname(fileURLToPath(import.meta.url)), "..", "src", "watch", "watchdog-server.js")
+);
+
+// mock res
+function mockRes() {
+  return {
+    code: 0,
+    body: null,
+    writeHead(c) {
+      this.code = c;
+      return this;
+    },
+    end(b) {
+      this.body = b ? JSON.parse(b) : null;
+    },
+  };
+}
+async function route(method, path, params, body) {
+  const res = mockRes();
+  const handled = await wdMod.tryHandleWatchdogRoute(path, method, params || {}, body || {}, res);
+  assert.ok(handled, "路由应被处理: " + method + " " + path);
+  return res;
+}
+
+// 1) 心跳: 带 clashHealthChannels（daemon 真实形状: meta.proxy.subscriptions）
+const hb = await route("POST", "/api/watchdog/heartbeat", { clientId: "F-1@host" }, {
+  hostname: "host1",
+  config: { userId: "F-1" },
+  processes: [],
+  clashHealth: {
+    node: "US-01",
+    meta: { countryFilter: ["US"], proxy: { subscriptions: [{ name: "sub-1", upload: 0, download: usedMock.v, total: 100 * 1073741824, expire: 0 }] } },
+  },
+  clashHealthChannels: [
+    { port: 7897, node: "US-01", meta: { proxy: { subscriptions: [{ name: "sub-1", upload: 0, download: usedMock.v, total: 100 * 1073741824, expire: 0 }] } } },
+  ],
+});
+assert.strictEqual(hb.code, 200, "心跳 200");
+assert.ok(hb.body.ok, "心跳 ok");
+
+// 2) clients 响应带订阅视图（此时池子为空 → 代报无处落，先验证空态）
+const cl0 = await route("GET", "/api/watchdog/clients", {}, {});
+assert.ok(Array.isArray(cl0.body.subscriptions), "clients 含 subscriptions 数组");
+
+// 3) 新增订阅（URL 与节点配置一致）
+const add = await route("POST", "/api/watchdog/subscriptions", {}, { name: "E2E订阅", url: subUrl, note: "e2e" });
+assert.strictEqual(add.code, 200, "新增成功");
+const subId = add.body.entry.id;
+
+// 入池后下一拍心跳（生产 agent 每 15s 一拍）→ 代报落池
+await route("POST", "/api/watchdog/heartbeat", { clientId: "F-1@host" }, {
+  hostname: "host1",
+  config: { userId: "F-1" },
+  processes: [],
+  clashHealthChannels: [
+    { port: 7897, node: "US-01", meta: { proxy: { subscriptions: [{ name: "sub-1", upload: 0, download: usedMock.v, total: 100 * 1073741824, expire: 0 }] } } },
+  ],
+});
+
+// 代报已有 → 立即出现在视图（source=node，兜底通道生效）
+const cl1 = await route("GET", "/api/watchdog/clients", {}, {});
+const v1 = cl1.body.subscriptions.find((s) => s.id === subId);
+assert.ok(v1, "视图含新订阅");
+assert.strictEqual(v1.source, "node", "节点代报兜底生效");
+assert.strictEqual(v1.refs.length, 1, "引用计算（user F-1）");
+
+// 4) 手动探测 → source 变 probe
+const probe = await route("POST", "/api/watchdog/subscriptions/probe", {}, { id: subId });
+assert.strictEqual(probe.code, 200, "探测成功");
+assert.strictEqual(probe.body.subscription.source, "probe", "探测为主数据源");
+assert.strictEqual(probe.body.subscription.used, usedMock.v, "探测用量正确");
+
+// 5) 禁用/启用
+const dis = await route("POST", "/api/watchdog/subscriptions/update", {}, { id: subId, enabled: false });
+assert.strictEqual(dis.body.entry.enabled, false, "禁用生效");
+const en = await route("POST", "/api/watchdog/subscriptions/update", {}, { id: subId, enabled: true });
+assert.strictEqual(en.body.entry.enabled, true, "启用生效");
+
+// 6) 删除: 无引用时直接删（引用来自节点配置，先删配置再验证 force 逻辑）
+// 当前有引用 → 需 force
+const del1 = await route("POST", "/api/watchdog/subscriptions/delete", {}, { id: subId });
+assert.strictEqual(del1.code, 409, "有引用删除返回 409");
+const del2 = await route("POST", "/api/watchdog/subscriptions/delete", {}, { id: subId, force: true });
+assert.strictEqual(del2.code, 200, "force 删除成功");
+
+// 重复删除 → 400
+const del3 = await route("POST", "/api/watchdog/subscriptions/delete", {}, { id: subId, force: true });
+assert.strictEqual(del3.code, 400, "重复删除 400");
+
+mock.close();
+console.log("\n订阅中心 API 端到端测试通过 ✅");
+process.exit(0);

package/scripts/test-subscription-center-smoke.mjs

@@ -0,0 +1,154 @@
+/**
+ * 订阅中心冒烟测试 — CRUD / 主动探测 / 重置检测 / 状态推导 / 节点代报映射 / 引用删除保护
+ *
+ * 运行（HOME 隔离到临时目录，绝不读写真实 ~/.tt-help-watchdog*.json）:
+ *   cd tiktok-cli
+ *   HOME=$(mktemp -d) node scripts/test-subscription-center-smoke.mjs
+ *
+ * 本地起 mock 机场端点（返回 subscription-userinfo 头），无需外网。
+ */
+import http from "http";
+import assert from "assert";
+import { writeFileSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const HOME = process.env.HOME;
+if (!HOME || HOME === "/") {
+  console.error("请用隔离 HOME 运行: HOME=$(mktemp -d) node scripts/test-subscription-center-smoke.mjs");
+  process.exit(1);
+}
+mkdirSync(HOME, { recursive: true });
+
+const usedA = { v: 50 * 1073741824 }; // 初始已用 50GB
+const TOTAL = 100 * 1073741824;
+const EXPIRE = Math.floor(Date.now() / 1000) + 30 * 86400; // 30 天后到期
+let uaSeen = "";
+
+const mock = http.createServer((req, res) => {
+  uaSeen = req.headers["user-agent"] || "";
+  const expireMs = req.url.includes("token=MS") ? (EXPIRE * 1000).toString() : null; // 机场发毫秒戳的兼容用例
+  res.writeHead(200, {
+    "content-type": "text/plain",
+    "subscription-userinfo": expireMs
+      ? `upload=0; download=${usedA.v}; total=${TOTAL}; expire=${expireMs}`
+      : `upload=0; download=${usedA.v}; total=${TOTAL}; expire=${EXPIRE}`,
+  });
+  res.end("proxies:\n  - name: node1");
+});
+await new Promise((r) => mock.listen(0, "127.0.0.1", r));
+const port = mock.address().port;
+
+// 预置节点配置: user1 引用两条订阅（一条在池中、一条不在），测引用计数与代报映射
+writeFileSync(
+  join(HOME, ".tt-help-watchdog.json"),
+  JSON.stringify({
+    proxySettings: {
+      user1: {
+        subscriptions: [
+          { name: "", url: `http://127.0.0.1:${port}/sub?token=A` },
+          { name: "custom", url: "http://127.0.0.1:9/sub?token=NOT-IN-POOL" },
+        ],
+      },
+      user2: { subscriptions: [] },
+    },
+  }),
+);
+
+const sc = await import(
+  join(dirname(fileURLToPath(import.meta.url)), "..", "src", "watch", "subscription-center.js")
+);
+
+// 1) CRUD
+const add1 = sc.addSubscription({ name: "机场A-月付", url: `http://127.0.0.1:${port}/sub?token=A`, note: "每月1号重置" });
+assert.ok(add1.ok, "新增订阅1");
+const add2 = sc.addSubscription({ url: `http://127.0.0.1:${port}/sub?token=B` });
+assert.ok(add2.ok, "新增订阅2（自动命名）");
+assert.ok(!sc.addSubscription({ url: `http://127.0.0.1:${port}/sub?token=A` }).ok, "重复 URL 拒绝");
+assert.ok(!sc.addSubscription({ url: "ftp://x" }).ok, "非法 URL 拒绝");
+console.log("✓ CRUD（含重复/非法 URL 拒绝）");
+
+// 2) 主动探测（UA / total / 历史）
+const p1 = await sc.probeSubscription(add1.entry.id, { manual: true });
+assert.ok(p1.ok && p1.entry.probe.ok, "探测成功");
+assert.strictEqual(uaSeen, "clash.meta/1.19.31", "Clash UA 正确");
+assert.strictEqual(p1.entry.probe.total, TOTAL, "total 解析");
+assert.strictEqual(p1.entry.history.length, 1, "历史 +1");
+
+// 2.1) 机场发毫秒 expire 的兼容（>1e12 按毫秒归一为秒）
+const addMs = sc.addSubscription({ url: `http://127.0.0.1:${port}/sub?token=MS` });
+assert.ok(addMs.ok, "新增毫秒用例订阅");
+const pMs = await sc.probeSubscription(addMs.entry.id, { manual: true });
+assert.ok(pMs.ok && pMs.entry.probe.ok, "毫秒用例探测成功");
+assert.strictEqual(pMs.entry.probe.expire, EXPIRE, "毫秒 expire 归一为秒");
+
+// 3) 流量重置检测（用量下降 50GB→5GB）
+usedA.v = 5 * 1073741824;
+await new Promise((r) => setTimeout(r, 1100)); // 保证快照 ts 单调
+const p2 = await sc.probeSubscription(add1.entry.id, { manual: true });
+assert.ok(p2.ok && p2.entry.resets.length === 1, "重置检测");
+console.log("✓ 主动探测 + Clash UA + 重置检测");
+
+// 4) 状态推导
+const now = Date.now();
+const mk = (over) =>
+  sc.deriveStatus(Object.assign({ enabled: true, probe: null, lastNodeReport: null }, over), now);
+assert.strictEqual(mk({}).code, "unknown", "无数据→未知");
+assert.strictEqual(mk({ probe: { ok: false, at: now, error: "x" } }).code, "probe-failed", "探测失败");
+assert.strictEqual(
+  mk({ probe: { ok: false, at: now }, lastNodeReport: { at: now, upload: 1, download: 1, total: 100, expire: 0 } }).code,
+  "ok",
+  "探测失败但代报新鲜→正常（兜底）",
+);
+assert.strictEqual(
+  mk({ probe: { ok: true, at: now, upload: 0, download: 0, total: 100, expire: Math.floor(now / 1000) - 1 } }).code,
+  "expired",
+  "已到期",
+);
+assert.strictEqual(
+  mk({ probe: { ok: true, at: now, upload: 0, download: 0, total: 100, expire: Math.floor((now + 3 * 86400000) / 1000) } }).code,
+  "expiring",
+  "临期3天",
+);
+assert.strictEqual(
+  mk({ probe: { ok: true, at: now, upload: 95 * 1073741824, download: 0, total: 100 * 1073741824, expire: 0 } }).code,
+  "quota-critical",
+  "余量<10%",
+);
+assert.strictEqual(
+  mk({ probe: { ok: true, at: now, upload: 100 * 1073741824, download: 0, total: 100 * 1073741824, expire: 0 } }).code,
+  "exhausted",
+  "已耗尽",
+);
+assert.strictEqual(mk({ enabled: false, probe: { ok: false, at: now } }).code, "disabled", "已禁用优先");
+assert.strictEqual(mk({ probe: { ok: true, at: now, upload: 0, download: 0, total: 0, expire: 0 } }).code, "ok", "expire=0/total=0 哨兵→正常");
+console.log("✓ 状态推导（9 种场景含哨兵值）");
+
+// 5) 节点代报映射（sub-1 按行序映射回池中 URL）
+const entryA = sc.getSubscriptionView().find((s) => s.url.endsWith("token=A"));
+assert.ok(entryA, "视图包含订阅A");
+sc.ingestNodeReport(
+  "user1",
+  { meta: { proxy: { subscriptions: [{ name: "sub-1", upload: 0, download: usedA.v, total: TOTAL, expire: EXPIRE }] } } },
+  [],
+);
+const viewA = sc.getSubscriptionView().find((s) => s.url.endsWith("token=A"));
+assert.ok(viewA.lastNodeReport, "代报已入库");
+assert.strictEqual(viewA.lastNodeReport.by, "user1", "代报来源");
+
+// 6) 引用计数 + 删除保护
+assert.strictEqual(entryA.refs.length, 1, "user1 引用订阅A");
+assert.strictEqual(entryA.refs[0].count, 1, "引用计数=1");
+const delGuard = sc.deleteSubscription(entryA.id);
+assert.ok(delGuard.needForce && delGuard.refs.length === 1, "有引用删除需 force");
+assert.ok(sc.deleteSubscription(entryA.id, { force: true }).ok, "force 删除成功");
+console.log("✓ 节点代报映射 + 引用计数 + 删除保护");
+
+// 7) 视图字段完整性
+const v = sc.getSubscriptionView().find((s) => s.id === add2.entry.id);
+for (const k of ["id", "name", "url", "enabled", "status", "used", "total", "remain", "usedRatio", "expireAt", "source", "lastProbe", "refs", "historyRecent"])
+  assert.ok(k in v, "视图字段 " + k);
+console.log("✓ 视图字段完整");
+
+mock.close();
+console.log("\n全部冒烟测试通过 ✅");

package/scripts/test-subscription-center-ui.mjs

@@ -0,0 +1,111 @@
+/**
+ * 订阅中心 UI 自动化截图（服务端无头 Edge，走真实页面流程）
+ *
+ * 前置: watch 服务 127.0.0.1:3123 + mock 机场 127.0.0.1:3199 已在跑
+ * 流程: 列表(1条正常) → 新增弹窗 → 保存并自动探测(故意 404 → 失败态置顶) → 禁用 → 恢复
+ * 输出: /tmp/subcenter-ui-*.png
+ */
+import { chromium } from "playwright";
+
+const BASE = "http://127.0.0.1:3123";
+const shots = (n) => `/tmp/subcenter-ui-${n}.png`;
+
+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()); // alert/confirm 自动接受
+
+// 0) 登录（当日密码 tt@YYYYMMDD）
+const pad = (n) => String(n).padStart(2, "0");
+const d = new Date();
+const todayPwd = `tt@${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}`;
+await page.goto(BASE + "/", { waitUntil: "domcontentloaded" });
+await page.fill("#password", todayPwd);
+// 等登录接口真正返回（cookie 落定）再跳转，否则后续 API 全部 401
+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(800);
+console.log("✓ 已登录（当日密码）");
+
+// 1) 打开看门狗页，等订阅中心渲染出数据
+await page.goto(BASE + "/#watchdog", { waitUntil: "domcontentloaded" });
+await page.waitForFunction(
+  () => {
+    const el = document.getElementById("wdSubsSummary");
+    return el && el.textContent.includes("共");
+  },
+  { timeout: 20000 },
+);
+const section = page.locator("#wdSubsSection");
+await section.screenshot({ path: shots(1) });
+console.log("✓ 截图1: 默认折叠汇总条");
+
+// 0.5) 验证折叠态: 列表应为空
+const collapsedRows = await page.evaluate(
+  () => document.querySelectorAll("#wdSubsList > div").length,
+);
+if (collapsedRows !== 0) throw new Error(`默认应折叠（列表无行），实际 ${collapsedRows} 行`);
+console.log("✓ 默认折叠确认");
+
+// 1.5) 清理上轮残留的演示订阅（保证脚本可重复跑）
+const existing = await (await fetch(BASE + "/api/watchdog/subscriptions")).json();
+for (const s of existing.subscriptions || []) {
+  if (s.url.includes("token=DEAD")) {
+    await fetch(BASE + "/api/watchdog/subscriptions/delete", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ id: s.id, force: true }),
+    });
+    console.log("⟳ 已清理残留演示订阅");
+  }
+}
+await page.waitForTimeout(500);
+
+// 2) 打开新增弹窗，填一条故意探测失败的地址（mock 只认 MOCK-A）
+await page.getByRole("button", { name: /新增订阅/ }).click();
+await page.fill("#wdSubName", "失效机场-测试");
+await page.fill("#wdSubUrl", "http://127.0.0.1:3199/sub?token=DEAD");
+await page.fill("#wdSubNote", "演示探测失败态");
+await page.locator("#wdSubModal").screenshot({ path: shots(2) });
+console.log("✓ 截图2: 新增弹窗（已填入失效地址）");
+
+// 3) 保存 → 自动探测失败 → 点表头展开，失败态置顶
+await page.locator("#wdSubModal").getByRole("button", { name: "保存" }).click();
+await page.waitForTimeout(1500); // 等保存+自动探测+回拉数据
+await page.click("#wdSubsHeader"); // 展开
+await page.waitForFunction(
+  () => document.querySelectorAll("#wdSubsList > div").length >= 2,
+  { timeout: 20000 },
+);
+await page.waitForTimeout(1500); // 等下一轮数据回填
+await section.screenshot({ path: shots(3) });
+console.log("✓ 截图3: 展开后两条订阅（失败态置顶）");
+
+// 4) 对正常订阅点「检测」（手动探测）
+const probeBtn = page.locator("#wdSubsList button", { hasText: "🔍 检测" }).last();
+await probeBtn.click();
+await page.waitForTimeout(2000);
+await section.screenshot({ path: shots(4) });
+console.log("✓ 截图4: 手动检测后");
+
+// 5) 禁用失败态订阅 → 半透明 + 已禁用徽标
+await page.locator("#wdSubsList button", { hasText: "⏸ 禁用" }).first().click();
+await page.waitForFunction(
+  () => {
+    const el = document.getElementById("wdSubsSummary");
+    return el && el.textContent.includes("禁用 1");
+  },
+  { timeout: 10000 },
+);
+await section.screenshot({ path: shots(5) });
+console.log("✓ 截图5: 禁用态");
+
+await browser.close();
+console.log("\nUI 流程截图完成 ✅（/tmp/subcenter-ui-1..5.png）");