mslxdff 0.1.244 → 0.1.246

package/src/warp-pool/revive.js

@@ -1,168 +0,0 @@
-// warp-pool · 复活与取证（真机事故后新增，2026-10-16）。
-//
-// 三件事，都来自组长 VPS 上暴露的缺陷：
-//
-// 1. 隧道退出后必须自愈：原先只有「全池不通」才补拉，一条死隧道会让池静默从 4 降到 3，直到 daemon 重启。
-// 2. 入池后必须实测各节点真实出口：WARP 的 IPv4 出口是共享 NAT，「N 设备」很可能折叠成一个出口
-//    （2026-10-17 组长 VPS 实测：4 条隧道只拿到 2 个出口地址 ⇒ 隧道数 ≠ 上游名额数）。
-// 3. 复活必须**真的活下来**（2026-10-16 组长 VPS 事故）：`tunnels.has(port)` 只证明「spawn 被调用了」，
-//    wireproxy 起一条死一条（端口被上一代孤儿进程占着 ⇒ bind 失败 ⇒ 退出码 1），旧逻辑次次判「已复活」
-//    ⇒ 下一次退出立刻再复活 ⇒ 无限重启刷屏，该端口永远起不来。
-//
-// 复活只走**磁盘上已有的 conf**：进程挂了 ≠ 设备失效，重注册只会白烧 CF 配额。
-import { probeTunnel } from "./wireproxy.js";
-import { fmtExits } from "./report.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] : "";
-}
-
-/** 子进程末行输出当退出原因（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>, 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, 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();
-
-  function entry(port) {
-    let s = state.get(port);
-    if (!s) {
-      s = { attempts: 0, nextAt: 0, busy: false };
-      state.set(port, s);
-    }
-    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 {
-    onExit: (port) => attempt(port),
-    /** 探活成功时调用：清掉退避账与待触发定时器，恢复正常节奏。 */
-    noteHealthy(port) {
-      const h = timers.get(port);
-      if (h) {
-        try { cancel(h); } catch {}
-        timers.delete(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()),
-      }));
-    },
-
-    /** 池关闭时调用：别再有定时器去打复活。 */
-    stop() {
-      for (const h of timers.values()) {
-        try { cancel(h); } catch {}
-      }
-      timers.clear();
-      state.clear();
-    },
-  };
-}
-
-/**
- * 入池后实测各节点真实出口地址并打日志（含撞车警告）。
- * 只读探测：打 Cloudflare 的 trace 端点，不碰上游配额。
- * @param {{ ports?: number[], dir?: string, fetchImpl?: Function, timeoutMs?: number, log?: Function }} [opts]
- * @returns {Promise<{ ip: string, nodes: number[] }[]>} 按出口地址分组的节点清单
- */
-export async function labelExits({ ports = [], dir = "", 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 }));
-  const line = fmtExits({ groups, dir });
-  if (line) log(line);
-  if (failed) log(`[warp-pool] ${failed} 个节点出口取证失败（不影响进池，只影响轮换时「出口到底变没变」的比对）`);
-  return groups;
-}

package/src/warp-pool/rotate.js

