mslxdff 0.1.181 → 0.1.183

package/package.json

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

package/src/cli/commands/daemon.js

@@ -1,14 +1,27 @@
 import { existsSync, writeFileSync } from "node:fs";
-import { startDaemon, stopDaemon, readPid, readPidVersion, isPidAlive, pidFile, logFile } from "../../daemon.js";
+import { startDaemon, stopDaemon, readPid, readPidVersion, isPidAlive, pidFile, logFile, waitPidGone, reapGhostDaemons } from "../../daemon.js";
 import { setPort } from "../../state.js";
 import { logDir, eventsFile, callsFile, errorsFile } from "../../logs.js";
 import { effectivePort, waitForHealth, stopDaemonIfOutdated, compareSemver, argValue } from "../policy.js";
 import { printStatus } from "../status.js";
 import { compatFetch, timeoutSignal } from "../../compat.js";
+import { findDaemons, fmtAlive } from "../../runtime/proc-info.js";
+
+/** 停 daemon 并**等它真死**：只发 SIGTERM 就起新的会留下幽灵（隧道子进程把事件循环钉住，见 daemon.js waitPidGone）。 */
+async function stopDaemonHard(reason) {
+  const pid = readPid();
+  const r = stopDaemon({ reason });
+  if (pid && r.stopped) {
+    const g = await waitPidGone(pid);
+    if (!g.died) console.log(`⚠ 旧 daemon (pid ${pid}) 等了 ${Math.round(g.waitedMs / 1000)}s 仍没退（已补 SIGKILL）—— 若仍在世，它会和新的抢端口`);
+    else if (g.forced) console.log(`旧 daemon (pid ${pid}) 未响应 SIGTERM，已 SIGKILL（等了 ${Math.round(g.waitedMs / 1000)}s）`);
+  }
+  return r;
+}
 
 export async function handleStop(args) {
   if (!(args.includes("-stop") || args.includes("--stop"))) return false;
-  const { stopped, pid, reason } = stopDaemon();
+  const { stopped, pid, reason } = await stopDaemonHard("stop");
   if (stopped) {
     console.log(`mslxdff daemon stopped (pid ${pid})`);
   } else {
@@ -23,14 +36,17 @@ export async function handleRestart(args, VERSION) {
   const alive = pid ? isPidAlive(pid) : false;
   if (alive) {
     console.log(`restarting daemon (pid ${pid})...`);
-    stopDaemon({ reason: "restart" });
-    await new Promise((r) => setTimeout(r, 300));
+    await stopDaemonHard("restart");
   } else if (pid) {
     console.log(`daemon pid ${pid} is stale (not running) — starting fresh...`);
     try { stopDaemon({ reason: "restart" }); } catch {}
   } else {
-    console.log(`daemon not running — starting...`);
+    console.log("daemon not running — starting...");
   }
+  // 结构性盲区收口：不在 daemon.pid 里的 daemon 永远杀不到（真机：Oct16 起的旧 daemon 活了一整天，
+  // 与新版互杀 warp-pool 端口；两边日志格式交错才暴露）。起新的之前先清干净。
+  const ghosts = await reapGhostDaemons({ log: (m) => console.log(m) });
+  if (ghosts.length) console.log(`已清掉 ${ghosts.length} 个不在册的 daemon（pid ${ghosts.map((g) => g.pid).join(", ")}）`);
   const port = effectivePort(args);
   const spawnedPid = startDaemon([]);
   await waitForHealth(port, 4000);
@@ -39,7 +55,12 @@ export async function handleRestart(args, VERSION) {
     const r = await compatFetch(`http://127.0.0.1:${port}/health`, { signal: timeoutSignal(1200) });
     ok = r.ok;
   } catch {}
-  if (ok) console.log(`mslxdff v${VERSION} restarted as a background daemon (pid ${spawnedPid})`);
+  // 诚实报错：/health 可能由**残留的旧 daemon** 应答（它也在监听同一个端口），所以不能只看 health
+  const leftover = findDaemons({ self: spawnedPid });
+  const leftTxt = leftover.map((g) => `pid ${g.pid}（已运行 ${fmtAlive(g.aliveSec)}）`).join("；");
+  if (leftover.length) {
+    console.log(`⚠ 仍有 ${leftover.length} 个旧 daemon 在跑：${leftTxt} —— 它们会和新的抢出口池端口，请 kill 掉`);
+  } else if (ok) console.log(`mslxdff v${VERSION} restarted as a background daemon (pid ${spawnedPid})`);
   else console.log(`mslxdff v${VERSION} restarted (pid ${spawnedPid}) — health check pending (http://127.0.0.1:${port}/health)`);
   console.log(`endpoint:   http://localhost:${port}/v1`);
   console.log(`log:        ${logFile()}`);

package/src/daemon.js

@@ -4,6 +4,7 @@ import { join, dirname } from "node:path";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
 import { writeExitMarker } from "./runtime/lifecycle-forensics.js";
+import { aliveSec, findDaemons, fmtAlive } from "./runtime/proc-info.js";
 
 export function daemonDir() {
   return process.env.MSLXDFF_DAEMON_DIR || join(os.homedir(), ".config", "mslxdff");
@@ -110,3 +111,85 @@ export function stopDaemon({ reason = "stop" } = {}) {
   if (killFailed) return { stopped: false, pid, reason: "EPERM — process kill denied (try running terminal as Administrator, or use restart-daemon.bat)" };
   return { stopped: true, pid, stale: !victimAlive };
 }
+
+/**
+ * 等目标进程真的死掉，超时补 SIGKILL。返回 { died, forced, waitedMs }。
+ * 为什么必须有：只发 SIGTERM 就 spawn 新 daemon，会留下「收到信号但退不出去」的幽灵
+ * （隧道子进程把事件循环钉住）——它不在 daemon.pid 里，从此 `-restart` 结构性碰不到它。
+ */
+export async function waitPidGone(pid, { timeoutMs = 5000, killWaitMs = 2000, stepMs = 100, kill = process.kill, isAlive = isPidAlive, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) } = {}) {
+  const t0 = Date.now();
+  while (isAlive(pid) && Date.now() - t0 < timeoutMs) await sleep(stepMs);
+  if (!isAlive(pid)) return { died: true, forced: false, waitedMs: Date.now() - t0 };
+  try { kill(pid, "SIGKILL"); } catch {}
+  const t1 = Date.now();
+  while (isAlive(pid) && Date.now() - t1 < killWaitMs) await sleep(stepMs);
+  return { died: !isAlive(pid), forced: true, waitedMs: Date.now() - t0 };
+}
+
+/**
+ * 清「不在 daemon.pid 里的」幽灵 daemon —— `-restart` 的结构性盲区
+ *（真机事故：旧 daemon 活了一整天，与新版互杀 warp-pool 端口，两边日志格式交错才暴露）。
+ * 先 SIGTERM 全清 → 等 5s → 仍活着的 SIGKILL。返回**确实清掉**的清单（供调用方诚实汇报）。
+ */
+export async function reapGhostDaemons({ self = process.pid, list = () => findDaemons({ self }), kill = process.kill, log = () => {}, isAlive = isPidAlive, settleMs = 5000, killWaitMs = 2000, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) } = {}) {
+  const ghosts = list();
+  if (!ghosts.length) return [];
+  for (const g of ghosts) log(`[daemon] 发现不在册的 daemon pid=${g.pid}（父 ${g.ppid}，已运行 ${fmtAlive(g.aliveSec)}）—— -restart 杀不到它，清掉`);
+  for (const g of ghosts) { try { kill(g.pid, "SIGTERM"); } catch {} }
+  const t0 = Date.now();
+  while (Date.now() - t0 < settleMs && ghosts.some((g) => isAlive(g.pid))) await sleep(100);
+  const stuck = ghosts.filter((g) => isAlive(g.pid));
+  for (const g of stuck) { try { kill(g.pid, "SIGKILL"); } catch {} }
+  const t1 = Date.now();
+  while (Date.now() - t1 < killWaitMs && stuck.some((g) => isAlive(g.pid))) await sleep(100);
+  return ghosts.filter((g) => !isAlive(g.pid));
+}
+
+/**
+ * 接管：内存里若还有**别的** mslxdff daemon，先把比我们旧的那批请出去。
+ * 为什么必须有（用户点名要求 + 真机 2026-10-17 事故）：`-restart` 只认 `daemon.pid`，
+ * 不在册的 daemon（SIGTERM 后没真退出、pid 文件又被删掉的那个）会活一整天，与新版互抢
+ * warp-pool 的 4 个端口——日志里只能看到「起一条死一条」，看不出是两个 daemon 在互杀。
+ * 判据：比自己早启动 ≥ `minAgeMs` 的一律清（SIGTERM → 等 → SIGKILL）；与本次启动几乎同时的不动
+ * （谁该活由 8989 的 bind 决定，`server-lifecycle` 的 EADDRINUSE 自愈会收口），避免两边互杀。
+ * 全程不抛（接管失败绝不能挡住启动）。
+ * @returns {Promise<{killed:number[], skipped:number[], remaining:number[]}>}
+ */
+export async function takeoverOlderDaemons({
+  self = process.pid,
+  list = () => findDaemons({ self }),
+  kill = process.kill,
+  isAlive = isPidAlive,
+  log = () => {},
+  minAgeMs = 3000,
+  settleMs = 5000,
+  killWaitMs = 2000,
+  myAliveSec = undefined,
+  sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
+} = {}) {
+  const sibs = list();
+  if (!sibs.length) return { killed: [], skipped: [], remaining: [] };
+  const mine = myAliveSec === undefined ? aliveSec(self) : myAliveSec;
+  // 取不到运行时长（非 Linux / 读不到 /proc）时保守处理：一律当成「旧的」，因为只允许一个 daemon 活着
+  const isOlder = (d) => mine == null || d.aliveSec == null || (d.aliveSec - mine) * 1000 >= minAgeMs;
+  const older = sibs.filter(isOlder);
+  const skipped = sibs.filter((d) => !isOlder(d));
+
+  for (const d of older) log(`[daemon] 内存里还有别的 mslxdff daemon：pid ${d.pid}（父 ${d.ppid}，已运行 ${fmtAlive(d.aliveSec)}，比本进程旧）—— 先请它退出，否则两个 daemon 会抢同一批端口（warp-pool 起一条死一条的真因）`);
+  for (const d of older) { try { kill(d.pid, "SIGTERM"); } catch {} }
+  const t0 = Date.now();
+  while (Date.now() - t0 < settleMs && older.some((d) => isAlive(d.pid))) await sleep(100);
+  const stuck = older.filter((d) => isAlive(d.pid));
+  for (const d of stuck) log(`[daemon] pid ${d.pid} 收到 SIGTERM 后 ${Math.round((Date.now() - t0) / 1000)}s 仍没退，补 SIGKILL`);
+  for (const d of stuck) { try { kill(d.pid, "SIGKILL"); } catch {} }
+  const t1 = Date.now();
+  while (Date.now() - t1 < killWaitMs && stuck.some((d) => isAlive(d.pid))) await sleep(100);
+
+  const remaining = older.filter((d) => isAlive(d.pid));
+  const killed = older.filter((d) => !isAlive(d.pid)).map((d) => d.pid);
+  for (const d of skipped) log(`[daemon] ⚠ 同机还有 pid ${d.pid}（与本次启动几乎同时，不是旧的）—— 不动它，由 8989 的 bind 决定谁活`);
+  if (remaining.length) log(`[daemon] ⚠ 请不走：pid ${remaining.map((d) => d.pid).join(",")}（SIGKILL 都没用，可能是僵尸或权限不足）—— 它仍会抢端口，请手动 kill -9`);
+  else if (killed.length) log(`[daemon] ✓ 已请走 ${killed.length} 个旧 daemon（pid ${killed.join(",")}），本进程独占`);
+  return { killed, skipped: skipped.map((d) => d.pid), remaining: remaining.map((d) => d.pid) };
+}

package/src/runtime/bootstrap.js

@@ -14,6 +14,17 @@ const logs = { appendCall, appendError, appendEvent, appendTimeline, appendModel
 export async function startDaemonMain(VERSION) {
   const { installLifecycleLog } = await import("./lifecycle-log.js");
   installLifecycleLog({ version: VERSION, logs });
+  // 接管：内存里若还有旧的 mslxdff daemon，先请它退出。它不在 daemon.pid 里（-restart 结构性碰不到它），
+  // 两个 daemon 会互抢 warp-pool 的端口（真机 2026-10-17：旧 daemon 活了一整天，日志只显示「起一条死一条」）。
+  // 必须早于 setupProviders —— 那一步才建池抢端口。debug 前台有自己的收口逻辑，不在这里抢。
+  if (process.env.MSLXDFF_DAEMON === "1" && process.env.MSLXDFF_DEBUG !== "1") {
+    try {
+      const { takeoverOlderDaemons } = await import("../daemon.js");
+      await takeoverOlderDaemons({ log: (m) => console.log(m) });
+    } catch (e) {
+      console.log(`[daemon] 接管旧 daemon 失败（不阻断启动）：${String(e?.message || e)}`);
+    }
+  }
   const ctx = await setupProviders();
   const { srv, bus } = await startServerLifecycle({ VERSION, ...ctx, logs });
   void srv;

package/src/runtime/proc-info.js

@@ -0,0 +1,137 @@
+// 进程取证层（Linux /proc 只读）——2026-10-17 组长 VPS「幽灵 daemon 互杀」事故后新增。
+//
+// 事故：两个 daemon 同时活着（一个从昨天起活了一整天），都管同一份 warp-pool 目录，
+// 把对方的 wireproxy 当「上一代残留」杀掉 ⇒ 无限互杀、池永远不稳。三处都缺「读 /proc 说事实」的能力：
+//   ① 日志不知道「同机还有几个 daemon」（只能靠人肉 ps 才发现）；
+//   ② 清理不知道「这个 wireproxy 的父进程还活着（= 另一个 daemon 的活隧道）」；
+//   ③ 「SIGKILL 都清不掉」其实是**僵尸**（state=Z，kill 对它无效，但 kill(pid,0) 仍返回成功）。
+// 放 runtime 而不是 warp-pool：daemon 与 warp-pool 都要用，放 warp-pool 会让 daemon 反向依赖它。
+// 非 Linux 一律返回空 —— 读不到 /proc 就别猜（不在别的平台做危险推断）。
+import { readFileSync, readdirSync } from "node:fs";
+
+/** /proc/<pid>/cmdline 是 NUL 分隔的字节串；切成参数数组（丢掉结尾空串）。 */
+export function parseCmdline(buf) {
+  return String(buf == null ? "" : buf).split("\0").filter((s) => s !== "");
+}
+
+/**
+ * /proc/<pid>/stat → 我们关心的三格。
+ * 格式 `pid (comm) state ppid ... starttime`：comm 里可能有空格和括号 ⇒ 从**最后一个** `)` 之后切，
+ * 否则 comm 带括号的进程会让后面所有字段错位。
+ * @returns {{state:string, ppid:number, startTicks:number} | null}
+ */
+export function parseStat(raw) {
+  const s = String(raw == null ? "" : raw);
+  const cut = s.lastIndexOf(")");
+  if (cut < 0) return null;
+  const f = s.slice(cut + 1).trim().split(/\s+/);
+  if (f.length < 20) return null;
+  return { state: String(f[0] || ""), ppid: Number(f[1]) || 0, startTicks: Number(f[19]) || 0 };
+}
+
+/** 僵尸：已死、等父进程收尸。kill 对它无效，但 kill(pid, 0) 仍返回成功 ⇒ 必须单独判。 */
+export function isZombie(state) {
+  return String(state || "").toUpperCase() === "Z";
+}
+
+/** 进程是否还在（信号 0 = 只做存在性检查，不真发信号）。 */
+export function pidAlive(pid, kill = process.kill) {
+  try {
+    kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function defaultPids() {
+  try {
+    return readdirSync("/proc").filter((f) => /^\d+$/.test(f)).map(Number);
+  } catch {
+    return [];
+  }
+}
+
+export function defaultCmdline(pid) {
+  try {
+    return parseCmdline(readFileSync(`/proc/${pid}/cmdline`));
+  } catch {
+    return [];
+  }
+}
+
+export function defaultStat(pid) {
+  try {
+    return parseStat(readFileSync(`/proc/${pid}/stat`, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/** 本机已开机秒数（/proc/uptime 第一列）；读不到返回 0。 */
+export function uptimeSec() {
+  try {
+    const n = Number(String(readFileSync("/proc/uptime", "utf8")).trim().split(/\s+/)[0]);
+    return Number.isFinite(n) ? n : 0;
+  } catch {
+    return 0;
+  }
+}
+
+/** 进程已运行秒数 = 开机秒数 − starttime/USER_HZ（Linux USER_HZ 恒为 100）。取不到返回 null。 */
+export function aliveSec(pid, { uptime = uptimeSec, stat = defaultStat } = {}) {
+  const st = stat(pid);
+  const up = uptime();
+  if (!st || !(up > 0) || !(st.startTicks > 0)) return null;
+  return Math.max(0, Math.round(up - st.startTicks / 100));
+}
+
+/** argv 看起来是我们的 daemon：带 `--daemon`，且有参数以 `mslxdff` / `mslxdff.js` 结尾。 */
+export function isDaemonArgv(argv) {
+  const list = Array.isArray(argv) ? argv : [];
+  return list.includes("--daemon") && list.some((a) => /(^|[\\/])mslxdff(\.js)?$/i.test(String(a)));
+}
+
+/** 「已运行 6h12m」这种人话时长（取证日志用）。 */
+export function fmtAlive(sec) {
+  if (!Number.isFinite(sec)) return "运行时长未知";
+  const s = Math.max(0, Math.round(sec));
+  if (s < 60) return `${s}s`;
+  if (s < 3600) return `${Math.floor(s / 60)}m`;
+  return `${Math.floor(s / 3600)}h${Math.floor((s % 3600) / 60)}m`;
+}
+
+/**
+ * 同机其它我们的 daemon（排除 self）。
+ * 「不在 daemon.pid 里的 daemon」是 `-restart` 的结构性盲区 —— 必须能列出来，才谈得上清理与告警。
+ * @returns {Array<{pid:number, ppid:number, state:string, aliveSec:number|null}>}
+ */
+export function findDaemons({ self = 0, pids = defaultPids, cmdline = defaultCmdline, stat = defaultStat, uptime = uptimeSec } = {}) {
+  const out = [];
+  for (const pid of pids()) {
+    if (pid === self) continue;
+    if (!isDaemonArgv(cmdline(pid))) continue;
+    const st = stat(pid);
+    out.push({
+      pid,
+      ppid: st ? st.ppid : 0,
+      state: st ? st.state : "",
+      aliveSec: aliveSec(pid, { uptime, stat: () => st }),
+    });
+  }
+  return out;
+}
+
+/**
+ * 该进程的父进程是不是**另一个活着的 mslxdff daemon**？
+ * 是 ⇒ 这不是「上一代残留」，是**别人的活隧道**（清了就是互杀）。
+ * 自家子进程（ppid=self）、孤儿（ppid<=1 或父进程已死）、读不到 stat 都返回 null（照旧清）。
+ * @returns {{pid:number, aliveSec:number|null} | null}
+ */
+export function otherDaemonParent(pid, { self = process.pid, stat = defaultStat, cmdline = defaultCmdline, kill = process.kill, uptime = uptimeSec } = {}) {
+  const st = stat(pid);
+  if (!st || st.ppid <= 1 || st.ppid === self) return null;
+  if (!pidAlive(st.ppid, kill)) return null;
+  if (!isDaemonArgv(cmdline(st.ppid))) return null;
+  return { pid: st.ppid, aliveSec: aliveSec(st.ppid, { uptime, stat }) };
+}

package/src/server.js

@@ -38,9 +38,18 @@ export function startServer({ router, signals = true, host, onBeforeClose }, por
     // 关停留痕（Linux 有效：可捕获 SIGTERM/SIGINT 并记录）。Windows 注意：process.kill 的
     // SIGTERM 实为 TerminateProcess 强杀，被杀的 JS 进程收不到该事件，此处不会触发——
     // Windows 的"谁杀了我"靠 src/daemon.js stopDaemon() 的杀者留痕 + 最后一条 heartbeat。
+    let stopping = false;
     const onSignal = (sig) => {
+      if (stopping) return;
+      stopping = true;
       try { console.log(`[lifecycle] ${sig} received — shutting down (pid ${process.pid}, uptime ${Math.round(process.uptime())}s)`); } catch {}
-      close();
+      // 关停必须**真的退出**：warp-pool 的 wireproxy 子进程 stdio 是 pipe，活着的子进程会把事件循环钉住；
+      // 只 close() server（放开 8989）会留下「不监听端口却还活着」的幽灵 daemon
+      //（真机 2026-10-17：Oct16 起的幽灵与新版互杀 warp-pool 端口一整天，且它不在 daemon.pid 里，-restart 永远碰不到）。
+      // process.exit 会跑 exit 钩子（warp-pool 杀隧道、lifecycle 写遗书），故清理不会被跳过。
+      const hard = setTimeout(() => { try { console.log(`[lifecycle] ${sig} 优雅关停 8s 未完成 — 强制退出`); } catch {} process.exit(0); }, 8000);
+      hard.unref?.();
+      close().then(() => process.exit(0), (e) => { try { console.log(`[lifecycle] 关停抛错：${String(e?.message || e)}`); } catch {} process.exit(1); });
     };
     process.on("SIGINT", () => onSignal("SIGINT"));
     process.on("SIGTERM", () => onSignal("SIGTERM"));

package/src/warp-pool/index.js

@@ -9,8 +9,9 @@ import { registerWarpDevice } from "./register.js";
 import { ensureBinary, probeTunnel, resolveAsset, startTunnel, writeTunnelConf } from "./wireproxy.js";
 import { createReviver, labelExits, tailReason } from "./revive.js";
 import { portInUse, portOwner, reclaimPort, waitPortFree } from "./ports.js";
-import { fmtConf, fmtExit, fmtPool, fmtPoolEmpty, fmtProbe, fmtProbeGiveUp, fmtPortBlocked, fmtSpawn, startupReport } from "./report.js";
+import { fmtConf, fmtExit, fmtPool, fmtPoolEmpty, fmtProbe, fmtProbeGiveUp, fmtPortBlocked, fmtSiblings, fmtSpawn, startupReport } from "./report.js";
 import { wireRotation } from "./identity.js";
+import { findDaemons } from "../runtime/proc-info.js";
 
 /** 重拨节流：连续失败指数退避。网络不通的机器绝不能让重注册把 CF 刷到 429。 */
 const REDIAL_MIN_GAP_MS = 5 * 60_000;
@@ -177,6 +178,9 @@ export function createWarpPool({
     // 1. 复用磁盘上已注册的节点
     let nodes = loadNodes(cfg.dir, cfg.ports);
     await startupReport({ cfg, nodes, binPath, ownerOf: (port) => portOwner({ dir: cfg.dir, port }), log });
+    // 同机其它 daemon：两个 daemon 会互相把对方的活隧道当「残留」杀掉（真机事故根因），必须一开池就报出来
+    const siblings = findDaemons({ self: process.pid });
+    if (siblings.length) log(fmtSiblings({ list: siblings }));
 
     // 2. 补足：逐个注册（拉长间隔，避免 CF 注册限流与同网段撞车）
     const used = new Set(nodes.map((n) => n.port));

package/src/warp-pool/ports.js

@@ -1,18 +1,18 @@
-// warp-pool · 端口占用与「上一代进程残留」清理（2026-10-16 组长 VPS 真机事故后新增）。
+// warp-pool · 端口占用与「上一代进程残留」清理（2026-10-16 真机事故后新增；2026-10-17 七次修订）。
 //
-// 事故：daemon 被强杀（WMI TerminateProcess / taskkill /F）时 `process.once("exit")` 钩子不执行，
-// wireproxy 子进程变成孤儿，继续占着 127.0.0.1:10800+ 这些端口。新 daemon 再起隧道就 bind 失败
-// （wireproxy 立刻退出 code=1），而旧代码把「spawn 成功」当成「复活成功」⇒ 无限重启、日志刷屏、
-// 且该端口的隧道永远起不来。治本是「起隧道前先把自家残留清掉」，并「端口被别人占着就别硬起」。
-import { readFileSync, readdirSync } from "node:fs";
+// 事故一（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/<pid>/cmdline 是 NUL 分隔的字节串；切成参数数组（丢掉结尾空串）。 */
-export function parseCmdline(buf) {
-  return String(buf == null ? "" : buf).split("\0").filter((s) => s !== "");
-}
+// /proc 读取层已上移到 runtime/proc-info.js（daemon 侧也要用同一套判据）；这里原样再导出，既有调用方路径不变。
+export { parseCmdline, pidAlive };
 
 /**
  * 该进程是不是「正在跑我们这条 conf」的 wireproxy。
@@ -25,37 +25,13 @@ export function isOurWireproxy(argv, conf) {
   return isBin && list.includes(conf);
 }
 
-function defaultPids() {
-  try {
-    return readdirSync("/proc").filter((f) => /^\d+$/.test(f)).map(Number);
-  } catch {
-    return [];
-  }
-}
-
-function defaultCmdline(pid) {
-  try {
-    return parseCmdline(readFileSync(`/proc/${pid}/cmdline`));
-  } catch {
-    return [];
-  }
-}
-
-/** 进程是否还在（信号 0 = 只做存在性检查，不真发信号）。 */
-export function pidAlive(pid, kill = process.kill) {
-  try {
-    kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 /**
- * 清掉「占着该端口那条 conf」的上一代 wireproxy。返回被清理的 pid 列表。
- * 非 Linux 直接返回 []（读不到 /proc，别拿别的平台做危险猜测）。
- * @param {{ dir: string, port: number, log?: Function, platform?: string,
- *           pids?: Function, cmdline?: Function, kill?: Function, sleep?: Function, waitRounds?: number }} opts
+ * 清掉占着该端口那条 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,
@@ -64,33 +40,58 @@ export async function reclaimPort({
   platform = process.platform,
   pids = defaultPids,
   cmdline = defaultCmdline,
+  stat = defaultStat,
   kill = process.kill,
   sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
   waitRounds = 15,
 } = {}) {
-  if (platform !== "linux") return [];
+  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 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");
-    } catch {}
+  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);
   }
-  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 {}
+
+  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 gone = !targets.some((p) => pidAlive(p, kill));
-  log(fmtReclaim({ port, scanned: all.length, ours: targets, waitedMs: Date.now() - startedAt, killed: gone }));
-  return targets;
+  const r = shape(all.length, targets, zombies, foreign);
+  log(fmtReclaim({ port, ...r }));
+  return r;
 }
 
 /** 该端口是否已有人在监听（TCP 连得上 = 占用；连不上/被拒 = 空闲）。 */
@@ -125,19 +126,30 @@ export async function waitPortFree(port, { inUse = portInUse, sleep = (ms) => ne
 }
 
 /**
- * 端口占用者取证：谁在监听——本池 wireproxy 残留？别人的进程？还是空闲。
- * 「孤儿占端口」这类事故唯一能一眼看出结论的读数：只报「占用 / 拒绝再起」是查不出问题的（第 2 轮返工的教训）。
- * @returns {Promise<{busy:boolean, ours:number[], others:Array<{pid:number,name:string}>}>}
+ * 端口占用者取证：谁在监听——本池残留？另一个 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, inUse = portInUse } = {}) {
+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: [], others: [] };
+  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;
     }

package/src/warp-pool/report.js

@@ -1,9 +1,11 @@
-// warp-pool · 日志与自检报告（2026-10-16 四轮返工后新增）。
+// warp-pool · 日志与自检报告（2026-10-16 四轮返工后新增；2026-10-17 七次修订补「同机其它 daemon」）。
 //
-// 为什么单独一个模块（四轮返工的教训）：日志若只说「失败了」、不说「谁干的、为什么」，就只能靠猜——
-// 第 1 轮猜孤儿占端口、第 2 轮分不清旧 daemon 子进程与刚被杀还没释放的套接字、第 3 轮分不清握手未完成与上游拒绝。
-// 故把可判定信息一次摆全：配置快照、端口占用者（pid+命令行+是否本池残留）、身份文件、每条隧道完整生命周期
-// （清理→写配置→spawn pid→探活耗时/状态/错误→退出码/信号/存活时长/末行）、池子结论与「下一步敲什么命令」。
+// 为什么单独一个模块（五轮返工的教训）：日志若只说「失败了」、不说「谁干的、为什么」，就只能靠猜——
+// 第 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`);
@@ -35,21 +37,30 @@ export function fmtIdentities(nodes, ports) {
   return `[warp-pool] ${MARK.step} 身份文件 ${nodes.length}/${ports.length}：${parts.join(" ")}（✓=有 id+token+私钥，✗缺=现场注册）`;
 }
 
-/** 单端口占用者：区分「本池残留」「别人的进程」「空闲」——第 1 轮返工缺的就是这一行。 */
-export function fmtPortState({ port, busy, ours = [], others = [] }) {
+/** 「另一个 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 (ours.length) return `[warp-pool]     :${port} 被 pid ${ours.join(",")} 占：本池 wireproxy 残留（上一代 daemon 被强杀留下的孤儿）→ 起隧道前清理`;
+  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}）`;
 }
 
-/** 清理残留的结果：扫了多少进程、命中谁、等了多久、清掉没——第 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)}）`;
+/** 清理残留的结果：扫了多少进程、命中谁、等了多久、清掉没、以及「另一个 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）。 */
@@ -83,11 +94,13 @@ export function fmtExit({ port, code, signal, pid, aliveMs, tail }) {
   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 都没清掉：可能僵尸或权限不足）` : "";
+/** 端口最终被占着、拒绝硬起时，把「另一个 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 = [oursTxt, othTxt].filter(Boolean).join("；") || "未知进程（已等套接字释放仍连得上）";
+  const who = [foreignTxt, oursTxt, zombieTxt, othTxt].filter(Boolean).join("；") || "未知进程（已等套接字释放仍连得上）";
   return `[warp-pool] :${port} ${MARK.fail} 端口被 ${who} 占着，拒绝再起（硬起只会 bind 失败、无限重启刷屏）。查明：ss -ltnp | grep :${port}`;
 }
 
@@ -121,11 +134,18 @@ export function fmtHeartbeat({ alive, total, pooled, exits, cooling, lastAllDown
   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[], others:Array<{pid:number,name:string}>}>,
+ *           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 = () => {} }) {
@@ -137,13 +157,21 @@ export async function startupReport({ cfg, nodes, binPath = "", binSize = 0, own
     try {
       states.push({ port, ...(await ownerOf(port)) });
     } catch (e) {
-      states.push({ port, busy: false, ours: [], others: [], error: String(e?.message || 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;
 }