mslxdff 0.1.245 → 0.1.246

package/src/warp-pool/nodes.js

@@ -1,95 +0,0 @@
-// warp-pool · 节点元数据持久化。
-// 含 WireGuard 私钥文件与设备 token ⇒ 一律 0600，且只落在日志根（MSLXDFF_WARP_DIR），不进工作树。
-import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-const SECRET_MODE = 0o600;
-
-/** 节点两件套：WireGuard 配置（含私钥）与元数据（含设备 token）。 */
-export function nodePaths(dir, port) {
-  return {
-    conf: join(dir, `node-${port}.conf`),
-    meta: join(dir, `node-${port}.json`),
-  };
-}
-
-/** 写敏感文件：新建用 0600，存量补 chmod（mode 只在新建时生效）。 */
-export function writeSecret(file, content) {
-  const existed = existsSync(file);
-  writeFileSync(file, content, existed ? undefined : { mode: SECRET_MODE });
-  try { chmodSync(file, SECRET_MODE); } catch {}
-  return file;
-}
-
-export function ensureDir(dir) {
-  mkdirSync(dir, { recursive: true, mode: 0o700 });
-  return dir;
-}
-
-/** 读单个节点元数据；文件缺失/损坏返回 null，绝不抛。 */
-export function loadNode(dir, port) {
-  const { meta } = nodePaths(dir, port);
-  try {
-    const j = JSON.parse(readFileSync(meta, "utf8"));
-    if (!j || typeof j !== "object") return null;
-    return {
-      port,
-      id: String(j.id || ""),
-      token: String(j.token || ""),
-      v4: String(j.v4 || ""),
-      v6: String(j.v6 || ""),
-      endpoint: String(j.endpoint || ""),
-      peerKey: String(j.peerKey || ""),
-      privateKey: String(j.privateKey || ""), // 必须读回：bringUp 靠它渲染 conf，漏了就是 PrivateKey = undefined（2026-10-16 真机事故：复用节点的隧道全起不来）
-      registeredAt: String(j.registeredAt || ""),
-      ...(j.cooldownUntil ? { cooldownUntil: Number(j.cooldownUntil) } : {}),
-    };
-  } catch {
-    return null;
-  }
-}
-
-export function saveNode(dir, node) {
-  const { meta } = nodePaths(dir, node.port);
-  return writeSecret(meta, `${JSON.stringify(node, null, 2)}\n`);
-}
-
-export function removeNode(dir, port) {
-  const { conf, meta } = nodePaths(dir, port);
-  for (const f of [conf, meta]) {
-    try { if (existsSync(f)) unlinkSync(f); } catch {}
-  }
-}
-
-/** 读回配置目录里已注册的节点（按端口升序）。 */
-export function loadNodes(dir, ports) {
-  const out = [];
-  for (const p of ports) {
-    const n = loadNode(dir, p);
-    if (n && n.id && n.token && n.privateKey) out.push(n);
-  }
-  return out;
-}
-
-/** WireGuard + wireproxy INI（[http] 段把隧道暴露成本地 HTTP 代理出口；undici v5 的 ProxyAgent 只吃 http/https）。 */
-export function renderWireproxyConf({ privateKey, v4, v6, endpoint, peerKey, port }) {
-  const addresses = [
-    v4 ? `Address = ${v4}/32` : "",
-    v6 ? `Address = ${v6}/128` : "",
-  ].filter(Boolean).join("\n");
-  return `[Interface]
-PrivateKey = ${privateKey}
-${addresses}
-DNS = 1.1.1.1
-MTU = 1280
-
-[Peer]
-PublicKey = ${peerKey}
-AllowedIPs = 0.0.0.0/0, ::/0
-Endpoint = ${endpoint}
-PersistentKeepalive = 25
-
-[http]
-BindAddress = 127.0.0.1:${port}
-`;
-}

package/src/warp-pool/ports.js