@@ -1,214 +0,0 @@
-// warp-pool · 轮换 dispatcher：把每个请求委派给不同出口节点的 ProxyAgent。
-// 契约（MODULES.md §1）：只需 dispatch(opts, handler) + close()/destroy()。
-// 注入点：src/transport/index.js 的 extDispatcher —— legacy（transport.request）与 SDK（sdk/attempt.js
-// 的 dispatcherFetch）两条路共用同一个 dispatcher 对象，故一处实现、两条路生效。
-//
-// 空池语义：bootstrap（注册设备/起隧道）完成前 list 为空 → 走直连兜底，行为与未启用本功能时一致；
-// bootstrap 完成后 setNodes() 换上真实出口。这样 daemon 启动不会因注册/下载而被阻塞。
-import { getUndici } from "../compat.js";
-import { createSelector } from "./strategy.js";
-import { looksLikeQuotaSignal, SIGNAL_MAX_BYTES, SIGNAL_STATUSES } from "./verdict.js";
-
-const SESSION_HEADER = "x-opencode-session";
-
-/** undici 的 dispatch opts.headers 是扁平数组 [k, v, k, v, ...]。 */
-export function headerValue(headers, name) {
-  if (!Array.isArray(headers)) return "";
-  const target = String(name).toLowerCase();
-  for (let i = 0; i + 1 < headers.length; i += 2) {
-    if (String(headers[i]).toLowerCase() === target) return String(headers[i + 1] ?? "");
-  }
-  return "";
-}
-
-/**
- * 让 dispatcher 看见上游的失败信号：复制一层 handler，其余方法原样转发（全部调用都落在副本上，this 一致）。
- *
- * 403/429 要**连正文一起**交出去才能判决（`403 FreeTierError` 与 `429 FreeUsageLimitError` 是同一条件，
- * 而 `429 BlackUsageLimitError` 是账号配额、绝不能换出口）——参照实现 zen-router 就是按正文里的具名判决
- * 分类的（internal/zen/errors.go）。故这两类状态码延迟到「正文到手」再回调：凑够具名判决即提前回调，
- * 否则等 onComplete/onError/触顶。其余状态码照旧在 onHeaders 立即回调（正文为空）。
- * 正文只**旁听**不消费：onData 原样转发给下游 handler，捕获 ≤ SIGNAL_MAX_BYTES 字节。
- */
-export function tapHandler(handler, tap) {
-  if (!tap || !handler || typeof handler !== "object") return handler;
-  const out = Object.assign(Object.create(Object.getPrototypeOf(handler)), handler);
-  const origHeaders = handler.onHeaders;
-  const origData = handler.onData;
-  const origComplete = handler.onComplete;
-  const origError = handler.onError;
-  /** @type {null | { status: number, buf: Buffer[], size: number, done: boolean }} */
-  let capture = null;
-  const fire = () => {
-    if (!capture || capture.done) return;
-    capture.done = true;
-    try { tap({ status: capture.status, text: Buffer.concat(capture.buf).toString("utf8") }); } catch {}
-  };
-
-  out.onHeaders = function (statusCode, headers, resume, statusText) {
-    const code = Number(statusCode);
-    // 只有 403/429 值得等正文；且必须下游真能收数据，否则退回「只按状态码判决」。
-    if (SIGNAL_STATUSES.includes(code) && typeof origData === "function") {
-      capture = { status: code, buf: [], size: 0, done: false };
-    } else {
-      try { tap({ status: code, text: "" }); } catch {}
-    }
-    return typeof origHeaders === "function" ? origHeaders.call(this, statusCode, headers, resume, statusText) : undefined;
-  };
-  out.onData = function (chunk) {
-    if (capture && !capture.done) {
-      try {
-        const b = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
-        const room = SIGNAL_MAX_BYTES - capture.size;
-        if (room > 0) {
-          const slice = b.length > room ? b.subarray(0, room) : b;
-          capture.buf.push(slice);
-          capture.size += slice.length;
-        }
-      } catch {}
-      // 具名判决一到手就判决，不必等整条 body；触顶也判（大 body 不许把判决拖成慢扫描）
-      const text = capture.buf.length ? Buffer.concat(capture.buf).toString("utf8") : "";
-      if (capture.size >= SIGNAL_MAX_BYTES || looksLikeQuotaSignal(text)) fire();
-    }
-    return typeof origData === "function" ? origData.call(this, chunk) : undefined;
-  };
-  out.onComplete = function (trailers) {
-    fire();
-    return typeof origComplete === "function" ? origComplete.call(this, trailers) : undefined;
-  };
-  out.onError = function (err) {
-    fire();
-    return typeof origError === "function" ? origError.call(this, err) : undefined;
-  };
-  return out;
-}
-
-/**
- * @param {{ nodes?: Array<{port:number, uri:string}>, strategy?: "session"|"request",
- *           cooldownMs?: number, now?: () => number, log?: (s:string)=>void, onStatus?: (status:number, port:number)=>void,
- *           agentOptions?: object, selector?: object }} [opts]
- */
-export function createRotatingDispatcher({
-  nodes = [],
-  strategy = "session",
-  cooldownMs = 600_000,
-  now = Date.now,
-  log = () => {},
-  onStatus = null,
-  agentFactory,
-  fallbackAgent,
-  agentOptions = { connections: 8, keepAliveTimeout: 30_000, keepAliveMaxTimeout: 60_000, pipelining: 1 },
-  selector = createSelector({ strategy }),
-} = {}) {
-  const { ProxyAgent, Agent } = getUndici();
-  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 = build(nodes);
-
-  function build(nodesIn) {
-    return (nodesIn || []).map((n, i) => ({
-      index: i,
-      port: Number(n.port),
-      uri: String(n.uri),
-      agent: agentFactory ? agentFactory(n.uri) : new ProxyAgent({ uri: n.uri, ...agentOptions }),
-      cooldownUntil: 0,
-      fails: 0,
-    }));
-  }
-
-  function availableIndexes() {
-    const t = now();
-    const out = [];
-    for (const e of list) if (e.cooldownUntil <= t) out.push(e.index);
-    return out;
-  }
-
-  function markFailure(index) {
-    const e = list[index];
-    if (!e) return;
-    e.fails += 1;
-    e.cooldownUntil = now() + cooldownMs;
-    if (e.fails === 1 || e.fails % 10 === 0) log(`[warp-pool] 节点 :${e.port} 连续失败 ${e.fails} 次，冷却 ${Math.round(cooldownMs / 1000)}s（中间次数静默：健康探活每分钟一轮，一个不通的节点曾把日志刷成 12 行/分钟）`);
-  }
-
-  function markOk(index) {
-    const e = list[index];
-    if (e) {
-      e.fails = 0;
-      e.cooldownUntil = 0;
-    }
-  }
-
-  async function closePool(entries) {
-    await Promise.all(
-      entries.map((e) => {
-        try {
-          return Promise.resolve(e.agent.close?.()).catch(() => {});
-        } catch {
-          return Promise.resolve();
-        }
-      }),
-    );
-  }
-
-  return {
-    /** 每次请求调一次 = 轮换粒度。 */
-    dispatch(opts, handler) {
-      if (!list.length) {
-        if (fallback) return fallback.dispatch(opts, handler);
-        throw new Error("warp-pool：节点池为空且无直连兜底");
-      }
-      const avail = availableIndexes();
-      // 全池冷却 ⇒ 直连兜底优先：硬派给已知不可用的节点 = 把请求挂到超时。
-      if (!avail.length) return (fallback || list[0].agent).dispatch(opts, handler);
-      const sessionKey = strategy === "session" ? headerValue(opts?.headers, SESSION_HEADER) : "";
-      const e = list[selector.pick(avail, sessionKey)];
-      return e.agent.dispatch(opts, tapHandler(handler, onStatus ? (sc) => onStatus(sc, e.port) : null));
-    },
-
-    /** 运行期换上一批出口（bootstrap 完成后调用）；旧 Agent 池关闭。 */
-    async setNodes(nodesIn) {
-      const old = list;
-      list = build(nodesIn);
-      await closePool(old);
-      return list.length;
-    },
-
-    /** 只读快照，供 health 探活用。 */
-    entries() {
-      return list.map((e) => ({ index: e.index, port: e.port, uri: e.uri, cooldownUntil: e.cooldownUntil, fails: e.fails }));
-    },
-
-    async close() {
-      await closePool(list);
-      list = [];
-      if (fallback) {
-        try {
-          await fallback.close?.();
-        } catch {}
-      }
-    },
-
-    async destroy() {
-      return this.close();
-    },
-
-    stats() {
-      const t = now();
-      return list.map((e) => ({
-        port: e.port,
-        uri: e.uri,
-        cooling: e.cooldownUntil > t,
-        cooldownMsLeft: Math.max(0, e.cooldownUntil - t),
-        fails: e.fails,
-      }));
-    },
-
-    markFailure,
-    markOk,
-    get size() {
-      return list.length;
-    },
-  };
-}

