mslxdff 0.1.244 → 0.1.246

package/src/v6pool/rotate.js

@@ -1,263 +0,0 @@
-// v6pool · 槽位 dispatcher：每槽一个源地址 + 一个自带 `localAddress` 的 undici Agent。
-//
-// 契约与 warp-pool 的轮换 dispatcher 一致：`dispatch(opts, handler)` + `close()`，
-// 注入点同为 `transport` 的 extDispatcher（legacy 与 SDK 两条路共用同一个对象，见 MODULES.md §1）。
-//
-// 与 WARP 池的差别只在「换出口」这一步：
-//   WARP：重注册设备 + 重启隧道（实测 5~8 秒，还会被 CF 注册限流）
-//   v6  ：从前缀里挑一个新地址（≈0 成本：只多一条 `ip addr add`，bind 模式下连这条都省）
-// 判决表照旧复用 warp-pool/verdict.js（403 FreeTierError 与 429 FreeUsageLimitError 同一条件 ⇒ 强制换）。
-//
-// 两个刻意的设计：
-//   ① 换址**不重置**旧槽的冷却账，而是把旧地址推进 retiring：先关旧 Agent、延后释放地址，
-//      在飞请求（SSE 长连接）不会因为源地址被抽走而断。retiring 有硬上限 RETAIN_MAX。
-//   ② 每次响应都记账（不只 403/429）：`fmtFirstOk` 那行「新地址首个 200」就是
-//      「429 换 IP 到底有没有换来新额度」的直接证据——这正是本次要回答的问题。
-import { getUndici } from "../compat.js";
-import { headerValue, tapHandler } from "../warp-pool/rotate.js";
-import { createSelector } from "../warp-pool/strategy.js";
-import { SIGNAL_STATUSES, classifyWarpSignal } from "../warp-pool/verdict.js";
-import { fmtDirect, fmtDispatch, fmtFirstOk, fmtNoRotate, fmtRetire, fmtSwap, fmtSwapFail, fmtVerdictNo } from "./report.js";
-
-const SESSION_HEADER = "x-opencode-session";
-
-/** 最多留几个「已换下但地址还在网卡上」的旧出口：保护在飞请求，同时给地址数量一个硬上限。 */
-export const RETAIN_MAX = 8;
-/** 挑新地址时最多重试几次（前缀太小/已在用的地址太多时会一直撞）。 */
-export const PICK_TRIES = 16;
-
-/**
- * @param {{ addrs?: string[], strategy?: "session"|"request", retireMs?: number, rotate?: boolean, debug?: boolean,
- *           now?: () => number, log?: (s: string) => void, claimer?: object|null, pickAddress?: () => string,
- *           agentFactory?: (addr: string) => object, agentOptions?: object, fallbackAgent?: object, selector?: object }} [opts]
- */
-export function createV6Dispatcher({
-  addrs = [],
-  strategy = "session",
-  retireMs = 60_000,
-  rotate = true,
-  debug = false,
-  now = Date.now,
-  log = () => {},
-  claimer = null,
-  pickAddress = () => "",
-  agentFactory,
-  agentOptions = { connections: 4, pipelining: 1, keepAliveTimeout: 30_000, keepAliveMaxTimeout: 60_000 },
-  fallbackAgent,
-  selector = createSelector({ strategy }),
-} = {}) {
-  const { Agent } = getUndici();
-  if (typeof agentFactory !== "function") {
-    if (typeof Agent !== "function") throw new Error("undici Agent 不可用：无法建立 v6 出口池");
-    agentFactory = (addr) => new Agent({ connect: { localAddress: addr }, ...agentOptions });
-  }
-  const fallback = fallbackAgent !== undefined ? fallbackAgent : typeof Agent === "function" ? new Agent(agentOptions) : null;
-
-  let list = [];
-  /** @type {Array<{addr:string, agent:object, at:number, release:null|Function, counts:object, swaps:number}>} */
-  const retiring = [];
-  const history = [];
-  let directWarned = false;
-
-  function buildSlot(index, addr) {
-    return { index, addr, agent: agentFactory(addr), cooldownUntil: 0, swaps: 0, swapping: false, counts: {}, firstOkAt: 0 };
-  }
-
-  /** 装上源地址（bootstrap 探活通过后调用；空数组 = 池为空 ⇒ 直连兜底）。 */
-  function setAddresses(next = []) {
-    list = (next || []).map((a, i) => buildSlot(i, a));
-    return list.length;
-  }
-  // 构造时就装上地址（与 warp-pool 的轮换 dispatcher 同形状：入参即初始池）。
-  setAddresses(addrs);
-
-  function availableIndexes() {
-    const t = now();
-    return list.filter((e) => e.cooldownUntil <= t && !e.swapping).map((e) => e.index);
-  }
-
-  /** 退休账结算：只有「已过退休时长」且「超出保留上限」的才真关+真释放（close 时 force 全清）。 */
-  async function flushRetired({ force = false } = {}) {
-    const sorted = [...retiring].sort((a, b) => a.at - b.at);
-    const over = Math.max(0, sorted.length - RETAIN_MAX);
-    const keep = [];
-    for (let i = 0; i < sorted.length; i++) {
-      const r = sorted[i];
-      const aged = now() - r.at >= retireMs;
-      if (!force && !(aged && i < over)) {
-        keep.push(r);
-        continue;
-      }
-      try {
-        await r.agent?.close?.();
-      } catch {
-        /* 关不掉旧 Agent 不影响新出口 */
-      }
-      if (r.release) {
-        try {
-          await r.release();
-        } catch {
-          /* 释放失败已由 claim.js 自己打日志 */
-        }
-      }
-      history.push({ addr: r.addr, swaps: r.swaps, counts: { ...r.counts } });
-      if (history.length > 32) history.shift();
-      log(fmtRetire({ addr: r.addr }));
-    }
-    retiring.length = 0;
-    retiring.push(...keep);
-  }
-
-  /** 换该槽的源地址：挑新地址 → 认领 → 建新 Agent → 旧 Agent 退休（先关 Agent 再延后释放地址）。 */
-  async function swap(index, verdict = {}) {
-    const e = list[index];
-    if (!e) return { skipped: true };
-    if (e.swapping) return { skipped: true, reason: "该槽已在换址中" };
-    e.swapping = true;
-    try {
-      const taken = new Set(list.map((s) => s.addr));
-      let addr = "";
-      for (let i = 0; i < PICK_TRIES && (!addr || taken.has(addr)); i++) addr = pickAddress();
-      if (!addr || taken.has(addr)) throw new Error(`前缀里连续 ${PICK_TRIES} 次都撞上已在用的地址（前缀太小？）`);
-      if (claimer) await claimer.ensure(addr);
-      const oldAddr = e.addr;
-      const prevCounts = { ...e.counts };
-      const prevSwaps = e.swaps;
-      retiring.push({
-        addr: oldAddr,
-        agent: e.agent,
-        at: now(),
-        release: claimer ? () => claimer.release(oldAddr) : null,
-        counts: prevCounts,
-        swaps: prevSwaps,
-      });
-      e.addr = addr;
-      e.agent = agentFactory(addr);
-      e.cooldownUntil = 0;
-      e.swaps = prevSwaps + 1;
-      e.counts = {};
-      e.firstOkAt = 0;
-      log(fmtSwap({ from: oldAddr, to: addr, status: verdict.status, kind: verdict.kind, forced: verdict.forced, swaps: e.swaps, prevCounts }));
-      await flushRetired();
-      return { ok: true, from: oldAddr, to: addr };
-    } finally {
-      e.swapping = false;
-    }
-  }
-
-  /** 上游响应旁听：记账 → 换址后首个 200 的取证行 → 配额信号才换址。 */
-  function onTap(signal, e) {
-    const status = Number(signal?.status);
-    e.counts[status] = (e.counts[status] || 0) + 1;
-    if (status === 200 && !e.firstOkAt) {
-      e.firstOkAt = now();
-      log(fmtFirstOk({ addr: e.addr, swaps: e.swaps, counts: e.counts }));
-    }
-    if (!SIGNAL_STATUSES.includes(status)) return;
-    const v = classifyWarpSignal(signal);
-    if (!rotate) {
-      log(fmtNoRotate({ addr: e.addr, status, kind: v.kind }));
-      return;
-    }
-    if (!v.rotate) {
-      log(fmtVerdictNo({ addr: e.addr, status, kind: v.kind, why: v.why }));
-      return;
-    }
-    const addr = e.addr;
-    void swap(e.index, { ...v, status }).catch((err) => log(fmtSwapFail({ addr, error: String(err?.message || err) })));
-  }
-
-  return {
-    /** 每次请求调一次 = 选槽粒度（session 策略下同会话粘同一源地址）。 */
-    dispatch(opts, handler) {
-      if (!list.length) {
-        if (fallback) return fallback.dispatch(opts, handler);
-        throw new Error("v6pool：源地址池为空且无直连兜底");
-      }
-      const avail = availableIndexes();
-      if (!avail.length) {
-        // 全池都在冷却/换址中 ⇒ 直连兜底优先：硬派给正在换址的槽 = 把请求挂到超时
-        if (!directWarned) {
-          directWarned = true;
-          log(fmtDirect({ reason: `全部 ${list.length} 个源地址都在冷却/换址中（下一条恢复后自动回到池内）` }));
-        }
-        return (fallback || list[0].agent).dispatch(opts, handler);
-      }
-      directWarned = false;
-      const sessionKey = strategy === "session" ? headerValue(opts?.headers, SESSION_HEADER) : "";
-      const e = list[selector.pick(avail, sessionKey)];
-      if (debug) log(fmtDispatch({ addr: e.addr, session: sessionKey || "(无)" }));
-      return e.agent.dispatch(opts, tapHandler(handler, (sig) => onTap(sig, e)));
-    },
-
-    setAddresses,
-
-    /** 手动换某个槽的源地址（供运维/测试；正常路径由配额信号触发）。 */
-    swap,
-
-    /**
-     * G1a（ADR-0061）：**请求内**换出口——撞出口池级 429 后由 upstream.js await 这一发，
-     * 把该会话粘的槽换新源地址，返回**换址完成后**的新 Agent 供同一请求立刻重发。
-     * 与 onTap 的 fire-and-forget 换址（只救下一个请求）不同，这里救的是**在飞请求**。
-     * 仅 v6 池提供本方法：换源地址成本≈0（bind/ip addr add）；WARP 的换出口=重注册设备
-     * （6s~600s，会被 CF 限流），绝不允许在请求内做——白等 N 分钟换不来更快收场。
-     * 空池/全槽换址中/该槽被并发占走 ⇒ 返回 null（调用方正常收场，绝不黑洞）。
-     * 粘性安全：swap 是**原地**换 e.addr/e.agent（index 不变），session→slot 映射不失效。
-     * @param {string} sessionKey x-opencode-session 值（无 key 时由轮转游标挑槽）
-     * @returns {Promise<null | {agent: object, addr: string, from: string}>}
-     */
-    async rotateFor(sessionKey = "") {
-      if (!list.length) return null;
-      const avail = availableIndexes();
-      if (!avail.length) return null;
-      const index = selector.pick(avail, strategy === "session" ? sessionKey : "");
-      const e = list[index];
-      if (!e) return null;
-      const r = await swap(index, { kind: "in-request-rotate", status: 429, forced: true });
-      if (r.skipped) return null;
-      const slot = list[index];
-      return { agent: slot.agent, addr: slot.addr, from: r.from };
-    },
-
-    /** 只读快照（含已退休出口的最终计数——"换址到底有没有换来新额度"看这里）。 */
-    stats() {
-      const t = now();
-      return {
-        slots: list.map((e) => ({ addr: e.addr, cooling: e.cooldownUntil > t, swaps: e.swaps, swapping: e.swapping, counts: { ...e.counts }, firstOk: !!e.firstOkAt })),
-        history: history.map((h) => ({ ...h, counts: { ...h.counts } })),
-      };
-    },
-
-    entries() {
-      return list.map((e) => ({ index: e.index, addr: e.addr, cooldownUntil: e.cooldownUntil, swaps: e.swaps }));
-    },
-
-    async close() {
-      const slots = list;
-      list = [];
-      for (const e of slots) {
-        try {
-          await e.agent?.close?.();
-        } catch {
-          /* 收摊时关不掉就算了 */
-        }
-      }
-      await flushRetired({ force: true });
-      if (fallback) {
-        try {
-          await fallback.close?.();
-        } catch {
-          /* 同上 */
-        }
-      }
-    },
-
-    async destroy() {
-      return this.close();
-    },
-
-    get size() {
-      return list.length;
-    },
-  };
-}

