mslxdff 0.1.203 → 0.1.208

package/src/warp-pool/keys.js

@@ -1,29 +1,29 @@
-// warp-pool · WireGuard 密钥（`wg genkey` / `wg pubkey` 的 Node 原生等价物）。
-// WireGuard 用 Curve25519(x25519)：密钥是 32 字节 raw，编码为 44 字符 base64。
-// Node 原生 generateKeyPairSync('x25519') 导出的 DER 末 32 字节即 raw key（本机实测通过）。
-import crypto from "node:crypto";
-
-const RAW_BYTES = 32;
-
-/** DER(SPKI/PKCS8) 的末 32 字节就是 Curve25519 raw key。 */
-function rawTail(der) {
-  const raw = der.subarray(-RAW_BYTES);
-  if (raw.length !== RAW_BYTES) throw new Error("x25519 密钥导出异常：DER 长度不足 32 字节");
-  return raw;
-}
-
-/**
- * 生成一对 WireGuard 密钥（base64，44 字符）。
- * 注册 WARP 设备时把 publicKey 填进请求体的 `key` 字段。
- */
-export function generateWgKeyPair() {
-  const { publicKey, privateKey } = crypto.generateKeyPairSync("x25519");
-  const privateKeyB64 = rawTail(privateKey.export({ type: "pkcs8", format: "der" })).toString("base64");
-  const publicKeyB64 = rawTail(publicKey.export({ type: "spki", format: "der" })).toString("base64");
-  return { privateKey: privateKeyB64, publicKey: publicKeyB64 };
-}
-
-/** WireGuard base64 密钥形状自检：恒 44 字符、以 '=' 收尾（Nothing-up-my-sleeve 检查用）。 */
-export function isWgKey(v) {
-  return typeof v === "string" && /^[A-Za-z0-9+/]{43}=$/.test(v);
-}
+// warp-pool · WireGuard 密钥（`wg genkey` / `wg pubkey` 的 Node 原生等价物）。
+// WireGuard 用 Curve25519(x25519)：密钥是 32 字节 raw，编码为 44 字符 base64。
+// Node 原生 generateKeyPairSync('x25519') 导出的 DER 末 32 字节即 raw key（本机实测通过）。
+import crypto from "node:crypto";
+
+const RAW_BYTES = 32;
+
+/** DER(SPKI/PKCS8) 的末 32 字节就是 Curve25519 raw key。 */
+function rawTail(der) {
+  const raw = der.subarray(-RAW_BYTES);
+  if (raw.length !== RAW_BYTES) throw new Error("x25519 密钥导出异常：DER 长度不足 32 字节");
+  return raw;
+}
+
+/**
+ * 生成一对 WireGuard 密钥（base64，44 字符）。
+ * 注册 WARP 设备时把 publicKey 填进请求体的 `key` 字段。
+ */
+export function generateWgKeyPair() {
+  const { publicKey, privateKey } = crypto.generateKeyPairSync("x25519");
+  const privateKeyB64 = rawTail(privateKey.export({ type: "pkcs8", format: "der" })).toString("base64");
+  const publicKeyB64 = rawTail(publicKey.export({ type: "spki", format: "der" })).toString("base64");
+  return { privateKey: privateKeyB64, publicKey: publicKeyB64 };
+}
+
+/** WireGuard base64 密钥形状自检：恒 44 字符、以 '=' 收尾（Nothing-up-my-sleeve 检查用）。 */
+export function isWgKey(v) {
+  return typeof v === "string" && /^[A-Za-z0-9+/]{43}=$/.test(v);
+}

package/src/warp-pool/nodes.js

@@ -1,95 +1,95 @@
-// 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}
-`;
-}
+// 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 +1,160 @@
-// 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;
-}
+// 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;
+}