mslxdff 0.1.177 → 0.1.179

package/package.json

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

package/src/warp-pool/config.js

@@ -2,9 +2,9 @@
 import { join } from "node:path";
 import { logDir } from "../logs.js";
 
-/** 缺省关：2026-10-16 真机实测证伪「N 设备 = N 桶」（免费版 WARP 的 IPv4 出口是共享 NAT，见 ADR-0059 修订）。 */
+/** 缺省开 + 429 时换身份换出口：他项目真机实测「同一身份连发 3 次 429，身份一换同一个请求立刻 200」⇒ 换身份＝换桶。 */
 export const DEFAULTS = {
-  enabled: false,
+  enabled: true,
   mode: "leader",
   count: 4,
   basePort: 10800,
@@ -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,14 +1,15 @@
 // warp-pool · 装配入口。
 //
-// 定位（见 MODULES.md §0/§10）：WARP 池是**增量**出口，不是替代成员自身出口。开关缺省**关**——
-// 2026-10-16 真机实测证伪「N 设备 = N 桶」（免费版 WARP 的 IPv4 出口是共享 NAT）；设 MSLXDFF_WARP_POOL=1 才建池。
+// 定位（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";
-import { createReviver, labelExits } from "./revive.js";
+import { createReviver, labelExits, tailReason } from "./revive.js";
+import { portInUse, reclaimPort } from "./ports.js";
+import { wireRotation } from "./identity.js";
 
 /** 重拨节流：连续失败指数退避。网络不通的机器绝不能让重注册把 CF 刷到 429。 */
 const REDIAL_MIN_GAP_MS = 5 * 60_000;
@@ -44,7 +45,10 @@ 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();
 
@@ -52,11 +56,19 @@ export function createWarpPool({
   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);
+    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, log });
+  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;
@@ -71,23 +83,40 @@ export function createWarpPool({
     }
   });
 
