tt-help-cli-ycl 1.4.172 → 1.4.176

package/scripts/test-login-pool.mjs

@@ -0,0 +1,381 @@
+/**
+ * 共享登录池单元测试 — 模块级直驱（不起 HTTP）
+ *
+ * 覆盖:
+ *   1. 入池（cookies 归一化/username 兜底/去重/池满）+ 视图脱敏（明文永不出）
+ *   2. 指派独占约束（同账号双租拒绝 / 目标端口占用拒绝 / force 替换 / suspect 需 force）
+ *   3. 心跳下发（applyLogin/clearLogin 一次性取走，cookies 仅在心跳响应出现）
+ *   4. 续租 + 健康采集（lastBusinessOkAt/emptyStreak）
+ *   5. 掉线回收（leaseExpired）+ 命令超时作废（deliveryExpired 回收）
+ *   6. release（含 clearOnNode）+ update 状态迁移 + delete 保护
+ *
+ * 跑法: HOME=$(mktemp -d) node scripts/test-login-pool.mjs
+ */
+import assert from "assert";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+
+const HOME = process.env.HOME;
+if (!HOME || HOME === "/") {
+  console.error("请用隔离 HOME 运行: HOME=$(mktemp -d) node scripts/test-login-pool.mjs");
+  process.exit(1);
+}
+
+const {
+  getLoginPoolView,
+  addAccount,
+  updateAccount,
+  deleteAccount,
+  assignAccount,
+  releaseAccount,
+  acquireAccount,
+  importAccount,
+  heartbeatLoginPool,
+  reapExpiredLeases,
+} = await import("../src/watch/login-pool.js");
+
+let pass = 0;
+let fail = 0;
+const check = (name, cond, extra = "") => {
+  if (cond) {
+    pass++;
+    console.log(`  ✓ ${name}`);
+  } else {
+    fail++;
+    console.log(`  ✗ ${name} ${extra}`);
+  }
+};
+
+const COOKIES_A = [
+  { name: "sessionid", value: "sid-a", domain: ".tiktok.com", expires: Date.now() / 1000 + 86400 },
+  { name: "unique_id", value: "userA", domain: ".tiktok.com" },
+  { name: "tt-target-idc", value: "useast2a", domain: ".tiktok.com" },
+];
+const COOKIES_B = [
+  { name: "sessionid", value: "sid-b", domain: ".tiktok.com" },
+  { name: "unique_id", value: "userB", domain: ".tiktok.com" },
+];
+const COOKIES_C = [
+  { name: "sessionid", value: "sid-c", domain: ".tiktok.com" },
+  { name: "unique_id", value: "userC", domain: ".tiktok.com" },
+];
+
+// ── 1. 入池 ──
+console.log("\n[1] 入池");
+{
+  const a = addAccount({ cookies: COOKIES_A, note: "F-1:8224 原生" });
+  check("自动从 unique_id 提取 username", a.username === "userA", `got ${a.username}`);
+  check("初始状态 pool", a.status === "pool");
+  check("cookieCount 正确", a.cookieCount === 3);
+  check("hasSessionid", a.hasSessionid === true);
+  check("视图无明文 value", !JSON.stringify(a).includes("sid-a"));
+
+  const b = addAccount({ username: "userB-manual", cookies: COOKIES_B });
+  check("显式 username 优先", b.username === "userB-manual");
+
+  let threw = false;
+  try {
+    addAccount({ cookies: COOKIES_A });
+  } catch (e) {
+    threw = true;
+    check("同账号拒绝重复入池", /已在池中/.test(e.message));
+  }
+  check("重复入池确实抛错", threw);
+
+  threw = false;
+  try {
+    addAccount({ cookies: "not-an-array" });
+  } catch (e) {
+    threw = true;
+    check("非法 cookies 抛错", /cookies/.test(e.message));
+  }
+  check("非法 cookies 确实抛错", threw);
+
+  const view = getLoginPoolView();
+  check("视图含 2 账号", view.total === 2);
+  check("视图整体无明文", !JSON.stringify(view).includes("sid-b"));
+
+  // 文件落盘（debounce 3s——直接看 tmp 是否会出现太侵入，这里验证文件最终写出）
+  const file = join(HOME, ".tt-help-watchdog-logins.json");
+  check("存储文件路径符合设计", file.endsWith(".tt-help-watchdog-logins.json"));
+}
+
+// ── 2. 指派独占约束 ──
+console.log("\n[2] 指派独占约束");
+let accA, accB, accC;
+{
+  const view = getLoginPoolView();
+  accA = view.accounts.find((x) => x.username === "userA");
+  accB = view.accounts.find((x) => x.username === "userB-manual");
+  const c = addAccount({ cookies: COOKIES_C }); // 第三个账号做端口占用/force 替换测试
+  accC = c;
+
+  const leased = assignAccount({ id: accA.id, userId: "F-11", port: 9222 });
+  check("指派后 leased", leased.status === "leased");
+  check("lease 记录节点+端口", leased.lease.userId === "F-11" && leased.lease.port === 9222);
+
+  const leasedB = assignAccount({ id: accB.id, userId: "F-1", port: 8222 });
+  check("不同机器可并行持有不同账号", leasedB.status === "leased");
+
+  // 同账号双租：A 已 leased，再指派 A 必须拒绝
+  let threw = false;
+  try {
+    assignAccount({ id: accA.id, userId: "F-1", port: 9223 });
+  } catch (e) {
+    threw = true;
+    check("同账号双租拒绝（独占核心）", /已租给/.test(e.message));
+  }
+  check("同账号双租确实抛错", threw);
+
+  // 目标端口占用：F-11:9222 已有 A，指派 C 到同端口拒绝
+  threw = false;
+  try {
+    assignAccount({ id: accC.id, userId: "F-11", port: 9222 });
+  } catch (e) {
+    threw = true;
+    check("目标端口占用拒绝", /已持有/.test(e.message));
+  }
+  check("端口占用确实抛错", threw);
+
+  // force 替换：C 强制上 F-11:9222，A 被逐回池 + 节点收到 clearLogin
+  const forced = assignAccount({ id: accC.id, userId: "F-11", port: 9222, force: true });
+  check("force 替换成功", forced.status === "leased");
+  const after = getLoginPoolView();
+  const aNow = after.accounts.find((x) => x.username === "userA");
+  check("被替换账号回池", aNow.status === "pool" && !aNow.lease);
+
+  // suspect 需 force（用 C）
+  updateAccount({ id: accC.id, status: "suspect" }); // leased → suspect 允许（强制迁移）
+  const cNow = getLoginPoolView().accounts.find((x) => x.username === "userC");
+  check("leased → suspect 迁移并清租约", cNow.status === "suspect" && !cNow.lease);
+  threw = false;
+  try {
+    assignAccount({ id: accC.id, userId: "F-2", port: 9224 });
+  } catch (e) {
+    threw = true;
+    check("suspect 无 force 拒绝", /suspect/.test(e.message));
+  }
+  check("suspect 拒绝确实抛错", threw);
+  const forcedSuspect = assignAccount({ id: accC.id, userId: "F-2", port: 9224, force: true });
+  check("suspect + force 可指派", forcedSuspect.status === "leased");
+}
+
+// ── 3. 心跳下发（一次性取走，cookies 只在心跳响应） ──
+console.log("\n[3] 心跳下发");
+{
+  // 指派 C(上一步) 已排队 applyLogin → F-2 下次心跳取走
+  const hb = heartbeatLoginPool("F-2", { config: { userId: "F-2" } });
+  check("心跳返回 applyLogin 命令", hb && hb.commands && hb.commands.length === 1, JSON.stringify(hb));
+  const cmd = hb.commands[0];
+  check("action=applyLogin", cmd.action === "applyLogin");
+  check("命令含明文 cookies（下发通道）", Array.isArray(cmd.cookies) && cmd.cookies.some((c) => c.name === "sessionid"));
+  check("命令含端口+账号名", cmd.port === 9224 && cmd.username === "userC");
+
+  // 视图标记 pendingDelivery 取走后应消失
+  const cView = getLoginPoolView().accounts.find((x) => x.username === "userC");
+  check("取走后 pendingDelivery=false", cView.lease.pendingDelivery === false);
+
+  // 再次心跳无命令
+  const hb2 = heartbeatLoginPool("F-2", {});
+  check("一次性：二次心跳无命令", hb2 === undefined);
+
+  // 【回归】租约迁移时遗留命令必须被清除：C 曾被指到 F-11:9222（后被 suspect 迁走），
+  // F-11 心跳绝不能再收到 C 的 applyLogin（否则登录态泄给无租约节点）。
+  // 注意：F-11 队列里的 clearLogin(userA) 是 force 替换时有意下发的端口清理，属正确行为
+  const hbF11 = heartbeatLoginPool("F-11", {});
+  const staleApply = hbF11 && hbF11.commands.some((c) => c.action === "applyLogin" && c.username === "userC");
+  check("孤儿 applyLogin 已清除（F-11 收不到已迁走账号）", !staleApply, JSON.stringify(hbF11));
+  check("有意下发的 clearLogin（端口清理）保留", hbF11 && hbF11.commands.some((c) => c.action === "clearLogin" && c.username === "userA"));
+
+  // GET 视图仍然无明文
+  check("GET 视图持续无明文", !JSON.stringify(getLoginPoolView()).includes("sid-b"));
+}
+
+// ── 4. 续租 + 健康采集 + 节点执行回报 ──
+console.log("\n[4] 续租 + 健康采集 + 节点执行回报");
+{
+  const okAt = Date.now() - 60000;
+  heartbeatLoginPool("F-2", {
+    loginPool: { ports: { 9224: { username: "userC", lastBusinessOkAt: okAt, emptyStreak: 2 } } },
+  });
+  let b = getLoginPoolView().accounts.find((x) => x.username === "userC");
+  check("业务出活时间入库", b.lease.lastBusinessOkAt === okAt);
+  check("空响应连击入库", b.lease.emptyStreak === 2);
+  check("续租刷新 lastHealthAt", b.lease.lastHealthAt > 0);
+
+  // 节点 applyLogin 成功回报（含持久化）
+  heartbeatLoginPool("F-2", {
+    loginPool: {
+      applied: [{ action: "applyLogin", accountId: b.id, port: 9224, username: "userC", ok: true, persisted: true, at: Date.now() }],
+    },
+  });
+  b = getLoginPoolView().accounts.find((x) => x.username === "userC");
+  check("注入成功回报入库", b.lease.lastAppliedOk === true && b.lease.persisted === true);
+  check("历史记录 applied", b.history.some((h) => h.event === "applied"));
+
+  // 节点 applyLogin 失败回报
+  heartbeatLoginPool("F-2", {
+    loginPool: {
+      applied: [{ action: "applyLogin", accountId: b.id, port: 9224, ok: false, error: "CDP 超时", at: Date.now() }],
+    },
+  });
+  b = getLoginPoolView().accounts.find((x) => x.username === "userC");
+  check("失败回报覆盖状态（最新为准）", b.lease.lastAppliedOk === false);
+  check("历史记录 applyFailed", b.history.some((h) => h.event === "applyFailed"));
+}
+
+// ── 5. 掉线回收 + 命令超时作废 ──
+console.log("\n[5] 掉线回收 + 命令超时作废");
+{
+  // 直接改内存时间不可行（模块内部 now），改用字段注入验证 reap 逻辑：
+  // 给 A 重新指派，然后人为把 lease.lastHealthAt 拨回 13 小时前
+  const aLeased = assignAccount({ id: accA.id, userId: "F-3", port: 9225 });
+  check("A 再指派成功", aLeased.status === "leased");
+  // 取走 F-3 的命令，避免干扰
+  heartbeatLoginPool("F-3", {});
+
+  // 内部状态篡改：用 update 不行（不暴露 lease 写），通过文件回写模拟时间流逝
+  const file = join(HOME, ".tt-help-watchdog-logins.json");
+  // 强制落盘：scheduleSave 是 3s debounce；reapExpiredLeases 内部 ensureLoaded 读文件，
+  // 这里直接改文件 + 清模块缓存不可行（ESM 无缓存清理）→ 用 lastHealthAt 拨回方式：
+  // 模块导出 _accountsInternal 供测试直改内存
+  const internal = (await import("../src/watch/login-pool.js"))._accountsInternal();
+  const aInternal = internal.find((x) => x.username === "userA");
+  aInternal.lease.lastHealthAt = Date.now() - 13 * 60 * 60 * 1000; // 13h 前
+  const reaped = reapExpiredLeases();
+  check("超时租约被回收", reaped === 1, `reaped=${reaped}`);
+  const aView = getLoginPoolView().accounts.find((x) => x.username === "userA");
+  check("回收后回池", aView.status === "pool" && !aView.lease);
+  check("历史记录 leaseExpired", aView.history.some((h) => h.event === "leaseExpired"));
+}
+
+// ── 6. release / update / delete ──
+console.log("\n[6] release / update / delete");
+{
+  const b = getLoginPoolView().accounts.find((x) => x.username === "userC");
+  const rel = releaseAccount({ id: b.id, clearOnNode: true });
+  check("释放回池", rel.status === "pool" && !rel.lease);
+  const hb = heartbeatLoginPool("F-2", {});
+  check("clearOnNode 下发 clearLogin", hb && hb.commands[0].action === "clearLogin");
+
+  // retired 后才能删
+  updateAccount({ id: b.id, status: "retired" });
+  const del = deleteAccount(b.id);
+  check("retired 后删除成功", del.username === "userC");
+
+  // leased 删除保护：重新入池 + 指派 + 尝试删
+  const d = addAccount({ username: "userD", cookies: COOKIES_B });
+  assignAccount({ id: d.id, userId: "F-4", port: 9226 });
+  heartbeatLoginPool("F-4", {});
+  let threw = false;
+  try {
+    deleteAccount(d.id);
+  } catch (e) {
+    threw = true;
+    check("leased 删除保护", /先 release/.test(e.message));
+  }
+  check("leased 删除确实抛错", threw);
+
+  // 落盘文件存在且不含明文（saveNow debounce 后才有；主动触发一次读回验证结构）
+  const file = join(HOME, ".tt-help-watchdog-logins.json");
+  await new Promise((r) => setTimeout(r, 3200)); // 等 debounce
+  if (existsSync(file)) {
+    const raw = readFileSync(file, "utf-8");
+    check("文件落盘（含明文 cookies，属设计内）", raw.includes("sessionid"));
+    check("文件为 accounts 数组结构", JSON.parse(raw).accounts.length >= 1);
+  } else {
+    check("文件落盘", false, "3.2s 后仍无文件");
+  }
+}
+
+// ── 7. 取号排序（双键+冷却）· 自动释放（一实例一号）· retired 排除 ──
+console.log("\n[7] 取号·导入·自动释放");
+{
+  // 清池重建：全量 release→retired→delete，再导入 4 个新号（uc 全 0，createdAt 递增）
+  for (const a of getLoginPoolView().accounts) {
+    try { releaseAccount({ id: a.id }); } catch {}
+    try { updateAccount({ id: a.id, status: "retired" }); } catch {}
+    try { deleteAccount(a.id); } catch (e) { console.log("  [wipe]", e.message); }
+  }
+  const mk = (u) => importAccount({
+    userId: "seed",
+    username: u,
+    cookies: [{ name: "sessionid", value: "sid-" + u, domain: ".tiktok.com", expires: Math.floor(Date.now() / 1000) + 90 * 86400 }],
+  });
+  mk("userE"); mk("userF"); mk("userG"); mk("userH");
+  check("重建后池=4", getLoginPoolView().total === 4);
+
+  // 7.1 双键排序：uc 全 0 → createdAt 升序 → userE
+  const t1 = acquireAccount({ userId: "n1" });
+  check("永不用过的优先（userE）", t1.username === "userE", `got ${t1.username}`);
+  check("取号次数 +1", t1.useCount === 1);
+
+  // 7.2 第二低（userF）[自动释放：n2 无旧租约，无操作]
+  const t2 = acquireAccount({ userId: "n2" });
+  check("其次取 userF", t2.username === "userF", `got ${t2.username}`);
+
+  // 7.3 错峰冷却：还回 userE（lastUsedAt=now → 10min 冷却）→ 不立即复用
+  releaseAccount({ id: t1.id });
+  const t3 = acquireAccount({ userId: "n3" });
+  check("刚还的号不立即复用（取 userG）", t3.username === "userG", `got ${t3.username}`);
+
+  // 7.4 最后一个非冷却空闲号（userH）
+  const t4 = acquireAccount({ userId: "n4" });
+  check("取 userH", t4.username === "userH", `got ${t4.username}`);
+
+  // 7.5 ③ 自动释放：池内放入新号 → n1 再取 → 拿新号 + n1 名下旧租约（userE）自动归还
+  importAccount({ userId: "x", username: "userZ", cookies: [{ name: "sessionid", value: "sid-z" }] });
+  const t5 = acquireAccount({ userId: "n1" });
+  check("n1 取到新放入的 userZ", t5.username === "userZ", `got ${t5.username}`);
+  const eAfter = getLoginPoolView().accounts.find((x) => x.username === "userE");
+  check("旧租约被自动释放（userE 回池）", eAfter.status === "pool", `got ${eAfter.status}`);
+
+  // 7.6 去重：同 username 重复导入 → 幂等不覆盖
+  const impDup = importAccount({ userId: "n9", username: "userZ", cookies: [{ name: "sessionid", value: "HIJACK" }] });
+  check("重复导入幂等", impDup.dedup === true);
+  check("不覆盖池内 cookies", !JSON.stringify(impDup.account).includes("HIJACK"));
+
+  // 7.7 retired 不参与取号：停用 userZ → 取号拿到别的
+  const zId = getLoginPoolView().accounts.find((x) => x.username === "userZ").id;
+  releaseAccount({ id: zId }).account; // 若在租则释放
+  updateAccount({ id: zId, status: "retired" });
+  const t6 = acquireAccount({ userId: "n5" });
+  check("retired 不被取用", t6.username !== "userZ", `got ${t6.username}`);
+
+  // 7.8 参数拒绝
+  let threw = false;
+  try { importAccount({ userId: "n6", username: "x" }); } catch (e) { threw = true; check("缺 cookies 拒绝", /cookies/.test(e.message)); }
+  check("缺 cookies 确实抛错", threw);
+}
+
+// ── 8. 登录态导入 import（节点 → 中心，登记语义 + lastImportFrom） ──
+console.log("\n[8] 登录态导入 import");
+{
+  // 清池重建
+  for (const a of getLoginPoolView().accounts) {
+    try { releaseAccount({ id: a.id }); } catch {}
+    try { updateAccount({ id: a.id, status: "retired" }); } catch {}
+    try { deleteAccount(a.id); } catch (e) { console.log("  [wipe]", e.message); }
+  }
+  const COOKIES_D = [
+    { name: "sessionid", value: "sid-d", domain: ".tiktok.com", expires: Math.floor(Date.now() / 1000) + 86400 },
+    { name: "unique_id", value: "userD", domain: ".tiktok.com" },
+  ];
+  const imp = importAccount({ userId: "F-9", port: 9300, username: "userD", cookies: COOKIES_D, note: "节点启动同步" });
+  check("导入为空闲（无租约，未被消费）", imp.account.status === "pool" && imp.account.lease === null);
+  check("导入不计次数（useCount=0）", imp.account.useCount === 0);
+  check("记录来源元数据 lastImportFrom", imp.account.lastImportFrom && imp.account.lastImportFrom.userId === "F-9" && imp.account.lastImportFrom.port === 9300);
+  check("不入命令队列（不下发注入）", !(heartbeatLoginPool("F-9", {}) || {}).commands);
+
+  const imp2 = importAccount({ userId: "F-8", port: 9301, username: "userD", cookies: [{ name: "sessionid", value: "OTHER-SESSION" }], note: "另机重复会话" });
+  check("重复导入幂等（dedup=true）", imp2.dedup === true);
+  check("不覆盖池内 cookies", !JSON.stringify(imp2.account).includes("OTHER-SESSION"));
+  check("原来源元数据不动", imp2.account.lastImportFrom.userId === "F-9");
+
+  let threw = false;
+  try { importAccount({ userId: "F-1", username: "x" }); } catch (e) { threw = true; check("缺 cookies 拒绝", /cookies/.test(e.message)); }
+  check("缺 cookies 确实抛错", threw);
+}
+
+console.log(`\n═══ 结果: ${pass} 通过, ${fail} 失败 ═══`);
+process.exit(fail > 0 ? 1 : 0);

