mslxdff 0.1.244 → 0.1.246

package/src/warp-pool/identity.js

@@ -1,141 +0,0 @@
-// warp-pool · 身份轮换：换一台 WARP 设备身份来换出口 IP。
-//
-// 依据（他项目真机实测，非推测）：kyomufs/zen-router 的 internal/zen/errors.go:32-42 记录
-//   同一身份连发 3 次 → 429 FreeUsageLimitError；身份一换，同一个请求立刻 200
-//   （104.28.198.244 → 429 ×3，104.28.198.247 → 200）。
-// 故「多名额」的正解不是「N 台设备同时在线」（真机实测同时注册会折叠成同一个出口），
-// 而是**串行换身份**：换一台设备 ⇒ 换一个出口 ⇒ 换一份按 IP 计的名额。
-//
-// 与 zen-router 对齐的三条纪律：
-// 1. 轮换后**必须实测确认出口真的变了**；没变就整个 cycle 重试（它用 4 次，这里同）。
-//    「注册成功」不等于「出口换了」——不校验就会拿同一个桶反复撞 429。
-// 2. 同端口并发轮换去重 + 最小间隔，防 429 风暴把 CF 注册刷到限流（同类项目事故）。
-// 3. 只轮换、不销毁别的节点：轮换失败保持原节点可用，绝不把池打空。
-import { probeTunnel } from "./wireproxy.js";
-import { EXIT_PROBE_URL, parseExitIp } from "./revive.js";
-
-/** 经隧道读该端口真实出口地址（CF trace）；取不到返回 ""，绝不抛。 */
-export async function readExitIp({ port, fetchImpl, timeoutMs = 12_000 } = {}) {
-  try {
-    const res = await probeTunnel({ port, baseUrl: EXIT_PROBE_URL, path: "", fetchImpl, timeoutMs, wantText: true });
-    return typeof res?.text === "string" ? parseExitIp(res.text) : "";
-  } catch {
-    return "";
-  }
-}
-
-/**
- * 身份轮换器。
- * @param {{ register: Function, apply: (node:object)=>Promise<void>, readIp?: Function,
- *           maxAttempts?: number, settleMs?: number, sleep?: Function, now?: Function,
- *           log?: (s:string)=>void }} opts
- *   apply 由调用方注入：把新身份落盘并起隧道（含停掉旧隧道）。
- */
-export function createIdentityRotator({
-  register,
-  apply,
-  readIp = readExitIp,
-  maxAttempts = 4,
-  settleMs = 3000,
-  sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
-  now = Date.now,
-  log = () => {},
-} = {}) {
-  /** @type {Map<number, {ip:string, at:number}>} 各端口已知出口 */
-  const known = new Map();
-  /** @type {Map<number, Promise<object>>} 在途轮换（同端口去重） */
-  const inflight = new Map();
-
-  async function cycle(port, oldIp) {
-    for (let i = 1; i <= maxAttempts; i++) {
-      let reg;
-      try {
-        reg = await register({ log });
-      } catch (e) {
-        log(`[warp-pool] :${port} 轮换 ${i}/${maxAttempts}：注册失败（${String(e?.message || e).slice(0, 120)}）`);
-        await sleep(settleMs);
-        continue;
-      }
-      try {
-        await apply({ port, ...reg });
-      } catch (e) {
-        log(`[warp-pool] :${port} 轮换 ${i}/${maxAttempts}：起隧道失败（${String(e?.message || e).slice(0, 120)}）`);
-      }
-      await sleep(settleMs);
-      const ip = await readIp({ port });
-      if (ip && ip !== oldIp) {
-        known.set(port, { ip, at: now() });
-        log(`[warp-pool] :${port} 身份已轮换：出口 ${oldIp || "?"} → ${ip}（第 ${i}/${maxAttempts} 次）`);
-        return { ok: true, ip, attempts: i };
-      }
-      log(`[warp-pool] :${port} 轮换 ${i}/${maxAttempts}：出口未变（仍取到 ${ip || "空"}），重试`);
-    }
-    return { ok: false, attempts: maxAttempts };
-  }
-
-  return {
-    /** 记下入池时的实测出口（bootstrap 取证后调用）。 */
-    note(port, ip) {
-      if (ip) known.set(port, { ip, at: now() });
-    },
-    /** 该端口当前已知出口（"" = 未知）。 */
-    ipOf(port) {
-      return known.get(port)?.ip || "";
-    },
-    /**
-     * 轮换某节点身份换出口。同端口在途时返回同一个 Promise；minGapMs 内重复请求被掐
-     * （429 风暴时每个失败请求都触发一次轮换会把 CF 刷黑）。
-     * @returns {Promise<{ok:boolean, ip?:string, attempts?:number, skipped?:boolean}>}
-     */
-    rotate(port, { minGapMs = 60_000, force = false } = {}) {
-      const dup = inflight.get(port);
-      if (dup) return dup;
-      const prev = known.get(port);
-      if (!force && prev && now() - prev.at < minGapMs) {
-        return Promise.resolve({ ok: false, skipped: true });
-      }
-      const p = cycle(port, prev?.ip || "")
-        .catch((e) => {
-          log(`[warp-pool] :${port} 轮换异常：${String(e?.message || e)}`);
-          return { ok: false };
-        })
-        .finally(() => inflight.delete(port));
-      inflight.set(port, p);
-      return p;
-    },
-
-    /** 入池取证结果（labelExits 的分组）批量记账：每个节点的出口 IP 都要记住，轮换才能比对「是否真变了」。 */
-    noteExits(groups) {
-      for (const g of groups || []) for (const p of g.nodes || []) if (g.ip) known.set(p, { ip: g.ip, at: now() });
-    },
-    /** 轮换进行中 = 该节点正在换出口（调用方可据此避开它）。 */
-    busy(port) {
-      return inflight.has(port);
-    },
-    stats() {
-      return [...known.entries()].map(([port, v]) => ({ port, ip: v.ip, at: v.at }));
-    },
-  };
-}
-
-/**
- * 把「429 → 换身份换出口」接进一个已建好的池。轮换窗口内**先把该节点冷却**（端口已停，
- * 请求过去必失败），换好再放回。依赖全由调用方注入，本模块不反向依赖池。
- * @returns {{note:Function, noteExits:Function, ipOf:Function, rotate:Function, busy:Function, stats:Function}}
- */
-export function wireRotation({ dispatcher, register, tunnels, bringUp, swap = () => {}, log = () => {}, ...rest } = {}) {
-  return createIdentityRotator({
-    register,
-    apply: async (node) => {
-      const idx = dispatcher.entries().find((e) => e.port === node.port)?.index;
-      if (idx !== undefined) dispatcher.markFailure(idx); // 轮换窗口内先冷却：端口已停，请求过去必失败
-      tunnels.get(node.port)?.stop();
-      tunnels.delete(node.port);
-      swap(node.port, node);
-      await bringUp(node);
-      if (idx !== undefined) dispatcher.markOk(idx);
-    },
-    log,
-    ...rest,
-  });
-}