+  /** 起一条隧道的完整动作：清残留 → 写 conf → 确认端口真空着 → spawn → 记表。 */
   async function bringUp(node) {
+    await reclaimPort({ dir: cfg.dir, port: node.port, log }); // 清上一代孤儿（daemon 被强杀时子进程不会自己退）
     writeTunnelConf(cfg.dir, node);
     if (tunnels.has(node.port)) return;
+    if (await portInUse(node.port)) {
+      throw new Error(`端口 :${node.port} 已被非本池进程占用，拒绝再起（硬起只会 bind 失败、无限重启刷屏）`);
+    }
     const t = start({
       binPath,
       dir: cfg.dir,
       port: node.port,
       log,
-      onExit: ({ port, code }) => {
+      onExit: ({ port, code, signal, tail }) => {
         tunnels.delete(port);
-        log(`[warp-pool] 隧道 :${port} 退出（code=${code}），尝试复活`);
+        const why = tailReason(tail) || "进程没留下任何输出";
+        log(`[warp-pool] :${port} 隧道意外退出（退出码 ${code}${signal ? `，信号 ${signal}` : ""}）：${why}`);
         void reviver.onExit(port);
       },
     });
     tunnels.set(node.port, t);
+    log(`[warp-pool] :${node.port} 隧道已起：HTTP 代理 http://127.0.0.1:${node.port} → 经 WARP 出网（pid ${t.pid ?? "?"}）`);
   }
 
+  // 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);
@@ -97,14 +126,14 @@ export function createWarpPool({
       const why = !cfg.bin && !resolveAsset()
         ? `本平台（${process.platform}-${process.arch}）无预编译 wireproxy，如需启用请设 MSLXDFF_WARP_BIN`
         : String(e?.message || e);
-      log(`[warp-pool] 出口池跳过：${why}`);
+      log(`[warp-pool] 出口池本次跳过（不启用，请求走直连）：${why}`);
       return;
     }
     if (closed) return;
 
     // 1. 复用磁盘上已注册的节点
     let nodes = loadNodes(cfg.dir, cfg.ports);
-    log(`[warp-pool] 已有节点 ${nodes.length}/${cfg.count}`);
+    log(`[warp-pool] 复用磁盘上已注册的身份 ${nodes.length}/${cfg.count} 个（端口 ${cfg.ports.join(", ")}；缺的现场注册）`);
 
     // 2. 补足：逐个注册（拉长间隔，避免 CF 注册限流与同网段撞车）
     const used = new Set(nodes.map((n) => n.port));
@@ -118,9 +147,9 @@ export function createWarpPool({
         const node = nodeFromReg(port, reg, now);
         saveNode(cfg.dir, node);
         nodes.push(node);
-        log(`[warp-pool] 注册节点 :${port}（v6=${reg.v6}）`);
+        log(`[warp-pool] 注册新身份 :${port} 成功（设备 v6=${reg.v6}，WireGuard 密钥对在本地生成）`);
       } catch (e) {
-        log(`[warp-pool] 注册节点 :${port} 失败：${String(e?.message || e)}`);
+        log(`[warp-pool] :${port} 注册身份失败，本轮跳过这个端口：${String(e?.message || e)}`);
       }
     }
 
@@ -129,7 +158,7 @@ export function createWarpPool({
       try {
         await bringUp(n);
       } catch (e) {
-        log(`[warp-pool] 起隧道 :${n.port} 失败：${String(e?.message || e)}`);
+        log(`[warp-pool] :${n.port} 起隧道失败，这个端口本轮不可用：${String(e?.message || e)}`);
       }
     }
 
@@ -139,17 +168,17 @@ export function createWarpPool({
       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 || "?"}），不进池`);
+      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} 个节点`);
+      log(`[warp-pool] 出口池就绪：${live.length} 条隧道可用（选路策略 ${cfg.strategy}${cfg.rotate ? "，撞 429 会自动换身份换出口" : ""}）`);
     } else {
-      log("[warp-pool] 无可用节点，保持直连");
+      log("[warp-pool] 没有一条隧道探通 ⇒ 池为空，全部请求照旧直连（不影响可用性，只是没多出口）");
     }
 
     // 5. 出口取证：把每台设备的真实出口地址打进日志（免费版 WARP 的 IPv4 是共享 NAT，N 台设备很可能折叠成同一个出口）
-    if (live.length) await labelExits({ ports: live.map((n) => n.port), log });
+    if (live.length) rotator.noteExits(await labelExits({ ports: live.map((n) => n.port), log }));
   }
 
   const monitor = createHealthMonitor({
@@ -208,6 +237,7 @@ export function createWarpPool({
       if (closed) return;
       closed = true;
       monitor.stop();
+      reviver.stop();
       for (const t of tunnels.values()) {
         try {
           t.stop();
@@ -224,6 +254,7 @@ export function createWarpPool({
         dir: cfg.dir,
         tunnels: tunnels.size,
         nodes: dispatcher.stats(),
+        exits: rotator ? rotator.stats() : [],
       };
     },
   };

package/src/warp-pool/ports.js

@@ -0,0 +1,110 @@
+// warp-pool · 端口占用与「上一代进程残留」清理（2026-10-16 组长 VPS 真机事故后新增）。
+//
+// 事故：daemon 被强杀（WMI TerminateProcess / taskkill /F）时 `process.once("exit")` 钩子不执行，
+// wireproxy 子进程变成孤儿，继续占着 127.0.0.1:10800+ 这些端口。新 daemon 再起隧道就 bind 失败
+// （wireproxy 立刻退出 code=1），而旧代码把「spawn 成功」当成「复活成功」⇒ 无限重启、日志刷屏、
+// 且该端口的隧道永远起不来。治本是「起隧道前先把自家残留清掉」，并「端口被别人占着就别硬起」。
+import { readFileSync, readdirSync } from "node:fs";
+import { connect } from "node:net";
+import { nodePaths } from "./nodes.js";
+
+/** /proc/<pid>/cmdline 是 NUL 分隔的字节串；切成参数数组（丢掉结尾空串）。 */
+export function parseCmdline(buf) {
+  return String(buf == null ? "" : buf).split("\0").filter((s) => s !== "");
+}
+
+/**
+ * 该进程是不是「正在跑我们这条 conf」的 wireproxy。
+ * 判据刻意收紧（argv 里得有 wireproxy 这个可执行文件名，且 conf 路径逐字相等），
+ * 免得误杀别人的进程。缺一不可。
+ */
+export function isOurWireproxy(argv, conf) {
+  const list = Array.isArray(argv) ? argv : [];
+  const isBin = list.some((a) => /(^|[\\/])wireproxy(\.exe)?$/i.test(a));
+  return isBin && list.includes(conf);
+}
+
+function defaultPids() {
+  try {
+    return readdirSync("/proc").filter((f) => /^\d+$/.test(f)).map(Number);
+  } catch {
+    return [];
+  }
+}
+
+function defaultCmdline(pid) {
+  try {
+    return parseCmdline(readFileSync(`/proc/${pid}/cmdline`));
+  } catch {
+    return [];
+  }
+}
+
+/** 进程是否还在（信号 0 = 只做存在性检查，不真发信号）。 */
+export function pidAlive(pid, kill = process.kill) {
+  try {
+    kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 清掉「占着该端口那条 conf」的上一代 wireproxy。返回被清理的 pid 列表。
+ * 非 Linux 直接返回 []（读不到 /proc，别拿别的平台做危险猜测）。
+ * @param {{ dir: string, port: number, log?: Function, platform?: string,
+ *           pids?: Function, cmdline?: Function, kill?: Function, sleep?: Function, waitRounds?: number }} opts
+ */
+export async function reclaimPort({
+  dir,
+  port,
+  log = () => {},
+  platform = process.platform,
+  pids = defaultPids,
+  cmdline = defaultCmdline,
+  kill = process.kill,
+  sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
+  waitRounds = 15,
+} = {}) {
+  if (platform !== "linux") return [];
+  const conf = nodePaths(dir, port).conf;
+  const targets = pids().filter((pid) => isOurWireproxy(cmdline(pid), conf));
+  if (!targets.length) return [];
+
+  log(
+    `[warp-pool] 端口 :${port} 发现上一代 wireproxy 残留（pid ${targets.join(", ")}）：` +
+      `daemon 被强杀时子进程不会自己退出，它会一直占着端口让新隧道 bind 失败。先清掉再起。`,
+  );
+  for (const pid of targets) {
+    try {
+      kill(pid, "SIGTERM");
+    } catch {}
+  }
+  for (let i = 0; i < waitRounds && targets.some((p) => pidAlive(p, kill)); i++) await sleep(100);
+  for (const pid of targets.filter((p) => pidAlive(p, kill))) {
+    try {
+      kill(pid, "SIGKILL");
+    } catch {}
+  }
+  return targets;
+}
+
+/** 该端口是否已有人在监听（TCP 连得上 = 占用；连不上/被拒 = 空闲）。 */
+export function portInUse(port, { host = "127.0.0.1", timeoutMs = 800, connectFn = connect } = {}) {
+  return new Promise((resolve) => {
+    let done = false;
+    const sock = connectFn({ host, port });
+    const finish = (v) => {
+      if (done) return;
+      done = true;
+      try {
+        sock.destroy();
+      } catch {}
+      resolve(v);
+    };
+    sock.setTimeout(timeoutMs, () => finish(false));
+    sock.once("connect", () => finish(true));
+    sock.once("error", () => finish(false));
+  });
+}

package/src/warp-pool/revive.js

@@ -1,14 +1,14 @@
 // warp-pool · 复活与取证（真机事故后新增，2026-10-16）。
 //
-// 两件事，都来自组长 VPS 上暴露的缺陷：
+// 三件事，都来自组长 VPS 上暴露的缺陷：
 //
-// 1. `revive`: 隧道进程意外退出后**必须自愈**。原先 `onExit` 只把端口从表里删掉、打一行日志就完事，
-//    而唯一的补拉路径 `onExhausted` 要求「全池不通」——3 条活着时探活一直成功，那条死隧道
-//    就**再也不会被拉起**，池静默从 4 降到 3，直到 daemon 重启。（真机：:10800 死了就一直死。）
-//    注意：复活走**磁盘上已有的 conf**（不重新注册）——进程挂了不代表设备失效，重注册只会白烧 CF 配额。
+// 1. 隧道退出后必须自愈：原先只有「全池不通」才补拉，一条死隧道会让池静默从 4 降到 3，直到 daemon 重启。
+// 2. 入池后必须实测各节点真实出口：WARP 的 IPv4 出口是共享 NAT，「N 设备」很可能折叠成一个出口。
+// 3. 复活必须**真的活下来**（2026-10-16 组长 VPS 事故）：`tunnels.has(port)` 只证明「spawn 被调用了」，
+//    wireproxy 起一条死一条（端口被上一代孤儿进程占着 ⇒ bind 失败 ⇒ 退出码 1），旧逻辑次次判「已复活」
+//    ⇒ 下一次退出立刻再复活 ⇒ 无限重启刷屏，该端口永远起不来。
 //
-// 2. `labelExits`: 入池后实测各节点**真实出口地址**并标注撞车。WARP 的 IPv4 出口是共享 NAT，
-//    「N 设备」很可能折叠成一个出口；没有这条读数就只能靠人手工 curl 才发现。
+// 复活只走**磁盘上已有的 conf**：进程挂了 ≠ 设备失效，重注册只会白烧 CF 配额。
 import { probeTunnel } from "./wireproxy.js";
 
 /** 出口取证目标：Cloudflare 自己的 trace 端点，回 `ip=` 一行（不烧上游 token）。 */
@@ -20,12 +20,20 @@ export function parseExitIp(text) {
   return m ? m[1] : "";
 }
 
+/** 子进程末行输出当退出原因（wireproxy 的真实报错都在 stderr）；没有输出返回 ""。 */
+export function tailReason(tail, max = 300) {
+  const lines = String(tail || "").split("\n").map((s) => s.trim()).filter(Boolean);
+  return lines.length ? lines[lines.length - 1].slice(0, max) : "";
+}
+
 /**
  * 按端口独立的退避复活器。
- * @param {{ revive: (port:number)=>Promise<boolean>, minGapMs?: number, maxGapMs?: number,
- *           now?: ()=>number, log?: (s:string)=>void }} opts
+ * @param {{ revive: (port:number)=>Promise<boolean>, isAlive?: (port:number)=>boolean, minGapMs?: number,
+ *           maxGapMs?: number, settleMs?: number, now?: ()=>number, sleep?: Function,
+ *           schedule?: Function, cancel?: Function, log?: (s:string)=>void }} opts
+ * 复活是否算数由 `isAlive` 在 `settleMs` 后复查；失败按指数退避并**自己用定时器安排下一次重试**。
  */
-export function createReviver({ revive, minGapMs = 30_000, maxGapMs = 10 * 60_000, now = Date.now, log = () => {} } = {}) {
+export function createReviver({ revive, isAlive, minGapMs = 30_000, maxGapMs = 10 * 60_000, settleMs = 1_200, now = Date.now, sleep = (ms) => new Promise((r) => setTimeout(r, ms)), schedule = (fn, ms) => setTimeout(fn, ms), cancel = (h) => clearTimeout(h), log = () => {} } = {}) {
   /** @type {Map<number, {attempts:number, nextAt:number, busy:boolean}>} */
   const state = new Map();
 
@@ -38,37 +46,71 @@ export function createReviver({ revive, minGapMs = 30_000, maxGapMs = 10 * 60_00
     return s;
   }
 
+  /** @type {Map<number, object>} 每端口最多一个待触发的重试定时器 */
+  const timers = new Map();
+
+  /** 安排「到点自动重试」；没有它，日志里那句「N s 后自动再试」就是空话。 */
+  function armRetry(port, ms) {
+    if (timers.has(port)) return;
+    const h = schedule(() => {
+      timers.delete(port);
+      void attempt(port);
+    }, Math.max(0, ms));
+    if (h && typeof h.unref === "function") h.unref();
+    timers.set(port, h);
+  }
+
+  /**
+   * 复活一次：首次立即复活，失败按 30s→10min 指数退避并自己安排下一次重试。
+   * 复活算不算数由 `isAlive` 在 `settleMs` 后复查——不许拿「spawn 被调用了」冒充「活下来了」。
+   */
+  async function attempt(port) {
+    const s = entry(port);
+    if (s.busy) return false;
+    const wait = Math.max(0, s.nextAt - now());
+    if (wait > 0) {
+      log(`[warp-pool] :${port} 距上次复活不足退避间隔，${Math.ceil(wait / 1000)}s 后再试（防抖动刷屏，不是故障）`);
+      armRetry(port, wait);
+      return false;
+    }
+    s.busy = true;
+    s.attempts += 1;
+    const gap = Math.min(minGapMs * 2 ** (s.attempts - 1), maxGapMs);
+    let ok = false;
+    try {
+      ok = await revive(port);
+    } catch (e) {
+      log(`[warp-pool] :${port} 复活抛出异常：${String(e?.message || e)}`);
+    }
+    if (ok && isAlive) {
+      if (settleMs > 0) await sleep(settleMs);
+      ok = isAlive(port);
+      if (!ok) log(`[warp-pool] :${port} 复活后进程立刻又退出 —— 不认这次复活（原因见上面那条「意外退出」）`);
+    }
+    s.busy = false;
+    if (ok) {
+      const n = s.attempts;
+      s.attempts = 0;
+      s.nextAt = now() + minGapMs; // 稳定期：期间再退出先等一轮，防「起一条死一条」把日志刷爆
+      log(`[warp-pool] :${port} 已复活（第 ${n} 次尝试成功）；${Math.round(minGapMs / 1000)}s 内若又退出会先等一轮再重启`);
+      return true;
+    }
+    s.nextAt = now() + gap;
+    const hint = s.attempts >= 3 ? ` 排查：ss -ltnp | grep :${port}；或前台跑隧道二进制 -c node-${port}.conf 看真实报错` : "";
+    log(`[warp-pool] :${port} 复活未成功（第 ${s.attempts} 次），${Math.round(gap / 1000)}s 后自动再试。${hint}`);
+    armRetry(port, gap);
+    return false;
+  }
+
   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;
-    },
-    /** 探活成功时调用：清掉退避账，恢复正常节奏。 */
+    onExit: (port) => attempt(port),
+    /** 探活成功时调用：清掉退避账与待触发定时器，恢复正常节奏。 */
     noteHealthy(port) {
+      const h = timers.get(port);
+      if (h) {
+        try { cancel(h); } catch {}
+        timers.delete(port);
+      }
       state.delete(port);
     },
     stats() {
@@ -79,6 +121,15 @@ export function createReviver({ revive, minGapMs = 30_000, maxGapMs = 10 * 60_00
         cooldownMsLeft: Math.max(0, s.nextAt - now()),
       }));
     },
+
+    /** 池关闭时调用：别再有定时器去打复活。 */
+    stop() {
+      for (const h of timers.values()) {
+        try { cancel(h); } catch {}
+      }
+      timers.clear();
+      state.clear();
+    },
   };
 }
 
@@ -108,10 +159,10 @@ export async function labelExits({ ports = [], fetchImpl, timeoutMs = 12_000, lo
 
   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）`);
+    log(`[warp-pool] ⚠ 出口不分散：${groups[0].nodes.length} 条隧道同时在线只有 1 个出口地址（${groups[0].ip}）：免费版 WARP 的 IPv4 是共享 NAT，多开隧道换不到多份名额；多份名额靠撞 429 时的身份轮换`);
   } else if (groups.length > 1) {
-    log(`[warp-pool] 出口分散：${groups.length} 个不同地址 / ${groups.reduce((a, g) => a + g.nodes.length, 0)} 个节点`);
+    log(`[warp-pool] 出口分散：${groups.length} 个出口地址 / ${groups.reduce((a, g) => a + g.nodes.length, 0)} 条隧道同时在线（同时在线就有 ${groups.length} 份上游名额）`);
   }
-  if (failed) log(`[warp-pool] ${failed} 个节点出口取证失败（不影响其进池）`);
+  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 池关闭。 */