mslxdff 0.1.239 → 0.1.241

package/package.json

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

package/src/cli/commands/multi-ip-pool.js

@@ -0,0 +1,174 @@
+// mslxdff -multi-ip-pool [test|status|help]
+//   多出口池（VPNGate 免费 OpenVPN 节点当出口）：**组长/单机**专属，只服务 opencode 免费层。
+//
+// 为什么需要这条命令（用户要的"取证"）：换出口到底有没有换来新额度，只有实测能回答。
+// 本命令做 A/B：直连打一条免费层请求取基线 → 逐条 VPN 隧道打**同一条**请求 → 对照判语。
+import { join } from "node:path";
+import { runMultiIpCompare, VERDICT_ZH, MITEST_DEFAULT, MITEST_MAX } from "../../multi-ip-pool/selftest.js";
+import { fetchNodesToFile } from "../../multi-ip-pool/nodes-fetch.js";
+import { resolveMultiIpConfig, resolveRole } from "../../multi-ip-pool/config.js";
+import { checkOpenvpn, isRoot, isSupportedPlatform } from "../../multi-ip-pool/tunnel.js";
+import { loadGroupsJoined } from "../../state.js";
+import { argValue } from "../policy.js";
+
+const FLAG = "-multi-ip-pool";
+
+function flagValue(args, ...names) {
+  for (const name of names) {
+    const v = argValue(args, name);
+    if (v !== null && v !== undefined && !String(v).startsWith("-")) return v;
+    const eq = args.find((a) => a.startsWith(`${name}=`));
+    if (eq) return eq.slice(eq.indexOf("=") + 1);
+  }
+  return null;
+}
+
+const kindZh = { "free-quota": "429 额度耗尽", "free-tier": "403 免费层资格", "ip-limit": "429 限流", "black-quota": "账号日配额", network: "网络不可达", none: "非额度信号" };
+const line = (r) => {
+  if (r.error) return `✗ 不可达（${String(r.error).slice(0, 60)}）`;
+  if (r.ok) return `✅ HTTP ${r.status} 有额度`;
+  return `⛔ HTTP ${r.status} ${kindZh[r.kind] || r.kind}`;
+};
+
+export async function handleMultiIpPool(args = []) {
+  const at = args.findIndex((x) => x === FLAG || x.startsWith(`${FLAG}=`));
+  if (at < 0) return false;
+  const sub = (args[at].includes("=") ? args[at].split("=")[1] : args[at + 1] || "test").toLowerCase();
+  if (["-h", "--help", "help"].includes(sub)) return printUsage();
+  if (sub === "status") return await printStatus(args);
+  if (sub === "fetch" || sub === "grab") return await runFetch(args);
+  return await runTest(args);
+}
+
+async function runTest(args) {
+  const count = (() => { const v = flagValue(args, "--count", "-n"); return v === null ? MITEST_DEFAULT : Math.max(1, Math.min(MITEST_MAX, Number(v) || MITEST_DEFAULT)); })();
+  const model = flagValue(args, "--model", "-m") || "";
+  console.log("=".repeat(66));
+  console.log("  多出口池取证 —— 「直连 429 时，换成 VPN 出口还有额度吗」");
+  console.log("=".repeat(66));
+  console.log("");
+  console.log(`  探测模型 ${model || "(默认免费模型)"}｜采样 ${count} 条隧道｜只换出口，其余请求完全相同`);
+  console.log("");
+
+  const onProgress = (ev) => {
+    if (ev.phase === "nodes") console.log(`  ▸ 节点表：${ev.source}（${ev.total} 个节点）`);
+    else if (ev.phase === "baseline-start") console.log("  ▸ 基线：直连（系统默认出口）打一条免费层请求…");
+    else if (ev.phase === "baseline-done") {
+      console.log(`    基线结果：${line(ev)}${ev.body ? `（${String(ev.body).slice(0, 80).replace(/\s+/g, " ")}）` : ""}`);
+      console.log("");
+    } else if (ev.phase === "exit-start") console.log(`  [${String(ev.i).padStart(2)}/${ev.n}] ${ev.row.hostName}（${ev.row.countryShort || "?"}）…`);
+    else if (ev.phase === "exit-done") console.log(`      ${line(ev)}${ev.exitIp ? `｜出口 IP ${ev.exitIp}` : ""}`);
+  };
+
+  let r;
+  try {
+    r = await runMultiIpCompare({ count, ...(model ? { model } : {}), onProgress });
+  } catch (e) {
+    console.log("");
+    console.log(`❌ 测试执行出错：${e?.message ?? e}`);
+    console.log(`   重试：mslxdff ${FLAG}`);
+    process.exit(1);
+    return true;
+  }
+  if (r.status === "skip") {
+    console.log(`❌ 测不了：${r.reason}`);
+    console.log(`   下一步：${r.hint}`);
+    process.exit(1);
+    return true;
+  }
+
+  console.log("");
+  console.log("-".repeat(66));
+  console.log(`  基线（直连）：${line(r.baseline)}`);
+  console.log(`  VPN 出口：有额度 ${r.okCount}｜受限 ${r.limitedCount}｜不可达 ${r.netCount}（共 ${r.requested}）`);
+  console.log("");
+  const v = VERDICT_ZH[r.verdict] || { text: "未判定", next: "" };
+  const mark = r.verdict === "multi-ip-works" ? "✅" : r.verdict === "mixed" ? "△" : "⛔";
+  console.log(`  ${mark} ${v.text}：${r.okCount}/${r.requested} 条隧道拿到 200`);
+  if (v.next) console.log(`   ${v.next}`);
+  console.log("");
+  console.log(`   重试：mslxdff ${FLAG} --count ${r.requested}${model ? ` --model ${model}` : ""}`);
+  process.exit(r.verdict === "multi-ip-works" || r.verdict === "mixed" ? 0 : 1);
+}
+
+/**
+ * `-multi-ip-pool fetch [路径]`：在**能连节点源**的机器上抓一份 VPNGate 表落成文件，scp 到受限网络的组长机，
+ * 那边设 `MSLXDFF_MULTI_IP_NODES_FILE=<路径>` 即可完全跳过取表网络请求（2026-10-25 真机：华为云 ECS 上 vpngate.net 不可达）。
+ */
+async function runFetch(args) {
+  const cfg = resolveMultiIpConfig(process.env);
+  const out = flagValue(args, "--out", "-o") || join(cfg.dir, "vpngate.csv");
+  console.log(`  节点源（按序试）：${cfg.sources.join("\n              ")}`);
+  console.log("");
+  try {
+    const got = await fetchNodesToFile({ sources: cfg.sources, out, timeoutMs: cfg.probeTimeoutMs });
+    const usable = got.rows.filter((r) => r.config).length;
+    console.log(`  ✅ ${got.rows.length} 个节点（${usable} 个配置可解码）已写入：${out}`);
+    console.log(`     来源：${got.source}`);
+    console.log("");
+    console.log("  带到受限网络的机器上：");
+    console.log(`     scp ${out} root@<组长机>:/root/.config/mslxdff/multi-ip-pool/vpngate.csv`);
+    console.log("     export MSLXDFF_MULTI_IP_NODES_FILE=/root/.config/mslxdff/multi-ip-pool/vpngate.csv");
+    console.log("     （之后取表零网络请求；表会旧，免费节点掉得快，建议隔几天重抓一次）");
+    process.exit(0);
+  } catch (e) {
+    console.log(`  ❌ 一个源都没取到：${String(e?.message || e)}`);
+    console.log("     下一步：换网络重试，或 MSLXDFF_MULTI_IP_SOURCES=<你自己能连的镜像/本地路径> 再跑一次");
+    process.exit(1);
+  }
+  return true;
+}
+
+async function printStatus(args) {
+  const cfg = resolveMultiIpConfig(process.env);
+  const role = resolveRole({ mode: cfg.mode, joined: loadGroupsJoined() });
+  const platform = process.platform;
+  const root = isRoot();
+  const openvpn = await checkOpenvpn(cfg.openvpnBin);
+  console.log("=".repeat(66));
+  console.log("  多出口池状态（不做任何隧道动作，只回答「开没开、为什么」）");
+  console.log("=".repeat(66));
+  console.log("");
+  console.log(`  开关       ${cfg.enabled ? "开（MSLXDFF_MULTI_IP_POOL 缺省开）" : "关（MSLXDFF_MULTI_IP_POOL=0）"}`);
+  console.log(`  角色门     role=${role.role} ⇒ ${role.active ? "通过" : "不建池"}（${role.why}）`);
+  console.log(`  平台门     ${isSupportedPlatform(platform) ? "通过（Linux）" : `不通过（${platform}：没有 tun + ip rule）`}`);
+  console.log(`  权限门     ${root ? "通过（root）" : "不通过（需要 root 才能建 tun 与策略路由）"}`);
+  console.log(`  openvpn    ${openvpn.ok ? `可用（${openvpn.version}）` : `不可用（${openvpn.why}）`}`);
+  console.log(`  隧道数     ${cfg.count}｜国家 ${cfg.countries.length ? cfg.countries.join("/") : "不限"}｜Score ≥ ${cfg.minScore}｜表号 ${cfg.baseTable}+`);
+  console.log(`  备选池     配 ${cfg.standby} 条（每 ${Math.round((cfg.standbyEveryMs || 0) / 60_000)} 分钟重拨一批；入池标准是 hi 回 200，不是"隧道起来了"）`);
+  console.log(`             实际就绪几条**只有 daemon 知道**（本命令不建池、不拨号）→ 看 mslxdff -log 里的 [multi-ip-pool] 备选池 行`);
+  console.log(`  目录       ${cfg.dir}`);
+  console.log(`  节点源     ${cfg.nodesFile ? `本地表优先：${cfg.nodesFile}（其后 ${cfg.sources.length - 1} 个网络源）` : cfg.sources.join("，")}`);
+  console.log("");
+  console.log(`  下一步：mslxdff ${FLAG} test（真机取证：换出口到底有没有换来新额度）`);
+  process.exit(0);
+  return true;
+}
+
+function printUsage() {
+  console.log(`用法: mslxdff ${FLAG} [test|status|fetch|help] [--count N] [--model <id>] [--out <路径>]`);
+  console.log("");
+  console.log("  在多出口池上做 A/B：直连打一条 free 层请求取基线，再逐条 VPN 隧道打同一条，");
+  console.log("  对照判语：");
+  console.log("    基线 429 + VPN 出口有 200 ⇒ 池有用（换 IP 换到新额度）");
+  console.log("    基线 429 + VPN 出口也全 429 ⇒ 换 IP 抬不动（上游不按出口 IP 计额）");
+  console.log("");
+  console.log("  前置：Linux + root + openvpn（tun 设备与策略路由必需）。非 Linux 如实跳过。");
+  console.log("");
+  console.log("相关 env（与 daemon 建池同源）：");
+  console.log("    MSLXDFF_MULTI_IP_POOL=0|1          关 / 开（缺省开）");
+  console.log("    MSLXDFF_MULTI_IP_MODE=auto|leader|member  角色门（缺省 auto：**只有组长**建池；组员与单机都不建，强开=leader）");
+  console.log("    MSLXDFF_MULTI_IP_COUNT=N            并行隧道数（缺省 2）");
+  console.log("    MSLXDFF_MULTI_IP_COUNTRY=JP,KR      国家白名单（缺省不限）");
+  console.log(`    MSLXDFF_MULTI_IP_MIN_SCORE=N        节点 Score 下限（缺省 1000000）`);
+  console.log("    MSLXDFF_MULTI_IP_SOURCES=url,url    节点表来源（缺省 VPNGate 官方 https+http，末位挂 aimili 仓库内镜像兜墙）");
+  console.log("    MSLXDFF_MULTI_IP_NODES_FILE=<路径>   本地表文件（排在最前，设了就不打网；配合 -multi-ip-pool fetch 生成）");
+  console.log("    MSLXDFF_MULTI_IP_BASE_TABLE=N       策略路由表起始号（缺省 210）");
+  console.log("    MSLXDFF_MULTI_IP_SYSCTL=0|1         是否放宽 rp_filter（缺省 1）");
+  console.log("    MSLXDFF_MULTI_IP_STANDBY=N          备选出口条数（缺省 5，**上限 5**，0=关）");
+  console.log("    MSLXDFF_MULTI_IP_STANDBY_EVERY_MS=N  备选池刷新周期（缺省 3600000＝每小时重拨一批）");
+  console.log("    MSLXDFF_MULTI_IP_STRATEGY=session    会话粘出口（request＝每请求换出口，会撞冷启动）");
+  console.log("    MSLXDFF_MULTI_IP_PROBE_MODEL=<id>     打 hi 探额度用的免费模型（空＝同款缺省）");
+  process.exit(0);
+  return true;
+}