package/scripts/test-subscription-allocator.mjs

@@ -216,5 +216,57 @@ t("空池 + 空存量 → 返回空列表 + pool-empty（无害兜底）", () =>
   assert.strictEqual(r.warn, "pool-empty");
 });
 
+console.log("\n[权重] weight: 打分第二项 = 占用/weight，缺省/非法 = 1 退化为现状");
+t("全部缺省 weights → 与无权重版结果一致（兼容性回归）", () => {
+  const noW = allocateSubscriptions({ available: avail4, count: 2, prevAlloc: [], usage: usageOf([f1]), isAvailUrl: isAvail4 });
+  const withW = allocateSubscriptions({ available: avail4, count: 2, prevAlloc: [], usage: usageOf([f1]), weights: {}, isAvailUrl: isAvail4 });
+  assert.deepStrictEqual(withW.alloc, noW.alloc, "weights 缺省 = 不传");
+  assert.deepStrictEqual(urls(withW.alloc), ["D", "A"]);
+});
+
+t("C 设 2 倍权重，从零配 5 槽 → [A,B,C,D,C]（C 占 2/5）", () => {
+  const r = allocateSubscriptions({
+    available: avail4, count: 5, prevAlloc: [], usage: {},
+    weights: { [C.url]: 2 }, isAvailUrl: isAvail4,
+  });
+  assert.deepStrictEqual(urls(r.alloc), ["A", "B", "C", "D", "C"]);
+});
+
+t("加权占用：C(w2) 已占 2 槽仍可与 A(w1) 占 1 槽并列，池序决胜取 C", () => {
+  // C 被其它机器占 2 槽（归一后 2/2=1），A 占 1 槽（1/1=1）→ 并列；C 池序靠前
+  const availCA = [C, A];
+  const r = allocateSubscriptions({
+    available: availCA, count: 1, prevAlloc: [], usage: { [C.url]: 2, [A.url]: 1 },
+    weights: { [C.url]: 2 }, isAvailUrl: mkIsAvail([A, C]),
+  });
+  assert.deepStrictEqual(urls(r.alloc), ["C"]);
+  // 无权重时同场景会选占用最少的 A
+  const noW = allocateSubscriptions({
+    available: availCA, count: 1, prevAlloc: [], usage: { [C.url]: 2, [A.url]: 1 },
+    isAvailUrl: mkIsAvail([A, C]),
+  });
+  assert.deepStrictEqual(urls(noW.alloc), ["A"]);
+});
+
+t("非法权重（0/负数/非数字）一律按 1 兑底", () => {
+  const badW = allocateSubscriptions({
+    available: avail4, count: 2, prevAlloc: [], usage: usageOf([f1]),
+    weights: { [A.url]: 0, [B.url]: -3, [C.url]: "abc" }, isAvailUrl: isAvail4,
+  });
+  assert.deepStrictEqual(urls(badW.alloc), ["D", "A"]);
+});
+
+t("权重不破坏粘性/决定性：带权重重跑幂等", () => {
+  const args = {
+    available: avail4, count: 5, prevAlloc: [A, B].map((v) => ({ name: v.name, url: v.url })),
+    usage: {}, weights: { [C.url]: 2 }, isAvailUrl: isAvail4,
+  };
+  const r1 = allocateSubscriptions(args);
+  const again = allocateSubscriptions({ ...args, prevAlloc: r1.alloc });
+  assert.deepStrictEqual(again.alloc, r1.alloc, "粘性: 对结果重算不再变化");
+  assert.strictEqual(urls(r1.alloc)[0], "A", "存量槽原位保留");
+  assert.strictEqual(urls(r1.alloc)[1], "B");
+});
+
 console.log(`\n订阅分配器单元测试通过 ✅ (${passed} 用例)\n`);
 process.exit(0);