@@ -1,160 +0,0 @@
-// warp-pool · 端口占用与「上一代进程残留」清理（2026-10-16 真机事故后新增；2026-10-17 七次修订）。
-//
-// 事故一（0.1.179）：daemon 被强杀时 `process.once("exit")` 钩子不执行，wireproxy 子进程变孤儿继续占着端口。
-// 事故二（七次修订，真机铁证）：**两个 daemon 同时活着**（一个从昨天起活了一整天），两者都用同一份
-//   `node-<port>.conf` 判「本池残留」⇒ 互相把对方的**活隧道**当残留杀掉 ⇒ 无限互杀、池永远不稳。
-// 两条教训写进判据：
-//   ① 父进程是**另一个活着的 daemon** ⇒ 那不是残留，是「别人的活隧道」，清了就是互杀 ⇒ 不许清，只报出来；
-//   ② 「SIGKILL 都清不掉」多半是**僵尸**（state=Z：kill 无效，但 kill(pid,0) 仍返回成功）⇒ 僵尸算已死。
-import { connect } from "node:net";
-import { defaultCmdline, defaultPids, defaultStat, isZombie, otherDaemonParent, parseCmdline, pidAlive } from "../runtime/proc-info.js";
-import { nodePaths } from "./nodes.js";
-import { fmtReclaim } from "./report.js";
-
-// /proc 读取层已上移到 runtime/proc-info.js（daemon 侧也要用同一套判据）；这里原样再导出，既有调用方路径不变。
-export { parseCmdline, pidAlive };
-
-/**
- * 该进程是不是「正在跑我们这条 conf」的 wireproxy。
- * 判据刻意收紧（argv 里得有 wireproxy 这个可执行文件名，且 conf 路径逐字相等），
- * 免得误杀别人的进程。缺一不可。
- */
-export function isOurWireproxy(argv, conf) {
-  const list = Array.isArray(argv) ? argv : [];
-  const isBin = list.some((a) => /(^|[\\/])wireproxy(\.exe)?$/i.test(a));
-  return isBin && list.includes(conf);
-}
-
-/**
- * 清掉占着该端口那条 conf 的**真残留**：自家丢引用的子进程、父进程已死的孤儿。
- * 不动的三类：僵尸（kill 无效，也不是真占用者）、**父进程是另一个活 daemon 的活隧道**（清了就是互杀）、
- * argv 不匹配的别人的进程。
- * 非 Linux 直接返回空（读不到 /proc，别拿别的平台做危险猜测）。
- * @returns {Promise<{scanned:number, killed:number[], zombies:number[],
- *           foreign:Array<{pid:number,ppid:number,aliveSec:number|null}>, waitedMs:number, gone:boolean}>}
- */
-export async function reclaimPort({
-  dir,
-  port,
-  log = () => {},
-  platform = process.platform,
-  pids = defaultPids,
-  cmdline = defaultCmdline,
-  stat = defaultStat,
-  kill = process.kill,
-  sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
-  waitRounds = 15,
-} = {}) {
-  const startedAt = Date.now();
-  const shape = (scanned, killed, zombies, foreign) => ({
-    scanned,
-    killed,
-    zombies,
-    foreign,
-    waitedMs: Date.now() - startedAt,
-    gone: !killed.some((p) => pidAlive(p, kill)),
-  });
-  if (platform !== "linux") return shape(0, [], [], []);
-
-  const conf = nodePaths(dir, port).conf;
-  const all = pids();
-  const zombies = [];
-  const foreign = [];
-  const targets = [];
-  for (const pid of all) {
-    if (!isOurWireproxy(cmdline(pid), conf)) continue;
-    const st = stat(pid);
-    if (st && isZombie(st.state)) {
-      zombies.push(pid);
-      continue;
-    }
-    const other = otherDaemonParent(pid, { stat, cmdline, kill });
-    if (other) {
-      foreign.push({ pid, ppid: other.pid, aliveSec: other.aliveSec });
-      continue;
-    }
-    targets.push(pid);
-  }
-
-  if (targets.length) {
-    for (const pid of targets) {
-      try {
-        kill(pid, "SIGTERM");
-      } catch {}
-    }
-    for (let i = 0; i < waitRounds && targets.some((p) => pidAlive(p, kill)); i++) await sleep(100);
-    for (const pid of targets.filter((p) => pidAlive(p, kill))) {
-      try {
-        kill(pid, "SIGKILL");
-      } catch {}
-    }
-  }
-  const r = shape(all.length, targets, zombies, foreign);
-  log(fmtReclaim({ port, ...r }));
-  return r;
-}
-
-/** 该端口是否已有人在监听（TCP 连得上 = 占用；连不上/被拒 = 空闲）。 */
-export function portInUse(port, { host = "127.0.0.1", timeoutMs = 800, connectFn = connect } = {}) {
-  return new Promise((resolve) => {
-    let done = false;
-    const sock = connectFn({ host, port });
-    const finish = (v) => {
-      if (done) return;
-      done = true;
-      try {
-        sock.destroy();
-      } catch {}
-      resolve(v);
-    };
-    sock.setTimeout(timeoutMs, () => finish(false));
-    sock.once("connect", () => finish(true));
-    sock.once("error", () => finish(false));
-  });
-}
-
-/**
- * 等端口真正空出来（SIGTERM 之后套接字要几百毫秒才释放，这期间连得上 ≠ 别人的进程占着）。
- * 返回 true = 空了；false = 等了 rounds 轮还是被占。
- */
-export async function waitPortFree(port, { inUse = portInUse, sleep = (ms) => new Promise((r) => setTimeout(r, ms)), rounds = 12, stepMs = 250 } = {}) {
-  for (let i = 0; i < rounds; i++) {
-    if (!(await inUse(port))) return true;
-    await sleep(stepMs);
-  }
-  return !(await inUse(port));
-}
-
-/**
- * 端口占用者取证：谁在监听——本池残留？另一个 daemon 的活隧道？僵尸？别人的进程？还是空闲。
- * 「孤儿占端口」「两个 daemon 互杀」这两类事故唯一能一眼看出结论的读数：只报「占用 / 拒绝再起」是查不出问题的。
- * @returns {Promise<{busy:boolean, ours:number[], zombies:number[],
- *           foreign:Array<{pid:number,ppid:number,aliveSec:number|null}>, others:Array<{pid:number,name:string}>}>}
- */
-export async function portOwner({ dir, port, platform = process.platform, pids = defaultPids, cmdline = defaultCmdline, stat = defaultStat, kill = process.kill, inUse = portInUse } = {}) {
-  const busy = await inUse(port);
-  const out = { busy, ours: [], zombies: [], foreign: [], others: [] };
-  if (!busy || platform !== "linux") return out;
-  const conf = nodePaths(dir, port).conf;
-  for (const pid of pids()) {
-    const argv = cmdline(pid);
-    if (!argv.length) continue;
-    if (isOurWireproxy(argv, conf)) {
-      const st = stat(pid);
-      if (st && isZombie(st.state)) {
-        out.zombies.push(pid);
-        continue;
-      }
-      const other = otherDaemonParent(pid, { stat, cmdline, kill });
-      if (other) {
-        out.foreign.push({ pid, ppid: other.pid, aliveSec: other.aliveSec });
-        continue;
-      }
-      out.ours.push(pid);
-      continue;
-    }
-    // 非 root 看不到别人的 listen 表，退一步：命令行里带着这个端口号的进程也值得报出来
-    if (argv.some((a) => String(a).includes(`:${port}`))) out.others.push({ pid, name: String(argv[0]).split("/").pop() });
-  }
-  return out;
-}