package/src/v6pool/selftest.js

@@ -1,178 +0,0 @@
-// v6pool · 出口对照测试：回答「这台 VPS 的 IPv4 出口撞 429 时，换成 IPv6 出口还有没有额度」。
-//
-// 这才是 v6 池的**唯一价值判据**：opencode 免费层按**出口 IP** 计额。若本机 IPv4 已耗尽
-// （打上游回 429 FreeUsageLimitError），而某个 IPv6 出口还能 200 ⇒ 池有用（换 IP 换到新额度）；
-// 若 IPv6 出口也 429 ⇒ 要么上游按别的东西计额（账号/session），要么该段没真路由出去。
-//
-// 对照纪律：**除"源地址"外一切相同** —— 同 URL、同 UA、同**身份四件套 header**、同模型、同 `stream:true`+五核心工具
-// （免费层要流式+五核心工具+身份头，缺任一项都会 403 FreeTierError 而非 429，测出来的不是额度）；
-// 整轮基线+v6 共用同一个 session。差异只允许来自"哪个源地址出网"。
-// 判定复用 `warp-pool/verdict.js` 的 classifyWarpSignal（与生产换址判决同源，不自造一套）。
-//
-// IO 全部注入（agentFactory/fetch/detect/claimer），零真机依赖，可单测。
-import { getUndici, timeoutSignal } from "../compat.js";
-import { classifyWarpSignal } from "../warp-pool/verdict.js";
-import { opencodeUa, genId } from "../opencode-identity.js";
-import { CORE_AGENT_TOOL_NAMES } from "../free-lane.js";
-import { detectPool } from "./detect.js";
-import { resolveV6Config } from "./config.js";
-import { createClaimer } from "./claim.js";
-import { randomAddress, parsePrefix, hostBitsOf } from "./prefix.js";
-
-/** 采样上限：抽查，不扫全段。 */
-export const V6TEST_MAX = 64;
-export const V6TEST_DEFAULT = 6;
-
-/** 默认探测模型：免费池里最有代表性、额度最容易耗的一个。 */
-export const DEFAULT_PROBE_MODEL = "deepseek-v4.1-flash-free";
-
-/** 免费层请求体形状（stream:true + 五核心工具名），缺了会 403 而非 429 ⇒ 测不出额度。 */
-export function freeLaneBody(model, prompt = "hi") {
-  return {
-    model,
-    stream: true,
-    max_tokens: 16,
-    messages: [{ role: "user", content: prompt }],
-    tools: CORE_AGENT_TOOL_NAMES.map((name) => ({
-      type: "function",
-      function: { name, description: `The ${name} tool.`, parameters: { type: "object", properties: {} } },
-    })),
-  };
-}
-
-/** 读响应正文（有上界，失败给空串——不读就无法判决 403/429 的具名类名）。 */
-async function readBody(res, max = 2048) {
-  try {
-    const t = await res.text();
-    return t.slice(0, max);
-  } catch {
-    return "";
-  }
-}
-
-/** 免费层身份头（与生产 buildHeaders 同源，见 src/upstream.js）：**缺了必 403 FreeTierError**。
- * 实测 2026-10-19：只发 User-Agent → 403；补上 x-opencode-* 四件套 → 200。
- * session 用随机 genId（对照测试测的是"出口 IP"不是"会话亲和"，每个探针独立即可）。 */
-export function freeLaneHeaders({ session = genId("ses_") } = {}) {
-  return {
-    "Content-Type": "application/json",
-    Accept: "text/event-stream",
-    "User-Agent": opencodeUa(),
-    "x-opencode-client": "desktop",
-    "x-opencode-session": session,
-    "x-opencode-request": genId("msg_"),
-    "x-opencode-project": "global",
-    "HTTP-Referer": "https://hermes-agent.nousresearch.com",
-    "X-Title": "Hermes Agent",
-  };
-}
-
-/**
- * 从某个源地址打一次免费层 chat，返回判决。
- * `addr=""` 表示**直连**（走本机默认路由 = IPv4 出口，或双栈默认）。
- * @returns {Promise<{addr, ok, status, kind, rotate, ms, body, error}>}
- */
-export async function probeUpstreamFrom({ addr = "", model, baseUrl = "https://opencode.ai", agentFactory, fetchImpl, timeoutMs = 20_000, prompt, session } = {}) {
-  const t0 = Date.now();
-  let agent = null;
-  try {
-    agent = addr ? agentFactory(addr) : null; // 直连：不注入 dispatcher，走系统默认出口
-    const f = fetchImpl || getUndici().fetch;
-    const res = await f(`${baseUrl}/zen/v1/chat/completions`, {
-      method: "POST",
-      headers: freeLaneHeaders({ session }),
-      body: JSON.stringify(freeLaneBody(model, prompt)),
-      ...(agent ? { dispatcher: agent } : {}),
-      signal: timeoutSignal(timeoutMs),
-    });
-    const body = await readBody(res);
-    const v = classifyWarpSignal({ status: res.status, text: body });
-    return { addr, ok: res.status >= 200 && res.status < 300, status: res.status, kind: v.kind, rotate: v.rotate, ms: Date.now() - t0, body };
-  } catch (e) {
-    return { addr, ok: false, status: 0, kind: "network", rotate: true, ms: Date.now() - t0, body: "", error: String(e?.message || e) };
-  } finally {
-    if (agent) { try { await agent.close?.(); } catch { /* 一次性 Agent */ } }
-  }
-}
-
-/**
- * 跑一次出口对照测试。返回结构化结果，由 CLI 渲染（本模块不打印）。
- *
- * @param {{ env?: object, count?: number, model?: string, baseUrl?: string,
- *           onProgress?: (ev: object) => void,
- *           deps?: { detect?, claimer?, agentFactory?, fetchImpl?, probe?, randomAddress? } }} opts
- */
-export async function runV6PoolCompare({
-  env = process.env,
-  count = V6TEST_DEFAULT,
-  model = DEFAULT_PROBE_MODEL,
-  baseUrl = "https://opencode.ai",
-  onProgress,
-  deps = {},
-} = {}) {
-  const cfg = resolveV6Config(env);
-  const tick = (ev) => { try { onProgress?.(ev); } catch { /* 渲染出错不打断测试 */ } };
-
-  const detect = deps.detect || detectPool;
-  const d = detect({ cfg, env });
-  if (!d.ok) return { status: "skip", reason: d.reason, hint: d.hint };
-  const prefix = parsePrefix(`${d.prefix}`);
-  if (!prefix) return { status: "skip", reason: `前缀解析失败：${d.prefix}`, hint: "用 MSLXDFF_V6_PREFIX=<段>/<位数> 显式指定" };
-
-  const { Agent } = getUndici();
-  const agentFactory = deps.agentFactory || ((addr) => new Agent({ connect: { localAddress: addr }, connections: 1, keepAliveTimeout: 5_000 }));
-  const probe = deps.probe || probeUpstreamFrom;
-  const pick = deps.randomAddress || ((p) => randomAddress(p));
-  // 整轮共用一个 session：对照纪律「除源地址外一切相同」——让差异只可能来自出口 IP，
-  // 而不是会话随机性（免费层按出口 IP 计额，但共用 session 才能把这一点测干净）。
-  const session = deps.session || genId("ses_");
-
-  // ① 基准：直连（IPv4 / 系统默认出口），记下它的额度状态作为对照基线
-  tick({ phase: "baseline-start", prefix: d.prefix, model });
-  const baseline = await probe({ addr: "", model, baseUrl, agentFactory, fetchImpl: deps.fetchImpl, session });
-  tick({ phase: "baseline-done", ...baseline });
-
-  // ② IPv6 池采样：每个随机源地址打同一条请求
-  const n = Math.max(1, Math.min(V6TEST_MAX, Number(count) || V6TEST_DEFAULT));
-  const claimer = deps.claimer ? deps.claimer(d, cfg) : createClaimer({ iface: d.iface, mode: d.mode, dir: cfg.dir });
-  const mineSet = new Set(d.mine || []);
-  const v6 = [];
-  try {
-    for (let i = 0; i < n; i++) {
-      let addr = pick(prefix);
-      for (let k = 0; k < 16 && mineSet.has(addr); k++) addr = pick(prefix);
-      await claimer.ensure(addr);
-      tick({ phase: "v6-start", i: i + 1, n, addr });
-      const r = await probe({ addr, model, baseUrl, agentFactory, fetchImpl: deps.fetchImpl, session });
-      v6.push(r);
-      tick({ phase: "v6-done", i: i + 1, n, ...r });
-    }
-  } finally {
-    try { await claimer.releaseAll(); } catch { /* 释放失败交给下次 sweepStale */ }
-  }
-
-  // ③ 判语：对照基线
-  const baseLimited = baseline.status === 429 || baseline.kind === "free-quota" || baseline.kind === "free-tier" || baseline.kind === "ip-limit";
-  const v6Ok = v6.filter((r) => r.ok);
-  // 受限 = 有 HTTP 响应但拿不到额度（403 FreeTierError / 429 额度 / 其余 4xx-5xx）；
-  // 只有网络层失败（status=0）才算"够不着"。旧实现只认 429，403 全 0/4 时会掉进兜底 "mixed"
-  // 误判成「部分可用」（真机 2026-10-19 实测：4 个 v6 全 403 → 却报 0/4 部分可用）。
-  const v6Limited = v6.filter((r) => !r.ok && r.status);
-  const v6Net = v6.filter((r) => !r.status);
-
-  let verdict;
-  const allOk = v6Ok.length === v6.length && v6.length > 0;
-  if (allOk) verdict = "v6-works";                                  // 全部 v6 出口都有额度
-  else if (v6Limited.length === v6.length) verdict = "v6-also-limited"; // 全部受限 ⇒ 没换到新额度
-  else if (v6Net.length === v6.length) verdict = "v6-unreachable";  // 全部够不着 ⇒ 段没路由过来
-  else verdict = "mixed";                                           // 有的成有的不成
-
-  return {
-    status: "ok",
-    prefix: d.prefix, iface: d.iface, mode: d.mode, hostBits: hostBitsOf(prefix.bits), model, baseUrl,
-    baseline, baseLimited,
-    v6, requested: n,
-    v6OkCount: v6Ok.length, v6LimitedCount: v6Limited.length, v6NetCount: v6Net.length,
-    verdict,
-  };
-}