package/scripts/test-watchdog-subs-retry.mjs

@@ -0,0 +1,123 @@
+/**
+ * Bug 2 台架验证：订阅应用失败后心跳重试死锁
+ *
+ * 场景：agent「变化才转发」sig 已消耗 + daemon「失败不持久化待重发」约定脱节。
+ * 修复：agent 读 clash-health.json 的 meta.proxy.applyResult，失败(at > 转发时刻)则重置 sig，
+ *       服务端每跳无条件下发 proxySettings → 同轮心跳重发全量。
+ *
+ * 台架：真 WatchdogAgent（spawnDaemon:false）+ 本地 mock watch 服务（每跳返回固定订阅），
+ *       观测点 = ipc 默认通道命令文件 /tmp/clash-cmd.json 的写入次数。
+ *       daemon 侧行为（不真跑 daemon）由台架直接写 /tmp/clash-health.json 模拟。
+ *
+ * 跑法：node scripts/test-watchdog-subs-retry.mjs
+ */
+import http from "http";
+import { readFileSync, writeFileSync, existsSync, statSync } from "fs";
+import { WatchdogAgent } from "../src/watchdog/agent.js";
+
+const CMD_FILE = "/tmp/clash-cmd.json";
+const HEALTH_FILE = "/tmp/clash-health.json";
+
+let pass = 0;
+let fail = 0;
+const check = (name, cond, extra = "") => {
+  if (cond) {
+    pass++;
+    console.log(`  ✓ ${name}`);
+  } else {
+    fail++;
+    console.log(`  ✗ ${name} ${extra}`);
+  }
+};
+
+const cmdFileMtime = () => (existsSync(CMD_FILE) ? statSync(CMD_FILE).mtimeMs : 0);
+const cmdFileContent = () => (existsSync(CMD_FILE) ? readFileSync(CMD_FILE, "utf-8") : "");
+
+// ── mock watch 服务：每跳返回固定订阅 + 可注入 commands/clashCommands ──
+const SUBS = [{ name: "mock-sub-1", url: "https://example.com/sub-1" }];
+let inject = {}; // 台架可注入额外响应字段（如 loginPorts 无关字段不注入，保持干净）
+let hits = 0;
+const server = http.createServer((req, res) => {
+  let body = "";
+  req.on("data", (c) => (body += c));
+  req.on("end", () => {
+    hits++;
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({ commands: [], clashCommands: [], proxySettings: { subscriptions: SUBS }, ...inject }),
+    );
+  });
+});
+await new Promise((r) => server.listen(0, "127.0.0.1", r));
+const port = server.address().port;
+
+// ── agent 台架（不 start，不拉 daemon，手动逐跳）──
+const agent = new WatchdogAgent({
+  serverUrl: `http://127.0.0.1:${port}`,
+  clientId: "t1@test",
+  intervalMs: 15000,
+  spawnDaemon: false,
+});
+agent.running = true;
+const beat = () => agent._sendHeartbeat().catch((e) => console.error("beat err:", e.message));
+
+// 清场：移除旧 ipc 文件
+for (const f of [CMD_FILE, HEALTH_FILE]) {
+  try {
+    if (existsSync(f)) writeFileSync(f, "[]");
+  } catch {}
+}
+
+console.log("═ 跳1: 首次下发订阅 → 应转发（写命令文件）═");
+await beat();
+const sentAt1 = agent._proxySubsSentAt;
+check("命令文件已写入(setSubscription)", cmdFileContent().includes("mock-sub-1"));
+check("转发时间戳已记录", sentAt1 > 0);
+check("sig 已保存", agent._proxySubsSig === JSON.stringify(SUBS));
+
+console.log("═ 跳2: daemon 应用失败(applyResult.ok=false, at>转发时刻) → 应重置 sig 并同轮重发 ═");
+const t2 = Date.now(); // daemon 写的是过去的应用完成时刻（真实时序）
+writeFileSync(
+  HEALTH_FILE,
+  JSON.stringify({ lastCheck: new Date().toISOString(), meta: { proxy: { applyResult: { ok: false, at: t2, error: "实例1: no-vendor 不支持的平台: linux-amd64" } } } }),
+);
+await beat();
+check("sig 被重置(null)", agent._proxySubsSig === JSON.stringify(SUBS)); // 同轮已重发 → sig 恢复
+check("重发后 sentAt 更新", agent._proxySubsSentAt > sentAt1);
+check("命令文件被重写(重发)", cmdFileContent().includes("mock-sub-1") && statSync(CMD_FILE).mtimeMs > t2);
+
+console.log("═ 跳3: 旧失败结果(at<sentAt) 不应误触发重发 ═");
+const m3 = cmdFileMtime();
+await new Promise((r) => setTimeout(r, 60));
+await beat();
+check("命令文件未被重写", cmdFileMtime() === m3, `(mtime ${m3} → ${cmdFileMtime()})`);
+
+console.log("═ 跳4: daemon 应用成功(ok=true) → 不重置不重发 ═");
+writeFileSync(
+  HEALTH_FILE,
+  JSON.stringify({ lastCheck: new Date().toISOString(), meta: { proxy: { applyResult: { ok: true, at: Date.now() + 100 } } } }),
+);
+await beat();
+check("sig 保持", agent._proxySubsSig === JSON.stringify(SUBS));
+check("命令文件未被重写", cmdFileMtime() === m3);
+
+console.log("═ 跳5: 订阅再次失败(新 at) → 再次重置重发（持续收敛）═");
+const t5 = Date.now();
+writeFileSync(
+  HEALTH_FILE,
+  JSON.stringify({ lastCheck: new Date().toISOString(), meta: { proxy: { applyResult: { ok: false, at: t5, error: "实例1: 内核获取失败" } } } }),
+);
+await beat();
+check("重发发生(mtime 变化)", cmdFileMtime() > m3);
+check("sentAt 再次更新", agent._proxySubsSentAt > t5 - 3000 && agent._proxySubsSentAt <= Date.now() + 10);
+
+console.log("═ 跳6: 老版本 daemon(无 applyResult 字段) → 不触发、不重发（向后兼容）═");
+writeFileSync(HEALTH_FILE, JSON.stringify({ lastCheck: new Date().toISOString(), meta: { proxy: {} } }));
+const m6 = cmdFileMtime();
+await beat();
+check("命令文件未被重写", cmdFileMtime() === m6);
+check("sig 保持", agent._proxySubsSig === JSON.stringify(SUBS));
+
+console.log(`\n═══ 结果: ${pass} 通过 / ${fail} 失败 ═══`);
+server.close();
+process.exit(fail ? 1 : 0);