package/src/warp-pool/register.js

@@ -1,113 +0,0 @@
-// warp-pool · 注册 Cloudflare WARP 设备（换回一份 WireGuard 配置 + 设备 token）。
-// API 形状与限流纪律来自同类项目实战（catoncat/warp-pool）+ 本机实测（200 响应字段已核对）。
-import crypto from "node:crypto";
-import { compatFetch } from "../compat.js";
-import { generateWgKeyPair } from "./keys.js";
-
-export const REG_URL = "https://api.cloudflareclient.com/v0a2483/reg";
-// 客户端版本头：Cloudflare 换版后旧值会被 403/400 拒（届时换成最新 app 版本号）。
-export const CF_CLIENT_VERSION = "a-6.81-2410032352.1";
-export const MAX_ATTEMPTS = 4;
-
-export function buildRegisterBody({ publicKey, uuid = crypto.randomUUID(), now = Date.now } = {}) {
-  return {
-    install_id: "",
-    tos: new Date(now()).toISOString().replace(/\.\d{3}Z$/, ".000Z"),
-    key: publicKey,
-    fcm_token: "",
-    serial_number: uuid,
-    type: "Android",
-    model: "PC",
-    locale: "zh_CN",
-  };
-}
-
-/** 从注册响应抽建隧道所需字段；缺 config/id/token 视为失败。 */
-export function parseRegisterResponse(json = {}) {
-  const cfg = json?.config;
-  const peer = Array.isArray(cfg?.peers) ? cfg.peers[0] : null;
-  const addr = cfg?.interface?.addresses || {};
-  if (!peer?.public_key || !addr.v4 || !json?.id || !json?.token) {
-    throw new Error("注册响应缺少必要字段（config.peers/interface.addresses/id/token）");
-  }
-  return {
-    id: String(json.id),
-    token: String(json.token),
-    v4: String(addr.v4),
-    v6: String(addr.v6 || ""),
-    peerKey: String(peer.public_key),
-    endpoint: String(peer?.endpoint?.host || "engage.cloudflareclient.com:2408"),
-  };
-}
-
-/**
- * 退避：429/403 走长退避（短退避会被续封，同类项目 2026-08-18 事故记录），
- * 其它错误（网络层）走短随机退避。
- */
-export function backoffMs(status, attempt, rnd = Math.random) {
-  if (status === 429 || status === 403) return Math.round(60_000 + rnd() * 60_000);
-  return Math.round(12_000 * attempt + 5_000 + rnd() * 3_000);
-}
-
-/**
- * 注册一个 WARP 设备。成功返回 { id, token, v4, v6, peerKey, endpoint, privateKey, publicKey }。
- * @param {{ fetchImpl?: Function, keyPair?: {privateKey:string,publicKey:string}, uuid?: string,
- *           now?: () => number, sleep?: (ms:number)=>Promise<void>, log?: (s:string)=>void,
- *           maxAttempts?: number, timeoutMs?: number }} [opts]
- */
-export async function registerWarpDevice({
-  fetchImpl = compatFetch,
-  keyPair = generateWgKeyPair(),
-  uuid = crypto.randomUUID(),
-  now = Date.now,
-  sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
-  log = () => {},
-  maxAttempts = MAX_ATTEMPTS,
-  timeoutMs = 30_000,
-} = {}) {
-  const body = buildRegisterBody({ publicKey: keyPair.publicKey, uuid, now });
-  let lastStatus = 0;
-  let lastErr = null;
-
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    if (attempt > 1) {
-      const wait = backoffMs(lastStatus, attempt);
-      log(`[warp-pool] 注册重试 ${attempt}/${maxAttempts}（上次 HTTP ${lastStatus || "网络错误"}），退避 ${Math.round(wait / 1000)}s`);
-      await sleep(wait);
-    }
-    let res;
-    try {
-      res = await fetchImpl(REG_URL, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "CF-Client-Version": CF_CLIENT_VERSION,
-          Accept: "application/json",
-        },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(timeoutMs),
-      });
-    } catch (e) {
-      lastStatus = 0;
-      lastErr = e;
-      continue;
-    }
-    lastStatus = res.status;
-    const text = await res.text().catch(() => "");
-    if (res.status !== 200) {
-      lastErr = new Error(`HTTP ${res.status}: ${String(text).slice(0, 200)}`);
-      continue;
-    }
-    let json;
-    try {
-      json = JSON.parse(text);
-    } catch (e) {
-      lastErr = e;
-      continue;
-    }
-    return { ...parseRegisterResponse(json), privateKey: keyPair.privateKey, publicKey: keyPair.publicKey };
-  }
-  throw new Error(
-    `WARP 注册失败（已试 ${maxAttempts} 次，最后 HTTP ${lastStatus || "网络错误"}）：${String(lastErr?.message || lastErr)}`,
-  );
-}

