mslxdff 0.1.177 → 0.1.178

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.177",
+  "version": "0.1.178",
   "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,7 +1,6 @@
 // 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";
@@ -9,6 +8,7 @@ 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 { wireRotation } from "./identity.js";
 
 /** 重拨节流：连续失败指数退避。网络不通的机器绝不能让重注册把 CF 刷到 429。 */
 const REDIAL_MIN_GAP_MS = 5 * 60_000;
@@ -44,7 +44,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();
 
@@ -88,6 +91,16 @@ export function createWarpPool({
     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);
@@ -149,7 +162,7 @@ export function createWarpPool({
     }
 
     // 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({
@@ -224,6 +237,7 @@ export function createWarpPool({
         dir: cfg.dir,
         tunnels: tunnels.size,
         nodes: dispatcher.stats(),
+        exits: rotator ? rotator.stats() : [],
       };
     },
   };

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 池关闭。 */