package/src/clash/runtime.js

@@ -73,6 +73,7 @@ const VENDOR_MANIFEST = {
   "darwin-arm64": { file: `mihomo-darwin-arm64-${MIHOMO_VERSION}.gz`, sha256: "d131f44b3deb2a8356f7ac75048ad67a10d53243323951c4f3cda7b672922963" },
   "darwin-amd64": { file: `mihomo-darwin-amd64-${MIHOMO_VERSION}.gz`, sha256: "3546681ebef3415e5dcbe7210a61aa80748136e95e6552768fd883df345508ed" },
   "windows-amd64": { file: `mihomo-windows-amd64-${MIHOMO_VERSION}.zip`, sha256: "38b2420799d9e7cde77ec1a19c7150dd17ca77f7fb82d9f62cb8763a307eee67" },
+  "linux-amd64": { file: `mihomo-linux-amd64-${MIHOMO_VERSION}.gz`, sha256: "d5e74bbddbdfff49a1aef7775bf5911da59f0d7196ed509a0ac914b3653dd5f1" },
 };
 const UI_MANIFEST = { file: "metacubexd-dist.tgz", sha256: "93eb334af7e37d213317347c01de31bd28e6c591c9b90e86496d257f15135ed9" };
 
@@ -242,16 +243,19 @@ export async function ensureBinary({ log = () => {} } = {}) {
     return { ok: true, bin: custom, source: "custom" };
   }
   const { bin } = runtimePaths();
