mslxdff 0.1.176 → 0.1.178

package/package.json

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

package/src/warp-pool/config.js

@@ -2,7 +2,7 @@
 import { join } from "node:path";
 import { logDir } from "../logs.js";
 
-/** 缺省即开：组长升级/重启后无需改任何环境变量即可生效；不想用的节点设 MSLXDFF_WARP_POOL=0。 */
+/** 缺省开 + 429 时换身份换出口：他项目真机实测「同一身份连发 3 次 429，身份一换同一个请求立刻 200」⇒ 换身份＝换桶。 */
 export const DEFAULTS = {
   enabled: true,
   mode: "leader",
@@ -14,6 +14,7 @@ export const DEFAULTS = {
   registerMinGapMs: 6_000,
   registerMaxGapMs: 15_000,
   probePath: "/zen/v1/models",
+  rotate: true,
 };
 
 const OFF = ["0", "off", "false", "no", "disable", "disabled"];
@@ -50,6 +51,7 @@ export function resolveWarpConfig(env = process.env, { logDirFn = logDir } = {})
   const bin = envStr(env, "MSLXDFF_WARP_BIN", "");
   const autodownload = envBool(env, "MSLXDFF_WARP_AUTODOWNLOAD", DEFAULTS.autodownload);
   const probePath = envStr(env, "MSLXDFF_WARP_PROBE_PATH", DEFAULTS.probePath);
+  const rotate = envBool(env, "MSLXDFF_WARP_ROTATE", DEFAULTS.rotate);
 
   return {
     enabled,
@@ -63,6 +65,7 @@ export function resolveWarpConfig(env = process.env, { logDirFn = logDir } = {})
     bin,
     autodownload,
     probePath,
+    rotate,
     registerMinGapMs: DEFAULTS.registerMinGapMs,
     registerMaxGapMs: DEFAULTS.registerMaxGapMs,
     /** 节点端口列表：basePort .. basePort+count-1 */

package/src/warp-pool/identity.js

@@ -0,0 +1,141 @@
+// 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,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 池是**增量**出口，不是替代成员自身出口；缺省**开**，MSLXDFF_WARP_POOL=0 关。
 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, probeTunnel, resolveAsset, startTunnel, writeTunnelConf } from "./wireproxy.js";
-/** 重拨节流：连续失败指数退避。缺省开之后，网络不通的机器绝不能让重注册把 CF 刷到 429。 */
+import { createReviver, labelExits } from "./revive.js";
+import { wireRotation } from "./identity.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({
@@ -42,9 +44,22 @@ export function createWarpPool({
   const cfg = resolveWarpConfig(env);
   if (!cfg.active) return null;
 
-  const dispatcher = createRotatingDispatcher({ nodes: [], strategy: cfg.strategy, cooldownMs: cfg.cooldownMs, log });
+  /** 身份轮换器：429 时换一台 WARP 设备换出口 IP（串行换身份，见 identity.js 头注）。 */
+  let rotator = null;
+
+  const dispatcher = createRotatingDispatcher({ nodes: [], strategy: cfg.strategy, cooldownMs: cfg.cooldownMs, log, onStatus: (status, port) => { if (status === 429 && cfg.rotate && rotator) void rotator.rotate(port); } });
   /** @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;
@@ -69,12 +84,23 @@ 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);
   }
 
+  // 429 ＝ 上游按出口 IP 计的名额耗尽 ⇒ 换一台设备的身份换出口（换身份＝换桶）。
+  rotator = wireRotation({
+    dispatcher,
+    register,
+    tunnels,
+    bringUp,
+    swap: (port, node) => { removeNode(cfg.dir, port); saveNode(cfg.dir, node); },
+    log,
+  });
+
   async function bootstrap() {
     if (closed) return;
     ensureDir(cfg.dir);
@@ -102,17 +128,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}）`);
@@ -130,9 +146,7 @@ export function createWarpPool({
       }
     }
 
-    // 4. **入池前实测探活**：只判「进程还活着」不够——WARP 握手不通时 wireproxy 进程照样在跑却转不动流量
-    //    （实测经它 curl 挂到超时，不是快速失败）。那种节点一旦进池，dispatcher 会把**所有** opencode
-    //    请求派给它 ⇒ opencode 整体被黑洞而非直连兜底。探活打上游 models 路径，不烧 token。
+    // 入池前实测探活：WARP 握手不通时 wireproxy 进程照样在跑却转不动流量（挂到超时），那种节点进池会黑洞全部请求
     const live = [];
     for (const n of nodes) {
       if (!tunnels.has(n.port)) continue;
@@ -146,6 +160,9 @@ export function createWarpPool({
     } else {
       log("[warp-pool] 无可用节点，保持直连");
     }
+
+    // 5. 出口取证：把每台设备的真实出口地址打进日志（免费版 WARP 的 IPv4 是共享 NAT，N 台设备很可能折叠成同一个出口）
+    if (live.length) rotator.noteExits(await labelExits({ ports: live.map((n) => n.port), log }));
   }
 
   const monitor = createHealthMonitor({
@@ -154,9 +171,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] 隧道均存活但全池不通，判定为网络路径问题，跳过重拨");
@@ -177,17 +192,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)}`);
@@ -195,7 +200,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}` })));
       }
@@ -232,24 +237,20 @@ export function createWarpPool({
         dir: cfg.dir,
         tunnels: tunnels.size,
         nodes: dispatcher.stats(),
+        exits: rotator ? rotator.stats() : [],
       };
     },
   };
 }
 
-
-/**
- * 只取轮换 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/rotate.js

@@ -20,9 +20,21 @@ export function headerValue(headers, name) {
   return "";
 }
 
+/** 让 dispatcher 看见上游状态码：复制一层 handler，只截 onHeaders，其余方法原样转发（全部调用都落在副本上，this 一致）。 */
+export function tapHandler(handler, tap) {
+  if (!tap || !handler || typeof handler !== "object") return handler;
+  const out = Object.assign(Object.create(Object.getPrototypeOf(handler)), handler);
+  const orig = handler.onHeaders;
+  out.onHeaders = function (statusCode, headers, resume, statusText) {
+    try { tap(statusCode); } catch {}
+    return typeof orig === "function" ? orig.call(this, statusCode, headers, resume, statusText) : undefined;
+  };
+  return out;
+}
+
 /**
  * @param {{ nodes?: Array<{port:number, uri:string}>, strategy?: "session"|"request",
- *           cooldownMs?: number, now?: () => number, log?: (s:string)=>void,
+ *           cooldownMs?: number, now?: () => number, log?: (s:string)=>void, onStatus?: (status:number, port:number)=>void,
  *           agentOptions?: object, selector?: object }} [opts]
  */
 export function createRotatingDispatcher({
@@ -31,6 +43,7 @@ export function createRotatingDispatcher({
   cooldownMs = 600_000,
   now = Date.now,
   log = () => {},
+  onStatus = null,
   agentFactory,
   fallbackAgent,
   agentOptions = { connections: 8, keepAliveTimeout: 30_000, keepAliveMaxTimeout: 60_000, pipelining: 1 },
@@ -40,7 +53,7 @@ export function createRotatingDispatcher({
   if (typeof ProxyAgent !== "function") throw new Error("undici ProxyAgent 不可用：无法建立出口池");
   // 空池兜底：直连（等价 R3 里被顶掉的 keepAlive 池）。
   const fallback = fallbackAgent !== undefined ? fallbackAgent : typeof Agent === "function" ? new Agent(agentOptions) : null;
-  let list = [];
+  let list = build(nodes);
 
   function build(nodesIn) {
     return (nodesIn || []).map((n, i) => ({
@@ -96,11 +109,11 @@ export function createRotatingDispatcher({
         throw new Error("warp-pool：节点池为空且无直连兜底");
       }
       const avail = availableIndexes();
-      // 全池冷却时兜底用第一个，避免直接失败（宁可撞限流也别把请求打死）。
-      if (!avail.length) return list[0].agent.dispatch(opts, handler);
+      // 全池冷却 ⇒ 直连兜底优先：硬派给已知不可用的节点 = 把请求挂到超时。
+      if (!avail.length) return (fallback || list[0].agent).dispatch(opts, handler);
       const sessionKey = strategy === "session" ? headerValue(opts?.headers, SESSION_HEADER) : "";
-      const idx = selector.pick(avail, sessionKey);
-      return list[idx].agent.dispatch(opts, handler);
+      const e = list[selector.pick(avail, sessionKey)];
+      return e.agent.dispatch(opts, tapHandler(handler, onStatus ? (sc) => onStatus(sc, e.port) : null));
     },
 
     /** 运行期换上一批出口（bootstrap 完成后调用）；旧 Agent 池关闭。 */

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 {