package/src/warp-pool/strategy.js

@@ -1,43 +0,0 @@
-// warp-pool · 选节点策略。
-//
-// session（默认）：同一 `x-opencode-session` 恒粘同一出口。
-//   依据 src/upstream.js L14-16 的实测注释——上游按 session 做粘性路由（固定 session 两次请求 ~1.2s；
-//   每次随机时可能撞冷机器 26s+）。故"每请求换出口"会把请求打成冷启动。
-// request：每请求轮转，仅供实验（延迟代价见上）。
-const STICKY_MAX = 2000;
-
-export function createSelector({ strategy = "session" } = {}) {
-  const sticky = new Map();
-  let cursor = 0;
-
-  /** @param {number[]} available 可用节点下标 @param {string} sessionKey */
-  function pick(available, sessionKey) {
-    if (!Array.isArray(available) || available.length === 0) return null;
-    if (strategy === "session" && sessionKey) {
-      const hit = sticky.get(sessionKey);
-      if (hit !== undefined && available.includes(hit)) return hit;
-      const chosen = available[cursor++ % available.length];
-      sticky.set(sessionKey, chosen);
-      if (sticky.size > STICKY_MAX) {
-        const oldest = sticky.keys().next().value;
-        sticky.delete(oldest);
-      }
-      return chosen;
-    }
-    return available[cursor++ % available.length];
-  }
-
-  return {
-    pick,
-    forget(sessionKey) {
-      if (sessionKey === undefined) sticky.clear();
-      else sticky.delete(sessionKey);
-    },
-    get tracked() {
-      return sticky.size;
-    },
-    get strategy() {
-      return strategy;
-    },
-  };
-}