package/src/warp-pool/config.js

@@ -1,74 +0,0 @@
-// warp-pool · 配置解析：env 优先，缺省值集中在一处；纯函数，便于单测。
-import { join } from "node:path";
-import { logDir } from "../logs.js";
-
-/** 缺省开 + 429 时换身份换出口：他项目真机实测「同一身份连发 3 次 429，身份一换同一个请求立刻 200」⇒ 换身份＝换桶。 */
-export const DEFAULTS = {
-  enabled: true,
-  mode: "leader",
-  count: 4,
-  basePort: 10800,
-  strategy: "session",
-  cooldownMs: 600_000,
-  autodownload: true,
-  registerMinGapMs: 6_000,
-  registerMaxGapMs: 15_000,
-  probePath: "/zen/v1/models",
-  rotate: true,
-};
-
-const OFF = ["0", "off", "false", "no", "disable", "disabled"];
-
-function envBool(env, name, fallback) {
-  const raw = env[name];
-  if (raw === undefined || raw === null || raw === "") return fallback;
-  return !OFF.includes(String(raw).trim().toLowerCase());
-}
-
-function envInt(env, name, fallback) {
-  const v = Number(env[name]);
-  return Number.isInteger(v) && v > 0 ? v : fallback;
-}
-
-function envStr(env, name, fallback) {
-  const raw = env[name];
-  return typeof raw === "string" && raw.trim() ? raw.trim() : fallback;
-}
-
-/**
- * 解析 warp-pool 运行时配置。
- * @param {Record<string,string|undefined>} env
- * @param {{ logDirFn?: () => string }} [deps] 测试可注入 logDir
- */
-export function resolveWarpConfig(env = process.env, { logDirFn = logDir } = {}) {
-  const enabled = envBool(env, "MSLXDFF_WARP_POOL", DEFAULTS.enabled);
-  const mode = envStr(env, "MSLXDFF_WARP_MODE", DEFAULTS.mode);
-  const count = envInt(env, "MSLXDFF_WARP_COUNT", DEFAULTS.count);
-  const basePort = envInt(env, "MSLXDFF_WARP_BASE_PORT", DEFAULTS.basePort);
-  const strategy = envStr(env, "MSLXDFF_WARP_STRATEGY", DEFAULTS.strategy) === "request" ? "request" : "session";
-  const cooldownMs = envInt(env, "MSLXDFF_WARP_COOLDOWN_MS", DEFAULTS.cooldownMs);
-  const dir = envStr(env, "MSLXDFF_WARP_DIR", join(logDirFn(), "warp-pool"));
-  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,
-    active: enabled && mode === "leader",
-    mode,
-    count,
-    basePort,
-    strategy,
-    cooldownMs,
-    dir,
-    bin,
-    autodownload,
-    probePath,
-    rotate,
-    registerMinGapMs: DEFAULTS.registerMinGapMs,
-    registerMaxGapMs: DEFAULTS.registerMaxGapMs,
-    /** 节点端口列表：basePort .. basePort+count-1 */
-    ports: Array.from({ length: count }, (_, i) => basePort + i),
-  };
-}