package/src/warp-pool/index.js

@@ -1,358 +0,0 @@
-// warp-pool · 装配入口。
-//
-// 定位（MODULES.md §0/§10）：WARP 池是**增量**出口，不是替代成员自身出口；缺省**开**，MSLXDFF_WARP_POOL=0 关。
-import { statSync } from "node:fs";
-import { resolveWarpConfig } from "./config.js";
-import { createRotatingDispatcher } from "./rotate.js";
-import { classifyWarpSignal, SIGNAL_STATUSES } from "./verdict.js";
-import { createHealthMonitor } from "./health.js";
-import { ensureDir, loadNodes, removeNode, saveNode } from "./nodes.js";
-import { registerWarpDevice } from "./register.js";
-import { ensureBinary, probeTunnel, resolveAsset, startTunnel, writeTunnelConf } from "./wireproxy.js";
-import { createReviver, labelExits, tailReason } from "./revive.js";
-import { portInUse, portOwner, reclaimPort, waitPortFree } from "./ports.js";
-import { fmtConf, fmtExit, fmtIdentityDetail, fmtPool, fmtPoolEmpty, fmtProbe, fmtProbeGiveUp, fmtPortBlocked, fmtSiblings, fmtSpawn, startupReport } from "./report.js";
-import { wireRotation } from "./identity.js";
-import { findDaemons } from "../runtime/proc-info.js";
-
-/** 重拨节流：连续失败指数退避。网络不通的机器绝不能让重注册把 CF 刷到 429。 */
-const REDIAL_MIN_GAP_MS = 5 * 60_000;
-const REDIAL_MAX_GAP_MS = 30 * 60_000;
-
-/** 注册间隔（同类项目实测：密集注册会让设备落同一网段，且触发 CF 429）。 */
-function gapMs(cfg, rnd = Math.random) {
-  const span = Math.max(0, cfg.registerMaxGapMs - cfg.registerMinGapMs);
-  return Math.round(cfg.registerMinGapMs + rnd() * span);
-}
-
-/** 注册响应 → 节点对象（bootstrap 与重拨共用，避免同一份字段表写两遍）。 */
-function nodeFromReg(port, reg, now) {
-  return { port, id: reg.id, token: reg.token, v4: reg.v4, v6: reg.v6, endpoint: reg.endpoint, peerKey: reg.peerKey, privateKey: reg.privateKey, registeredAt: new Date(now()).toISOString() };
-}
-
-/**
- * 建池。开关缺省关，故「未启用」= 未设 MSLXDFF_WARP_POOL=1 或 非 leader；那时返回 null，调用方据此不注入。
- * @returns {null | { dispatcher: object, ready: Promise<void>, close: () => Promise<void>, stats: () => object }}
- */
-export function createWarpPool({
-  env = process.env,
-  baseUrl = "https://opencode.ai",
-  log = (m) => console.error(m),
-  register = registerWarpDevice,
-  ensureBin = ensureBinary,
-  start = startTunnel,
-  probe = probeTunnel,
-  reclaim = reclaimPort,
-  inUse = portInUse,
-  waitFree = waitPortFree,
-  now = Date.now,
-  rnd = Math.random,
-  wait = (ms) => new Promise((r) => setTimeout(r, ms)),
-} = {}) {
-  const cfg = resolveWarpConfig(env);
-  if (!cfg.active) return null;
-
-  /** 身份轮换器：上游按出口 IP 计的限额（403 FreeTierError / 429 FreeUsage·GoUsage / 裸 429）时换一台 WARP 设备换出口。 */
-  let rotator = null;
-
-  const dispatcher = createRotatingDispatcher({
-    nodes: [],
-    strategy: cfg.strategy,
-    cooldownMs: cfg.cooldownMs,
-    log,
-    // 判决照抄参照实现 zen-router 的决策表（见 verdict.js 头注）：403 FreeTierError 与
-    // 429 FreeUsage/GoUsage 是同一条件、必须**强制**换出口（跳过冷却）；BlackUsageLimitError
-    // 是账号日配额、绝不换；其余状态码不参与判决、也不许刷日志。
-    onStatus: (signal, port) => {
-      const status = Number(signal?.status);
-      if (!SIGNAL_STATUSES.includes(status)) return;
-      const v = classifyWarpSignal(signal);
-      if (!cfg.rotate) {
-        log(`[warp-pool] :${port} 上游 ${status}（${v.kind}）—— 轮换开关关着（MSLXDFF_WARP_ROTATE=0），不换出口`);
-        return;
-      }
-      if (!v.rotate || !rotator) {
-        log(`[warp-pool] :${port} 上游 ${status} 判为「${v.kind}」⇒ 不换出口：${v.why}`);
-        return;
-      }
-      log(`[warp-pool] :${port} 上游 ${status} 判为「${v.kind}」⇒ 换身份换出口${v.forced ? "（强制，跳过冷却）" : ""}：${v.why}`);
-      void rotator.rotate(port, { force: v.forced })
-        .then((r) => { if (r && r.skipped) log(`[warp-pool] :${port} 换出口被冷却掐掉（距上次不足最小间隔）—— 这一发仍走原出口`); })
-        .catch(() => {});
-    },
-  });
-  /** @type {Map<number, {stop: () => void}>} */
-  const tunnels = new Map();
-
-  /** 复活：用磁盘已有 conf 重起，不重注册（进程挂了 ≠ 设备失效，省 CF 配额）。 */
-  async function reviveTunnel(port) {
-    if (closed) return false;
-    const node = loadNodes(cfg.dir, [port])[0];
-    if (!node) {
-      log(`[warp-pool] :${port} 放弃复活：磁盘上没有该节点的身份（node-${port}.json 缺失或缺私钥）`);
-      return false;
-    }
-    try {
-      await bringUp(node);
-    } catch (e) {
-      log(`[warp-pool] :${port} 复活起隧道失败：${String(e?.message || e)}`);
-      return false;
-    }
-    return true; // 真活没活由 createReviver 在 settleMs 后用 isAlive 复查，这里不许冒充成功
-  }
-  const reviver = createReviver({ revive: reviveTunnel, isAlive: (port) => { const t = tunnels.get(port); return !!t && t.alive !== false; }, log });
-  let binPath = "";
-  let closed = false;
-  let lastRedialAt = 0;
-  let redialGapMs = REDIAL_MIN_GAP_MS;
-
-  // 兜底清理：Node 退出不会回收 spawn 的子进程，daemon 突然退出时同步杀掉隧道。
-  // 同时置 closed：否则「杀子进程 → onExit → 立刻复活」会在退出过程中再 spawn 出一批孤儿（真机：每次重启漏一批）。
-  process.once("exit", () => {
-    closed = true;
-    try {
-      reviver.stop();
-    } catch {}
-    for (const t of tunnels.values()) {
-      try {
-        t.stop();
-      } catch {}
-    }
-  });
-
-  /** 起一条隧道的完整动作：确认不是重复起 → 清残留 → 写 conf → 等端口真空出来 → spawn → 记表。 */
-  async function bringUp(node) {
-    if (tunnels.has(node.port)) return; // 已归我们管：绝不再清残留（reclaim 会把自己这条隧道当残留杀掉）
-    await reclaim({ dir: cfg.dir, port: node.port, log }); // 清上一代孤儿（daemon 被强杀时子进程不会自己退）
-    const { conf, bytes } = writeTunnelConf(cfg.dir, node);
-    log(fmtConf({ port: node.port, conf, bytes }));
-    // SIGTERM 之后套接字要几百毫秒才释放，这期间连得上 ≠ 别人的进程占着——先等它真空出来再判
-    if (!(await waitFree(node.port, { inUse }))) {
-      const owner = await portOwner({ dir: cfg.dir, port: node.port }).catch(() => ({ ours: [], others: [] }));
-      throw new Error(fmtPortBlocked({ port: node.port, ...owner }));
-    }
-    const t = start({
-      binPath,
-      dir: cfg.dir,
-      port: node.port,
-      log,
-      onExit: ({ port, code, signal, tail, pid, aliveMs }) => {
-        tunnels.delete(port);
-        log(fmtExit({ port, code, signal, pid, aliveMs, tail: tailReason(tail) }));
-        if (!closed) void reviver.onExit(port); // 收摊中就别复活了，否则退出过程里又 spawn 出一批孤儿
-      },
-    });
-    tunnels.set(node.port, t);
-    log(fmtSpawn({ port: node.port, pid: t.pid, binPath, conf }));
-  }
-
-  // 429 ＝ 上游按出口 IP 计的名额耗尽 ⇒ 换一台设备的身份换出口（换身份＝换桶）。
-  rotator = wireRotation({
-    dispatcher,
-    register,
-    tunnels,
-    bringUp,
-    swap: (port, node) => { removeNode(cfg.dir, port); saveNode(cfg.dir, node); },
-    log,
-  });
-
-  /** 探活闸门参数：刚起的隧道要等 WireGuard 握手完成才通（真机：一起来就探 ⇒ 4 条全没通 ⇒ 池为空、WARP 白开）。 */
-  const PROBE_SETTLE_MS = 2_000;
-  const PROBE_ATTEMPTS = 2;
-
-  /**
-   * 入池前的实测闸门：给握手留时间 → 逐个探活 → 探不通的绝不进池。
-   * 为什么必须有：wireproxy 进程活着但隧道转不动流量时，请求会挂到超时（比直连更糟）。
-   * @returns {Promise<Array<object>>} 通过探活的节点
-   */
-  async function probeGate(list) {
-    const live = [];
-    await wait(PROBE_SETTLE_MS);
-    for (const n of list) {
-      if (!tunnels.has(n.port)) continue;
-      const url = `${String(baseUrl).replace(/\/+$/, "")}${cfg.probePath}`;
-      let r = { ok: false };
-      for (let i = 1; i <= PROBE_ATTEMPTS; i++) {
-        const t0 = now();
-        r = await probe({ port: n.port, baseUrl, path: cfg.probePath });
-        const ms = Number.isFinite(r.ms) ? r.ms : now() - t0;
-        log(fmtProbe({ port: n.port, attempt: i, attempts: PROBE_ATTEMPTS, url, ok: r.ok, status: r.status, error: r.error, ms }));
-        if (r.ok) break;
-        if (i < PROBE_ATTEMPTS) await wait(PROBE_SETTLE_MS);
-      }
-      if (r.ok) {
-        live.push(n);
-      } else {
-        log(fmtProbeGiveUp({ port: n.port, attempts: PROBE_ATTEMPTS, url }));
-      }
-    }
-    return live;
-  }
-  async function bootstrap() {
-    if (closed) return;
-    ensureDir(cfg.dir);
-    try {
-      binPath = await ensureBin({ dir: cfg.dir, bin: cfg.bin, autodownload: cfg.autodownload, log });
-    } catch (e) {
-      const why = !cfg.bin && !resolveAsset()
-        ? `本平台（${process.platform}-${process.arch}）无预编译 wireproxy，如需启用请设 MSLXDFF_WARP_BIN`
-        : String(e?.message || e);
-      log(`[warp-pool] 出口池本次跳过（不启用，请求走直连）：${why}`);
-      return;
-    }
-    if (closed) return;
-
-    // 1. 复用磁盘上已注册的节点
-    let nodes = loadNodes(cfg.dir, cfg.ports);
-    let binSize = 0;
-    try { binSize = statSync(binPath).size; } catch {}
-    await startupReport({ cfg, nodes, binPath, binSize, ownerOf: (port) => portOwner({ dir: cfg.dir, port }), log });
-    // 身份指纹：4 条隧道只拿到 2 个出口时，只有这组读数能区分「设备写重复」与「CF 共享 NAT 折叠」
-    for (const line of fmtIdentityDetail(nodes)) log(line);
-    // 同机其它 daemon：两个 daemon 会互相把对方的活隧道当「残留」杀掉（真机事故根因），必须一开池就报出来
-    const siblings = findDaemons({ self: process.pid });
-    if (siblings.length) log(fmtSiblings({ list: siblings }));
-
-    // 2. 补足：逐个注册（拉长间隔，避免 CF 注册限流与同网段撞车）
-    const used = new Set(nodes.map((n) => n.port));
-    const free = cfg.ports.filter((p) => !used.has(p));
-    for (const port of free) {
-      if (closed) return;
-      if (nodes.length >= cfg.count) break;
-      try {
-        if (nodes.length > 0) await wait(gapMs(cfg, rnd));
-        const reg = await register({ log });
-        const node = nodeFromReg(port, reg, now);
-        saveNode(cfg.dir, node);
-        nodes.push(node);
-        log(`[warp-pool] 注册新身份 :${port} 成功（设备 v6=${reg.v6}，WireGuard 密钥对在本地生成）`);
-      } catch (e) {
-        log(`[warp-pool] :${port} 注册身份失败，本轮跳过这个端口：${String(e?.message || e)}`);
-      }
-    }
-
-    // 3. 起隧道
-    for (const n of nodes) {
-      try {
-        await bringUp(n);
-      } catch (e) {
-        log(`[warp-pool] :${n.port} 起隧道失败，这个端口本轮不可用：${String(e?.message || e)}`);
-      }
-    }
-
-    // 入池前实测探活：WARP 握手没完成时 wireproxy 在跑却转不动流量（请求会挂到超时），那种节点进池会黑洞全部请求
-    const live = await probeGate(nodes);
-    if (live.length) {
-      await dispatcher.setNodes(live.map((n) => ({ port: n.port, uri: `http://127.0.0.1:${n.port}` })));
-      // 出口取证：一次拿到每个端口的真实出口，既喂给轮换器做「换没换动」的比对，也直接写进池结论那一行
-      const exits = await labelExits({ ports: live.map((n) => n.port), dir: cfg.dir, log });
-      rotator.noteExits(exits);
-      log(fmtPool({ pooled: live.length, total: nodes.length, exits }));
-    } else {
-      log(fmtPoolEmpty({ total: nodes.length, ports: cfg.ports }));
-    }
-  }
-
-  const monitor = createHealthMonitor({
-    dispatcher,
-    baseUrl,
-    probePath: cfg.probePath,
-    log,
-    infoOf: () => ({ alive: tunnels.size, pooled: dispatcher.size, exits: rotator ? rotator.stats() : [] }),
-    cooldownMs: cfg.cooldownMs,
-    onExhausted: async () => {
-      // 重拨 = 重新注册换出口。只重拨「进程已死」的隧道：全活却全挂 = 网络路径问题，重注册只会把 CF 刷到 429
-      const plan = redialPlan({ ports: cfg.ports, alivePorts: [...tunnels.keys()], lastRedialAt, redialGapMs, now });
-      if (plan.reason === "all-alive") {
-        log("[warp-pool] 隧道均存活但全池不通，判定为网络路径问题，跳过重拨");
-        return;
-      }
-      if (plan.reason === "throttled") {
-        log(`[warp-pool] 距上次重拨不足 ${Math.round(redialGapMs / 1000)}s，跳过本轮`);
-        return;
-      }
-      const dead = plan.dead;
-      lastRedialAt = now();
-      redialGapMs = Math.min(redialGapMs * 2, REDIAL_MAX_GAP_MS);
-      log(`[warp-pool] ${dead.length} 条隧道已死，重拨（下次最短间隔 ${Math.round(redialGapMs / 1000)}s）`);
-      for (const port of dead) {
-        if (closed) return;
-        try {
-          tunnels.get(port)?.stop();
-          tunnels.delete(port);
-          removeNode(cfg.dir, port);
-          const reg = await register({ log });
-          saveNode(cfg.dir, nodeFromReg(port, reg, now));
-          await bringUp({ port, ...reg });
-        } catch (e) {
-          log(`[warp-pool] 重拨 :${port} 失败：${String(e?.message || e)}`);
-        }
-        await wait(gapMs(cfg, rnd));
-      }
-      if (!closed && tunnels.size) {
-        // 重拨起来的隧道同样要过闸门：没过探活的隧道进池 = 把请求挂到超时（原先这里直接 setNodes，等于绕过闸门）
-        const alive = await probeGate([...tunnels.keys()].map((port) => ({ port })));
-        if (alive.length) {
-          redialGapMs = REDIAL_MIN_GAP_MS; // 确实有隧道能通 ⇒ 退避复位
-          await dispatcher.setNodes(alive.map((n) => ({ port: n.port, uri: `http://127.0.0.1:${n.port}` })));
-        } else {
-          log("[warp-pool] 重拨后仍没有一条隧道探通，保持直连（等下一轮健康检查）");
-        }
-      }
-    },
-  });
-
-  const ready = bootstrap()
-    .then(() => {
-      if (!closed) monitor.start();
-    })
-    .catch((e) => log(`[warp-pool] bootstrap 失败：${String(e?.message || e)}`));
-
-  return {
-    dispatcher,
-    ready,
-    config: cfg,
-    async close() {
-      if (closed) return;
-      closed = true;
-      monitor.stop();
-      reviver.stop();
-      for (const t of tunnels.values()) {
-        try {
-          t.stop();
-        } catch {}
-      }
-      tunnels.clear();
-      await dispatcher.close();
-    },
-    stats() {
-      return {
-        enabled: true,
-        mode: cfg.mode,
-        strategy: cfg.strategy,
-        dir: cfg.dir,
-        tunnels: tunnels.size,
-        nodes: dispatcher.stats(),
-        exits: rotator ? rotator.stats() : [],
-      };
-    },
-  };
-}
-
-/** 只取轮换 dispatcher 的便捷入口；未启用时返回 undefined（调用方直接透传即"关闭态"）。 */
-/** 隧道进程由模块内的 process exit 钩子兜底清理。 */
-export function createWarpDispatcher(opts) {
-  return createWarpPool(opts)?.dispatcher;
-}
-
-/**
- * 重拨门（纯函数，便于单测）：只「有隧道进程已死」且「距上次重拨超过退避间隔」才放行——全活却全挂是网络问题。
- * @returns {{ dead: number[], reason: "ok" | "all-alive" | "throttled" }}
- */
-export function redialPlan({ ports = [], alivePorts = [], lastRedialAt = 0, redialGapMs = REDIAL_MIN_GAP_MS, now = Date.now } = {}) {
-  const alive = new Set(alivePorts);
-  const dead = ports.filter((p) => !alive.has(p));
-  if (!dead.length) return { dead, reason: "all-alive" };
-  if (now() - lastRedialAt < redialGapMs) return { dead, reason: "throttled" };
-  return { dead, reason: "ok" };
-}

