tt-help-cli-ycl 1.4.169 → 1.4.172

package/src/watch/subscription-center.js

@@ -0,0 +1,590 @@
+/**
+ * 订阅中心 — 订阅池注册表 + 到期/流量主动探测 + 集中展示
+ *
+ * Phase 1（本期）: 纯服务端能力，节点行为零改动
+ *   - 订阅池 CRUD（~/.tt-help-watchdog-subs.json，与 watchdog 配置分离）
+ *   - 主动探测: 直接 GET 订阅 URL（Clash UA），解析 subscription-userinfo 响应头
+ *     （upload/download/total/expire 随 HTTP 响应头返回，无需把订阅加载进任何内核）
+ *   - 被动兜底: 各节点心跳上报的 mihomo provider 快照（按 userId+订阅名映射回 URL）
+ *   - 状态推导: 正常/临期/已到期/余量告急/已耗尽/探测失败/未知/已禁用
+ *   - 流量重置检测: 用量较上次快照下降 = 发生重置（自动记录）
+ *
+ * Worker 启动策略（单写者原则）:
+ *   由第一重心跳惰性启动（ensureWorker 在 handleHeartbeat 中调用）。
+ *   生产上心跳只会到达一个进程（watch 主程序），探测 worker 因此只在那一个进程运行；
+ *   standalone-server（17302）虽复用同一套路由但没有心跳，worker 不会启动，仅只读展示。
+ *
+ * 安全约定:
+ *   订阅 URL 含 token（等于密码），所有日志只打订阅名，不打 URL。
+ */
+
+import {
+  readFileSync,
+  writeFileSync,
+  renameSync,
+  existsSync,
+  unlinkSync,
+  statSync,
+} from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { randomBytes } from "crypto";
+
+const homeDir = homedir() || process.env.HOME || process.env.USERPROFILE || "";
+const SUBS_FILE = join(homeDir, ".tt-help-watchdog-subs.json");
+const WATCHDOG_CONFIG_PATH = join(homeDir, ".tt-help-watchdog.json");
+
+// ── 常量 ──
+const PROBE_INTERVAL_MS = 6 * 60 * 60 * 1000; // 每条订阅 6h 探测一次（机场风控安全线内）
+const WORKER_TICK_MS = 30 * 1000; // worker 轮询节拍
+const PROBE_TIMEOUT_MS = 30 * 1000; // 单次探测超时（实采：机场对热门 token 可能 >10s 才响应；同域其它 token 秒回）
+const EXPIRE_WARN_MS = 7 * 24 * 60 * 60 * 1000; // 临期阈值 7 天
+const QUOTA_WARN_RATIO = 0.1; // 余量告急阈值：剩余 <10%
+const HISTORY_MAX_ENTRIES = 512; // 快照历史上限（≈128 天 @6h）
+const HISTORY_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000; // 快照历史保留 30 天
+const RESETS_MAX = 20; // 重置事件最多保留条数
+const NODE_REPORT_STALE_MS = 26 * 60 * 60 * 1000; // 节点代报数据超过 26h 视为陈旧
+const SUBS_MAX = 64; // 订阅池容量上限
+const UA = "clash.meta/1.19.31"; // 机场按 UA 发货：浏览器 UA 拿到 HTML 页，Clash UA 才带头
+const SAVE_DEBOUNCE_MS = 3 * 1000;
+
+// ── 内存状态 ──
+let _subs = []; // 注册表
+let _loaded = false;
+let _saveTimer = null;
+let _workerTimer = null;
+const _probing = new Set(); // 单飞行：正在探测的订阅 id
+
+/** 订阅名归一化 — 与 src/clash/runtime.js normalizeSubscriptions 保持一致（映射节点上报用） */
+export function normalizeSubName(name, fallback) {
+  let n = typeof name === "string" ? name.trim() : "";
+  n = n.replace(/[^\w-]/g, "").slice(0, 32);
+  if (!n || /^\d+$/.test(n)) n = ""; // 纯数字/空名回退自动命名
+  return n || fallback;
+}
+
+/** 与 runtime.normalizeSubscriptions 同规则展开服务端 proxySettings（sub-N 按行序兜底命名） */
+function expandNodeSubs(list) {
+  const out = [];
+  for (const it of Array.isArray(list) ? list : []) {
+    const url =
+      typeof it === "string" ? it.trim() : it && String(it.url || "").trim();
+    if (!url || !/^https?:\/\//.test(url)) continue;
+    const idx = out.length + 1;
+    let name = normalizeSubName(
+      typeof it === "object" && it.name ? it.name : "",
+      `sub-${idx}`,
+    );
+    if (out.some((s) => s.name === name)) name = `${name}-${idx}`;
+    out.push({ name, url });
+  }
+  return out;
+}
+
+// ── 存取 ──
+// 多进程共存（watch 3001 / 3011 / standalone 可能同时加载本模块）：
+// 以文件 mtime 做缓存失效——任一进程写入（CRUD/探测/代报）后，其它进程下次访问自动重读，
+// 避免「进程内一次加载」导致跨进程数据不可见（生产 3011 入池、3001 页面看不到的实采坑）。
+let _fileMtime = 0;
+
+function load() {
+  let mtime = 0;
+  try {
+    mtime = statSync(SUBS_FILE).mtimeMs;
+  } catch {}
+  if (_loaded && mtime === _fileMtime) return; // 文件未变，用缓存
+  _loaded = true;
+  _fileMtime = mtime;
+  try {
+    if (existsSync(SUBS_FILE)) {
+      const data = JSON.parse(readFileSync(SUBS_FILE, "utf-8"));
+      _subs = Array.isArray(data.subscriptions) ? data.subscriptions : [];
+      if (mtime) console.error(`[订阅中心] 已加载订阅池: ${_subs.length} 条 (${SUBS_FILE})`);
+    }
+  } catch (e) {
+    console.error(`[订阅中心] 订阅池文件加载失败（忽略，按空池启动）: ${e.message}`);
+    _subs = [];
+  }
+}
+
+function saveNow() {
+  if (_saveTimer) {
+    clearTimeout(_saveTimer);
+    _saveTimer = null;
+  }
+  const tmp = SUBS_FILE + ".tmp";
+  try {
+    writeFileSync(tmp, JSON.stringify({ subscriptions: _subs }, null, 2), "utf-8");
+    renameSync(tmp, SUBS_FILE); // 原子替换，防并发读撕裂
+    try {
+      _fileMtime = statSync(SUBS_FILE).mtimeMs; // 自身写入不触发下次重读
+    } catch {}
+  } catch (e) {
+    try {
+      unlinkSync(tmp);
+    } catch {}
+    console.error(`[订阅中心] 订阅池保存失败: ${e.message}`);
+  }
+}
+
+function scheduleSave() {
+  if (_saveTimer) return;
+  _saveTimer = setTimeout(saveNow, SAVE_DEBOUNCE_MS);
+  if (_saveTimer.unref) _saveTimer.unref();
+}
+
+// ── 看门狗配置读取（仅读，算引用关系用；避免与 watchdog-server 循环依赖） ──
+
+function loadWatchdogConfig() {
+  try {
+    if (existsSync(WATCHDOG_CONFIG_PATH))
+      return JSON.parse(readFileSync(WATCHDOG_CONFIG_PATH, "utf-8"));
+  } catch {}
+  return {};
+}
+
+/** URL → 被哪些节点的配置引用（按 URL 匹配各 userId 的 proxySettings） */
+export function getReferences(url) {
+  const cfg = loadWatchdogConfig();
+  const ps = cfg.proxySettings || {};
+  const refs = [];
+  for (const userId of Object.keys(ps)) {
+    const list = Array.isArray(ps[userId] && ps[userId].subscriptions)
+      ? ps[userId].subscriptions
+      : [];
+    let count = 0;
+    const indexes = [];
+    list.forEach((it, i) => {
+      const u = typeof it === "string" ? it.trim() : it && String(it.url || "").trim();
+      if (u === url) {
+        count++;
+        indexes.push(i + 1);
+      }
+    });
+    if (count > 0) refs.push({ userId, count, indexes });
+  }
+  return refs;
+}
+
+// ── 状态推导 ──
+// 优先级: 已禁用 > 探测失败 > 未知 > 已到期 > 已耗尽 > 临期 > 余量告急 > 正常
+
+export function deriveStatus(entry, now = Date.now()) {
+  if (entry.enabled === false) return { code: "disabled", label: "已禁用", color: "#6b7280" };
+  const probeOk = entry.probe && entry.probe.ok;
+  const reportFresh =
+    entry.lastNodeReport &&
+    now - entry.lastNodeReport.at < NODE_REPORT_STALE_MS;
+  if (entry.probe && !entry.probe.ok && !reportFresh)
+    return { code: "probe-failed", label: "探测失败", color: "#fbbf24" };
+  // 生效快照 = 探测成功值 与 节点代报 中较新者
+  let eff = null;
+  if (probeOk && entry.lastNodeReport) {
+    eff = entry.probe.at >= entry.lastNodeReport.at ? entry.probe : entry.lastNodeReport;
+  } else if (probeOk) {
+    eff = entry.probe;
+  } else if (reportFresh) {
+    eff = entry.lastNodeReport;
+  }
+  if (!eff) return { code: "unknown", label: "未知", color: "#6b7280" };
+  const used = (eff.upload || 0) + (eff.download || 0);
+  const total = eff.total || 0;
+  const expireAt = eff.expire > 0 ? eff.expire * 1000 : 0;
+  if (expireAt && expireAt <= now)
+    return { code: "expired", label: "已到期", color: "#f87171" };
+  if (total > 0 && used >= total)
+    return { code: "exhausted", label: "已耗尽", color: "#f87171" };
+  if (expireAt && expireAt - now < EXPIRE_WARN_MS)
+    return { code: "expiring", label: "临期", color: "#f87171" };
+  if (total > 0 && (total - used) / total < QUOTA_WARN_RATIO)
+    return { code: "quota-critical", label: "余量告急", color: "#f87171" };
+  return { code: "ok", label: "正常", color: "#4ade80" };
+}
+
+// ── 探测 ──
+
+function parseUserinfo(raw) {
+  const out = {};
+  const re = /(\w+)=(\d+)/g;
+  let m;
+  while ((m = re.exec(raw))) out[m[1].toLowerCase()] = parseInt(m[2], 10) || 0;
+  return out;
+}
+
+/** 响应体轻校验（只决定是否标内容可疑，不做硬拒绝） */
+function looksLikeSubscription(peek) {
+  if (!peek) return true;
+  if (/^\s*proxies:|^\s*port:|^\s*password|vmess:|ss:|trojan:|hysteria|^\[Interface\]/im.test(peek))
+    return true;
+  return /^[A-Za-z0-9+/=\r\n_-]+$/.test(peek.slice(0, 64)); // base64 订阅
+}
+
+/**
+ * 探测单条订阅 URL: GET（Clash UA）→ subscription-userinfo 响应头
+ * @returns {Promise<{ok:boolean, httpCode?:number, error?:string, upload?, download?, total?, expire?, suspiciousBody?:boolean}>}
+ */
+async function probeUrl(url) {
+  let res;
+  try {
+    res = await fetch(url, {
+      headers: { "user-agent": UA, accept: "*/*" },
+      redirect: "follow", // 订阅地址常 302 到真实内容，头在最终响应上
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+    });
+  } catch (e) {
+    return { ok: false, error: e.name === "TimeoutError" ? `超时(${PROBE_TIMEOUT_MS / 1000}s)` : e.message };
+  }
+  const httpCode = res.status;
+  try {
+    const raw =
+      res.headers.get("subscription-userinfo") ||
+      res.headers.get("Subscription-Userinfo") ||
+      "";
+    // 只窥一小段响应体做轻校验，随即取消（订阅体可能几 MB，不整读）
+    let peek = "";
+    try {
+      const reader = res.body.getReader();
+      const first = await reader.read();
+      peek = Buffer.from(first.value || []).toString("latin1");
+      reader.cancel().catch(() => {});
+    } catch {}
+    if (!raw) {
+      return {
+        ok: false,
+        httpCode,
+        error: `HTTP ${httpCode} 无 subscription-userinfo 头（UA 不匹配或非订阅地址）`,
+        suspiciousBody: peek ? !looksLikeSubscription(peek) : false,
+      };
+    }
+    const ui = parseUserinfo(raw);
+    // 部分机场面板把 expire 发成毫秒时间戳（mihomo 内核同款 >1e12 兼容），统一归一为秒
+    let expire = ui.expire || 0;
+    if (expire > 1e12) expire = Math.round(expire / 1000);
+    return {
+      ok: true,
+      httpCode,
+      upload: ui.upload || 0,
+      download: ui.download || 0,
+      total: ui.total || 0,
+      expire,
+      suspiciousBody: peek ? !looksLikeSubscription(peek) : false,
+    };
+  } finally {
+    // res.body 可能仍被 reader 锁定：Node 22 里 cancel() 对锁定流返回 rejected promise
+    // （非同步抛错，try/catch 拦不住），必须接 .catch 否则 unhandledRejection 崩进程
+    try {
+      Promise.resolve(res.body?.cancel?.()).catch(() => {});
+    } catch {}
+  }
+}
+
+/**
+ * 探测一条订阅并落快照（探测成功才记历史 + 重置检测）
+ * @returns {Promise<{ok:boolean, error?:string, entry?:object}>}
+ */
+export async function probeSubscription(id, { manual = false } = {}) {
+  load();
+  const entry = _subs.find((s) => s.id === id);
+  if (!entry) return { ok: false, error: "订阅不存在" };
+  if (entry.enabled === false && !manual)
+    return { ok: false, error: "订阅已禁用" };
+  if (_probing.has(id)) return { ok: false, error: "探测进行中" };
+  _probing.add(id);
+  const now = Date.now();
+  try {
+    let r = await probeUrl(entry.url);
+    // 自动探测失败时重试一次（机场偶发抖动/慢响应实采：同域其它 token 秒回，个别 token 首探超时；
+    // 手动探测不重试——页面请求等不了 30s×2，失败态下轮 6h 周期自会再试）
+    if (!r.ok && !manual) {
+      await new Promise((res) => setTimeout(res, 5000));
+      r = await probeUrl(entry.url);
+    }
+    const prev = entry.probe && entry.probe.ok ? entry.probe : null;
+    entry.probe = {
+      at: now,
+      ok: !!r.ok,
+      httpCode: r.httpCode ?? null,
+      error: r.ok ? null : r.error || "未知错误",
+      upload: r.upload || 0,
+      download: r.download || 0,
+      total: r.total || 0,
+      expire: r.expire || 0,
+      suspiciousBody: !!r.suspiciousBody,
+    };
+    if (r.ok) {
+      const used = (r.upload || 0) + (r.download || 0);
+      // 流量重置检测: 累计用量只会涨，下降 = 面板侧发生了周期重置
+      if (prev && prev.total === r.total && prev.expire === r.expire) {
+        const prevUsed = (prev.upload || 0) + (prev.download || 0);
+        if (prevUsed > 0 && used < prevUsed) {
+          entry.resets = Array.isArray(entry.resets) ? entry.resets : [];
+          entry.resets.push({ at: now, prevUsed, used });
+          if (entry.resets.length > RESETS_MAX) entry.resets.shift();
+          console.error(
+            `[订阅中心] 🔄 「${entry.name}」检测到流量重置: ${Math.round(prevUsed / 1073741824)}GB → ${Math.round(used / 1073741824)}GB`,
+          );
+        }
+      }
+      entry.history = Array.isArray(entry.history) ? entry.history : [];
+      entry.history.push({ ts: now, used });
+      trimHistory(entry);
+    }
+    saveNow();
+    const days = r.ok && r.expire ? Math.round((r.expire * 1000 - now) / 86400000) : null;
+    console.error(
+      r.ok
+        ? `[订阅中心] ✓ 「${entry.name}」探测成功: HTTP ${r.httpCode}, 剩余 ${fmtGBShort((r.total || 0) - ((r.upload || 0) + (r.download || 0)))}${r.expire ? `, ${days <= 0 ? "已到期" : `剩 ${days} 天`} ` : "长期 "}用途`
+        : `[订阅中心] ✗ 「${entry.name}」探测失败: ${r.error}`,
+    );
+    return { ok: true, entry };
+  } catch (e) {
+    entry.probe = { at: now, ok: false, httpCode: null, error: e.message };
+    saveNow();
+    return { ok: false, error: e.message };
+  } finally {
+    _probing.delete(id);
+  }
+}
+
+function trimHistory(entry) {
+  if (!Array.isArray(entry.history)) return;
+  const cutoff = Date.now() - HISTORY_MAX_AGE_MS;
+  entry.history = entry.history.filter((h) => h.ts >= cutoff);
+  if (entry.history.length > HISTORY_MAX_ENTRIES)
+    entry.history = entry.history.slice(-HISTORY_MAX_ENTRIES);
+}
+
+function fmtGBShort(bytes) {
+  if (!bytes || bytes <= 0) return "0GB";
+  const gb = bytes / 1073741824;
+  return (gb >= 1024 ? (gb / 1024).toFixed(2) + "TB" : gb.toFixed(1) + "GB");
+}
+
+// ── 节点代报采集（心跳被动兜底） ──
+
+/**
+ * 从心跳里提取各通道 mihomo provider 快照，按「userId+订阅名」映射回池子 URL。
+ * 命名规则与 src/clash/runtime.js normalizeSubscriptions 一致（sub-N 按行序兜底）。
+ * @param {string} userId
+ * @param {object|null} mainHealth 主通道健康（clashHealth）
+ * @param {Array} channels 多通道健康（clashHealthChannels）
+ */
+export function ingestNodeReport(userId, mainHealth, channels) {
+  load();
+  if (!userId) return;
+  const nodeSubs = expandNodeSubs(
+    (loadWatchdogConfig().proxySettings || {})[userId]?.subscriptions || [],
+  );
+  if (!nodeSubs.length) return;
+  const now = Date.now();
+  const healths = [mainHealth, ...(Array.isArray(channels) ? channels : [])];
+  let changed = false;
+  for (const h of healths) {
+    const list = h && h.meta && h.meta.proxy && h.meta.proxy.subscriptions;
+    if (!Array.isArray(list)) continue;
+    for (const s of list) {
+      if (!s || !s.name) continue;
+      const matched = nodeSubs.find((n) => n.name === s.name);
+      if (!matched) continue;
+      const entry = _subs.find((e) => e.url === matched.url);
+      if (!entry) continue; // 不在池子里的节点配置不采集（Phase 1 池子为准）
+      const prev = entry.lastNodeReport;
+      const same =
+        prev &&
+        prev.upload === (s.upload || 0) &&
+        prev.download === (s.download || 0) &&
+        prev.total === (s.total || 0) &&
+        prev.expire === (s.expire || 0);
+      if (same) {
+        prev.at = now; // 只刷新新鲜度，不触发写盘
+        continue;
+      }
+      entry.lastNodeReport = {
+        at: now,
+        by: userId,
+        upload: s.upload || 0,
+        download: s.download || 0,
+        total: s.total || 0,
+        expire: s.expire || 0,
+      };
+      changed = true;
+    }
+  }
+  if (changed) scheduleSave();
+}
+
+// ── CRUD ──
+
+function makeId() {
+  return "sub_" + Date.now().toString(36) + randomBytes(3).toString("hex");
+}
+
+function cleanText(v, max) {
+  return typeof v === "string" ? v.trim().slice(0, max || 120) : "";
+}
+
+export function addSubscription({ name, url, note } = {}) {
+  load();
+  url = cleanText(url, 2048);
+  if (!url || !/^https?:\/\//.test(url))
+    return { ok: false, error: "订阅地址须为 http(s) URL" };
+  if (_subs.some((s) => s.url === url))
+    return { ok: false, error: "该订阅地址已存在于池中" };
+  if (_subs.length >= SUBS_MAX)
+    return { ok: false, error: `订阅池已满（上限 ${SUBS_MAX} 条）` };
+  const now = Date.now();
+  const entry = {
+    id: makeId(),
+    name: cleanText(name, 64) || `订阅-${_subs.length + 1}`,
+    url,
+    note: cleanText(note, 200),
+    enabled: true,
+    addedAt: now,
+    updatedAt: now,
+    probe: null,
+    lastNodeReport: null,
+    history: [],
+    resets: [],
+  };
+  _subs.push(entry);
+  saveNow();
+  console.error(`[订阅中心] ＋ 新增订阅「${entry.name}」`);
+  return { ok: true, entry };
+}
+
+export function updateSubscription({ id, name, url, note, enabled } = {}) {
+  load();
+  const entry = _subs.find((s) => s.id === id);
+  if (!entry) return { ok: false, error: "订阅不存在" };
+  if (url !== undefined) {
+    url = cleanText(url, 2048);
+    if (!url || !/^https?:\/\//.test(url))
+      return { ok: false, error: "订阅地址须为 http(s) URL" };
+    if (_subs.some((s) => s.id !== id && s.url === url))
+      return { ok: false, error: "该订阅地址已存在于池中" };
+    if (url !== entry.url) {
+      entry.url = url;
+      entry.probe = null; // URL 变了旧快照作废，触发重新探测
+    }
+  }
+  if (name !== undefined) entry.name = cleanText(name, 64) || entry.name;
+  if (note !== undefined) entry.note = cleanText(note, 200);
+  if (enabled !== undefined) entry.enabled = !!enabled;
+  entry.updatedAt = Date.now();
+  saveNow();
+  console.error(
+    `[订阅中心] ✏️ 更新订阅「${entry.name}」${enabled !== undefined ? (entry.enabled ? "(启用)" : "(禁用)") : ""}`,
+  );
+  return { ok: true, entry };
+}
+
+export function deleteSubscription(id, { force = false } = {}) {
+  load();
+  const idx = _subs.findIndex((s) => s.id === id);
+  if (idx === -1) return { ok: false, error: "订阅不存在" };
+  const entry = _subs[idx];
+  const refs = getReferences(entry.url);
+  if (refs.length && !force) {
+    return {
+      ok: false,
+      needForce: true,
+      error: `仍被 ${refs.length} 个节点引用（${refs.map((r) => r.userId).join("、")}），确认删除请传 force`,
+      refs,
+    };
+  }
+  _subs.splice(idx, 1);
+  saveNow();
+  console.error(`[订阅中心] 🗑 删除订阅「${entry.name}」${refs.length ? `（含 ${refs.length} 个节点引用）` : ""}`);
+  return { ok: true };
+}
+
+// ── 视图（给前端/API 的只读投影） ──
+
+export function getSubscriptionView() {
+  load();
+  const now = Date.now();
+  return _subs.map((e) => {
+    const status = deriveStatus(e, now);
+    // 生效快照（与 deriveStatus 同口径）
+    const probeOk = e.probe && e.probe.ok;
+    const reportFresh = e.lastNodeReport && now - e.lastNodeReport.at < NODE_REPORT_STALE_MS;
+    let eff = null;
+    let source = "none";
+    if (probeOk && reportFresh) {
+      if (e.probe.at >= e.lastNodeReport.at) {
+        eff = e.probe;
+        source = "probe";
+      } else {
+        eff = e.lastNodeReport;
+        source = "node";
+      }
+    } else if (probeOk) {
+      eff = e.probe;
+      source = "probe";
+    } else if (reportFresh) {
+      eff = e.lastNodeReport;
+      source = "node";
+    }
+    const used = eff ? (eff.upload || 0) + (eff.download || 0) : 0;
+    const total = eff ? eff.total || 0 : 0;
+    const expireAt = eff && eff.expire > 0 ? eff.expire * 1000 : 0;
+    return {
+      id: e.id,
+      name: e.name,
+      note: e.note || "",
+      enabled: e.enabled !== false,
+      addedAt: e.addedAt || 0,
+      // URL 仅控制页面可见，含 token 不进任何服务端日志
+      url: e.url,
+      status,
+      used,
+      total,
+      remain: total > 0 ? Math.max(0, total - used) : 0,
+      usedRatio: total > 0 ? Math.min(1, used / total) : null,
+      expireAt,
+      resetsCount: Array.isArray(e.resets) ? e.resets.length : 0,
+      lastResetAt: Array.isArray(e.resets) && e.resets.length ? e.resets[e.resets.length - 1].at : 0,
+      source, // probe | node | none
+      lastProbe: e.probe
+        ? { at: e.probe.at, ok: !!e.probe.ok, httpCode: e.probe.httpCode, error: e.probe.error || null }
+        : null,
+      lastNodeReport: e.lastNodeReport
+        ? { at: e.lastNodeReport.at, by: e.lastNodeReport.by }
+        : null,
+      dataAt: eff ? eff.at : 0,
+      refs: getReferences(e.url),
+      historyRecent: Array.isArray(e.history) ? e.history.slice(-48) : [], // ≈12 天 @6h
+    };
+  });
+}
+
+// ── 探测 worker（单写者：仅心跳所在进程启动） ──
+
+function tick() {
+  load();
+  const now = Date.now();
+  const due = _subs.find(
+    (e) =>
+      e.enabled !== false &&
+      (!e.probe || !e.probe.at || now - e.probe.at >= PROBE_INTERVAL_MS) &&
+      !_probing.has(e.id),
+  );
+  if (due) probeSubscription(due.id).catch(() => {});
+}
+
+/** 由心跳路径调用：首个心跳到达时启动（单例），之后调用幂等 */
+export function ensureWorker() {
+  if (_workerTimer) return;
+  _workerTimer = setInterval(tick, WORKER_TICK_MS);
+  if (_workerTimer.unref) _workerTimer.unref();
+  console.error(
+    `[订阅中心] 探测 worker 已启动（每条 ${PROBE_INTERVAL_MS / 3600000}h，节拍 ${WORKER_TICK_MS / 1000}s）`,
+  );
+  // 启动后 5s 先探一轮到期最久的
+  setTimeout(tick, 5000).unref?.();
+}
+
+/** 模块加载时读盘（不启动 worker） */
+export function initSubscriptionCenter() {
+  load();
+}