mslxdff 0.1.244 → 0.1.246

package/src/multi-ip-pool/nodes-fetch.js

@@ -1,110 +0,0 @@
-// multi-ip-pool · 节点表与出口的**网络侧**：取表（多源回退 + 本地表文件）/ 出口 IP 取证 / fetch 失败归因。
-//
-// 为什么单独一份：出口池的成败在受限网络里完全取决于「表取不取得到」，这一层的诊断信息
-// （DNS 污染 / 连接被掐 / 超时）必须与解析层分开演进。纯解析与落盘在 ./nodes.js，本文件只碰网络。
-import { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { compatFetch, getUndici, timeoutSignal } from "../compat.js";
-import { EXIT_PROBE_URL, parseExitIp } from "../warp-pool/revive.js";
-import { parseVpnGateCsv, saveNodeCache } from "./nodes.js";
-
-/**
- * fetch 失败的人话原因：undici 一律只回 `fetch failed`，真凶在 `e.cause`。
- * 这个区分是**功能性的**：受限网络下 ENOTFOUND（DNS 污染）与 ECONNRESET（连接被掐）
- * 与超时（IP 被墙）意味着完全不同的对策，糊成一句「fetch failed」等于没诊断。
- */
-export function describeFetchError(e) {
-  const c = e?.cause || {};
-  const code = String(c.code || c.errno || "");
-  const msg = String(c.message || e?.message || "");
-  if (code === "ENOTFOUND") return "DNS 解析失败 ENOTFOUND（域名可能被污染或不存在）";
-  if (code === "EAI_AGAIN") return "DNS 暂时解析不了 EAI_AGAIN（当前网络解析不了这个域）";
-  if (code === "ECONNREFUSED") return "连接被拒 ECONNREFUSED（端口没开或服务已下线）";
-  if (code === "ECONNRESET" || code === "EPIPE") return "连接被重置 ECONNRESET（中途被掐断，常见于墙/防火墙）";
-  if (code === "ETIMEDOUT" || /timeout|timed out|deadline|abort/i.test(msg)) return "连接超时（IP 不可达或被静默丢包）";
-  if (/cert|self-signed|SSL|TLS|handshake/i.test(msg + code)) return `TLS 握手失败 ${code || msg}`.trim();
-  if (code) return `网络失败 ${code}`;
-  return (msg || String(e || "未知原因")).slice(0, 70);
-}
-
-/** 把任何异常归成人话（有 cause 走 fetch 归因，否则取 message）。 */
-export function errorWhy(e) {
-  return e && e.cause ? describeFetchError(e) : String(e?.message || e);
-}
-
-/** 节点源 scheme 判定：`http(s)://` 走 fetch；`file://` 与裸路径都当**本地表文件**（受限网络「抓一份带过去」）。 */
-export function sourceToLocalPath(url) {
-  const s = String(url || "").trim();
-  if (!s || /^https?:\/\//i.test(s)) return null;
-  if (/^file:\/\/\//i.test(s) || /^file:\/\//i.test(s)) {
-    try {
-      return fileURLToPath(s);
-    } catch {
-      return s.replace(/^file:\/\/\/?/i, "");
-    }
-  }
-  return s;
-}
-
-/**
- * 逐源尝试取表；任一源返回可解析的 CSV 即成功（并顺手写缓存）。
- * 全失败时**逐源原因都进异常**（受限网络下「为什么取不到」就是用户唯一的线索）。
- * @returns {Promise<{ source: string, rows: object[], text: string }>} text 是原始 CSV，供 `fetchNodesToFile` 落盘
- */
-export async function fetchNodes({ sources = [], dir = "", fetchImpl, timeoutMs = 20_000, now = () => Date.now(), log = () => {} } = {}) {
-  const f = fetchImpl || getUndici().fetch || compatFetch;
-  const fails = [];
-  for (const url of sources) {
-    try {
-      const local = sourceToLocalPath(url);
-      let text = "";
-      if (local !== null) {
-        text = readFileSync(local, "utf8");
-      } else {
-        const res = await f(url, { signal: timeoutSignal(timeoutMs) });
-        if (!res.ok) throw new Error(`HTTP ${res.status}`);
-        text = await res.text();
-      }
-      const rows = parseVpnGateCsv(text);
-      if (!rows.length) throw new Error("返回体不是可解析的 VPNGate CSV");
-      log(`[multi-ip-pool] 节点表取自 ${url}（${rows.length} 个节点）`);
-      if (dir) saveNodeCache({ dir, source: url, rows, now });
-      return { source: url, rows, text };
-    } catch (e) {
-      const why = errorWhy(e);
-      fails.push(`${url}：${why}`);
-      log(`[multi-ip-pool] 节点源失败 ${url}：${why}`);
-    }
-  }
-  throw new Error(fails.length ? `全部 ${fails.length} 个节点源都失败 → ${fails.join(" ｜ ")}` : "没配任何节点源（MSLXDFF_MULTI_IP_SOURCES 为空）");
-}
-
-/**
- * 取表并原样落一份 CSV（`-multi-ip-pool fetch` 的实现）：在能连的机器上抓，scp 进受限网络的组长机，
- * 那边 `MSLXDFF_MULTI_IP_NODES_FILE=<路径>` 即可零网络取表。0600：表里是节点凭据，不该给同机用户读。
- */
-export async function fetchNodesToFile({ sources = [], out, fetchImpl, timeoutMs = 20_000, log } = {}) {
-  const got = await fetchNodes({ sources, fetchImpl, timeoutMs, log });
-  mkdirSync(dirname(out), { recursive: true });
-  writeFileSync(out, got.text, { mode: 0o600 });
-  return { ...got, out, file: out };
-}
-
-/**
- * 出口取证：从某槽的 tun 地址出网，读回真实出口 IP（照 warp-pool/revive.js 的同源判据）。
- * 这是「换 IP 到底换没换动」的直接证据——没有它，日志只能说"起了隧道"，说不了"出口变了"。
- * @returns {Promise<{ ok: boolean, ip: string, ms: number, error?: string }>}
- */
-export async function probeExitIp({ agent, fetchImpl, timeoutMs = 12_000 } = {}) {
-  const t0 = Date.now();
-  try {
-    const f = fetchImpl || getUndici().fetch || compatFetch;
-    const res = await f(EXIT_PROBE_URL, { ...(agent ? { dispatcher: agent } : {}), signal: timeoutSignal(timeoutMs) });
-    const text = await res.text();
-    const ip = parseExitIp(text);
-    return { ok: Boolean(ip), ip, ms: Date.now() - t0, ...(ip ? {} : { error: `取证响应认不出出口 IP：${text.slice(0, 80)}` }) };
-  } catch (e) {
-    return { ok: false, ip: "", ms: Date.now() - t0, error: errorWhy(e) };
-  }
-}

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

@@ -1,205 +0,0 @@
-// multi-ip-pool · VPNGate 节点表（**纯解析与落盘**侧）：解 CSV → 解 base64 配置 → 筛候选 → 落 conf/缓存。
-//
-// 为什么要拆开：出口 IP 的**来源**就是这些免费志愿者节点（参照实现 aimili-vpngate 用同一份 CSV），
-// 但「取表」在受限网络里是独立的成败关口，它的诊断逻辑单独住在 ./nodes-fetch.js（fetch/归因/出口取证）。
-// 纪律：候选的 conf / auth 一律 0600 落在**非工作树**目录（默认 logDir()/multi-ip-pool）。
-import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-/** CSV 列序（VPNGate `/api/iphone/`）：末列是 base64 配置，其余为节点元数据。 */
-export const VPNGATE_FIELDS = [
-  "hostName", "ip", "score", "ping", "speed", "countryLong", "countryShort",
-  "sessions", "uptime", "totalUsers", "totalTraffic", "logType", "operator", "message", "config",
-];
-
-const CACHE_FILE = "nodes.json";
-
-/** 0755 目录 + 0600 文件：conf 里有 VPNGate 的公证书与账号行，不该给同机其它用户读。 */
-function ensureDir(dir) {
-  mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-function writePrivate(file, text) {
-  writeFileSync(file, text, { mode: 0o600 });
-  // mode 只在新建时生效：存量文件补 chmod（照 AGENTS.md 的凭据落地纪律）
-  try {
-    chmodSync(file, 0o600);
-  } catch {
-    /* Windows / 不支持 chmod 的文件系统：忽略 */
-  }
-  return file;
-}
-
-/**
- * 解析 VPNGate CSV。只认「首列是 hostName 的数据行」：
- * 以 `*` 开头的是注释行、以 `#` 开头的是表头。
- * Message 列理论上可能含逗号 ⇒ **末列永远是 config**（base64 不含逗号），中间多余的列并回 message。
- */
-export function parseVpnGateCsv(text) {
-  const rows = [];
-  for (const rawLine of String(text || "").split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("*") || line.startsWith("#")) continue;
-    const parts = line.split(",");
-    if (parts.length < VPNGATE_FIELDS.length) continue;
-    const n = parts.length;
-    const row = {
-      hostName: parts[0],
-      ip: parts[1],
-      score: Number(parts[2]) || 0,
-      ping: Number(parts[3]) || 0,
-      speed: Number(parts[4]) || 0,
-      countryLong: parts[5],
-      countryShort: parts[6],
-      sessions: Number(parts[7]) || 0,
-      uptime: Number(parts[8]) || 0,
-      totalUsers: Number(parts[9]) || 0,
-      totalTraffic: Number(parts[10]) || 0,
-      logType: parts[11],
-      operator: parts[12],
-      message: parts.slice(13, n - 1).join(","),
-      config: parts[n - 1],
-    };
-    if (!row.hostName || !row.config) continue;
-    rows.push(row);
-  }
-  return rows;
-}
-
-/** base64 → OpenVPN 配置文本；不是一份能用的 client 配置就返回空串（绝不猜）。 */
-export function decodeConfig(b64) {
-  let text = "";
-  try {
-    text = Buffer.from(String(b64 || ""), "base64").toString("utf8");
-  } catch {
-    return "";
-  }
-  if (!/\bclient\b/.test(text) || !/^\s*remote\s+\S+/m.test(text)) return "";
-  return text;
-}
-
-/** 从配置文本里读出 `remote <host> <port>`（缺端口按 OpenVPN 默认 1194）。 */
-export function parseRemote(conf) {
-  const m = /^\s*remote\s+(\S+)(?:\s+(\d+))?/m.exec(String(conf || ""));
-  if (!m) return null;
-  return { host: m[1], port: m[2] ? Number(m[2]) : 1194 };
-}
-
-/** 国家白名单判据：空 = 不限；否则比对 ISO 两字母或全称（大小写无关）。 */
-export function matchCountry(row, countries = []) {
-  if (!countries.length) return true;
-  const short = String(row?.countryShort || "").toUpperCase();
-  const long = String(row?.countryLong || "").toUpperCase();
-  return countries.some((c) => c === short || c === long);
-}
-
-/**
- * 候选队列：按 Score 降序（Score 是 VPNGate 官方"还活着且跑得动"的综合分）。
- * @param {{ rows?: object[], countries?: string[], minScore?: number, scan?: number, skip?: Set<string> }} opts
- */
-export function candidateNodes({ rows = [], countries = [], minScore = 0, scan = 8, skip = new Set() } = {}) {
-  return rows
-    .filter((r) => r.config && r.score >= minScore && matchCountry(r, countries) && !skip.has(r.hostName))
-    .sort((a, b) => b.score - a.score || a.ping - b.ping)
-    .slice(0, scan);
-}
-
-/**
- * 节点「簇」：同一批免费节点往往同机房同网段（hostName 同前缀 + 同 /24），**一条连不上时整片都连不上**。
- * 真机 2026-10-25 实证：按 Score 取 3 个候选全落在 `public-vpn-*` / `219.100.37.x`，
- * 于是「一个机房的墙」被误读成「全部节点不通」。取样与候选排序都必须按簇摊开。
- */
-export function clusterOf(row) {
-  const host = String(row?.hostName || "").replace(/[-.\d]+$/, "");
-  const seg = String(row?.ip || "").split(".").slice(0, 3).join(".");
-  return `${host}|${seg}`;
-}
-
-/** 达标候选条数（只数不取：给「取样里有几个是达标的」这类结论用）。 */
-export function countCandidates({ rows = [], countries = [], minScore = 0 } = {}) {
-  return rows.filter((r) => r.config && r.score >= minScore && matchCountry(r, countries)).length;
-}
-
-/**
- * 取样候选：Score 降序，但**按簇轮转**（先每个机房各出一条，再轮到各家第二条…）。
- * 为什么不沿用纯 Score 序：免费表前列常被同一个机房霸榜，纯排序取样＝拿一个机房的运气赌整台机器能不能用。
- * 轮转不丢节点——簇内仍是 Score 降序，只是把同簇的连续几条摊到后面几轮去。
- * @param {{ rows?: object[], countries?: string[], minScore?: number, limit?: number,
- *           perCluster?: number, skip?: Set<string> }} opts perCluster=0 表示不设每簇上限
- */
-export function sampleCandidates({ rows = [], countries = [], minScore = 0, limit = 12, perCluster = 0, skip = new Set() } = {}) {
-  const pool = candidateNodes({ rows, countries, minScore, scan: Math.max(1, rows.length), skip });
-  const groups = new Map();
-  for (const r of pool) {
-    const key = clusterOf(r);
-    if (!groups.has(key)) groups.set(key, []);
-    groups.get(key).push(r);
-  }
-  const out = [];
-  for (let round = 0; out.length < limit && groups.size; round++) {
-    let added = 0;
-    for (const list of groups.values()) {
-      if (out.length >= limit) break;
-      if (round >= list.length || (perCluster > 0 && round >= perCluster)) continue;
-      out.push(list[round]);
-      added += 1;
-    }
-    if (!added) break; // 各簇都取空了
-  }
-  return out;
-}
-
-/** 只读地把一行解成「探什么/拨什么」（不落文件）：TCP 预检与选槽共用同一份解析。 */
-export function probeTargetOf(row) {
-  const conf = decodeConfig(row?.config);
-  if (!conf) return null;
-  const remote = parseRemote(conf);
-  if (!remote) return null;
-  return { decoded: conf, host: remote.host, port: remote.port, proto: (/^\s*proto\s+(\S+)/m.exec(conf) || [])[1] || "" };
-}
-
-/** 节点表缓存（TTL 内直接用，省一次外网请求；VPNGate 免费节点掉得快，默认 30min）。 */
-export function loadNodeCache({ dir, ttlMs = 0, now = () => Date.now() } = {}) {
-  try {
-    const raw = JSON.parse(readFileSync(join(dir, CACHE_FILE), "utf8"));
-    if (!Array.isArray(raw?.rows) || !raw.rows.length) return null;
-    if (ttlMs > 0 && now() - Number(raw.fetchedAt || 0) > ttlMs) return null;
-    return raw;
-  } catch {
-    return null;
-  }
-}
-
-export function saveNodeCache({ dir, source = "", rows = [], now = () => Date.now() } = {}) {
-  ensureDir(dir);
-  const payload = { fetchedAt: now(), source, rows };
-  writePrivate(join(dir, CACHE_FILE), JSON.stringify(payload));
-  return payload;
-}
-
-
-/** 落一份 node conf（设备名/路由由 CLI 覆盖，不改原配置文本）；返回文件路径。 */
-export function writeNodeConf({ dir, row, name = "" } = {}) {
-  ensureDir(dir);
-  const safe = String(row.hostName || "node").replace(/[^\w.-]/g, "_").slice(0, 48);
-  const alias = name || `${safe}-${row.ip}`;
-  return { path: writePrivate(join(dir, `node-${alias}.conf`), row.config), hostName: row.hostName };
-}
-
-/** writeNodeConf 落的是**解码后**的配置；这里复用 `probeTargetOf` 解码：
- * 解不开或缺 remote 的节点一律返 null（绝不猜），绝不把坏配置交给 openvpn。 */
-export function materializeNode({ dir, row, name = "" } = {}) {
-  const target = probeTargetOf(row);
-  if (!target) return null;
-  // 落盘的是解码后的配置文本；别名照旧按 hostName/ip 生成（与旧行为一致）
-  const written = writeNodeConf({ dir, row: { ...row, config: target.decoded }, name });
-  // host/port/proto 与 TCP 预检同源（都出自 `probeTargetOf`）：预检探的与这里拨的必须是同一份解释
-  return { ...row, conf: written.path, host: target.host, port: target.port, proto: target.proto };
-}
-
-/** VPNGate 公共账号（vpn/vpn）；落在 0600 文件里，绝不入库。 */
-export function writeAuthFile({ dir, user = "vpn", pass = "vpn" } = {}) {
-  ensureDir(dir);
-  return writePrivate(join(dir, "auth.txt"), `${user}\n${pass}\n`);
-}

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

@@ -1,162 +0,0 @@
-// multi-ip-pool · 日志文案（判据来自 warp-pool/report.js 的同一套纪律）：
-//   **「看完日志还需要的下一个命令，就是日志没写好的地方」**。
-//   行首符号：▸步骤 / ✓正常 / ✗失败 / ⚠警告；每条失败行都要带「为什么 + 下一步」。
-const SYM = { step: "▸", ok: "✓", bad: "✗", warn: "⚠" };
-const TAG = "[multi-ip-pool]";
-
-export function fmtConfig(cfg) {
-  return `${TAG} ${SYM.step} 多出口池配置：隧道 ${cfg.count} 条｜备选 ${cfg.standby} 条（每 ${Math.round((cfg.standbyEveryMs || 0) / 60_000)} 分钟重拨一批）｜打 hi 用 ${cfg.probeModel || "缺省免费模型"}｜国家 ${cfg.countries.length ? cfg.countries.join("/") : "不限"}｜Score ≥ ${cfg.minScore}｜表号 ${cfg.baseTable}+｜目录 ${cfg.dir}｜openvpn ${cfg.openvpnBin}｜轮换 ${cfg.rotate ? "开" : "关"}`;
-}
-
-export function fmtDisabled() {
-  return `${TAG} 出口池已关闭（MSLXDFF_MULTI_IP_POOL=0），请求走直连`;
-}
-
-export function fmtRoleSkip({ role, why }) {
-  return `${TAG} ${SYM.step} 跳过：本节点角色=${role}（${why}）—— 出口池只由组长建，组员与单机都不建`;
-}
-
-export function fmtRoleOk({ role, why }) {
-  return `${TAG} ${SYM.ok} 角色门通过：role=${role}（${why}）`;
-}
-
-export function fmtPlatformSkip({ platform, why }) {
-  return `${TAG} ${SYM.step} 跳过：${why}（当前平台 ${platform}）—— 本功能要 Linux 的 tun 设备与 ip rule，其它平台请用 v6 池或 WARP 池`;
-}
-
-export function fmtNoRoot() {
-  return `${TAG} ${SYM.step} 跳过：需要 root（要建 tun 设备 + 改策略路由 + 写 rp_filter）。下一步：sudo mslxdff -multi-ip-pool test（或让 root 起 daemon）`;
-}
-
-export function fmtNoOpenvpn({ bin, why }) {
-  return `${TAG} ${SYM.step} 跳过：没找到可用的 ${bin}（${why}）。下一步：apt install openvpn（或 MSLXDFF_MULTI_IP_OPENVPN 指到全路径）`;
-}
-
-export function fmtNodes({ source, total, countries, minScore }) {
-  return `${TAG} ${SYM.ok} 节点表来自 ${source}：共 ${total} 个节点（筛选：国家 ${countries.length ? countries.join("/") : "不限"}、Score ≥ ${minScore}）`;
-}
-
-export function fmtNodePick({ i, n, row, dev }) {
-  return `${TAG} ${SYM.step} [${i}/${n}] 尝试 ${row.hostName}（${row.countryShort || "?"} ${row.ip} Score=${row.score} ping=${row.ping}ms）→ ${dev}`;
-}
-
-export function fmtSpawn({ dev, pid, host, port, country, table }) {
-  return `${TAG} ${SYM.ok} ${dev} 隧道就绪（pid=${pid}，出口节点 ${host}:${port} ${country}，策略表 ${table}）`;
-}
-
-/** 实际执行的 openvpn 命令行（argv 原文）：真机排障第一问就是「你到底跑了什么」。 */
-export function fmtArgv({ bin, args }) {
-  return `${TAG} ${SYM.step} 执行：${bin} ${(args || []).join(" ")}`;
-}
-
-export function fmtTunAddrFail({ dev, out }) {
-  return `${TAG} ${SYM.bad} ${dev} 起来了但读不到 tun 地址（ip -4 addr show dev ${dev} 的输出：${(out || "(空)").slice(0, 200)}）—— 隧道建不起来，这槽换下一个节点`;
-}
-
-export function fmtRuleFail({ dev, cmd, error }) {
-  return `${TAG} ${SYM.bad} ${dev} 装策略路由失败：${cmd} → ${error}。下一步：ip rule show 看优先级、ip route show table all 看表号，是否被别人的规则/表号占了（可改 MSLXDFF_MULTI_IP_BASE_TABLE）`;
-}
-
-export function fmtRpf({ ok, skipped, changed = [], error = "" } = {}) {
-  if (skipped) return `${TAG} ${SYM.warn} rp_filter 未改（MSLXDFF_MULTI_IP_SYSCTL=0）：若隧道通了但请求全挂住，先查这里`;
-  if (ok && !changed.length) return `${TAG} ${SYM.ok} rp_filter 已是宽松模式（2），无需改动`;
-  if (ok) return `${TAG} ${SYM.warn} 已把 rp_filter 改为 2（宽松）：${changed.map((c) => `${c.path}: ${c.from}→2`).join("，")}｜还原命令：sysctl -w net.ipv4.conf.all.rp_filter=1`;
-  return `${TAG} ${SYM.warn} rp_filter 改不动（${error}）：可能隧道活着但请求挂住（不对称路由被内核丢了）。下一步：sysctl -w net.ipv4.conf.all.rp_filter=2`;
-}
-
-export function fmtProbe({ dev, url, ok, status, error, ms }) {
-  if (ok) return `${TAG} ${SYM.ok} ${dev} 探活通过：${url} → HTTP ${status}（${ms}ms）`;
-  return `${TAG} ${SYM.bad} ${dev} 探活不通：${url} → ${status ? `HTTP ${status}` : String(error || "无响应").slice(0, 120)}（${ms}ms）`;
-}
-
-export function fmtProbeGiveUp({ dev, attempts, url }) {
-  return `${TAG} ${SYM.bad} ${dev} 连续 ${attempts} 次探活都不过，本槽不进池（${url}）—— 隧道进程活着但转不动流量时进池会把请求挂到超时，比直连更糟`;
-}
-
-export function fmtExitIp({ dev, ip, ms, prev }) {
-  const what = prev ? (prev === ip ? `出口没变（仍是 ${ip}）` : `出口已换：${prev} → ${ip}`) : `出口 ${ip}`;
-  return `${TAG} ${SYM.ok} ${dev} 出口取证：${what}（${ms}ms）`;
-}
-
-export function fmtExitIpFail({ dev, error }) {
-  return `${TAG} ${SYM.bad} ${dev} 出口取证失败：${String(error || "").slice(0, 160)}—— 这条隧道的出口未知，不视为可用`;
-}
-
-export function fmtPool({ pooled, tried, exits }) {
-  return `${TAG} ${SYM.ok} 出口池就绪：${pooled}/${tried} 槽可用｜出口 IP：${exits.length ? exits.join("，") : "(待取证)"}`;
-}
-
-export function fmtPoolEmpty({ tried, why }) {
-  return `${TAG} ${SYM.bad} 出口池为空（试了 ${tried} 个节点都没起通）：${why}—— 请求继续走直连，不影响其它出口源`;
-}
-
-export function fmtSwap({ dev, from, to, status, kind, forced, swaps }) {
-  return `${TAG} ${SYM.step} ${dev} 上游 ${status} 判为「${kind}」⇒ 换出口${forced ? "（强制，跳过冷却）" : ""}：${from} → ${to}（第 ${swaps} 次换）`;
-}
-
-export function fmtSwapFail({ dev, error }) {
-  return `${TAG} ${SYM.bad} ${dev} 换出口失败：${String(error || "").slice(0, 200)}—— 原槽保持原状，不把池打空`;
-}
-
-export function fmtFirstOk({ dev, ip, swaps, counts }) {
-  return `${TAG} ${SYM.ok} ${dev} 换出口后首个 200（出口 ${ip}，换过 ${swaps} 次，本轮状态分布 ${JSON.stringify(counts)}）—— 这就是「换 IP 有没有换来新额度」的直接证据`;
-}
-
-export function fmtNoRotate({ dev, status, kind }) {
-  return `${TAG} ${SYM.warn} ${dev} 上游 ${status}（${kind}）—— 轮换开关关着（MSLXDFF_MULTI_IP_ROTATE=0），不换出口`;
-}
-
-export function fmtVerdictNo({ dev, status, kind, why }) {
-  return `${TAG} ${SYM.step} ${dev} 上游 ${status} 判为「${kind}」⇒ 不换出口：${why}`;
-}
-
-export function fmtDirect({ reason }) {
-  return `${TAG} ${SYM.warn} 全部槽都在冷却/换出口中，本发走直连兜底：${reason}`;
-}
-
-export function fmtExit({ dev, code, signal, pid, aliveMs, tail }) {
-  return `${TAG} ${SYM.warn} ${dev} 隧道进程退出（code=${code} signal=${signal} pid=${pid}${aliveMs ? ` 存活 ${Math.round(aliveMs / 1000)}s` : ""}）：${tail || "(无输出)"}`;
-}
-
-export function fmtClose({ closed, failed = 0 }) {
-  return `${TAG} ${SYM.step} 收摊：已关 ${closed} 条隧道${failed ? `，${failed} 条没关干净（下次启动查残留：ip link show | grep ${""}mltun）` : ""}`;
-}
-
-export function fmtResidual({ dev }) {
-  return `${TAG} ${SYM.warn} 发现上一代留下的设备 ${dev}（上次 daemon 被强杀时子进程不会自己退）：下一步 ip link del ${dev}`;
-}
-
-/** 免费层判决的人话名（与 `warp-pool/verdict.js` 的 kind 一一对应，不自造一套）。 */
-const KIND_ZH = { "free-quota": "429 额度耗尽", "free-tier": "403 免费层资格", "ip-limit": "429 限流", "black-quota": "账号日配额", network: "网络不可达", none: "非额度信号" };
-
-/** 「打一个 hi 到上游、要它 200」的读数行：只有 200 才算"这个出口此刻真有额度"。 */
-export function fmtHi({ dev, model, status, kind, ip, ms, error } = {}) {
-  const who = `${dev}${ip ? `（出口 ${ip}）` : ""}`;
-  if (status === 200) return `${TAG} ${SYM.ok} ${who} 打 hi 通过：${model} → HTTP 200（${ms}ms）—— 这个出口有额度`;
-  return `${TAG} ${SYM.bad} ${who} 打 hi 未通：${model} → ${status ? `HTTP ${status}（${KIND_ZH[kind] || kind || "?"}）` : String(error || "无响应").slice(0, 120)}（${ms}ms）—— 没额度的出口不当备用，换下一个`;
-}
-
-/** 备用出口收下：一条已验通（hi 200）的隧道躺在备选池里等 429。 */
-export function fmtStandbyAdd({ dev, node, exitIp, tunIp, have, want } = {}) {
-  return `${TAG} ${SYM.ok} 备选池 +1：${dev} ${node || "?"}（tun ${tunIp}，出口 ${exitIp || "未取证"}）→ 现有 ${have}/${want} 条待命`;
-}
-
-/** 补位结论行（每小时一次，也是"这轮找到几个新 IP"的读数）。 */
-export function fmtStandbyRefill({ added, have, want, dialed } = {}) {
-  return `${TAG} ${SYM.step} 备选池补位：本轮拨 ${dialed} 条、收下 ${added} 条 → ${have}/${want} 待命（标准是 hi 回 200，不是"隧道起来了"）`;
-}
-
-/** 取用备用出口那一刻的读数（429 后"立即启用"的证据）。 */
-export function fmtStandbyUse({ dev, tunIp, exitIp, node, left } = {}) {
-  return `${TAG} ${SYM.ok} 启用备用出口：${dev} ${node || "?"}（tun ${tunIp}，出口 ${exitIp || "未取证"}）→ 剩余备用 ${left} 条`;
-}
-
-/** 备用出口被丢弃的原因（复验没过 200 = 这一小时里那个 IP 的额度被别人吃光了）。 */
-export function fmtStandbyDrop({ dev, node, status, kind, error } = {}) {
-  return `${TAG} ${SYM.warn} 丢弃备用出口 ${dev} ${node || "?"}：复验 hi → ${status ? `HTTP ${status}（${KIND_ZH[kind] || kind || "?"}）` : String(error || "无响应").slice(0, 120)}—— 宁缺毋滥，不把没额度的 IP 交给请求`;
-}
-
-/** 备选池这轮没干成事（取不到候选 / 拨号异常）：必须留一行，否则"为什么没有备胎"无从判断。 */
-export function fmtStandbySkip({ why } = {}) {
-  return `${TAG} ${SYM.warn} 备选池本轮跳过：${why}—— 429 时若备胎为空只能现场拨号（慢），原因就是这条`;
-}

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

@@ -1,168 +0,0 @@
-// multi-ip-pool · 出口额度对照测试：回答「这台机器的直连出口撞 429 时，换成 VPNGate 出口还有没有额度」。
-//
-// 这才是多出口池的**唯一价值判据**（opencode 免费层按**出口 IP** 计额，见 docs/domain-notes.md §5）：
-//   基线（直连）429 而某个 VPN 出口 200 ⇒ 池有用；VPN 出口也全 429 ⇒ 换 IP 抬不动（上游按别的东西计额）。
-// 对照纪律：**除"从哪里出网"外一切相同** —— 同 URL / 同 UA / 同身份四件套 header / 同模型 /
-//   同 `stream:true` + 五核心工具名；整轮共用同一个 session（免费层按出口 IP 计额，共用 session 才测得干净）。
-// 请求形状**直接复用** `v6pool/selftest.js`（同一份免费层契约，绝不在两处各写一遍）。
-import { getUndici } from "../compat.js";
-import { genId } from "../opencode-identity.js";
-import { DEFAULT_PROBE_MODEL, probeUpstreamFrom } from "../v6pool/selftest.js";
-import { classifyWarpSignal } from "../warp-pool/verdict.js";
-import { resolveMultiIpConfig, resolveRole } from "./config.js";
-import { candidateNodes, loadNodeCache, materializeNode, writeAuthFile } from "./nodes.js";
-import { fetchNodes, probeExitIp } from "./nodes-fetch.js";
-import { bringUpTunnel, checkOpenvpn, isRoot, isSupportedPlatform, tearDownTunnel } from "./tunnel.js";
-import { fmtExitIp, fmtNodePick, fmtNodes, fmtProbe } from "./report.js";
-import { loadGroupsJoined } from "../state.js";
-
-/** 采样上限：VPNGate 免费节点起隧道是秒级操作，别把测试拖成十几分钟。 */
-export const MITEST_MAX = 8;
-export const MITEST_DEFAULT = 3;
-
-/**
- * 跑一次出口对照测试（本模块不打印，结构化返回给 CLI 渲染）。
- *
- * @param {{ env?: object, count?: number, model?: string, baseUrl?: string,
- *           onProgress?: (ev: object) => void,
- *           deps?: { joined?, platform?, supported?, isRoot?, checkOpenvpn?, loadNodeCache?, fetchNodes?,
- *                    materializeNode?, bringUpTunnel?, tearDownTunnel?, agentFactory?, probeExitIp?,
- *                    probeUpstream?, fetchImpl?, session?, log? }, slots?: object[] }} opts
- */
-export async function runMultiIpCompare({ env = process.env, count = MITEST_DEFAULT, model = DEFAULT_PROBE_MODEL, baseUrl = "https://opencode.ai", onProgress, deps = {}, slots = null } = {}) {
-  const cfg = resolveMultiIpConfig(env);
-  const tick = (ev) => { try { onProgress?.(ev); } catch { /* 渲染出错不打断测试 */ } };
-  const log = deps.log || (() => {});
-
-  if (!cfg.enabled) return { status: "skip", reason: "多出口池已关闭（MSLXDFF_MULTI_IP_POOL=0）", hint: "去掉该 env 或设为 1 再跑" };
-  const role = resolveRole({ mode: cfg.mode, joined: deps.joined ?? loadGroupsJoined() });
-  if (!role.active) return { status: "skip", reason: `本节点角色是 ${role.role}（${role.why}）`, hint: "本功能只给组长做取证；组员请用组长那条出口" };
-  const platform = deps.platform || process.platform;
-  if (!(deps.supported ?? isSupportedPlatform(platform))) {
-    return { status: "skip", reason: `本功能需要 Linux 的 tun 设备与策略路由（当前平台 ${platform}）`, hint: "在 Linux VPS 上跑；其它平台用 mslxdff -v6-pool 或 WARP 池" };
-  }
-  if (!(deps.isRoot ?? isRoot)()) {
-    return { status: "skip", reason: "需要 root（建 tun 设备 + 装策略路由 + 写 rp_filter）", hint: "sudo mslxdff -multi-ip-pool test" };
-  }
-  const openvpn = await (deps.checkOpenvpn || checkOpenvpn)(cfg.openvpnBin);
-  if (!openvpn.ok) return { status: "skip", reason: `${cfg.openvpnBin} 不可用（${openvpn.why}）`, hint: "apt install openvpn" };
-
-  const { Agent } = getUndici();
-  const agentFactory = deps.agentFactory || ((addr) => new Agent({ connect: { localAddress: addr }, connections: 1, keepAliveTimeout: 5_000 }));
-  const probe = deps.probeUpstream || probeUpstreamFrom;
-  const session = deps.session || genId("ses_");
-  const materialize = deps.materializeNode || materializeNode;
-  const startSlot = deps.bringUpTunnel || bringUpTunnel;
-  const stopSlot = deps.tearDownTunnel || tearDownTunnel;
-  const exitProbe = deps.probeExitIp || probeExitIp;
-
-  // 节点表：优先用缓存（不重复打 VPNGate），取不到再拉。
-  const cache = (deps.loadNodeCache || loadNodeCache)({ dir: cfg.dir, ttlMs: cfg.nodesTtlMs });
-  let rows = cache?.rows || [];
-  let source = cache?.source || "(本地缓存)";
-  if (!rows.length) {
-    try {
-      const got = await (deps.fetchNodes || fetchNodes)({ sources: cfg.sources, dir: cfg.dir, timeoutMs: cfg.probeTimeoutMs, log });
-      rows = got.rows;
-      source = got.source;
-    } catch (e) {
-      return { status: "skip", reason: `节点表取不到：${String(e?.message || e)}`, hint: "在能连的机器上跑 `mslxdff -multi-ip-pool fetch` 抓一份表带过来，或设 MSLXDFF_MULTI_IP_NODES_FILE / _SOURCES" };
-    }
-  }
-  tick({ phase: "nodes", source, total: rows.length });
-  log(fmtNodes({ source, total: rows.length, countries: cfg.countries, minScore: cfg.minScore }));
-
-  // ① 基线：直连（系统默认出口）打一条免费层请求
-  tick({ phase: "baseline-start", model });
-  const baseline = await probe({ addr: "", model, baseUrl, agentFactory, fetchImpl: deps.fetchImpl, session });
-  tick({ phase: "baseline-done", ...baseline });
-  // 候选：调用方给了 `slots` 就用它——CLI 侧已经「按簇取样 + TCP 预检」过，拨的必须就是探通的那些；
-  // 没给才自己按 Score 取（单测与旧路径）。两边各挑一次会让「探的」与「拨的」不是同一批，预检就白做了。
-
-  const picked = (Array.isArray(slots) && slots.length) ? slots.slice(0, MITEST_MAX) : candidateNodes({ rows, countries: cfg.countries, minScore: cfg.minScore, scan: Math.max(1, Math.min(MITEST_MAX, Number(count) || MITEST_DEFAULT)) });
-  if (!picked.length) return { status: "skip", reason: "没有满足条件的候选节点（国家/Score 过滤后为空）", hint: "放宽 MSLXDFF_MULTI_IP_MIN_SCORE 或去掉 MSLXDFF_MULTI_IP_COUNTRY" };
-  // auth 文件必须先落到磁盘再把路径交给 openvpn。取证路径以前把 `deps.authFile`（undefined）直接传下去
-  // ⇒ `--auth-user-pass` 拿到空参数 ⇒ openvpn 判「选项缺参数」，只留一句「Use --help」——2026-10-25 真机三条槽全挂在这。
-  const authFile = deps.authFile || (deps.writeAuthFile || writeAuthFile)({ dir: cfg.dir, user: cfg.authUser, pass: cfg.authPass });
-
-  const exits = [];
-  try {
-    for (let i = 0; i < picked.length; i++) {
-      const row = picked[i];
-      const dev = `${cfg.devPrefix}${i}`;
-      tick({ phase: "exit-start", i: i + 1, n: picked.length, row });
-      log(fmtNodePick({ i: i + 1, n: picked.length, row, dev }));
-      let slot = null;
-      try {
-        const node = materialize({ dir: cfg.dir, row });
-        if (!node) throw new Error("节点配置解不开（base64 或 remote 缺失）");
-        slot = await startSlot({ cfg, slotIndex: i, node, deps: { authFile, runCmdFn: deps.runCmdFn, spawnFn: deps.spawnFn, wait: deps.wait, log } });
-        const exit = await exitProbe({ agent: agentFactory(slot.tunIp), timeoutMs: cfg.probeTimeoutMs });
-        if (exit.ok) log(fmtExitIp({ dev: slot.dev, ip: exit.ip, ms: exit.ms }));
-        // 从这条隧道的出口打**同一条**免费层请求
-        const r = await probe({ addr: slot.tunIp, model, baseUrl, agentFactory, fetchImpl: deps.fetchImpl, session });
-        log(fmtProbe({ dev: slot.dev, url: `${baseUrl.replace(/\/+$/, "")}/zen/v1/chat/completions`, ok: r.ok, status: r.status, error: r.error, ms: r.ms }));
-        const entry = { ...r, hostName: row.hostName, country: row.countryShort, dev: slot.dev, exitIp: exit.ip || "" };
-        exits.push(entry);
-        tick({ phase: "exit-done", i: i + 1, n: picked.length, ...entry });
-      } catch (e) {
-        const entry = { hostName: row.hostName, country: row.countryShort, dev, ok: false, status: 0, kind: "network", ms: 0, exitIp: "", error: String(e?.message || e) };
-        exits.push(entry);
-        tick({ phase: "exit-done", i: i + 1, n: picked.length, ...entry });
-      } finally {
-        if (slot) await stopSlot({ slot, runCmdFn: deps.runCmdFn, log }).catch(() => {});
-      }
-    }
-  } catch (e) {
-    return { status: "skip", reason: `测试中断：${String(e?.message || e)}`, hint: "看 daemon.log 里的 [multi-ip-pool] 行" };
-  }
-
-  // ③ 判语：对照基线（受限 = 有 HTTP 响应但拿不到额度；只有 status=0 才算"够不着"）
-  const baseLimited = baseline.status === 429 || ["free-quota", "free-tier", "ip-limit"].includes(baseline.kind);
-  const ok = exits.filter((r) => r.ok);
-  const limited = exits.filter((r) => !r.ok && r.status);
-  const net = exits.filter((r) => !r.status);
-  let verdict;
-  if (ok.length && ok.length === exits.length) verdict = "multi-ip-works";
-  else if (limited.length === exits.length) verdict = "multi-ip-also-limited";
-  else if (net.length === exits.length) verdict = "multi-ip-unreachable";
-  else verdict = "mixed";
-
-  return {
-    status: "ok",
-    source, model, baseUrl, session,
-    baseLimited,
-    baseline,
-    exits,
-    requested: picked.length,
-    okCount: ok.length,
-    limitedCount: limited.length,
-    netCount: net.length,
-    verdict,
-  };
-}
-
-/** 判语 → 人话（CLI 与测试共用一份，避免两处口径漂移）。 */
-export const VERDICT_ZH = {
-  "multi-ip-works": {
-    text: "VPN 出口**能换到新额度**",
-    next: "结论：多出口池对这台机器**有用**——直连出口耗尽时换隧道就能续。daemon 侧缺省已开。",
-  },
-  "multi-ip-also-limited": {
-    text: "VPN 出口**也全受限**（换 IP 没换来新额度）",
-    next: "结论：换出口治不了（要么上游不按出口 IP 计额，要么节点出口本身已被大量共用到撞额）。建议 MSLXDFF_MULTI_IP_POOL=0。",
-  },
-  "multi-ip-unreachable": {
-    text: "VPN 出口**全都够不着上游**（隧道没转起来）",
-    next: "结论：这些节点起不通或上游被墙。查 rp_filter / 节点可用性，或换 MSLXDFF_MULTI_IP_SOURCES / 加国家白名单。",
-  },
-  mixed: {
-    text: "部分可用（有的出口有额度、有的没有）",
-    next: "结论：池**部分可用**（免费节点质量参差，属正常）。够用即可开着。",
-  },
-};
-
-/** 判语里的免费层分类（与生产判决同源：warp-pool/verdict.js）。 */
-export function classifyOf(status, text = "") {
-  return classifyWarpSignal({ status, text });
-}