mslxdff 0.1.175 → 0.1.177

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.175",
+  "version": "0.1.177",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/warp-pool/config.js

@@ -2,9 +2,9 @@
 import { join } from "node:path";
 import { logDir } from "../logs.js";
 
-/** 缺省即开：组长升级/重启后无需改任何环境变量即可生效；不想用的节点设 MSLXDFF_WARP_POOL=0。 */
+/** 缺省关：2026-10-16 真机实测证伪「N 设备 = N 桶」（免费版 WARP 的 IPv4 出口是共享 NAT，见 ADR-0059 修订）。 */
 export const DEFAULTS = {
-  enabled: true,
+  enabled: false,
   mode: "leader",
   count: 4,
   basePort: 10800,

package/src/warp-pool/index.js

@@ -1,18 +1,16 @@
 // warp-pool · 装配入口。
 //
-// 定位（见 MODULES.md §0）：WARP 池是**增量**出口，不是替代成员自身出口；
-// 开关缺省即开（MSLXDFF_WARP_POOL 缺省 1；设 0 则零副作用）；只有组长（MSLXDFF_WARP_MODE=leader）才真建池。
-//
-// 关键约束：bootstrap（注册设备 + 起隧道）很慢（注册有 6–15s 间隔、可能退避 60–120s），
-// 因此**绝不阻塞 daemon 启动**——createWarpPool 同步返回，dispatcher 先是空池（直连兜底），
-// bootstrap 完成后 setNodes() 换上真实出口。
+// 定位（见 MODULES.md §0/§10）：WARP 池是**增量**出口，不是替代成员自身出口。开关缺省**关**——
+// 2026-10-16 真机实测证伪「N 设备 = N 桶」（免费版 WARP 的 IPv4 出口是共享 NAT）；设 MSLXDFF_WARP_POOL=1 才建池。
 import { resolveWarpConfig } from "./config.js";
 import { createRotatingDispatcher } from "./rotate.js";
 import { createHealthMonitor } from "./health.js";
 import { ensureDir, loadNodes, removeNode, saveNode } from "./nodes.js";
 import { registerWarpDevice } from "./register.js";
-import { ensureBinary, resolveAsset, startTunnel, writeTunnelConf } from "./wireproxy.js";
-/** 重拨节流：连续失败指数退避。缺省开之后，网络不通的机器绝不能让重注册把 CF 刷到 429。 */
+import { ensureBinary, probeTunnel, resolveAsset, startTunnel, writeTunnelConf } from "./wireproxy.js";
+import { createReviver, labelExits } from "./revive.js";
+
+/** 重拨节流：连续失败指数退避。网络不通的机器绝不能让重注册把 CF 刷到 429。 */
 const REDIAL_MIN_GAP_MS = 5 * 60_000;
 const REDIAL_MAX_GAP_MS = 30 * 60_000;
 
@@ -22,9 +20,13 @@ function gapMs(cfg, rnd = Math.random) {
   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=0 或 非 leader；那时返回 null，调用方据此不注入。
+ * 建池。开关缺省关，故「未启用」= 未设 MSLXDFF_WARP_POOL=1 或 非 leader；那时返回 null，调用方据此不注入。
  * @returns {null | { dispatcher: object, ready: Promise<void>, close: () => Promise<void>, stats: () => object }}
  */
 export function createWarpPool({
@@ -34,6 +36,7 @@ export function createWarpPool({
   register = registerWarpDevice,
   ensureBin = ensureBinary,
   start = startTunnel,
+  probe = probeTunnel,
   now = Date.now,
   rnd = Math.random,
   wait = (ms) => new Promise((r) => setTimeout(r, ms)),
@@ -44,6 +47,16 @@ export function createWarpPool({
   const dispatcher = createRotatingDispatcher({ nodes: [], strategy: cfg.strategy, cooldownMs: cfg.cooldownMs, log });
   /** @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) return false;
+    await bringUp(node);
+    return tunnels.has(port);
+  }
+  const reviver = createReviver({ revive: reviveTunnel, log });
   let binPath = "";
   let closed = false;
   let lastRedialAt = 0;
@@ -68,7 +81,8 @@ export function createWarpPool({
       log,
       onExit: ({ port, code }) => {
         tunnels.delete(port);
-        log(`[warp-pool] 隧道 :${port} 退出（code=${code}）`);
+        log(`[warp-pool] 隧道 :${port} 退出（code=${code}），尝试复活`);
+        void reviver.onExit(port);
       },
     });
     tunnels.set(node.port, t);
@@ -101,17 +115,7 @@ export function createWarpPool({
       try {
         if (nodes.length > 0) await wait(gapMs(cfg, rnd));
         const reg = await register({ log });
-        const node = {
-          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(),
-        };
+        const node = nodeFromReg(port, reg, now);
         saveNode(cfg.dir, node);
         nodes.push(node);
         log(`[warp-pool] 注册节点 :${port}（v6=${reg.v6}）`);
@@ -129,14 +133,23 @@ export function createWarpPool({
       }
     }
 
-    // 4. 换上真实出口（失败/退出中的节点仍会被 health 摘除）
-    const live = nodes.filter((n) => tunnels.has(n.port));
+    // 入池前实测探活：WARP 握手不通时 wireproxy 进程照样在跑却转不动流量（挂到超时），那种节点进池会黑洞全部请求
+    const live = [];
+    for (const n of nodes) {
+      if (!tunnels.has(n.port)) continue;
+      const r = await probe({ port: n.port, baseUrl, path: cfg.probePath });
+      if (r.ok) live.push(n);
+      else log(`[warp-pool] 节点 :${n.port} 隧道未通（${r.status || r.error || "?"}），不进池`);
+    }
     if (live.length) {
       await dispatcher.setNodes(live.map((n) => ({ port: n.port, uri: `http://127.0.0.1:${n.port}` })));
       log(`[warp-pool] 出口池就绪：${live.length} 个节点`);
     } else {
       log("[warp-pool] 无可用节点，保持直连");
     }
+
+    // 5. 出口取证：把每台设备的真实出口地址打进日志（免费版 WARP 的 IPv4 是共享 NAT，N 台设备很可能折叠成同一个出口）
+    if (live.length) await labelExits({ ports: live.map((n) => n.port), log });
   }
 
   const monitor = createHealthMonitor({
@@ -145,9 +158,7 @@ export function createWarpPool({
     probePath: cfg.probePath,
     log,
     onExhausted: async () => {
-      // 重拨 = 重新注册 = 换新出口 IP（代价与限流见 MODULES.md）。
-      // 隧道全活却探活全挂 ⇒ 网络路径问题（实测墙内到 CF 的 UDP 被选择性屏蔽），
-      // 重注册换不来出路，只会把 CF 注册接口刷到 429 拉黑——故必须过 redialPlan 这道门。
+      // 重拨 = 重新注册换出口。只重拨「进程已死」的隧道：全活却全挂 = 网络路径问题，重注册只会把 CF 刷到 429
       const plan = redialPlan({ ports: cfg.ports, alivePorts: [...tunnels.keys()], lastRedialAt, redialGapMs, now });
       if (plan.reason === "all-alive") {
         log("[warp-pool] 隧道均存活但全池不通，判定为网络路径问题，跳过重拨");
@@ -168,17 +179,7 @@ export function createWarpPool({
           tunnels.delete(port);
           removeNode(cfg.dir, port);
           const reg = await register({ log });
-          saveNode(cfg.dir, {
-            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(),
-          });
+          saveNode(cfg.dir, nodeFromReg(port, reg, now));
           await bringUp({ port, ...reg });
         } catch (e) {
           log(`[warp-pool] 重拨 :${port} 失败：${String(e?.message || e)}`);
@@ -186,7 +187,7 @@ export function createWarpPool({
         await wait(gapMs(cfg, rnd));
       }
       if (!closed && [...tunnels.keys()].length) {
-        // 重拨确实把隧道拉起来了 ⇒ 退避复位，别让一次网络抖动永久拖慢恢复。
+        // 重拨确实把隧道拉起来了 ⇒ 退避复位
         redialGapMs = REDIAL_MIN_GAP_MS;
         await dispatcher.setNodes([...tunnels.keys()].map((port) => ({ port, uri: `http://127.0.0.1:${port}` })));
       }
@@ -228,19 +229,14 @@ export function createWarpPool({
   };
 }
 
-
-/**
- * 只取轮换 dispatcher 的便捷入口（隧道进程由模块内的 process exit 钩子兜底清理）。
- * 未启用（开关关 / 非 leader）时返回 undefined —— 调用方直接透传即是"关闭态"。
- */
+/** 只取轮换 dispatcher 的便捷入口；未启用时返回 undefined（调用方直接透传即"关闭态"）。 */
+/** 隧道进程由模块内的 process exit 钩子兜底清理。 */
 export function createWarpDispatcher(opts) {
   return createWarpPool(opts)?.dispatcher;
 }
 
 /**
- * 重拨门（纯函数，便于单测）：只有「有隧道进程已死」且「距上次重拨超过当前退避间隔」才放行。
- * 隧道全活却探活全挂 ⇒ 网络路径问题（实测：墙内到 CF 的 UDP 被选择性屏蔽），
- * 此时重拨换不来出路，只会把 CF 注册接口刷到 429 拉黑。
+ * 重拨门（纯函数，便于单测）：只「有隧道进程已死」且「距上次重拨超过退避间隔」才放行——全活却全挂是网络问题。
  * @returns {{ dead: number[], reason: "ok" | "all-alive" | "throttled" }}
  */
 export function redialPlan({ ports = [], alivePorts = [], lastRedialAt = 0, redialGapMs = REDIAL_MIN_GAP_MS, now = Date.now } = {}) {

package/src/warp-pool/nodes.js

@@ -40,6 +40,7 @@ export function loadNode(dir, port) {
       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) } : {}),
     };
@@ -65,7 +66,7 @@ export function loadNodes(dir, ports) {
   const out = [];
   for (const p of ports) {
     const n = loadNode(dir, p);
-    if (n && n.id && n.token) out.push(n);
+    if (n && n.id && n.token && n.privateKey) out.push(n);
   }
   return out;
 }

package/src/warp-pool/revive.js

@@ -0,0 +1,117 @@
+// warp-pool · 复活与取证（真机事故后新增，2026-10-16）。
+//
+// 两件事，都来自组长 VPS 上暴露的缺陷：
+//
+// 1. `revive`: 隧道进程意外退出后**必须自愈**。原先 `onExit` 只把端口从表里删掉、打一行日志就完事，
+//    而唯一的补拉路径 `onExhausted` 要求「全池不通」——3 条活着时探活一直成功，那条死隧道
+//    就**再也不会被拉起**，池静默从 4 降到 3，直到 daemon 重启。（真机：:10800 死了就一直死。）
+//    注意：复活走**磁盘上已有的 conf**（不重新注册）——进程挂了不代表设备失效，重注册只会白烧 CF 配额。
+//
+// 2. `labelExits`: 入池后实测各节点**真实出口地址**并标注撞车。WARP 的 IPv4 出口是共享 NAT，
+//    「N 设备」很可能折叠成一个出口；没有这条读数就只能靠人手工 curl 才发现。
+import { probeTunnel } from "./wireproxy.js";
+
+/** 出口取证目标：Cloudflare 自己的 trace 端点，回 `ip=` 一行（不烧上游 token）。 */
+export const EXIT_PROBE_URL = "https://cloudflare.com/cdn-cgi/trace";
+
+/** 从 cdn-cgi/trace 正文里取出口地址；取不到返回 ""。 */
+export function parseExitIp(text) {
+  const m = String(text || "").match(/^\s*ip=(\S+)\s*$/m);
+  return m ? m[1] : "";
+}
+
+/**
+ * 按端口独立的退避复活器。
+ * @param {{ revive: (port:number)=>Promise<boolean>, minGapMs?: number, maxGapMs?: number,
+ *           now?: ()=>number, log?: (s:string)=>void }} opts
+ */
+export function createReviver({ revive, minGapMs = 30_000, maxGapMs = 10 * 60_000, now = Date.now, log = () => {} } = {}) {
+  /** @type {Map<number, {attempts:number, nextAt:number, busy:boolean}>} */
+  const state = new Map();
+
+  function entry(port) {
+    let s = state.get(port);
+    if (!s) {
+      s = { attempts: 0, nextAt: 0, busy: false };
+      state.set(port, s);
+    }
+    return s;
+  }
+
+  return {
+    /** 进程退出时调用。首次立即复活，之后按 30s→10min 指数退避。 */
+    async onExit(port) {
+      const s = entry(port);
+      const wait = Math.max(0, s.nextAt - now());
+      if (wait > 0) {
+        log(`[warp-pool] :${port} 复活退避中（还剩 ${Math.round(wait / 1000)}s）`);
+        return false;
+      }
+      if (s.busy) return false;
+      s.busy = true;
+      s.attempts += 1;
+      const gap = Math.min(minGapMs * 2 ** (s.attempts - 1), maxGapMs);
+      s.nextAt = now() + gap;
+      let ok = false;
+      try {
+        ok = await revive(port);
+      } catch (e) {
+        log(`[warp-pool] :${port} 复活失败：${String(e?.message || e)}`);
+      }
+      s.busy = false;
+      if (ok) {
+        state.delete(port);
+        log(`[warp-pool] :${port} 已复活`);
+      } else {
+        log(`[warp-pool] :${port} 复活未成功（第 ${s.attempts} 次，下次最早 ${Math.round(gap / 1000)}s 后）`);
+      }
+      return ok;
+    },
+    /** 探活成功时调用：清掉退避账，恢复正常节奏。 */
+    noteHealthy(port) {
+      state.delete(port);
+    },
+    stats() {
+      return [...state.entries()].map(([port, s]) => ({
+        port,
+        attempts: s.attempts,
+        nextAt: s.nextAt,
+        cooldownMsLeft: Math.max(0, s.nextAt - now()),
+      }));
+    },
+  };
+}
+
+/**
+ * 入池后实测各节点真实出口地址并打日志（含撞车警告）。
+ * 只读探测：打 Cloudflare 的 trace 端点，不碰上游配额。
+ * @returns {Promise<{ ip: string, nodes: number[] }[]>} 按出口地址分组的节点清单
+ */
+export async function labelExits({ ports = [], fetchImpl, timeoutMs = 12_000, log = () => {} } = {}) {
+  const byIp = new Map();
+  let failed = 0;
+  for (const port of ports) {
+    let ip = "";
+    try {
+      const res = await probeTunnel({ port, baseUrl: EXIT_PROBE_URL, path: "", fetchImpl, timeoutMs, wantText: true });
+      ip = typeof res?.text === "string" ? parseExitIp(res.text) : "";
+    } catch {
+      ip = "";
+    }
+    if (!ip) {
+      failed += 1;
+      continue;
+    }
+    if (!byIp.has(ip)) byIp.set(ip, []);
+    byIp.get(ip).push(port);
+  }
+
+  const groups = [...byIp.entries()].map(([ip, nodes]) => ({ ip, nodes }));
+  if (groups.length === 1) {
+    log(`[warp-pool] ⚠ 出口不分散：${groups[0].nodes.length} 个节点共用同一个出口 ${groups[0].ip}（免费版 WARP 的 IPv4 是共享 NAT）`);
+  } else if (groups.length > 1) {
+    log(`[warp-pool] 出口分散：${groups.length} 个不同地址 / ${groups.reduce((a, g) => a + g.nodes.length, 0)} 个节点`);
+  }
+  if (failed) log(`[warp-pool] ${failed} 个节点出口取证失败（不影响其进池）`);
+  return groups;
+}

package/src/warp-pool/wireproxy.js

@@ -91,6 +91,7 @@ function runCommand(cmd, args, { log = () => {} } = {}) {
 
 /** 写出某节点的 wireproxy 配置（含私钥 ⇒ 0600）。 */
 export function writeTunnelConf(dir, node) {
+  if (!node?.privateKey) throw new Error(`节点 :${node?.port} 缺 WireGuard 私钥，拒绝写出一份跑不起来的配置`);
   const { conf } = nodePaths(dir, node.port);
   return writeSecret(conf, renderWireproxyConf({ ...node, port: node.port }));
 }
@@ -135,7 +136,7 @@ export function startTunnel({ binPath: exe, dir, port, log = () => {}, onExit =
 }
 
 /** 探活一个已起的隧道：经该端口访问上游 models 路径（不烧 token）。 */
-export async function probeTunnel({ port, baseUrl = "https://opencode.ai", path = "/zen/v1/models", fetchImpl = compatFetch, timeoutMs = 8000, headers = {} } = {}) {
+export async function probeTunnel({ port, baseUrl = "https://opencode.ai", path = "/zen/v1/models", fetchImpl = compatFetch, timeoutMs = 8000, headers = {}, wantText = false } = {}) {
   const { ProxyAgent } = getUndici();
   const agent = new ProxyAgent({ uri: `http://127.0.0.1:${port}`, connections: 2, keepAliveTimeout: 10_000 });
   try {
@@ -144,7 +145,10 @@ export async function probeTunnel({ port, baseUrl = "https://opencode.ai", path
       signal: AbortSignal.timeout(timeoutMs),
       dispatcher: agent,
     });
-    return { ok: res.ok, status: res.status };
+    const base = { ok: res.ok, status: res.status };
+    if (!wantText) return base;
+    const text = await res.text().catch(() => "");
+    return { ...base, text: String(text).slice(0, 2000) };
   } catch (e) {
     return { ok: false, status: 0, error: String(e?.message || e) };
   } finally {