package/src/warp-pool/health.js

@@ -1,106 +0,0 @@
-// warp-pool · 节点健康：主动探活（经隧道打上游 models，不烧 token）+ 失败冷却 + 连续失败触发重拨换 IP。
-import { probeTunnel } from "./wireproxy.js";
-import { fmtHealth, fmtHeartbeat, dur, MARK } from "./report.js";
-
-export function createHealthMonitor({
-  dispatcher,
-  baseUrl = "https://opencode.ai",
-  probePath = "/zen/v1/models",
-  unhealthyAfter = 3,
-  intervalMs = 60_000,
-  heartbeatEvery = 10,
-  infoOf = null,
-  cooldownMs = 600_000,
-  onExhausted = null,
-  probe = probeTunnel,
-  headers = {},
-  now = Date.now,
-  log = () => {},
-} = {}) {
-  let timer = null;
-  let rounds = 0;
-  let ticks = 0;
-  let lastAllDownAt = "";
-  /** @type {Map<number, boolean>} 每端口上一轮通不通（用来只在「状态变化」时打日志） */
-  const lastOk = new Map();
-  const stamp = () => new Date(now()).toISOString().slice(11, 19);
-
-  /**
-   * 跑一轮全池探活。日志纪律：**只在「状态有变化」「全池不通」「心跳点」时打**——每分钟一行会把日志淹掉。
-   * 每个不通的节点都要报全：HTTP 状态、错误原文、耗时、连续第几次、冷却多久（这样才不用靠猜）。
-   */
-  async function tick() {
-    if (!dispatcher) return { checked: 0, healthy: 0 };
-    const list = dispatcher.entries();
-    let healthy = 0;
-    let slowestMs = 0;
-    const problems = [];
-    const changes = [];
-    for (const e of list) {
-      const r = await probe({ port: e.port, baseUrl, path: probePath, headers }).catch((err) => ({
-        ok: false,
-        error: String(err?.message || err),
-      }));
-      if (Number(r.ms) > slowestMs) slowestMs = Number(r.ms);
-      if (r.ok) {
-        dispatcher.markOk(e.index);
-        healthy += 1;
-        if (lastOk.get(e.port) === false) changes.push(`:${e.port} 恢复（HTTP ${r.status}，${dur(r.ms)}）`);
-        lastOk.set(e.port, true);
-        continue;
-      }
-      dispatcher.markFailure(e.index);
-      if (lastOk.get(e.port) !== false) {
-        changes.push(`:${e.port} 掉线（HTTP ${r.status || 0}${r.error ? ` ${String(r.error).slice(0, 80)}` : ""}）`);
-      }
-      lastOk.set(e.port, false);
-      problems.push({ port: e.port, status: r.status, error: r.error, ms: r.ms, fails: Number(e.fails || 0) + 1, cooldownMs });
-    }
-    const allDown = list.length > 0 && healthy === 0;
-    ticks += 1;
-    if (allDown) {
-      rounds += 1;
-      lastAllDownAt = stamp();
-    } else {
-      rounds = 0;
-    }
-    if (changes.length || allDown || ticks % heartbeatEvery === 0) {
-      log(fmtHealth({ healthy, total: list.length, slowestMs, problems }));
-    }
-    for (const c of changes) log(`[warp-pool] ${MARK.warn} 状态变化：${c}`);
-    if (ticks % heartbeatEvery === 0) {
-      const extra = typeof infoOf === "function" ? infoOf() || {} : {};
-      log(fmtHeartbeat({
-        alive: extra.alive ?? list.length,
-        total: list.length,
-        pooled: extra.pooled ?? list.length,
-        exits: extra.exits || [],
-        cooling: list.filter((e) => Number(e.cooldownUntil) > now()).length,
-        lastAllDown: lastAllDownAt,
-      }));
-    }
-    if (allDown && rounds >= 2 && typeof onExhausted === "function") {
-      rounds = 0;
-      await onExhausted().catch((e) => log(`[warp-pool] 重拨失败：${String(e?.message || e)}`));
-    }
-    return { checked: list.length, healthy };
-  }
-
-  return {
-    tick,
-    start() {
-      if (timer || !(intervalMs > 0)) return;
-      timer = setInterval(() => {
-        tick().catch(() => {});
-      }, intervalMs);
-      if (typeof timer.unref === "function") timer.unref();
-    },
-    stop() {
-      if (timer) clearInterval(timer);
-      timer = null;
-    },
-    get running() {
-      return !!timer;
-    },
-  };
-}