mslxdff 0.1.179 → 0.1.181

package/package.json

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

package/src/warp-pool/health.js

@@ -1,5 +1,6 @@
 // warp-pool · 节点健康：主动探活（经隧道打上游 models，不烧 token）+ 失败冷却 + 连续失败触发重拨换 IP。
 import { probeTunnel } from "./wireproxy.js";
+import { fmtHealth, fmtHeartbeat, dur, MARK } from "./report.js";
 
 export function createHealthMonitor({
   dispatcher,
@@ -7,41 +8,81 @@ export function createHealthMonitor({
   probePath = "/zen/v1/models",
   unhealthyAfter = 3,
   intervalMs = 60_000,
+  heartbeatEvery = 10,
+  infoOf = null,
+  cooldownMs = 600_000,
   onExhausted = null,
   probe = probeTunnel,
   headers = {},
+  now = Date.now,
   log = () => {},
 } = {}) {
   let timer = null;
   let rounds = 0;
+  let ticks = 0;
+  let lastAllDownAt = "";
+  /** @type {Map<number, boolean>} 每端口上一轮通不通（用来只在「状态变化」时打日志） */
+  const lastOk = new Map();
+  const stamp = () => new Date(now()).toISOString().slice(11, 19);
 
-  /** 跑一轮全池探活。返回 { checked, healthy }。 */
+  /**
+   * 跑一轮全池探活。日志纪律：**只在「状态有变化」「全池不通」「心跳点」时打**——每分钟一行会把日志淹掉。
+   * 每个不通的节点都要报全：HTTP 状态、错误原文、耗时、连续第几次、冷却多久（这样才不用靠猜）。
+   */
   async function tick() {
     if (!dispatcher) return { checked: 0, healthy: 0 };
     const list = dispatcher.entries();
     let healthy = 0;
+    let slowestMs = 0;
+    const problems = [];
+    const changes = [];
     for (const e of list) {
       const r = await probe({ port: e.port, baseUrl, path: probePath, headers }).catch((err) => ({
         ok: false,
         error: String(err?.message || err),
       }));
+      if (Number(r.ms) > slowestMs) slowestMs = Number(r.ms);
       if (r.ok) {
         dispatcher.markOk(e.index);
         healthy += 1;
-      } else {
-        dispatcher.markFailure(e.index);
+        if (lastOk.get(e.port) === false) changes.push(`:${e.port} 恢复（HTTP ${r.status}，${dur(r.ms)}）`);
+        lastOk.set(e.port, true);
+        continue;
       }
+      dispatcher.markFailure(e.index);
+      if (lastOk.get(e.port) !== false) {
+        changes.push(`:${e.port} 掉线（HTTP ${r.status || 0}${r.error ? ` ${String(r.error).slice(0, 80)}` : ""}）`);
+      }
+      lastOk.set(e.port, false);
+      problems.push({ port: e.port, status: r.status, error: r.error, ms: r.ms, fails: Number(e.fails || 0) + 1, cooldownMs });
     }
-    if (list.length > 0 && healthy === 0) {
+    const allDown = list.length > 0 && healthy === 0;
+    ticks += 1;
+    if (allDown) {
       rounds += 1;
-      log(`[warp-pool] 全池 ${list.length} 个节点均不可用（连续第 ${rounds} 轮）`);
-      if (rounds >= 2 && typeof onExhausted === "function") {
-        rounds = 0;
-        await onExhausted().catch((e) => log(`[warp-pool] 重拨失败：${String(e?.message || e)}`));
-      }
+      lastAllDownAt = stamp();
     } else {
       rounds = 0;
     }
+    if (changes.length || allDown || ticks % heartbeatEvery === 0) {
+      log(fmtHealth({ healthy, total: list.length, slowestMs, problems }));
+    }
+    for (const c of changes) log(`[warp-pool] ${MARK.warn} 状态变化：${c}`);
+    if (ticks % heartbeatEvery === 0) {
+      const extra = typeof infoOf === "function" ? infoOf() || {} : {};
+      log(fmtHeartbeat({
+        alive: extra.alive ?? list.length,
+        total: list.length,
+        pooled: extra.pooled ?? list.length,
+        exits: extra.exits || [],
+        cooling: list.filter((e) => Number(e.cooldownUntil) > now()).length,
+        lastAllDown: lastAllDownAt,
+      }));
+    }
+    if (allDown && rounds >= 2 && typeof onExhausted === "function") {
+      rounds = 0;
+      await onExhausted().catch((e) => log(`[warp-pool] 重拨失败：${String(e?.message || e)}`));
+    }
     return { checked: list.length, healthy };
   }
 

package/src/warp-pool/index.js

@@ -8,7 +8,8 @@ import { ensureDir, loadNodes, removeNode, saveNode } from "./nodes.js";
 import { registerWarpDevice } from "./register.js";
 import { ensureBinary, probeTunnel, resolveAsset, startTunnel, writeTunnelConf } from "./wireproxy.js";
 import { createReviver, labelExits, tailReason } from "./revive.js";
-import { portInUse, reclaimPort } from "./ports.js";
+import { portInUse, portOwner, reclaimPort, waitPortFree } from "./ports.js";
+import { fmtConf, fmtExit, fmtPool, fmtPoolEmpty, fmtProbe, fmtProbeGiveUp, fmtPortBlocked, fmtSpawn, startupReport } from "./report.js";
 import { wireRotation } from "./identity.js";
 
 /** 重拨节流：连续失败指数退避。网络不通的机器绝不能让重注册把 CF 刷到 429。 */
@@ -38,6 +39,9 @@ export function createWarpPool({
   ensureBin = ensureBinary,
   start = startTunnel,
   probe = probeTunnel,
+  reclaim = reclaimPort,
+  inUse = portInUse,
+  waitFree = waitPortFree,
   now = Date.now,
   rnd = Math.random,
   wait = (ms) => new Promise((r) => setTimeout(r, ms)),
@@ -75,7 +79,12 @@ export function createWarpPool({
   let redialGapMs = REDIAL_MIN_GAP_MS;
 
   // 兜底清理：Node 退出不会回收 spawn 的子进程，daemon 突然退出时同步杀掉隧道。
+  // 同时置 closed：否则「杀子进程 → onExit → 立刻复活」会在退出过程中再 spawn 出一批孤儿（真机：每次重启漏一批）。
   process.once("exit", () => {
+    closed = true;
+    try {
+      reviver.stop();
+    } catch {}
     for (const t of tunnels.values()) {
       try {
         t.stop();
@@ -83,28 +92,30 @@ export function createWarpPool({
     }
   });
 
-  /** 起一条隧道的完整动作：清残留 → 写 conf → 确认端口真空着 → spawn → 记表。 */
+  /** 起一条隧道的完整动作：确认不是重复起 → 清残留 → 写 conf → 等端口真空出来 → spawn → 记表。 */
   async function bringUp(node) {
-    await reclaimPort({ dir: cfg.dir, port: node.port, log }); // 清上一代孤儿（daemon 被强杀时子进程不会自己退）
-    writeTunnelConf(cfg.dir, node);
-    if (tunnels.has(node.port)) return;
-    if (await portInUse(node.port)) {
-      throw new Error(`端口 :${node.port} 已被非本池进程占用，拒绝再起（硬起只会 bind 失败、无限重启刷屏）`);
+    if (tunnels.has(node.port)) return; // 已归我们管：绝不再清残留（reclaim 会把自己这条隧道当残留杀掉）
+    await reclaim({ dir: cfg.dir, port: node.port, log }); // 清上一代孤儿（daemon 被强杀时子进程不会自己退）
+    const { conf, bytes } = writeTunnelConf(cfg.dir, node);
+    log(fmtConf({ port: node.port, conf, bytes }));
+    // SIGTERM 之后套接字要几百毫秒才释放，这期间连得上 ≠ 别人的进程占着——先等它真空出来再判
+    if (!(await waitFree(node.port, { inUse }))) {
+      const owner = await portOwner({ dir: cfg.dir, port: node.port }).catch(() => ({ ours: [], others: [] }));
+      throw new Error(fmtPortBlocked({ port: node.port, ...owner }));
     }
     const t = start({
       binPath,
       dir: cfg.dir,
       port: node.port,
       log,
-      onExit: ({ port, code, signal, tail }) => {
+      onExit: ({ port, code, signal, tail, pid, aliveMs }) => {
         tunnels.delete(port);
-        const why = tailReason(tail) || "进程没留下任何输出";
-        log(`[warp-pool] :${port} 隧道意外退出（退出码 ${code}${signal ? `，信号 ${signal}` : ""}）：${why}`);
-        void reviver.onExit(port);
+        log(fmtExit({ port, code, signal, pid, aliveMs, tail: tailReason(tail) }));
+        if (!closed) void reviver.onExit(port); // 收摊中就别复活了，否则退出过程里又 spawn 出一批孤儿
       },
     });
     tunnels.set(node.port, t);
-    log(`[warp-pool] :${node.port} 隧道已起：HTTP 代理 http://127.0.0.1:${node.port} → 经 WARP 出网（pid ${t.pid ?? "?"}）`);
+    log(fmtSpawn({ port: node.port, pid: t.pid, binPath, conf }));
   }
 
   // 429 ＝ 上游按出口 IP 计的名额耗尽 ⇒ 换一台设备的身份换出口（换身份＝换桶）。
@@ -117,6 +128,38 @@ export function createWarpPool({
     log,
   });
 
+  /** 探活闸门参数：刚起的隧道要等 WireGuard 握手完成才通（真机：一起来就探 ⇒ 4 条全没通 ⇒ 池为空、WARP 白开）。 */
+  const PROBE_SETTLE_MS = 2_000;
+  const PROBE_ATTEMPTS = 2;
+
+  /**
+   * 入池前的实测闸门：给握手留时间 → 逐个探活 → 探不通的绝不进池。
+   * 为什么必须有：wireproxy 进程活着但隧道转不动流量时，请求会挂到超时（比直连更糟）。
+   * @returns {Promise<Array<object>>} 通过探活的节点
+   */
+  async function probeGate(list) {
+    const live = [];
+    await wait(PROBE_SETTLE_MS);
+    for (const n of list) {
+      if (!tunnels.has(n.port)) continue;
+      const url = `${String(baseUrl).replace(/\/+$/, "")}${cfg.probePath}`;
+      let r = { ok: false };
+      for (let i = 1; i <= PROBE_ATTEMPTS; i++) {
+        const t0 = now();
+        r = await probe({ port: n.port, baseUrl, path: cfg.probePath });
+        const ms = Number.isFinite(r.ms) ? r.ms : now() - t0;
+        log(fmtProbe({ port: n.port, attempt: i, attempts: PROBE_ATTEMPTS, url, ok: r.ok, status: r.status, error: r.error, ms }));
+        if (r.ok) break;
+        if (i < PROBE_ATTEMPTS) await wait(PROBE_SETTLE_MS);
+      }
+      if (r.ok) {
+        live.push(n);
+      } else {
+        log(fmtProbeGiveUp({ port: n.port, attempts: PROBE_ATTEMPTS, url }));
+      }
+    }
+    return live;
+  }
   async function bootstrap() {
     if (closed) return;
     ensureDir(cfg.dir);
@@ -133,7 +176,7 @@ export function createWarpPool({
 
     // 1. 复用磁盘上已注册的节点
     let nodes = loadNodes(cfg.dir, cfg.ports);
-    log(`[warp-pool] 复用磁盘上已注册的身份 ${nodes.length}/${cfg.count} 个（端口 ${cfg.ports.join(", ")}；缺的现场注册）`);
+    await startupReport({ cfg, nodes, binPath, ownerOf: (port) => portOwner({ dir: cfg.dir, port }), log });
 
     // 2. 补足：逐个注册（拉长间隔，避免 CF 注册限流与同网段撞车）
     const used = new Set(nodes.map((n) => n.port));
@@ -162,23 +205,17 @@ export function createWarpPool({
       }
     }
 
-    // 入池前实测探活：WARP 握手不通时 wireproxy 进程照样在跑却转不动流量（挂到超时），那种节点进池会黑洞全部请求
-    const live = [];
-    for (const n of nodes) {
-      if (!tunnels.has(n.port)) continue;
-      const r = await probe({ port: n.port, baseUrl, path: cfg.probePath });
-      if (r.ok) live.push(n);
-      else log(`[warp-pool] :${n.port} 隧道没探通（${r.status || r.error || "?"}），不进池：进池会把请求挂到超时，比直连更糟`);
-    }
+    // 入池前实测探活：WARP 握手没完成时 wireproxy 在跑却转不动流量（请求会挂到超时），那种节点进池会黑洞全部请求
+    const live = await probeGate(nodes);
     if (live.length) {
       await dispatcher.setNodes(live.map((n) => ({ port: n.port, uri: `http://127.0.0.1:${n.port}` })));
-      log(`[warp-pool] 出口池就绪：${live.length} 条隧道可用（选路策略 ${cfg.strategy}${cfg.rotate ? "，撞 429 会自动换身份换出口" : ""}）`);
+      // 出口取证：一次拿到每个端口的真实出口，既喂给轮换器做「换没换动」的比对，也直接写进池结论那一行
+      const exits = await labelExits({ ports: live.map((n) => n.port), log });
+      rotator.noteExits(exits);
+      log(fmtPool({ pooled: live.length, total: nodes.length, exits }));
     } else {
-      log("[warp-pool] 没有一条隧道探通 ⇒ 池为空，全部请求照旧直连（不影响可用性，只是没多出口）");
+      log(fmtPoolEmpty({ total: nodes.length, ports: cfg.ports }));
     }
-
-    // 5. 出口取证：把每台设备的真实出口地址打进日志（免费版 WARP 的 IPv4 是共享 NAT，N 台设备很可能折叠成同一个出口）
-    if (live.length) rotator.noteExits(await labelExits({ ports: live.map((n) => n.port), log }));
   }
 
   const monitor = createHealthMonitor({
@@ -186,6 +223,8 @@ export function createWarpPool({
     baseUrl,
     probePath: cfg.probePath,
     log,
+    infoOf: () => ({ alive: tunnels.size, pooled: dispatcher.size, exits: rotator ? rotator.stats() : [] }),
+    cooldownMs: cfg.cooldownMs,
     onExhausted: async () => {
       // 重拨 = 重新注册换出口。只重拨「进程已死」的隧道：全活却全挂 = 网络路径问题，重注册只会把 CF 刷到 429
       const plan = redialPlan({ ports: cfg.ports, alivePorts: [...tunnels.keys()], lastRedialAt, redialGapMs, now });
@@ -215,10 +254,15 @@ export function createWarpPool({
         }
         await wait(gapMs(cfg, rnd));
       }
-      if (!closed && [...tunnels.keys()].length) {
-        // 重拨确实把隧道拉起来了 ⇒ 退避复位
-        redialGapMs = REDIAL_MIN_GAP_MS;
-        await dispatcher.setNodes([...tunnels.keys()].map((port) => ({ port, uri: `http://127.0.0.1:${port}` })));
+      if (!closed && tunnels.size) {
+        // 重拨起来的隧道同样要过闸门：没过探活的隧道进池 = 把请求挂到超时（原先这里直接 setNodes，等于绕过闸门）
+        const alive = await probeGate([...tunnels.keys()].map((port) => ({ port })));
+        if (alive.length) {
+          redialGapMs = REDIAL_MIN_GAP_MS; // 确实有隧道能通 ⇒ 退避复位
+          await dispatcher.setNodes(alive.map((n) => ({ port: n.port, uri: `http://127.0.0.1:${n.port}` })));
+        } else {
+          log("[warp-pool] 重拨后仍没有一条隧道探通，保持直连（等下一轮健康检查）");
+        }
       }
     },
   });

package/src/warp-pool/ports.js

@@ -7,6 +7,7 @@
 import { readFileSync, readdirSync } from "node:fs";
 import { connect } from "node:net";
 import { nodePaths } from "./nodes.js";
+import { fmtReclaim } from "./report.js";
 
 /** /proc/<pid>/cmdline 是 NUL 分隔的字节串；切成参数数组（丢掉结尾空串）。 */
 export function parseCmdline(buf) {
@@ -69,13 +70,13 @@ export async function reclaimPort({
 } = {}) {
   if (platform !== "linux") return [];
   const conf = nodePaths(dir, port).conf;
-  const targets = pids().filter((pid) => isOurWireproxy(cmdline(pid), conf));
-  if (!targets.length) return [];
-
-  log(
-    `[warp-pool] 端口 :${port} 发现上一代 wireproxy 残留（pid ${targets.join(", ")}）：` +
-      `daemon 被强杀时子进程不会自己退出，它会一直占着端口让新隧道 bind 失败。先清掉再起。`,
-  );
+  const all = pids();
+  const targets = all.filter((pid) => isOurWireproxy(cmdline(pid), conf));
+  const startedAt = Date.now();
+  if (!targets.length) {
+    log(fmtReclaim({ port, scanned: all.length, ours: [], others: [], waitedMs: 0, killed: false }));
+    return [];
+  }
   for (const pid of targets) {
     try {
       kill(pid, "SIGTERM");
@@ -87,6 +88,8 @@ export async function reclaimPort({
       kill(pid, "SIGKILL");
     } catch {}
   }
+  const gone = !targets.some((p) => pidAlive(p, kill));
+  log(fmtReclaim({ port, scanned: all.length, ours: targets, waitedMs: Date.now() - startedAt, killed: gone }));
   return targets;
 }
 
@@ -108,3 +111,38 @@ export function portInUse(port, { host = "127.0.0.1", timeoutMs = 800, connectFn
     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));
+}
+
+/**
+ * 端口占用者取证：谁在监听——本池 wireproxy 残留？别人的进程？还是空闲。
+ * 「孤儿占端口」这类事故唯一能一眼看出结论的读数：只报「占用 / 拒绝再起」是查不出问题的（第 2 轮返工的教训）。
+ * @returns {Promise<{busy:boolean, ours:number[], others:Array<{pid:number,name:string}>}>}
+ */
+export async function portOwner({ dir, port, platform = process.platform, pids = defaultPids, cmdline = defaultCmdline, inUse = portInUse } = {}) {
+  const busy = await inUse(port);
+  const out = { busy, ours: [], 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)) {
+      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/report.js

@@ -0,0 +1,149 @@
+// warp-pool · 日志与自检报告（2026-10-16 四轮返工后新增）。
+//
+// 为什么单独一个模块（四轮返工的教训）：日志若只说「失败了」、不说「谁干的、为什么」，就只能靠猜——
+// 第 1 轮猜孤儿占端口、第 2 轮分不清旧 daemon 子进程与刚被杀还没释放的套接字、第 3 轮分不清握手未完成与上游拒绝。
+// 故把可判定信息一次摆全：配置快照、端口占用者（pid+命令行+是否本池残留）、身份文件、每条隧道完整生命周期
+// （清理→写配置→spawn pid→探活耗时/状态/错误→退出码/信号/存活时长/末行）、池子结论与「下一步敲什么命令」。
+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+私钥，✗缺=现场注册）`;
+}
+
+/** 单端口占用者：区分「本池残留」「别人的进程」「空闲」——第 1 轮返工缺的就是这一行。 */
+export function fmtPortState({ port, busy, ours = [], others = [] }) {
+  if (!busy) return `[warp-pool]     :${port} 空闲`;
+  if (ours.length) return `[warp-pool]     :${port} 被 pid ${ours.join(",")} 占：本池 wireproxy 残留（上一代 daemon 被强杀留下的孤儿）→ 起隧道前清理`;
+  const who = others.length ? others.map((o) => `pid ${o.pid} ${o.name}`).join("、") : "未知进程";
+  return `[warp-pool]     :${port} 被 ${who} 占：非本池进程 → 不碰它，这个端口本轮跳过（查明：ss -ltnp | grep :${port}）`;
+}
+
+/** 清理残留的结果：扫了多少进程、命中谁、等了多久、清掉没——第 2 轮返工缺的就是「谁在占」。 */
+export function fmtReclaim({ port, scanned, ours = [], others = [], waitedMs, killed }) {
+  if (!ours.length) {
+    const extra = others.length ? "（端口另有别的进程占着，不是本池的，不动它）" : "";
+    return `[warp-pool] :${port} ${MARK.step} 清理残留：扫 ${scanned} 个进程，无本池残留${extra}`;
+  }
+  return `[warp-pool] :${port} ${MARK.step} 清理残留：扫 ${scanned} 个进程，命中本池残留 pid ${ours.join(",")} → ${killed ? "已清掉" : "清不掉"}（等了 ${dur(waitedMs)}）`;
+}
+
+/** 写出的 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 || "没有输出"}"`;
+}
+
+/** 端口最终被非本池进程占着、拒绝硬起时，把占用者与「套接字还没释放」两种情形分开说。 */
+export function fmtPortBlocked({ port, ours = [], others = [] }) {
+  const oursTxt = ours.length ? `本池残留 pid ${ours.join(",")}（SIGTERM/SIGKILL 都没清掉：可能僵尸或权限不足）` : "";
+  const othTxt = others.length ? others.map((o) => `pid ${o.pid} ${o.name}`).join("、") : "";
+  const who = [oursTxt, 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} 个`;
+}
+
+/** 池空告警：最容易被误读成「功能在跑」，必须把结论与逐条自检命令一起说。 */
+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 || "未发生"}`;
+}
+
+/**
+ * 启动自检块：一次性把「这次按什么参数跑、二进制在哪多大、磁盘上有几个身份、端口分别被谁占着」打全。
+ * 第 1 轮返工只看到「退出 code=1 / 已复活」循环，就是缺这一块——真因（孤儿占端口）当时只能靠猜。
+ * @param {{ cfg: object, nodes: Array<object>, binPath?: string, binSize?: number,
+ *           ownerOf: (port:number)=>Promise<{busy:boolean, ours:number[], 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: [], 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));
+  const orphans = busy.filter((s) => (s.ours || []).length).length;
+  if (orphans) log(`[warp-pool] ${MARK.warn} 有 ${orphans} 个端口被本池残留占着（上一代 daemon 被强杀留下的孤儿）——起隧道前逐个清理，日志会写清 pid`);
+  return states;
+}

package/src/warp-pool/rotate.js

@@ -78,7 +78,7 @@ export function createRotatingDispatcher({
     if (!e) return;
     e.fails += 1;
     e.cooldownUntil = now() + cooldownMs;
-    log(`[warp-pool] 节点 :${e.port} 连续失败 ${e.fails} 次，冷却 ${Math.round(cooldownMs / 1000)}s`);
+    if (e.fails === 1 || e.fails % 10 === 0) log(`[warp-pool] 节点 :${e.port} 连续失败 ${e.fails} 次，冷却 ${Math.round(cooldownMs / 1000)}s（中间次数静默：健康探活每分钟一轮，一个不通的节点曾把日志刷成 12 行/分钟）`);
   }
 
   function markOk(index) {

package/src/warp-pool/wireproxy.js

@@ -93,16 +93,19 @@ function runCommand(cmd, args, { log = () => {} } = {}) {
 export function writeTunnelConf(dir, node) {
   if (!node?.privateKey) throw new Error(`节点 :${node?.port} 缺 WireGuard 私钥，拒绝写出一份跑不起来的配置`);
   const { conf } = nodePaths(dir, node.port);
-  return writeSecret(conf, renderWireproxyConf({ ...node, port: node.port }));
+  const text = renderWireproxyConf({ ...node, port: node.port });
+  writeSecret(conf, text);
+  return { conf, bytes: Buffer.byteLength(text) };
 }
 
 /**
  * 启动一条隧道。返回 { port, conf, stop() }。
  * 进程退出即视为隧道失效（不自动重启：由 health 层决策重拨换 IP）。
  */
-export function startTunnel({ binPath: exe, dir, port, log = () => {}, onExit = () => {} } = {}) {
+export function startTunnel({ binPath: exe, dir, port, log = () => {}, onExit = () => {}, now = Date.now } = {}) {
   const { conf } = nodePaths(dir, port);
   const child = spawn(exe, ["-c", conf], { stdio: ["ignore", "pipe", "pipe"] });
+  const startedAt = now();
   let tail = "";
   const keepTail = (d) => {
     tail = (tail + String(d)).slice(-800);
@@ -112,7 +115,7 @@ export function startTunnel({ binPath: exe, dir, port, log = () => {}, onExit =
 
   let stopped = false;
   child.on("exit", (code, signal) => {
-    if (!stopped) onExit({ port, code, signal, tail });
+    if (!stopped) onExit({ port, code, signal, tail, pid: child.pid, aliveMs: now() - startedAt });
   });
 
   return {
@@ -139,18 +142,20 @@ export function startTunnel({ binPath: exe, dir, port, log = () => {}, onExit =
 export async function probeTunnel({ port, baseUrl = "https://opencode.ai", path = "/zen/v1/models", fetchImpl = compatFetch, timeoutMs = 8000, headers = {}, wantText = false } = {}) {
   const { ProxyAgent } = getUndici();
   const agent = new ProxyAgent({ uri: `http://127.0.0.1:${port}`, connections: 2, keepAliveTimeout: 10_000 });
+  const url = `${String(baseUrl).replace(/\/+$/, "")}${path}`;
+  const t0 = Date.now();
   try {
-    const res = await fetchImpl(`${String(baseUrl).replace(/\/+$/, "")}${path}`, {
+    const res = await fetchImpl(url, {
       headers,
       signal: AbortSignal.timeout(timeoutMs),
       dispatcher: agent,
     });
-    const base = { ok: res.ok, status: res.status };
+    const base = { ok: res.ok, status: res.status, ms: Date.now() - t0, url };
     if (!wantText) return base;
     const text = await res.text().catch(() => "");
     return { ...base, text: String(text).slice(0, 2000) };
   } catch (e) {
-    return { ok: false, status: 0, error: String(e?.message || e) };
+    return { ok: false, status: 0, error: String(e?.message || e), ms: Date.now() - t0, url };
   } finally {
     try { await agent.close(); } catch {}
   }