mslxdff 0.1.245 → 0.1.246

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

@@ -1,83 +0,0 @@
-// mslxdff -multi-ip-pool [test|probe|status|fetch|help]
-//   多出口池（VPNGate 免费 OpenVPN 节点当出口）：**组长**专属，只服务 opencode 免费层。
-//
-// 本文件只做「分发 + status + 用法」；test / fetch 两条取证流程在 ./multi-ip-pool-test.js
-// （2026-10-25 起拆分：那边是全程 transcript 流水账，混在一起两边都顶过体积线）。
-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 { runFetch, runProbe } from "./multi-ip-pool-fetch.js";
-import { runTest } from "./multi-ip-pool-test.js";
-
-const FLAG = "-multi-ip-pool";
-
-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 === "probe" || sub === "ping") return await runProbe(args);
-  if (sub === "fetch" || sub === "grab") return await runFetch(args);
-  return await runTest(args);
-}
-
-/** status：只回答「开没开、为什么」。**不建池不拨号**，所以只能报告配置与门，报不了 daemon 内存里的池。 */
-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（真机取证：换出口到底有没有换来新额度）`);
-  console.log(`  测网络可达性（不要 root）：mslxdff ${FLAG} probe [--probe N]`);
-  process.exit(0);
-  return true;
-}
-
-function printUsage() {
-  console.log(`用法: mslxdff ${FLAG} [test|probe|status|fetch|help] [--count N] [--probe N] [--force] [--model <id>] [--out <路径>]`);
-  console.log("");
-  console.log("  test 在多出口池上做 A/B：直连打一条 free 层请求取基线，再逐条 VPN 隧道打同一条，");
-  console.log("  对照判语：");
-  console.log("    基线 429 + VPN 出口有 200 ⇒ 池有用（换 IP 换到新额度）");
-  console.log("    基线 429 + VPN 出口也全 429 ⇒ 换 IP 抬不动（上游不按出口 IP 计额）");
-  console.log("  test 每一步都编号打印并整份落盘（结尾给出 transcript 路径），失败即停在原地。");
-  console.log("");
-  console.log("  probe 只回答「这台机能连上表里几个节点」（按簇轮转取样 + 限并发 TCP 预检）：不拨号、不要 root、");
-  console.log("  不碰 openvpn/内核、不看角色门，任何平台都能跑 —— 池值不值得继续用的先行问题。");
-  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/commands/v6-pool.js

@@ -1,123 +0,0 @@
-// mslxdff -v6-pool [test|help] —— IPv6 出口额度对照测试（在 VPS 上验证 v6 池值不值得用）。
-//
-// 目的（用户 2026-10-18 明确）：**当这台 VPS 的 IPv4 出口撞 429 时，对比测一下 IPv6 出口还有没有额度**。
-// 所以本命令做 A/B：
-//   ① 直连（IPv4/系统默认出口）打一条免费层请求，记下额度状态作基线；
-//   ② 从 v6 段里随机采 N 个源地址，各打**同一条**请求（同 UA/模型/stream/tools，只换源地址）；
-//   ③ 对照两者：v6 有 200 ⇒ 池有用（换 IP 换到新额度）；v6 全 429 ⇒ 换 IP 抬不动。
-//
-// 纯可逆：自造的 /128 用完即撤（bind 模式不碰网卡）。非 Linux 如实跳过。
-import { runV6PoolCompare, V6TEST_DEFAULT, DEFAULT_PROBE_MODEL } from "../../v6pool/selftest.js";
-import { argValue } from "../policy.js";
-
-const FLAG = "-v6-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, 50)}）`;
-  if (r.ok) return `✅ HTTP ${r.status} 有额度`;
-  return `⛔ HTTP ${r.status} ${kindZh[r.kind] || r.kind}`;
-};
-
-export async function handleV6Pool(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();
-
-  const count = (() => { const v = flagValue(args, "--count", "-n"); return v === null ? V6TEST_DEFAULT : Math.max(1, Math.min(64, Number(v) || V6TEST_DEFAULT)); })();
-  const model = flagValue(args, "--model", "-m") || DEFAULT_PROBE_MODEL;
-
-  console.log("=".repeat(66));
-  console.log("  IPv6 出口额度对照 —— 「IPv4 撞 429 时，IPv6 还有额度吗」");
-  console.log("=".repeat(66));
-  console.log("");
-  console.log(`  探测模型 ${model}｜采样 ${count} 个 v6 源地址｜只换源地址，其余请求完全相同`);
-  console.log("");
-
-  const onProgress = (ev) => {
-    if (ev.phase === "baseline-start") console.log(`  ▸ 基线：直连（IPv4 / 系统默认出口）打一条免费层请求…`);
-    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 === "v6-start") process.stdout.write(`  [${String(ev.i).padStart(2)}/${ev.n}] ${ev.addr}  … `);
-    else if (ev.phase === "v6-done") process.stdout.write(`${line(ev)}\n`);
-  };
-
-  let r;
-  try {
-    r = await runV6PoolCompare({ count, 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(`❌ 无法测 v6 出口：${r.reason}`);
-    console.log(`   下一步：${r.hint}`);
-    process.exit(1);
-    return true;
-  }
-
-  console.log("");
-  console.log("-".repeat(66));
-  console.log(`  基线（IPv4/直连）：${line(r.baseline)}`);
-  console.log(`  v6 采样：有额度 ${r.v6OkCount}｜受限 ${r.v6LimitedCount}｜不可达 ${r.v6NetCount}（共 ${r.requested}）`);
-  console.log("");
-  const verdicts = {
-    "v6-works": {
-      mark: "✅",
-      text: `IPv6 **能换到新额度**：${r.v6OkCount}/${r.requested} 个 v6 出口拿到 200`,
-      next: `   结论：v6 池对这台机器**有用** —— IPv4 耗尽时换 v6 出口能续。daemon 建池时会自动启用。`,
-    },
-    "v6-also-limited": {
-      mark: "⛔",
-      text: `IPv6 **也全受限**（换 IP 没换到新额度）`,
-      next: `   结论：v6 池对这台机器**无意义**（要么上游不按出口 IP 计额，要么该段没真路由出去）。建议 MSLXDFF_V6_POOL=0。`,
-    },
-    "v6-unreachable": {
-      mark: "❌",
-      text: `IPv6 源地址**全都够不着上游**（段没路由到本机）`,
-      next: `   结论：本机这段 v6 不能用作出口。查机房是否把该段 routed 过来，或用 MSLXDFF_V6_PREFIX 指更准的段。`,
-    },
-    mixed: {
-      mark: "△",
-      text: `部分可用：${r.v6OkCount}/${r.requested} 个 v6 出口有额度`,
-      next: `   结论：v6 池**部分可用**（可能有些 /128 被沿途丢弃）。够用即可开着。`,
-    },
-  }[r.verdict] || { mark: "?", text: "未判定", next: "" };
-  console.log(`  ${verdicts.mark} ${verdicts.text}`);
-  if (verdicts.next) console.log(verdicts.next);
-  console.log("");
-  console.log(`   重试：mslxdff ${FLAG} --count ${r.requested}${model !== DEFAULT_PROBE_MODEL ? ` --model ${model}` : ""}`);
-  process.exit(r.verdict === "v6-works" || r.verdict === "mixed" ? 0 : 1);
-}
-
-function printUsage() {
-  console.log(`用法: mslxdff ${FLAG} [test] [--count N] [--model <id>]`);
-  console.log("");
-  console.log("  在 Linux VPS 上做 A/B：直连（IPv4）打一条 free 层请求取基线，");
-  console.log("  再从 v6 段随机采 N 个源地址各打同一条，对照 IPv6 出口还有没有额度。");
-  console.log("    基线 429 + v6 有 200 ⇒ 池有用（换 IP 换到新额度）");
-  console.log("    基线 429 + v6 也 429 ⇒ 换 IP 抬不动（上游不按出口 IP 计额 / 段没路由过来）");
-  console.log("");
-  console.log("相关 env（与 daemon 建池同源）：");
-  console.log("    MSLXDFF_V6_PREFIX=<段>/<位数>   显式指定池前缀（缺省取本机全局地址前缀）");
-  console.log("    MSLXDFF_V6_IFACE=<网卡>        指定网卡");
-  console.log("    MSLXDFF_V6_CLAIM=auto|bind|add 认领方式（bind 需 ip_nonlocal_bind=1；add 需 root）");
-  process.exit(0);
-  return true;
-}

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

@@ -1,157 +0,0 @@
-// 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 免费节点掉得快）
-  maxTableAgeMs: 24 * 60 * 60_000, // 表龄告警阈值：镜像表超过它就 ⚠（旧表 = 一堆早下线的 IP，白拨几分钟）
-  openvpnBin: "openvpn",
-  authUser: "vpn", // VPNGate 公共账号（非私人凭据）
-  authPass: "vpn",
-  debug: false,
-  sysctl: true, // 放宽 rp_filter（严格反向路径过滤会让隧道"活着但请求挂死"）
-};
-
-/**
- * VPNGate 节点源：**官方永远在前**，第三方镜像只作兜墙。
- * 纠错（2026-10-26 实测）：`aimili-vpngate` 的 Actions 只把新鲜快照发到 **GitHub Pages**（`openmili.github.io/aimili-vpngate/`），
- * **不往仓库里写表**；仓库内 `mirror/vpngate.csv` 是手工提交的死快照（2026-08-26 后未变）——此前当「每 15 分钟刷新」用 =
- * 拿两个月前的死 IP 白拨，真机症状与被墙一模一样。
- * 表只是公开节点配置 + VPNGate 公共账号（vpn/vpn）；不信任镜像就 `_SOURCES` 只留官方或 `_NODES_FILE` 自带。
- */
-export const NODE_SOURCES = [
-  "https://www.vpngate.net/api/iphone/",
-  "http://www.vpngate.net/api/iphone/",
-  "https://openmili.github.io/aimili-vpngate/vpngate.csv",
-  "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),
-    maxTableAgeMs: envInt(env, "MSLXDFF_MULTI_IP_MAX_TABLE_AGE_MS", DEFAULTS.maxTableAgeMs),
-    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/diagnose.js

@@ -1,159 +0,0 @@
-// multi-ip-pool · 诊断层：openvpn 输出归因 / 节点 TCP 预检 / 取证全程 transcript（argv 原文由 report.js:fmtArgv 出）。
-//
-// 为什么单独一份：2026-10-25 真机两轮都栽在「看得见结果、看不见环节」——openvpn 用法错误的末行恒是
-// `Use --help`，真凶在它上面；而 selftest 的内部步骤日志在 CLI 里被接到了空函数上。
-// 本文件把「哪一步出问题」变成一等信息：每一步都有编号、耗时、原文，并整份落盘可粘贴。
-import { mkdirSync, appendFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import net from "node:net";
-import { devNameFor, tableFor } from "./config.js";
-import { clusterOf } from "./nodes.js";
-
-/** 值得单独成行的报错关键词（openvpn 的用法/握手/认证/网络失败都在这里）。 */
-const ERRORISH = /options error|unrecognized|missing or extra|fatal|error:|can ?not|cannot|denied|failed|refused|reset|auth failed|tls|write udp|bind|permission/i;
-
-/**
- * openvpn 输出里挑「最能说明问题」的一行：用法错误的**末行恒是** `Use --help for more information.`，
- * 真凶（`Options error: …`）在它上面。只报末行等于把病因盖住。
- */
-export function openvpnErrorLine(text, max = 240) {
-  const lines = String(text || "").split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
-  if (!lines.length) return "";
-  const pick = lines.find((l) => ERRORISH.test(l));
-  return (pick || lines[lines.length - 1]).slice(0, max);
-}
-
-/**
- * 一行内的**多行摘要**：真凶行 + 其余最多 3 行（用 ` ‖ ` 分隔）。
- * 单行是为了日志文件仍可 grep；多行是为了人眼一次看完，不必再翻 openvpn 自己的输出。
- */
-export function openvpnErrorBrief(text, max = 620) {
-  const lines = String(text || "").split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
-  if (!lines.length) return "";
-  const first = lines.find((l) => ERRORISH.test(l)) || "";
-  const rest = lines.filter((l) => l !== first && !/^Use --help/i.test(l)).slice(-3);
-  return [first || lines[lines.length - 1], ...rest].join(" ‖ ").slice(0, max);
-}
-
-/**
- * 节点 TCP 预检：拨号前先确认「这台机能不能连到 host:port」。
- * 判语口径：VPNGate 实测 91/97 是 `proto tcp`，TCP 连不上基本就是节点/防火墙问题；
- * `proto udp` 的节点这条只作参考（UDP 无握手，连不上不代表隧道必挂），**必须如实分开说**。
- */
-export function probeTcp({ host, port, timeoutMs = 6_000, connectFn } = {}) {
-  const t0 = Date.now();
-  return new Promise((resolve) => {
-    const done = (ok, extra) => resolve({ ok, ms: Date.now() - t0, host, port, ...extra });
-    if (!host || !port) return done(false, { error: "缺 host/port" });
-    if (connectFn) {
-      return connectFn(host, port, timeoutMs)
-        .then((r) => done(Boolean(r?.ok), { ...(r?.error ? { error: r.error } : {}) }))
-        .catch((e) => done(false, { error: String(e?.message || e) }));
-    }
-    const s = net.connect({ host, port });
-    const timer = setTimeout(() => { s.destroy(); done(false, { error: `连接超时（${timeoutMs}ms）` }); }, timeoutMs);
-    s.once("connect", () => { clearTimeout(timer); s.destroy(); done(true, {}); });
-    s.once("error", (e) => { clearTimeout(timer); done(false, { error: String(e?.code || e?.message || e) }); });
-  });
-}
-
-/**
- * 批量 TCP 预检：**限并发**探一组节点，按输入顺序返回结果（`{ node, ok, ms, error }`）。
- * 为什么必须成批：真机实证「同一机房整片连不上」远多于「个别节点不通」——只探 3 条会给出
- * 一句误导的「全部不通」，探一批才看得出**是哪一片不通、还有哪片是通的**。
- */
-export async function probeBatch({ nodes = [], timeoutMs = 6_000, concurrency = 6, probe = probeTcp } = {}) {
-  const out = new Array(nodes.length);
-  let next = 0;
-  const worker = async () => {
-    for (;;) {
-      const i = next++;
-      if (i >= nodes.length) return;
-      const node = nodes[i];
-      out[i] = { node, ...(await probe({ host: node?.host, port: node?.port, timeoutMs })) };
-    }
-  };
-  const width = Math.max(1, Math.min(Math.max(1, concurrency), nodes.length || 1));
-  await Promise.all(Array.from({ length: width }, worker));
-  return out;
-}
-
-/**
- * 取样小结：一句「探了几条、通几条」+ **簇分布**（哪个机房整片不通，一眼看出）。
- * 判死口径必须分开写：`proto udp` 的节点无握手，TCP 探不通**不能**当成「这条隧道必挂」。
- */
-export function probeSummaryLines({ results = [], minScore = 0, clustersShown = 6 } = {}) {
-  const udp = results.filter((r) => String(r.node?.proto || "").toLowerCase() === "udp");
-  const tcp = results.filter((r) => !udp.includes(r));
-  const tcpLive = tcp.filter((r) => r.ok);
-  const strict = results.filter((r) => Number(r.node?.score || 0) >= minScore).length;
-  const groups = new Map();
-  for (const r of tcp) {
-    const key = clusterOf(r.node);
-    const cur = groups.get(key) || { total: 0, ok: 0 };
-    cur.total += 1;
-    cur.ok += r.ok ? 1 : 0;
-    groups.set(key, cur);
-  }
-  const tail = udp.length ? `（另有 ${udp.length} 条 UDP 节点：无握手，不计入判死）` : "";
-  const lines = [`取样 ${results.length} 个（Score 达下限 ${strict} 个）→ TCP 通 ${tcpLive.length}｜不通 ${tcp.length - tcpLive.length}${tail}`];
-  const shown = [...groups.entries()].slice(0, clustersShown).map(([key, v]) => `${key} ${v.ok}/${v.total} 通`);
-  if (shown.length) lines.push(`簇分布（机房/IP 段）：${shown.join("｜")}${groups.size > clustersShown ? `｜…共 ${groups.size} 簇` : ""}`);
-  if (!tcpLive.length && udp.some((r) => r.ok)) lines.push("探通的都是 UDP 节点 ⇒ TCP 探不出结论，下面仍按取样顺序真拨");
-  return lines;
-}
-
-/**
- * 取证全程 transcript：每行带 `[步骤号]` 与相对耗时，同时进屏幕与文件（0600）。
- * 落盘是为了「一次跑完贴一个文件给我」，不必复现；写文件失败绝不影响测试本体。
- */
-export function createTranscript({ dir, out = (s) => console.log(s), now = () => Date.now(), fs = { mkdirSync, appendFileSync }, fileName = "" } = {}) {
-  const t0 = now();
-  let step = 0;
-  const file = dir ? join(dir, fileName || `test-${new Date(t0).toISOString().replace(/[:.]/g, "-")}.log`) : "";
-  const emit = (raw) => {
-    const line = `[${String(step).padStart(2, "0")} +${((now() - t0) / 1000).toFixed(1)}s] ${raw}`;
-    out(line);
-    if (file) {
-      try { fs.appendFileSync(file, line + "\n"); } catch { /* 落盘失败只影响存档，不影响取证 */ }
-    }
-  };
-  try {
-    if (file) { fs.mkdirSync(dirname(file), { recursive: true }); fs.appendFileSync(file, `# multi-ip-pool 取证 transcript（本文件可整份粘贴）\n`); }
-  } catch { /* 同上 */ }
-  return {
-    file,
-    /** 一条步骤行（自动编号）。 */
-    step: (text) => { step += 1; emit(text); return step; },
-    /** 归属当前步骤的明细行（不占编号）。 */
-    say: (text) => emit(`      ${String(text).replace(/^\s+/, "")}`),
-    /** 小节标题。 */
-    section: (text) => { step += 1; emit(`—— ${text} ——`); return step; },
-  };
-}
-
-/** 环境快照：一眼看清「机器/权限/二进制/配置/磁盘上有什么」，省掉一轮来回。 */
-export function envSnapshotLines({ cfg, platform, root, openvpn, files = [], argvNode = "" } = {}) {
-  return [
-    `node ${argvNode || process.version}｜平台 ${platform}｜root ${root ? "是" : "否"}`,
-    `openvpn ${openvpn?.ok ? `可用：${openvpn.version}` : `不可用：${openvpn?.why || "?"}`}`,
-    `配置：隧道 ${cfg?.count} 条｜备胎 ${cfg?.standby} 条/每 ${Math.round((cfg?.standbyEveryMs || 0) / 60_000)} 分钟｜Score 下限 ${cfg?.minScore}｜国家 ${cfg?.countries?.length ? cfg.countries.join("/") : "不限"}｜策略 ${cfg?.strategy}`,
-    `目录 ${cfg?.dir}：${files.length ? files.join(" ") : "（空，本轮第一次跑）"}`,
-    `节点源（按序）：${(cfg?.sources || []).join(" → ")}`,
-  ];
-}
-
-/** 每槽的「设备名/路由表/优先级」对照表：内核侧出问题时按这张表查。 */
-export function slotPlanLines({ cfg, nodes = [] } = {}) {
-  return nodes.map((n, i) => `  槽 ${i}：${n.hostName}（${n.countryShort || "?"}）→ ${n.host}:${n.port}｜proto ${n.proto || "?"}｜设备 ${devNameFor(cfg.devPrefix, i)}｜表 ${tableFor(cfg.baseTable, i)}`);
-}
-
-/** 跑完（尤其是中途失败）后给全善后命令：设备与路由残留必须能一眼查清。 */
-export function residualHints() {
-  return [
-    "ip -brief addr show type tun",
-    "ip link show | grep -E 'mltun|tun'",
-    "ip rule show | grep -E 'from (10\\.|192\\.|172\\.)' | head",
-    "ip route show table all | grep -E 'mltun' | head",
-  ];
-}