package/src/warp-pool/keys.js

@@ -1,29 +0,0 @@
-// warp-pool · WireGuard 密钥（`wg genkey` / `wg pubkey` 的 Node 原生等价物）。
-// WireGuard 用 Curve25519(x25519)：密钥是 32 字节 raw，编码为 44 字符 base64。
-// Node 原生 generateKeyPairSync('x25519') 导出的 DER 末 32 字节即 raw key（本机实测通过）。
-import crypto from "node:crypto";
-
-const RAW_BYTES = 32;
-
-/** DER(SPKI/PKCS8) 的末 32 字节就是 Curve25519 raw key。 */
-function rawTail(der) {
-  const raw = der.subarray(-RAW_BYTES);
-  if (raw.length !== RAW_BYTES) throw new Error("x25519 密钥导出异常：DER 长度不足 32 字节");
-  return raw;
-}
-
-/**
- * 生成一对 WireGuard 密钥（base64，44 字符）。
- * 注册 WARP 设备时把 publicKey 填进请求体的 `key` 字段。
- */
-export function generateWgKeyPair() {
-  const { publicKey, privateKey } = crypto.generateKeyPairSync("x25519");
-  const privateKeyB64 = rawTail(privateKey.export({ type: "pkcs8", format: "der" })).toString("base64");
-  const publicKeyB64 = rawTail(publicKey.export({ type: "spki", format: "der" })).toString("base64");
-  return { privateKey: privateKeyB64, publicKey: publicKeyB64 };
-}
-
-/** WireGuard base64 密钥形状自检：恒 44 字符、以 '=' 收尾（Nothing-up-my-sleeve 检查用）。 */
-export function isWgKey(v) {
-  return typeof v === "string" && /^[A-Za-z0-9+/]{43}=$/.test(v);
-}