package/src/warp-pool/report.js

@@ -1,232 +0,0 @@
-// warp-pool · 日志与自检报告（2026-10-16 四轮返工后新增；2026-10-17 七次修订补「同机其它 daemon」）。
-//
-// 为什么单独一个模块（五轮返工的教训）：日志若只说「失败了」、不说「谁干的、为什么」，就只能靠猜——
-// 第 1 轮猜孤儿占端口、第 2 轮分不清旧 daemon 子进程与刚被杀还没释放的套接字、第 3 轮分不清握手未完成与上游拒绝、
-// 第 4~5 轮对着「退出 / 已复活」循环完全看不出真凶是**同机另一个 daemon**（两边都把对方的活隧道当残留杀）。
-// 故把可判定信息一次摆全：配置快照、**同机其它 daemon**、端口占用者（pid+ppid+命令行+本池残留/别人的活隧道/僵尸）、
-// 身份文件、每条隧道完整生命周期（清理→写配置→spawn pid→探活耗时/状态/错误→退出码/信号/存活时长/末行）、池子结论与「下一步敲什么命令」。
-import { fmtAlive } from "../runtime/proc-info.js";
-export const MARK = { step: "▸", ok: "✓", fail: "✗", warn: "⚠" };
-
-const KB = (n) => (n >= 1024 * 1024 ? `${(n / 1024 / 1024).toFixed(1)}MB` : `${Math.round(n / 1024)}KB`);
-
-/** 人类可读时长：412ms / 1.8s / 2m3s。 */
-export function dur(ms) {
-  const n = Number(ms);
-  if (!Number.isFinite(n) || n < 0) return "?";
-  if (n < 1000) return `${Math.round(n)}ms`;
-  if (n < 60_000) return `${(n / 1000).toFixed(1)}s`;
-  return `${Math.floor(n / 60_000)}m${Math.round((n % 60_000) / 1000)}s`;
-}
-
-/** 配置快照：一行说清这次到底按什么参数在跑。 */
-export function fmtConfig(cfg) {
-  return `[warp-pool] ${MARK.step} 启动自检：开关=${cfg.enabled ? "开" : "关"} 模式=${cfg.mode} 端口=${cfg.ports.join(",")} 策略=${cfg.strategy} 轮换=${cfg.rotate ? "开" : "关"} 冷却=${Math.round(cfg.cooldownMs / 1000)}s`;
-}
-
-/** 目录与二进制（带体积，顺手能看出二进制是不是被下坏了）。 */
-export function fmtEnv({ dir, binPath, binSize }) {
-  const bin = binPath ? `${binPath}（${binSize ? KB(binSize) : "体积未知"}）` : "未就绪";
-  return `[warp-pool] ${MARK.step} 目录=${dir} 二进制=${bin}`;
-}
-
-/** 身份文件盘点：哪个端口有 id+token+私钥，哪个缺。 */
-export function fmtIdentities(nodes, ports) {
-  const have = new Set(nodes.map((n) => n.port));
-  const parts = ports.map((p) => `:${p}${have.has(p) ? " ✓" : " ✗缺"}`);
-  return `[warp-pool] ${MARK.step} 身份文件 ${nodes.length}/${ports.length}：${parts.join(" ")}（✓=有 id+token+私钥，✗缺=现场注册）`;
-}
-
-/** 「另一个 daemon(pid 1558055，已运行 6h12m) 的活隧道 pid 33」——两个 daemon 互杀这类事故唯一能一眼看出结论的读数。 */
-export function fmtForeign(foreign = []) {
-  return (foreign || []).map((f) => `另一个 daemon(pid ${f.ppid}${f.aliveSec != null ? `，已运行 ${fmtAlive(f.aliveSec)}` : ""}) 的活隧道 pid ${f.pid}`).join("；");
-}
-
-/** 单端口占用者：区分「本池残留」「另一个 daemon 的活隧道」「僵尸」「别人的进程」「空闲」——两轮返工缺的就是这一行。 */
-export function fmtPortState({ port, busy, ours = [], zombies = [], foreign = [], others = [] }) {
-  if (!busy) return `[warp-pool]     :${port} 空闲`;
-  if (foreign.length) return `[warp-pool]     :${port} 被 ${fmtForeign(foreign)} 占着：那是**别人的活隧道**，本进程不碰它（清了就是和另一个 daemon 互杀）`;
-  if (ours.length) return `[warp-pool]     :${port} 被 pid ${ours.join(",")} 占：本池 wireproxy 残留（上一代 daemon 留下的孤儿）→ 起隧道前清理`;
-  if (zombies.length) return `[warp-pool]     :${port} 有本池僵尸 pid ${zombies.join(",")}（已死等收尸：kill 无效，也不再占端口）`;
-  const who = others.length ? others.map((o) => `pid ${o.pid} ${o.name}`).join("、") : "未知进程";
-  return `[warp-pool]     :${port} 被 ${who} 占：非本池进程 → 不碰它，这个端口本轮跳过（查明：ss -ltnp | grep :${port}）`;
-}
-
-/** 清理残留的结果：扫了多少进程、命中谁、等了多久、清掉没、以及「另一个 daemon 占着」这种不该动的情形。 */
-export function fmtReclaim({ port, scanned, killed = [], zombies = [], foreign = [], waitedMs = 0, gone = true }) {
-  const parts = [`扫 ${scanned} 个进程`];
-  if (killed.length) parts.push(`命中本池残留 pid ${killed.join(",")} → ${gone ? "已清掉" : "清不掉（SIGTERM/SIGKILL 都试过）"}`);
-  else parts.push("无本池残留");
-  if (zombies.length) parts.push(`僵尸 pid ${zombies.join(",")}（已死等收尸，kill 无效）`);
-  if (foreign.length) parts.push(`${MARK.warn} ${fmtForeign(foreign)}——不碰它（清了就是和另一个 daemon 互杀）`);
-  const wait = killed.length ? `（等了 ${dur(waitedMs)}）` : "";
-  return `[warp-pool] :${port} ${MARK.step} 清理残留：${parts.join("；")}${wait}`;
-}
-
-/** 写出的 WireGuard 配置（体积能看出是不是缺字段：缺私钥那次就是 338B vs 373B）。 */
-export function fmtConf({ port, conf, bytes }) {
-  return `[warp-pool] :${port} ${MARK.step} 写配置 ${conf}（${bytes}B，0600）`;
-}
-
-/** 起隧道：pid + 完整命令行，事后可 `ps -p <pid>` 对账。 */
-export function fmtSpawn({ port, pid, binPath, conf }) {
-  return `[warp-pool] :${port} ${MARK.step} 起隧道 pid=${pid ?? "?"}：${binPath} -c ${conf}`;
-}
-
-/** 探活单次：URL、状态、耗时、错误原文——第 3 轮返工缺的就是「到底哪一步不通」。 */
-export function fmtProbe({ port, attempt, attempts, url, ok, status, error, ms }) {
-  const head = `[warp-pool] :${port} ${ok ? MARK.ok : MARK.fail} 探活 ${attempt}/${attempts}：GET ${url} 经 127.0.0.1:${port}`;
-  const tail = ok
-    ? `HTTP ${status}（${dur(ms)}）→ 进池`
-    : `HTTP ${status || 0}（${dur(ms)}）${error ? ` 错误=${String(error).slice(0, 160)}` : ""} → 稍后重试`;
-  return `${head} → ${tail}`;
-}
-
-/** 探活彻底失败：说清「不进池」的后果与自检命令，而不是只丢一句「没探通」。 */
-export function fmtProbeGiveUp({ port, attempts, url }) {
-  return `[warp-pool] :${port} ${MARK.fail} 探活 ${attempts} 次都不通 ⇒ 不进池（进程可能在跑但隧道转不动流量，进池会把请求挂到超时，比直连更糟）。自检：curl --proxy http://127.0.0.1:${port} ${url}`;
-}
-
-/** 隧道退出：退出码/信号/存活时长/pid/是否外部终止/stderr 末行（含「谁杀的」这一层推断）。 */
-export function fmtExit({ port, code, signal, pid, aliveMs, tail }) {
-  const how = signal ? `信号 ${signal}` : `退出码 ${code}`;
-  const killed = signal ? "本进程未调用 stop ⇒ 外部终止（别人杀了它 / 系统回收）" : "进程自行退出（多为配置被拒或端口被占）";
-  return `[warp-pool] :${port} ${MARK.fail} 隧道退出：${how}｜存活 ${aliveMs == null ? "?" : dur(aliveMs)}｜pid ${pid ?? "?"}｜${killed}｜末行="${tail || "没有输出"}"`;
-}
-
-/** 端口最终被占着、拒绝硬起时，把「另一个 daemon 的活隧道 / 本池残留 / 僵尸 / 别人的进程 / 套接字还没释放」分开说。 */
-export function fmtPortBlocked({ port, ours = [], zombies = [], foreign = [], others = [] }) {
-  const foreignTxt = foreign.length ? `${fmtForeign(foreign)}（清了就是互杀，故本进程不碰）——先停掉那个 daemon：kill ${[...new Set(foreign.map((f) => f.ppid))].join(" ")}` : "";
-  const oursTxt = ours.length ? `本池残留 pid ${ours.join(",")}（SIGTERM/SIGKILL 都没清掉）` : "";
-  const zombieTxt = zombies.length ? `本池僵尸 pid ${zombies.join(",")}（已死等收尸，不占端口）` : "";
-  const othTxt = others.length ? others.map((o) => `pid ${o.pid} ${o.name}`).join("、") : "";
-  const who = [foreignTxt, oursTxt, zombieTxt, othTxt].filter(Boolean).join("；") || "未知进程（已等套接字释放仍连得上）";
-  return `[warp-pool] :${port} ${MARK.fail} 端口被 ${who} 占着，拒绝再起（硬起只会 bind 失败、无限重启刷屏）。查明：ss -ltnp | grep :${port}`;
-}
-
-/** 池子结论：入池几个、各端口出口是什么、几种不同地址——一句话判断「WARP 到底有没有在用」。 */
-export function fmtPool({ pooled, total, exits }) {
-  const head = `[warp-pool] ${MARK.step} 出口池就绪：${pooled}/${total} 条入池`;
-  const ipOf = new Map();
-  for (const g of exits || []) for (const p of g.nodes || []) if (g.ip) ipOf.set(p, g.ip);
-  if (!ipOf.size) return `${head}｜出口地址未知（CF trace 取证失败，不影响使用）`;
-  const table = [...ipOf.entries()].map(([p, ip]) => `:${p}=${ip}`).join(" ");
-  return `${head}｜出口：${table}｜不同地址 ${new Set(ipOf.values()).size} 个`;
-}
-
-/**
- * 身份指纹：每个端口的短设备 id / WARP 内网 IPv6 尾段 / 对端端点 / 注册时间。
- * 为什么必须有：4 条隧道只拿到 2 个出口地址时（真机 2026-10-17），只有这组读数能区分
- * 「设备本身被写重复了」和「CF 把不同设备折叠成一个出口」——没有它就只能猜。
- *
- * ⚠ 判据**不看 IPv4**：`172.16.0.2` 是 WARP 的**固定接口地址**（6 次实测全是它：组长 4 台 +
- * 本机 2 台；公开的 wgcf 生成配置里同样是 `Address = 172.16.0.2/32`），按它判「重复」是误报
- * （2026-10-17 十一次修订前确实这么误报过）。每台设备真正唯一的是 **IPv6**（`2606:4700:110:…`）
- * 与密钥对，所以指纹打 v6 尾段。
- */
-/** v6 尾段做指纹（`2606:4700:110:81b5:56ec:72b3:9542:e3de` → `…:9542:e3de`）；缺了给「无」。 */
-export function v6Tail(v6) {
-  const s = String(v6 || "");
-  if (!s) return "无";
-  const parts = s.split(":");
-  return parts.length > 2 ? `…:${parts.slice(-2).join(":")}` : s;
-}
-export function fmtIdentityDetail(nodes = []) {
-  const out = [];
-  const byId = new Map();
-  const byEp = new Map();
-  for (const n of nodes || []) {
-    if (n?.id) byId.set(n.id, [...(byId.get(n.id) || []), n.port]);
-    if (n?.endpoint) byEp.set(n.endpoint, [...(byEp.get(n.endpoint) || []), n.port]);
-    out.push(`[warp-pool]     :${n?.port} 设备=${n?.id ? String(n.id).slice(0, 8) : "无id"} 内网v6=${v6Tail(n?.v6)} 端点=${n?.endpoint || "?"} 注册=${String(n?.registeredAt || "?").slice(0, 19)}`);
-  }
-  const dupId = [...byId.entries()].filter(([, p]) => p.length > 1).map(([k, p]) => `${String(k).slice(0, 8)} ← :${p.join(",:")}`).join("；");
-  if (dupId) out.push(`[warp-pool] ${MARK.warn} 设备 id 重复：${dupId} —— 同一个 WARP 设备被写到多个端口，出口必然相同；删掉重复端口的 node-<port>.json 再重启，它会重新注册`);
-  // 端点全同 = 大家都从同一个 CF 入口出去（CF 对每次注册都回同一个 hostname）：出口撞车由此而来
-  const total = (nodes || []).length;
-  const sameEp = [...byEp.entries()].find(([, p]) => total > 1 && p.length === total);
-  if (sameEp) out.push(`[warp-pool] ${MARK.step} ${total} 条隧道都用同一个端点（${sameEp[0]}）—— CF 对每次注册都回同一个 hostname，故大家都从同一个 CF 入口出去，出口地址撞车由此而来（想分散：把 node-<port>.json 的 endpoint 改成别的 WARP 入口 IP 后重启）`);
-  return out;
-}
-
-/**
- * 出口分散结论：几个出口地址 / 几条隧道在线、撞车的是谁、以及「想多要一份该怎么办」。
- * 措辞必须自洽：免费 WARP 的 IPv4 是共享 NAT，**隧道数 ≠ 上游名额数**——旧措辞
- * 「同时在线就有 N 份名额」与紧邻的「出口不分散」分支自相矛盾（真机 4 条隧道只拿到 2 个出口）。
- */
-export function fmtExits({ groups = [], dir = "" } = {}) {
-  if (!groups.length) return "";
-  const online = groups.reduce((a, g) => a + g.nodes.length, 0);
-  if (groups.length === 1) {
-    return `[warp-pool] ${MARK.warn} 出口不分散：${online} 条隧道同时在线只有 1 个出口地址（${groups[0].ip}）：免费版 WARP 的 IPv4 是共享 NAT，多开隧道换不到多份名额；多份名额靠撞 429 时的身份轮换`;
-  }
-  const collide = groups.filter((g) => g.nodes.length > 1);
-  const drop = collide.flatMap((g) => g.nodes.slice(1));
-  const base = dir || "$HOME/.config/mslxdff/warp-pool";
-  const next = drop.length
-    ? `｜${MARK.warn} 撞车：${collide.map((g) => `${g.ip} ← :${g.nodes.join(",:")}`).join("；")}（它们共用同一份上游名额）⇒ 想多要一份：rm -f ${drop.map((p) => `${base}/node-${p}.json`).join(" ")} && mslxdff -restart（重新注册换出口；共享 NAT 下常换不动，要试几次）`
-    : "";
-  return `[warp-pool] ${MARK.step} 出口分散：${groups.length} 个出口地址 / ${online} 条隧道在线（上游按出口 IP 计名额 ⇒ 最多 ${groups.length} 份；隧道数 ≠ 名额数：免费版 WARP 的 IPv4 是共享 NAT）${next}`;
-}
-
-/** 池空告警：最容易被误读成「功能在跑」，必须把结论与逐条自检命令一起说。 */
-export function fmtPoolEmpty({ total, ports }) {
-  return `[warp-pool] ${MARK.warn} 没有一条隧道探通 ⇒ 池为空，全部请求照旧直连（不影响可用性，但 WARP 出口等于没启用）。逐条自检：for p in ${ports.join(" ")}; do echo -n ":$p "; curl -s --max-time 8 --proxy http://127.0.0.1:$p https://cloudflare.com/cdn-cgi/trace | grep '^ip='; done`;
-}
-
-/** 健康检查一轮：只在状态变化/心跳时打（每分钟一行会把日志淹掉）。 */
-export function fmtHealth({ healthy, total, slowestMs, problems = [] }) {
-  if (!problems.length) return `[warp-pool] ${MARK.ok} 健康检查：${healthy}/${total} 通（最慢 ${dur(slowestMs)}）`;
-  const detail = problems
-    .map((p) => `:${p.port} 第 ${p.fails} 次不通（HTTP ${p.status || 0}${p.error ? ` ${String(p.error).slice(0, 80)}` : ""}，${dur(p.ms)}）冷却 ${Math.round(p.cooldownMs / 1000)}s`)
-    .join("；");
-  return `[warp-pool] ${MARK.warn} 健康检查：${healthy}/${total} 通｜不通：${detail}`;
-}
-
-/** 心跳：一行给全部关键状态，省得「日志翻半天不知道现在啥情况」。 */
-export function fmtHeartbeat({ alive, total, pooled, exits, cooling, lastAllDown }) {
-  const ips = [...new Set((exits || []).map((e) => e.ip).filter(Boolean))];
-  return `[warp-pool] ${MARK.step} 心跳：隧道 ${alive}/${total} 活｜入池 ${pooled}｜出口 ${ips.length ? `${ips.length} 种（${ips.join(",")}）` : "未知"}｜冷却中 ${cooling}｜全池不通 ${lastAllDown || "未发生"}`;
-}
-
-/** 同机其它 daemon：两个 daemon 抢同一批端口会互杀（真机事故根因），必须一次说清并给出精确 kill 命令。 */
-export function fmtSiblings({ list = [] } = {}) {
-  if (!list.length) return "";
-  const who = list.map((d) => `pid ${d.pid}（父 ${d.ppid}${d.aliveSec != null ? `，已运行 ${fmtAlive(d.aliveSec)}` : ""}）`).join("；");
-  return `[warp-pool] ${MARK.warn} 同机还有 ${list.length} 个别的 mslxdff daemon 在跑：${who} —— 它也在管同一个出口池目录，两边会把对方的隧道当「残留」杀掉（本池每个 conf 只允许一个拥有者）。先停掉它：kill ${list.map((d) => d.pid).join(" ")}`;
-}
-
-/**
- * 启动自检块：一次性把「这次按什么参数跑、二进制在哪多大、磁盘上有几个身份、端口分别被谁占着」打全。
- * 第 1 轮返工只看到「退出 code=1 / 已复活」循环，就是缺这一块——真因（孤儿占端口）当时只能靠猜。
- * @param {{ cfg: object, nodes: Array<object>, binPath?: string, binSize?: number,
- *           ownerOf: (port:number)=>Promise<{busy:boolean, ours:number[], zombies:number[], foreign:Array<object>, others:Array<{pid:number,name:string}>}>,
- *           log?: Function }} opts
- */
-export async function startupReport({ cfg, nodes, binPath = "", binSize = 0, ownerOf, log = () => {} }) {
-  log(fmtConfig(cfg));
-  log(fmtEnv({ dir: cfg.dir, binPath, binSize }));
-  log(fmtIdentities(nodes, cfg.ports));
-  const states = [];
-  for (const port of cfg.ports) {
-    try {
-      states.push({ port, ...(await ownerOf(port)) });
-    } catch (e) {
-      states.push({ port, busy: false, ours: [], zombies: [], foreign: [], others: [], error: String(e?.message || e) });
-    }
-  }
-  const busy = states.filter((s) => s.busy);
-  log(`[warp-pool] ${MARK.step} 端口体检：${busy.length} 个被占 / ${states.length} 个端口`);
-  for (const s of states) log(fmtPortState(s));
-  // 另一个 daemon 占着端口 = 两个 daemon 互杀（真机事故根因）：必须单独大声报，并给出精确 kill 命令
-  const foreign = busy.flatMap((s) => s.foreign || []);
-  if (foreign.length) {
-    const pids = [...new Set(foreign.map((f) => f.ppid))];
-    log(`[warp-pool] ${MARK.warn} ${foreign.length} 个端口被 ${fmtForeign(foreign)} 占着 —— 那不是残留，本进程不碰它（清了就是互杀）。若那是上一代的 daemon：kill ${pids.join(" ")}`);
-  }
-  const orphans = busy.filter((s) => (s.ours || []).length).length;
-  if (orphans) log(`[warp-pool] ${MARK.warn} 有 ${orphans} 个端口被本池残留占着（上一代 daemon 被强杀留下的孤儿）——起隧道前逐个清理，日志会写清 pid`);
-  const zombies = busy.filter((s) => (s.zombies || []).length).length;
-  if (zombies) log(`[warp-pool] ${MARK.step} 有 ${zombies} 个端口上还有本池僵尸进程（已死等收尸：kill 无效，也不再占端口，无需处理）`);
-  return states;
-}