-  const entry = VENDOR_MANIFEST[platformKey()];
-  if (!entry) return { ok: false, error: `不支持的平台: ${platformKey()}` };
 
   // 1) 本地缓存: 版本与清单一致 → 跳过（老机器平滑：无 version 字段的旧 stamp 会被后续步骤补齐）
+  //    必须先于平台清单检查：缓存有效不应因 manifest 缺平台条目而失败（Linux 节点踩坑，F-11）
   const stamp = readStamp();
   if (existsSync(bin) && stamp?.core?.version === MIHOMO_VERSION) {
     return { ok: true, bin, source: "cache" };
   }
 
-  // 2) 包内 vendor（dev / npm link / 手动放置）
+  // 2) 平台清单检查（此后所有路径都需要 entry）
+  const entry = VENDOR_MANIFEST[platformKey()];
+  if (!entry) return { ok: false, error: `不支持的平台: ${platformKey()}` };
+
+  // 3) 包内 vendor（dev / npm link / 手动放置）
   const art = findVendorCore();
   if (art) {
     if (installUpToDate(art, "core") && existsSync(bin)) {
@@ -265,7 +269,7 @@ export async function ensureBinary({ log = () => {} } = {}) {
     return installCoreFromArt(art.path, entry, { log });
   }
 
-  // 3) 下载链（自建服务器 → GitHub 兼底）
+  // 4) 下载链（自建服务器 → GitHub 兼底）
   const dlFile = join(RUNTIME_DIR, `.dl-${entry.file}`);
   mkdirSync(RUNTIME_DIR, { recursive: true });
   for (const base of vendorBases()) {