package/src/warp-pool/nodes.js

@@ -1,95 +0,0 @@
-// warp-pool · 节点元数据持久化。
-// 含 WireGuard 私钥文件与设备 token ⇒ 一律 0600，且只落在日志根（MSLXDFF_WARP_DIR），不进工作树。
-import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-const SECRET_MODE = 0o600;
-
-/** 节点两件套：WireGuard 配置（含私钥）与元数据（含设备 token）。 */
-export function nodePaths(dir, port) {
-  return {
-    conf: join(dir, `node-${port}.conf`),
-    meta: join(dir, `node-${port}.json`),
-  };
-}
-
-/** 写敏感文件：新建用 0600，存量补 chmod（mode 只在新建时生效）。 */
-export function writeSecret(file, content) {
-  const existed = existsSync(file);
-  writeFileSync(file, content, existed ? undefined : { mode: SECRET_MODE });
-  try { chmodSync(file, SECRET_MODE); } catch {}
-  return file;
-}
-
-export function ensureDir(dir) {
-  mkdirSync(dir, { recursive: true, mode: 0o700 });
-  return dir;
-}
-
-/** 读单个节点元数据；文件缺失/损坏返回 null，绝不抛。 */
-export function loadNode(dir, port) {
-  const { meta } = nodePaths(dir, port);
-  try {
-    const j = JSON.parse(readFileSync(meta, "utf8"));
-    if (!j || typeof j !== "object") return null;
-    return {
-      port,
-      id: String(j.id || ""),
-      token: String(j.token || ""),
-      v4: String(j.v4 || ""),
-      v6: String(j.v6 || ""),
-      endpoint: String(j.endpoint || ""),
-      peerKey: String(j.peerKey || ""),
-      privateKey: String(j.privateKey || ""), // 必须读回：bringUp 靠它渲染 conf，漏了就是 PrivateKey = undefined（2026-10-16 真机事故：复用节点的隧道全起不来）
-      registeredAt: String(j.registeredAt || ""),
-      ...(j.cooldownUntil ? { cooldownUntil: Number(j.cooldownUntil) } : {}),
-    };
-  } catch {
-    return null;
-  }
-}
-
-export function saveNode(dir, node) {
-  const { meta } = nodePaths(dir, node.port);
-  return writeSecret(meta, `${JSON.stringify(node, null, 2)}\n`);
-}
-
-export function removeNode(dir, port) {
-  const { conf, meta } = nodePaths(dir, port);
-  for (const f of [conf, meta]) {
-    try { if (existsSync(f)) unlinkSync(f); } catch {}
-  }
-}
-
-/** 读回配置目录里已注册的节点（按端口升序）。 */
-export function loadNodes(dir, ports) {
-  const out = [];
-  for (const p of ports) {
-    const n = loadNode(dir, p);
-    if (n && n.id && n.token && n.privateKey) out.push(n);
-  }
-  return out;
-}
-
-/** WireGuard + wireproxy INI（[http] 段把隧道暴露成本地 HTTP 代理出口；undici v5 的 ProxyAgent 只吃 http/https）。 */
-export function renderWireproxyConf({ privateKey, v4, v6, endpoint, peerKey, port }) {
-  const addresses = [
-    v4 ? `Address = ${v4}/32` : "",
-    v6 ? `Address = ${v6}/128` : "",
-  ].filter(Boolean).join("\n");
-  return `[Interface]
-PrivateKey = ${privateKey}
-${addresses}
-DNS = 1.1.1.1
-MTU = 1280
-
-[Peer]
-PublicKey = ${peerKey}
-AllowedIPs = 0.0.0.0/0, ::/0
-Endpoint = ${endpoint}
-PersistentKeepalive = 25
-
-[http]
-BindAddress = 127.0.0.1:${port}
-`;
-}