mslxdff 0.1.245 → 0.1.246

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

@@ -1,160 +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 即成功（顺手写缓存 + 问一句表龄：`maxAgeMs`）。
- * 全失败时**逐源原因都进异常**（受限网络下「为什么取不到」就是用户唯一的线索）。
- * @returns {Promise<{ source: string, rows: object[], text: string, meta: object|null, stale: boolean }>} text 供 `fetchNodesToFile` 落盘
- */
-export async function fetchNodes({ sources = [], dir = "", fetchImpl, timeoutMs = 20_000, now = () => Date.now(), maxAgeMs = 0, 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");
-      const meta = await fetchTableMeta({ source: url, fetchImpl: f, timeoutMs: Math.min(5_000, timeoutMs), now });
-      const stale = noteTable({ url, rows, meta, maxAgeMs, dir, now, log });
-      return { source: url, rows, text, meta, stale };
-    } 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, maxAgeMs = 0, log } = {}) {
-  const got = await fetchNodes({ sources, fetchImpl, timeoutMs, maxAgeMs, 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) };
-  }
-}
-
-/** 镜像表的同源元数据文件名（上游 `build_vpngate_mirror.py` 固定产出，含 `generated_at_iso`）。 */
-const TABLE_META_NAME = "vpngate.meta.json";
-
-/** 表 URL → 同目录元数据 URL：只认 `.../vpngate.csv` 这类镜像表（官方 `api/iphone/`、本地表文件都没有 meta）。 */
-export function metaUrlFor(url) {
-  const m = /^(https?:\/\/\S*\/)vpngate\.csv$/i.exec(String(url || "").trim());
-  return m ? `${m[1]}${TABLE_META_NAME}` : "";
-}
-
-/** 表龄的人话（分钟/小时/天）。 */
-export function humanAge(ms) {
-  const mins = Math.round(Number(ms) / 60_000);
-  if (!Number.isFinite(mins) || mins < 0) return "未知";
-  if (mins < 60) return `${mins} 分钟`;
-  const hours = mins / 60;
-  return hours < 48 ? `${hours.toFixed(1)} 小时` : `${Math.round(hours / 24)} 天`;
-}
-
-/**
- * 问一句「这份表是什么时候生成的」——镜像源长得一模一样（同样 15 列、同样能解析），
- * 但可能是**几个月前的手工快照**：真机 2026-10-26 实测，参照实现仓库内那份 2026-08-26 生成、
- * 而它的活表在 GitHub Pages（2026-10-24 生成）⇒ 拿旧表就是拿一堆早已下线的 IP 白拨几分钟，
- * 症状与被墙完全一样。拿不到 meta（官方源/本地表/网络失败）就返回 null，绝不猜。
- * @returns {Promise<{ ageMs: number, generatedAtIso: string } | null>}
- */
-export async function fetchTableMeta({ source = "", fetchImpl, timeoutMs = 5_000, now = () => Date.now() } = {}) {
-  const url = metaUrlFor(source);
-  if (!url) return null;
-  try {
-    const f = fetchImpl || getUndici().fetch || compatFetch;
-    const res = await f(url, { signal: timeoutSignal(timeoutMs) });
-    if (!res.ok) return null;
-    const meta = JSON.parse(await res.text());
-    const at = Number(meta?.generated_at) * 1000 || Date.parse(String(meta?.generated_at_iso || ""));
-    if (!Number.isFinite(at) || at <= 0) return null;
-    return { ageMs: Math.max(0, now() - at), generatedAtIso: String(meta.generated_at_iso || new Date(at).toISOString()) };
-  } catch {
-    return null;
-  }
-}
-
-/** 取到表后的一次性记账：打「表龄」行、过期就 ⚠、按需写缓存，返回是否过期。 */
-function noteTable({ url = "", rows = [], meta = null, maxAgeMs = 0, dir = "", now = () => Date.now(), log = () => {} } = {}) {
-  const stale = Boolean(meta && maxAgeMs > 0 && meta.ageMs > maxAgeMs);
-  log(`[multi-ip-pool] 节点表取自 ${url}（${rows.length} 个节点${meta ? `，${humanAge(meta.ageMs)}前生成` : ""}）${stale ? " ⚠ 表已过期" : ""}`);
-  if (stale) log(`[multi-ip-pool] ⚠ 这张表已 ${humanAge(meta.ageMs)}没更新 ⇒ 节点多半早已下线（免费节点掉得快），拿它拨号就是白等几分钟：换源 MSLXDFF_MULTI_IP_SOURCES，或自带表 MSLXDFF_MULTI_IP_NODES_FILE`);
-  if (dir) saveNodeCache({ dir, source: url, rows, now });
-  return stale;
-}

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 时若备胎为空只能现场拨号（慢），原因就是这条`;
-}