mslxdff 0.1.240 → 0.1.241

package/package.json

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

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

@@ -3,7 +3,9 @@
 //
 // 为什么需要这条命令（用户要的"取证"）：换出口到底有没有换来新额度，只有实测能回答。
 // 本命令做 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";
@@ -34,6 +36,7 @@ export async function handleMultiIpPool(args = []) {
   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);
 }
 
@@ -88,6 +91,34 @@ async function runTest(args) {
   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() });
@@ -104,9 +135,10 @@ async function printStatus(args) {
   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)} 分钟重拨一批；429 时立即启用，启用前再打一次 hi 要 200）`);
+  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.sources.join("，")}`);
+  console.log(`  节点源     ${cfg.nodesFile ? `本地表优先：${cfg.nodesFile}（其后 ${cfg.sources.length - 1} 个网络源）` : cfg.sources.join("，")}`);
   console.log("");
   console.log(`  下一步：mslxdff ${FLAG} test（真机取证：换出口到底有没有换来新额度）`);
   process.exit(0);
@@ -114,7 +146,7 @@ async function printStatus(args) {
 }
 
 function printUsage() {
-  console.log(`用法: mslxdff ${FLAG} [test|status] [--count N] [--model <id>]`);
+  console.log(`用法: mslxdff ${FLAG} [test|status|fetch|help] [--count N] [--model <id>] [--out <路径>]`);
   console.log("");
   console.log("  在多出口池上做 A/B：直连打一条 free 层请求取基线，再逐条 VPN 隧道打同一条，");
   console.log("  对照判语：");
@@ -129,7 +161,8 @@ function printUsage() {
   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）");
+  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=关）");

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

@@ -37,10 +37,18 @@ export const DEFAULTS = {
   sysctl: true, // 放宽 rp_filter（严格反向路径过滤会让隧道"活着但请求挂死"）
 };
 
-/** VPNGate 官方节点源：HTTPS 优先、HTTP 兜底；受限网络用 MSLXDFF_MULTI_IP_SOURCES 换镜像（不硬编码第三方）。 */
+/**
+ * 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"];
@@ -92,9 +100,12 @@ export function tableFor(baseTable, i) {
  */
 export function resolveMultiIpConfig(env = process.env, { logDirFn = logDir } = {}) {
   const modeRaw = envStr(env, "MSLXDFF_MULTI_IP_MODE", DEFAULTS.mode).toLowerCase();
-  const sources = envList(env, "MSLXDFF_MULTI_IP_SOURCES").length
+  // 受限网络兜墙：`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,
@@ -118,6 +129,7 @@ export function resolveMultiIpConfig(env = process.env, { logDirFn = logDir } =
     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),
   };

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

@@ -8,7 +8,8 @@
 // 拆成独立模块的原因：装配（index）、拨号（本文件）、备选池（standby）三件事各自都要单测，混一起必超 10KB 门。
 import { getUndici } from "../compat.js";
 import { DEFAULT_PROBE_MODEL, probeUpstreamFrom } from "../v6pool/selftest.js";
-import { candidateNodes, fetchNodes, loadNodeCache, materializeNode, probeExitIp } from "./nodes.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";

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

@@ -0,0 +1,110 @@
+// 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,12 +1,10 @@
-// multi-ip-pool · VPNGate 节点表：取表（多源回退 + 本地缓存）→ 解 base64 配置 → 筛候选 → 落 conf。
+// multi-ip-pool · VPNGate 节点表（**纯解析与落盘**侧）：解 CSV → 解 base64 配置 → 筛候选 → 落 conf/缓存。
 //
-// 为什么要这层：出口 IP 的**来源**就是这些免费志愿者节点。参照实现（aimili-vpngate）用同一份
-// CSV（`/api/iphone/`，每行末列是 base64 的 OpenVPN 配置），我们直接取它、不引入 Python 侧任何代码。
+// 为什么要拆开：出口 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";
-import { compatFetch, getUndici, timeoutSignal } from "../compat.js";
-import { EXIT_PROBE_URL, parseExitIp } from "../warp-pool/revive.js";
 
 /** CSV 列序（VPNGate `/api/iphone/`）：末列是 base64 配置，其余为节点元数据。 */
 export const VPNGATE_FIELDS = [
@@ -126,27 +124,6 @@ export function saveNodeCache({ dir, source = "", rows = [], now = () => Date.no
   return payload;
 }
 
-/** 逐源尝试取表；任一源返回可解析的 CSV 即成功（并顺手写缓存）。 */
-export async function fetchNodes({ sources = [], dir = "", fetchImpl, timeoutMs = 20_000, now = () => Date.now(), log = () => {} } = {}) {
-  const f = fetchImpl || getUndici().fetch || compatFetch;
-  let lastErr = null;
-  for (const url of sources) {
-    try {
-      const res = await f(url, { signal: timeoutSignal(timeoutMs) });
-      const text = await res.text();
-      if (!res.ok) throw new Error(`HTTP ${res.status}`);
-      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 };
-    } catch (e) {
-      lastErr = e;
-      log(`[multi-ip-pool] 节点源失败 ${url}：${String(e?.message || e)}`);
-    }
-  }
-  throw new Error(`全部节点源都失败：${String(lastErr?.message || lastErr || "无源可试")}`);
-}
 
 /** 落一份 node conf（设备名/路由由 CLI 覆盖，不改原配置文本）；返回文件路径。 */
 export function writeNodeConf({ dir, row, name = "" } = {}) {
@@ -171,21 +148,3 @@ export function writeAuthFile({ dir, user = "vpn", pass = "vpn" } = {}) {
   ensureDir(dir);
   return writePrivate(join(dir, "auth.txt"), `${user}\n${pass}\n`);
 }
-
-/**
- * 出口取证：从某槽的 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: String(e?.message || e) };
-  }
-}

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

@@ -10,7 +10,8 @@ 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, fetchNodes, loadNodeCache, materializeNode, probeExitIp } from "./nodes.js";
+import { candidateNodes, loadNodeCache, materializeNode } 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";
@@ -65,7 +66,7 @@ export async function runMultiIpCompare({ env = process.env, count = MITEST_DEFA
       rows = got.rows;
       source = got.source;
     } catch (e) {
-      return { status: "skip", reason: `节点表取不到：${String(e?.message || e)}`, hint: "先在能连 vpngate.net 的网络里跑一次，或设 MSLXDFF_MULTI_IP_SOURCES" };
+      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 });