package/src/cli/index.js

@@ -44,6 +44,9 @@ export async function run(args = process.argv.slice(2)) {
   const { handleV6Pool } = await import("./commands/v6-pool.js");
   if (await handleV6Pool(args)) return;
 
+  const { handleMultiIpPool } = await import("./commands/multi-ip-pool.js");
+  if (await handleMultiIpPool(args)) return;
+
   const { handleProviders, handleProvider } = await import("./commands/provider.js");
   if (await handleProviders(args)) return;
   if (await handleProvider(args)) return;

package/src/multi-ip-pool/config.js

@@ -0,0 +1,155 @@
+// multi-ip-pool · 配置解析：env 优先，缺省值集中一处；纯函数，便于单测。
+//
+// 定位：第三.种出口源（与 v6pool 换本机源地址、warp-pool 换 WARP 出口同层）。
+// 思路参照 aimili-vpngate（VPNGate 免费 OpenVPN 节点当出口），但本模块是：
+//   ① Node 实现（不再需要 Python 侧那套进程/代理）；② **N 槽并行**（参照实现一次只挂 1 条隧道）；
+//   ③ 只服务 opencode 免费层（免费层按**出口 IP** 计额，见 docs/domain-notes.md §5）。
+import { join } from "node:path";
+import { logDir } from "../logs.js";
+
+/**
+ * 缺省**开** + **只有组长建**（用户 2026-10-25 补裁）：`joined` 里存在"自己当组长"的组才建池。
+ * 组员、以及**没带任何组的单机都不建**（这种机器上要用，显式 `MSLXDFF_MULTI_IP_MODE=leader`）。
+ * 另三条硬门：只有 Linux（tun + ip rule）、要 root、要有 openvpn 可执行文件。
+ */
+export const DEFAULTS = {
+  enabled: true,
+  mode: "auto", // auto | leader | member
+  count: 2, // 并行隧道数：每槽一条 openvpn + 一条策略路由表
+  country: "", // 国家白名单（ISO 两字母，逗号分隔；空 = 不限）
+  minScore: 1_000_000, // VPNGate Score 下限（低于它的节点基本连不动）
+  scan: 8, // 起隧道时最多按序尝试多少个候选
+  baseTable: 210, // 策略路由表起始号（避开通信/策略常用表）
+  devPrefix: "mltun", // tun 设备名前缀（留足内核 15 字符上限）
+  probeModel: "", // 「打 hi 探额度」用的免费模型（空 = 与 v6 池对照测试同款）
+  strategy: "session", // 会话粘出口：上游按 session 做粘性路由，每请求换出口会撞冷启动
+  standby: 5, // 备选出口上限（用户定：**不多于 5**；0 = 关备选池）
+  standbyEveryMs: 60 * 60_000, // 备选池刷新周期（每小时重拨一批新 IP）
+  connectTimeoutMs: 25_000, // 等 "Initialization Sequence Completed" 的上限
+  probeTimeoutMs: 20_000, // 探活/出口取证单发超时
+  cooldownMs: 600_000, // 槽失败冷却
+  rotate: true, // 撞额度信号时换槽
+  nodesTtlMs: 30 * 60_000, // 节点表缓存有效期（VPNGate 免费节点掉得快）
+  openvpnBin: "openvpn",
+  authUser: "vpn", // VPNGate 公共账号（非私人凭据）
+  authPass: "vpn",
+  debug: false,
+  sysctl: true, // 放宽 rp_filter（严格反向路径过滤会让隧道"活着但请求挂死"）
+};
+
+/**
+ * VPNGate 节点源：**官方永远在前**，第三方镜像只作兜墙的最后一条。
+ * 镜像 `aimili-vpngate` 仓库内 `mirror/vpngate.csv` 由它的 GitHub Actions **每 15 分钟**从官方表刷新
+ * （cron `7,22,37,52 * * * *`），实测 2026-10-25 与官方**同 15 列同 schema**、99 节点全部可解码 ⇒ 解析器零改动。
+ * 注意：它自己配的那条 GitHub Pages 镜像 `baoweise-bot.github.io/...` 已 404 死（实测），故不采用。
+ * 表内容只是**公开节点的连接配置 + VPNGate 公共账号（vpn/vpn）**，不含任何私人凭据；仍不信任镜像就用
+ * `MSLXDFF_MULTI_IP_SOURCES` 只留官方，或 `MSLXDFF_MULTI_IP_NODES_FILE` 自带一份本地表。
+ */
+export const NODE_SOURCES = [
+  "https://www.vpngate.net/api/iphone/",
+  "http://www.vpngate.net/api/iphone/",
+  "https://raw.githubusercontent.com/OpenMili/aimili-vpngate/main/mirror/vpngate.csv",
+];
+
+const OFF = ["0", "off", "false", "no", "disable", "disabled"];
+const MODES = ["auto", "leader", "member"];
+
+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;
+}
+
+function envList(env, name, fallback = "") {
+  return String(env[name] ?? fallback)
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+/** 备选出口上限：0 = 关；**硬上限 5**（用户 2026-10-25：不多于 5 个备选 IP）。 */
+function standbyCount(env) {
+  const raw = Number(env.MSLXDFF_MULTI_IP_STANDBY);
+  if (!Number.isFinite(raw) || raw < 0) return DEFAULTS.standby;
+  return Math.min(5, Math.floor(raw));
+}
+
+/** 槽 i 的 tun 设备名（内核上限 15 字符：前缀默认 6 + 序号 ≤2 位，安全）。 */
+export function devNameFor(prefix, i) {
+  return `${prefix}${i}`;
+}
+
+/** 槽 i 的策略路由表号（每槽独立表：`ip rule from <tun 地址> lookup <table>`）。 */
+export function tableFor(baseTable, i) {
+  return baseTable + i;
+}
+
+/**
+ * 解析 multi-ip 出口池配置。
+ * @param {Record<string, string|undefined>} env
+ * @param {{ logDirFn?: () => string }} [deps] 测试可注入 logDir
+ */
+export function resolveMultiIpConfig(env = process.env, { logDirFn = logDir } = {}) {
+  const modeRaw = envStr(env, "MSLXDFF_MULTI_IP_MODE", DEFAULTS.mode).toLowerCase();
+  // 受限网络兜墙：`MSLXDFF_MULTI_IP_NODES_FILE` 指的本地表**排在最前**（设了就一次网络都不打）。
+  const nodesFile = envStr(env, "MSLXDFF_MULTI_IP_NODES_FILE", "");
+  const baseSources = envList(env, "MSLXDFF_MULTI_IP_SOURCES").length
+    ? envList(env, "MSLXDFF_MULTI_IP_SOURCES")
+    : NODE_SOURCES;
+  const sources = nodesFile ? [nodesFile, ...baseSources.filter((s) => s !== nodesFile)] : baseSources;
+  return {
+    enabled: envBool(env, "MSLXDFF_MULTI_IP_POOL", DEFAULTS.enabled),
+    mode: MODES.includes(modeRaw) ? modeRaw : DEFAULTS.mode,
+    count: Math.min(8, envInt(env, "MSLXDFF_MULTI_IP_COUNT", DEFAULTS.count)),
+    countries: envList(env, "MSLXDFF_MULTI_IP_COUNTRY").map((c) => c.toUpperCase()),
+    minScore: envInt(env, "MSLXDFF_MULTI_IP_MIN_SCORE", DEFAULTS.minScore),
+    scan: Math.min(32, envInt(env, "MSLXDFF_MULTI_IP_SCAN", DEFAULTS.scan)),
+    baseTable: envInt(env, "MSLXDFF_MULTI_IP_BASE_TABLE", DEFAULTS.baseTable),
+    devPrefix: envStr(env, "MSLXDFF_MULTI_IP_DEV_PREFIX", DEFAULTS.devPrefix),
+    probeModel: envStr(env, "MSLXDFF_MULTI_IP_PROBE_MODEL", DEFAULTS.probeModel),
+    strategy: envStr(env, "MSLXDFF_MULTI_IP_STRATEGY", DEFAULTS.strategy) === "request" ? "request" : "session",
+    standby: standbyCount(env),
+    standbyEveryMs: envInt(env, "MSLXDFF_MULTI_IP_STANDBY_EVERY_MS", DEFAULTS.standbyEveryMs),
+    connectTimeoutMs: envInt(env, "MSLXDFF_MULTI_IP_CONNECT_TIMEOUT_MS", DEFAULTS.connectTimeoutMs),
+    probeTimeoutMs: envInt(env, "MSLXDFF_MULTI_IP_PROBE_TIMEOUT_MS", DEFAULTS.probeTimeoutMs),
+    cooldownMs: envInt(env, "MSLXDFF_MULTI_IP_COOLDOWN_MS", DEFAULTS.cooldownMs),
+    rotate: envBool(env, "MSLXDFF_MULTI_IP_ROTATE", DEFAULTS.rotate),
+    nodesTtlMs: envInt(env, "MSLXDFF_MULTI_IP_NODES_TTL_MS", DEFAULTS.nodesTtlMs),
+    openvpnBin: envStr(env, "MSLXDFF_MULTI_IP_OPENVPN", DEFAULTS.openvpnBin),
+    authUser: envStr(env, "MSLXDFF_MULTI_IP_AUTH_USER", DEFAULTS.authUser),
+    authPass: envStr(env, "MSLXDFF_MULTI_IP_AUTH_PASS", DEFAULTS.authPass),
+    dir: envStr(env, "MSLXDFF_MULTI_IP_DIR", join(logDirFn(), "multi-ip-pool")),
+    sources,
+    nodesFile,
+    debug: envBool(env, "MSLXDFF_MULTI_IP_DEBUG", DEFAULTS.debug),
+    sysctl: envBool(env, "MSLXDFF_MULTI_IP_SYSCTL", DEFAULTS.sysctl),
+  };
+}
+
+/**
+ * 角色门（纯函数）：**只有组长建池**（用户 2026-10-25 补裁）；判据与 `-group` 同口径 —— `joined` 里 `leaderUrl` 为空即本节点是组长。
+ * 纯组员与"没带任何组的单机"都不建；确需强开设 MSLXDFF_MULTI_IP_MODE=leader。
+ * @param {{ mode?: string, joined?: Array<{leaderUrl?: string}> }} opts
+ * @returns {{ active: boolean, role: "leader" | "member" | "solo", why: string }}
+ */
+export function resolveRole({ mode = "auto", joined = [] } = {}) {
+  const list = Array.isArray(joined) ? joined : [];
+  const leads = list.some((g) => g && !g.leaderUrl);
+  const derived = list.length === 0 ? "solo" : leads ? "leader" : "member";
+  // 显式覆盖优先于推导（escape hatch：单机/组员机器上 MSLXDFF_MULTI_IP_MODE=leader 强开）
+  if (mode === "leader") return { active: true, role: "leader", why: "MSLXDFF_MULTI_IP_MODE=leader（显式强开）" };
+  if (mode === "member") return { active: false, role: "member", why: "MSLXDFF_MULTI_IP_MODE=member（显式）" };
+  const why = derived === "leader" ? "本节点是组长（自己带的组）" : derived === "solo"
+    ? "本节点没带任何组（单机）：按「只有组长启用」不建池，要启用请设 MSLXDFF_MULTI_IP_MODE=leader"
+    : "本节点是组员，出口池只由组长建";
+  return { active: derived === "leader", role: derived, why };
+}

package/src/multi-ip-pool/dial.js

@@ -0,0 +1,177 @@
+// multi-ip-pool · 拨号与体检：候选队列 → 起一条隧道 → **打一个 hi 到上游要它 200** → 才算可用出口。
+//
+// 为什么"要 200"而不是"能连上就行"（用户 2026-10-25 定）：
+//   这条池的唯一目的是**换新额度**。隧道起来了但那个 IP 已经没额度（429/403），拿它换出口等于白换——
+//   所以判据必须是"这个出口现在真能出活"，即免费层 chat 打 `hi` 回 **200**。
+//   请求形状复用 `v6pool/selftest.js`（`stream:true` + 五核心工具名 + 身份四件套）：缺任何一项上游回
+//   **403 FreeTierError 而不是 429**，那测的是形状、不是额度（真机 2026-10-19 踩过）。
+// 拆成独立模块的原因：装配（index）、拨号（本文件）、备选池（standby）三件事各自都要单测，混一起必超 10KB 门。
+import { getUndici } from "../compat.js";
+import { DEFAULT_PROBE_MODEL, probeUpstreamFrom } from "../v6pool/selftest.js";
+import { candidateNodes, loadNodeCache, materializeNode } from "./nodes.js";
+import { fetchNodes, probeExitIp } from "./nodes-fetch.js";
+import { bringUpTunnel, tearDownTunnel } from "./tunnel.js";
+import { AGENT_OPTIONS } from "./dispatch.js";
+import { fmtExitIpFail, fmtHi, fmtNodePick, fmtNodes } from "./report.js";
+
+/**
+ * @param {{ cfg: object, baseUrl?: string, log?: Function, deps?: {
+ *            bringUpTunnel?, tearDownTunnel?, materializeNode?, fetchNodes?, loadNodeCache?, probeExitIp?,
+ *            probeHi?, agentFactory?, fetchImpl?, runCmdFn?, spawnFn?, wait?, authFile?, probeSession? } }} opts
+ */
+export function createDialer({ cfg, baseUrl = "https://opencode.ai", log = () => {}, deps = {} } = {}) {
+  const startSlot = deps.bringUpTunnel || bringUpTunnel;
+  const stopSlot = deps.tearDownTunnel || tearDownTunnel;
+  const materialize = deps.materializeNode || materializeNode;
+  const probeExit = deps.probeExitIp || probeExitIp;
+  const probeHi = deps.probeHi || probeUpstreamFrom;
+  const { Agent } = getUndici();
+  const agentFactory = deps.agentFactory || ((addr) => new Agent({ connect: { localAddress: addr }, ...AGENT_OPTIONS }));
+
+  /** 本拨号器起过的所有隧道（含备用的）：退出钩子与 close 都从这儿收，一条都不许漏。 */
+  const tunnels = new Set();
+  const used = new Set(); // 已试过的节点（含正在用的）：绝不重复拨同一台
+  let pending = [];
+  let source = "(未取表)";
+  let authFile = deps.authFile || "";
+
+  function setAuthFile(f) {
+    authFile = f || "";
+  }
+
+  /** 探额度用的免费模型（上游不同模型额度池可能独立，需要时可换）。 */
+  function probeModel() {
+    return cfg.probeModel || DEFAULT_PROBE_MODEL;
+  }
+
+  /**
+   * 「打一个 hi，要 200」：一发请求同时拿两个读数——**有没有额度**（status）与**真实出口 IP**（取证）。
+   * @returns {Promise<{ok: boolean, status: number, kind: string, ms: number, ip: string, error: string}>}
+   */
+  async function hiProbe(entry) {
+    const r = await probeHi({
+      addr: entry.tunIp,
+      model: probeModel(),
+      baseUrl,
+      agentFactory,
+      fetchImpl: deps.fetchImpl,
+      session: deps.probeSession,
+    });
+    let ip = entry.exitIp || "";
+    if (!ip) {
+      const agent = agentFactory(entry.tunIp);
+      try {
+        const e = await probeExit({ agent, timeoutMs: cfg.probeTimeoutMs, fetchImpl: deps.fetchImpl });
+        ip = e.ip || "";
+      } finally {
+        try {
+          await agent.close?.();
+        } catch {
+          /* 一次性 Agent */
+        }
+      }
+    }
+    return { ok: Boolean(r.ok), status: Number(r.status) || 0, kind: r.kind || "", ms: Number(r.ms) || 0, ip, error: r.error || "" };
+  }
+
+  /** 取节点表 → 候选队列（按 Score 降序，剔除已用过的）；`force` = 绕过缓存重取（每小时刷新备选池用）。 */
+  async function ensureCandidates({ force = false } = {}) {
+    if (!force && pending.length) return pending.length;
+    let rows = [];
+    if (!force) {
+      const cache = (deps.loadNodeCache || loadNodeCache)({ dir: cfg.dir, ttlMs: cfg.nodesTtlMs });
+      if (cache?.rows?.length) {
+        rows = cache.rows;
+        source = cache.source || "(本地缓存)";
+      }
+    }
+    if (!rows.length) {
+      const got = await (deps.fetchNodes || fetchNodes)({ sources: cfg.sources, dir: cfg.dir, timeoutMs: cfg.probeTimeoutMs, log });
+      rows = got.rows;
+      source = got.source;
+    }
+    pending = candidateNodes({ rows, countries: cfg.countries, minScore: cfg.minScore, skip: used, scan: cfg.scan * (cfg.count + cfg.standby + 1) });
+    log(fmtNodes({ source, total: rows.length, countries: cfg.countries, minScore: cfg.minScore }));
+    return pending.length;
+  }
+
+  /** 拆一条隧道并忘掉它（先撤策略路由再收子进程，见 tunnel.js）。 */
+  async function drop(entry, why = "") {
+    if (!entry) return;
+    tunnels.delete(entry);
+    try {
+      await stopSlot({ slot: entry, runCmdFn: deps.runCmdFn, log });
+    } catch (e) {
+      log(`[multi-ip-pool] ${entry.dev} 拆隧道没拆干净：${String(e?.message || e)}${why ? `（${why}）` : ""}`);
+    }
+  }
+
+  /**
+   * 开一个出口：按序试候选，每个都走「起隧道 → hi 要 200」，**不 200 当场拆掉换下一个**。
+   * 为什么这道闸门必须有：隧道进程活着但转不动流量、或那个 IP 早已没额度时，把它塞进池等于
+   * 把请求挂到超时或继续 429——比直连更糟（与 WARP 池 probeGate 同一纪律）。
+   * @returns {Promise<null | { dev, table, priority, tunIp, pid, stop, node, exitIp }>}
+   */
+  async function openSlot(slotIndex, { dev = "", gate = true } = {}) {
+    for (let attempt = 1; attempt <= cfg.scan; attempt++) {
+      if (!pending.length) {
+        try {
+          await ensureCandidates();
+        } catch (e) {
+          log(`[multi-ip-pool] 取节点表失败：${String(e?.message || e)}`);
+          return null;
+        }
+        if (!pending.length) return null;
+      }
+      const row = pending.shift();
+      if (!row || used.has(row.hostName)) continue;
+      used.add(row.hostName);
+      log(fmtNodePick({ i: attempt, n: cfg.scan, row, dev }));
+      let slot = null;
+      try {
+        let node = row;
+        if (!node.conf) {
+          node = materialize({ dir: cfg.dir, row });
+          if (!node) throw new Error("节点配置解不开（base64 或 remote 缺失）");
+        }
+        slot = await startSlot({
+          cfg,
+          slotIndex,
+          node,
+          deps: { authFile, runCmdFn: deps.runCmdFn, spawnFn: deps.spawnFn, wait: deps.wait, log, onExit: () => tunnels.delete(slot) },
+        });
+        tunnels.add(slot);
+        const p = await hiProbe(slot);
+        log(fmtHi({ dev: slot.dev, model: probeModel(), ip: p.ip, ...p }));
+        if (!p.ip) log(fmtExitIpFail({ dev: slot.dev, error: p.error || "出口取证无响应" }));
+        if (gate && p.status !== 200) {
+          await drop(slot, "hi 未回 200");
+          continue;
+        }
+        return { ...slot, node, exitIp: p.ip || "" };
+      } catch (e) {
+        await drop(slot);
+        log(`[multi-ip-pool] ${slot?.dev || `${cfg.devPrefix}${slotIndex}`} 起隧道失败：${String(e?.message || e)}`);
+      }
+    }
+    return null;
+  }
+
+  return {
+    tunnels,
+    agentFactory,
+    used,
+    setAuthFile,
+    probeModel,
+    hiProbe,
+    ensureCandidates,
+    openSlot,
+    drop,
+    get sourceLabel() {
+      return source;
+    },
+    get pendingCount() {
+      return pending.length;
+    },
+  };
+}