package/src/warp-pool/verdict.js

@@ -1,69 +0,0 @@
-// warp-pool · 上游失败信号的「换不换出口」判决（纯函数，零 IO）。
-//
-// 判据逐字对齐参照实现 kyomufs/zen-router：
-//   - internal/zen/errors.go 的 Kind 分类表（哪些错误算「按出口 IP 计的限额」）；
-//   - internal/router/stage.go 的 NextAttempt 决策表（每种 Kind 该换什么、要不要绕过冷却）。
-//
-// 立此模块的原因（2026-10-17 十次修订）：我原先只在 rotate.js 的 onStatus 里认 `status === 429`，
-// 漏掉了参照实现表里**最重要的一格**——`403 FreeTierError` 与 `429 FreeUsageLimitError` 是
-// **同一个条件的两种状态码**（上游按自己的窗口状态二选一，文案完全相同）。参照实现实测：
-// 同一身份连发 3 次 429，**身份一换同一个请求立刻 200**（errors.go:32-42）；
-// 而它最初把 403 当通用 403 不重试，代价是整轮请求直接死掉（errors.go:50-61 记录得很清楚）。
-// 我这边更糟：`terminal-verdict.js` 把 FreeTierError 判成**终局**（跳过接力），
-// warp-pool 又只认 429 ⇒ **403 FreeTierError 从来没有任何换出口动作**。
-//
-// 反向护栏同样照抄：`BlackUsageLimitError` 是真正的**账号日配额**，换出口抬不动，
-// 参照实现明确「绝不旋转身份」（stage.go:125-128、errors.go:28-31）；换 key 才是它的正解。
-// 裸 403（正文没有 FreeTier 判决）也不旋转：参照实现的 kindByStatus 把 403 归为
-// KindClient（不可重试），换出口对形状/区域/凭据类 403 毫无用处。
-//
-// 读不到正文时的退路也照抄 kindByStatus：429 → 当出口 IP 限流（换）；403 → 不换。
-
-/** 上游失败正文里判定免费层资格的具名判决（与 terminal-verdict.js 的 FREE_TIER_PATTERNS 同源口径）。 */
-const FREE_TIER_RE = /FreeTierError|free tier can only be used/i;
-/** 匿名免费层 429（参照实现实测：按出口 IP 计，换身份即换桶）。 */
-const FREE_QUOTA_RE = /FreeUsageLimitError|GoUsageLimitError/i;
-/** 黑名单层：真账号日配额，换出口抬不动。 */
-const BLACK_QUOTA_RE = /BlackUsageLimitError/i;
-
-/** 只这两类状态码参与判决；其余（含 200）一律不参与、也不许刷日志。 */
-export const SIGNAL_STATUSES = [403, 429];
-
-/** 正文捕获上限（判据只需要文案里的类名，2KB 足够，且防大 body 拖成慢扫描）。 */
-export const SIGNAL_MAX_BYTES = 2048;
-
-/** 正文里出现了具名判决（供 tapHandler 一凑够就提前判决，不必等整条 body 读完）。 */
-export function looksLikeQuotaSignal(text) {
-  const t = typeof text === "string" ? text : "";
-  return FREE_TIER_RE.test(t) || FREE_QUOTA_RE.test(t) || BLACK_QUOTA_RE.test(t);
-}
-
-/**
- * 一次上游失败该不该换出口。
- * @param {{ status?: number, text?: string }} signal 上游状态码 + 正文（≤ SIGNAL_MAX_BYTES；读不到给空串）
- * @returns {{ kind: "free-tier"|"free-quota"|"black-quota"|"ip-limit"|"none", rotate: boolean,
- *            forced: boolean, why: string }}
- *   forced=true 表示必须**跳过**冷却（参照实现的 RotateForced：冷却曾把第一次真实反应吞掉，
- *   于是重试复用了同一个已限额的出口 —— stage.go:315-324）。
- */
-export function classifyWarpSignal({ status, text = "" } = {}) {
-  const code = Number(status);
-  const body = typeof text === "string" ? text : "";
-  if (!SIGNAL_STATUSES.includes(code)) {
-    return { kind: "none", rotate: false, forced: false, why: `上游 ${code || "?"} 不是 403/429，与出口限额无关` };
-  }
-  // 顺序即优先级，照抄 errors.go 的 classify()：先认正文里的具名判决，再退回状态码。
-  if (BLACK_QUOTA_RE.test(body)) {
-    return { kind: "black-quota", rotate: false, forced: false, why: "BlackUsageLimitError 是真正的账号日配额，换出口抬不动（参照实现同样绝不旋转）——该换 key，不是换 IP" };
-  }
-  if (FREE_TIER_RE.test(body)) {
-    return { kind: "free-tier", rotate: true, forced: true, why: "403 FreeTierError 与 429 FreeUsageLimitError 是同一条件的两种状态码；参照实现实测换身份后同一个请求立刻 200 ⇒ 强制换出口，跳过冷却" };
-  }
-  if (FREE_QUOTA_RE.test(body)) {
-    return { kind: "free-quota", rotate: true, forced: true, why: "匿名免费层 429 实测是**按出口 IP** 计的限额（同一身份连发 3 次全 429，换身份立刻 200）⇒ 强制换出口，跳过冷却" };
-  }
-  if (code === 429) {
-    return { kind: "ip-limit", rotate: true, forced: false, why: "裸 429（正文无配额判决）= 出口 IP 限流信号 ⇒ 换出口；保留冷却，防 429 风暴把 CF 注册刷爆" };
-  }
-  return { kind: "none", rotate: false, forced: false, why: "403 但正文没有 FreeTier 判决 ⇒ 不是配额信号（形状/区域/凭据类），换出口无用" };
-}

package/src/warp-pool/wireproxy.js

@@ -1,162 +0,0 @@
-// warp-pool · wireproxy 进程管理：取二进制 → 生成配置 → 启动 → 守护/销毁。
-// wireproxy（octeep/wireproxy，Go，用户态 WireGuard，无需 root/TUN）把 WARP 隧道暴露为本地 HTTP 代理。
-// 为什么是 [http] 而非 [Socks5]：项目 undici 为 v5（实测 5.29.0），其 ProxyAgent 只接受 http/https，
-// 「SOCKS5 支持」是 undici 后续版本才加的（实测 socks5:// 直接抛 Invalid URL protocol）。
-import { spawn } from "node:child_process";
-import { chmodSync, existsSync, createWriteStream, readdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { pipeline } from "node:stream/promises";
-import { compatFetch, getUndici } from "../compat.js";
-import { ensureDir, nodePaths, renderWireproxyConf, writeSecret } from "./nodes.js";
-
-export const WIREPROXY_VERSION = "v1.1.3";
-const RELEASE_BASE = "https://github.com/octeep/wireproxy/releases/download";
-
-const ASSETS = {
-  "linux-x64": "wireproxy_linux_amd64.tar.gz",
-  "linux-arm64": "wireproxy_linux_arm64.tar.gz",
-  "darwin-x64": "wireproxy_darwin_amd64.tar.gz",
-  "darwin-arm64": "wireproxy_darwin_arm64.tar.gz",
-};
-
-/** 依平台选发布包；不支持的平台返回 null（改用 MSLXDFF_WARP_BIN 自备二进制）。 */
-export function resolveAsset(platform = process.platform, arch = process.arch) {
-  const key = `${platform}-${arch}`;
-  return ASSETS[key] || null;
-}
-
-/** 本地二进制路径（bin/ 下按平台固定名）。 */
-export function binaryPath(dir) {
-  return join(dir, "bin", process.platform === "win32" ? "wireproxy.exe" : "wireproxy");
-}
-
-/**
- * 确保 wireproxy 可用：优先 env 指定 → 本地已下载 → 自动下载解包。
- * @returns {Promise<string>} 可执行文件绝对路径
- */
-export async function ensureBinary({ dir, bin = "", autodownload = true, fetchImpl = compatFetch, log = () => {}, platform = process.platform, arch = process.arch } = {}) {
-  if (bin) {
-    if (!existsSync(bin)) throw new Error(`MSLXDFF_WARP_BIN 指向的文件不存在：${bin}`);
-    return bin;
-  }
-  const local = binaryPath(dir);
-  if (existsSync(local)) return local;
-
-  if (!autodownload) throw new Error(`未找到 wireproxy（${local}），且已关闭自动下载：请设 MSLXDFF_WARP_BIN 或开启 MSLXDFF_WARP_AUTODOWNLOAD`);
-  const asset = resolveAsset(platform, arch);
-  if (!asset) throw new Error(`暂不支持自动下载 wireproxy（平台 ${platform}-${arch}）：请自备二进制并设 MSLXDFF_WARP_BIN`);
-
-  ensureDir(join(dir, "bin"));
-  const url = `${RELEASE_BASE}/${WIREPROXY_VERSION}/${asset}`;
-  const tarball = join(dir, "bin", asset);
-  log(`[warp-pool] 下载 wireproxy ${WIREPROXY_VERSION}（${asset}）`);
-  const res = await fetchImpl(url, { signal: AbortSignal.timeout(120_000) });
-  if (!res.ok) throw new Error(`下载 wireproxy 失败：HTTP ${res.status}`);
-  await pipeline(res.body, createWriteStream(tarball));
-
-  // 解包用系统 tar（Linux/macOS 必带；不引入 npm 依赖去解析 tar 格式）。
-  await runCommand("tar", ["-xzf", tarball, "-C", join(dir, "bin")], { log });
-  try { rmSync(tarball, { force: true }); } catch {}
-
-  const extracted = findWireproxy(join(dir, "bin"));
-  if (!extracted) throw new Error(`解包后未找到 wireproxy 可执行文件（目录：${join(dir, "bin")}）`);
-  if (extracted !== local) {
-    try { chmodSync(extracted, 0o755); } catch {}
-  }
-  try { chmodSync(local, 0o755); } catch {}
-  return existsSync(local) ? local : extracted;
-}
-
-function findWireproxy(binDir) {
-  try {
-    const hit = readdirSync(binDir).find((f) => f === "wireproxy" || f === "wireproxy.exe");
-    return hit ? join(binDir, hit) : null;
-  } catch {
-    return null;
-  }
-}
-
-function runCommand(cmd, args, { log = () => {} } = {}) {
-  return new Promise((resolve, reject) => {
-    let err = "";
-    const p = spawn(cmd, args, { stdio: ["ignore", "ignore", "pipe"] });
-    p.stderr.on("data", (d) => { err += String(d); });
-    p.on("error", reject);
-    p.on("close", (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`${cmd} 退出码 ${code}${err ? `：${err.slice(0, 200)}` : ""}`));
-    });
-  });
-}
-
-/** 写出某节点的 wireproxy 配置（含私钥 ⇒ 0600）。 */
-export function writeTunnelConf(dir, node) {
-  if (!node?.privateKey) throw new Error(`节点 :${node?.port} 缺 WireGuard 私钥，拒绝写出一份跑不起来的配置`);
-  const { conf } = nodePaths(dir, node.port);
-  const text = renderWireproxyConf({ ...node, port: node.port });
-  writeSecret(conf, text);
-  return { conf, bytes: Buffer.byteLength(text) };
-}
-
-/**
- * 启动一条隧道。返回 { port, conf, stop() }。
- * 进程退出即视为隧道失效（不自动重启：由 health 层决策重拨换 IP）。
- */
-export function startTunnel({ binPath: exe, dir, port, log = () => {}, onExit = () => {}, now = Date.now } = {}) {
-  const { conf } = nodePaths(dir, port);
-  const child = spawn(exe, ["-c", conf], { stdio: ["ignore", "pipe", "pipe"] });
-  const startedAt = now();
-  let tail = "";
-  const keepTail = (d) => {
-    tail = (tail + String(d)).slice(-800);
-  };
-  child.stdout.on("data", keepTail);
-  child.stderr.on("data", keepTail);
-
-  let stopped = false;
-  child.on("exit", (code, signal) => {
-    if (!stopped) onExit({ port, code, signal, tail, pid: child.pid, aliveMs: now() - startedAt });
-  });
-
-  return {
-    port,
-    conf,
-    get pid() {
-      return child.pid;
-    },
-    get alive() {
-      return !stopped && child.exitCode === null;
-    },
-    get tail() {
-      return tail;
-    },
-    stop() {
-      if (stopped) return;
-      stopped = true;
-      try { child.kill("SIGTERM"); } catch {}
-    },
-  };
-}
-
-/** 探活一个已起的隧道：经该端口访问上游 models 路径（不烧 token）。 */
-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 });
-  const url = `${String(baseUrl).replace(/\/+$/, "")}${path}`;
-  const t0 = Date.now();
-  try {
-    const res = await fetchImpl(url, {
-      headers,
-      signal: AbortSignal.timeout(timeoutMs),
-      dispatcher: agent,
-    });
-    const base = { ok: res.ok, status: res.status, ms: Date.now() - t0, url };
-    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), ms: Date.now() - t0, url };
-  } finally {
-    try { await agent.close(); } catch {}
-  }
-}