@trim21/personal-pi-extensions 0.1.443 → 0.1.445

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trim21/personal-pi-extensions",
-  "version": "0.1.443",
+  "version": "0.1.445",
   "type": "module",
   "description": "Custom pi coding-agent extensions: bwrap sandbox, workspace guard, opencode edit, and more",
   "keywords": [

package/src/bwrap/core.ts

@@ -380,7 +380,6 @@ function killChild(child: ChildProcess): void {
 /** 网络栈子进程输出转发通道，仅用于诊断（默认丢弃）。 */
 export interface NetworkStackLog {
   holder?: (chunk: string) => void;
-  slirp?: (chunk: string) => void;
 }
 
 /** 为 net-allowlist 模式创建网络栈；非该模式返回 undefined。每次命令现建现停。 */
@@ -395,7 +394,6 @@ export async function createNetworkStack(
     mihomoPath: findMihomo(resolved.mihomoPath),
     slirp4netnsPath: findSlirp4netns(resolved.slirp4netnsPath),
     ...(log?.holder && { onHolderOutput: log.holder }),
-    ...(log?.slirp && { onSlirpOutput: log.slirp }),
   });
 }
 

package/src/bwrap/holder.js

@@ -1,10 +1,14 @@
 import { spawn } from "node:child_process";
+import { rmSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 const args = process.argv.slice(2);
 const configPath = args[0];
 const mihomoPath = args[1];
-if (!configPath || !mihomoPath) {
+const slirp4netnsPath = args[2];
+const tunMtu = Number(args[3]);
+if (!configPath || !mihomoPath || !slirp4netnsPath || !tunMtu) {
   process.exit(2);
 }
 function tap0Exists() {
@@ -22,6 +26,19 @@ async function waitFor(attempts, delayMs, predicate) {
   return false;
 }
 async function main() {
+  process.stdin.resume();
+  process.stdin.on("end", () => {
+    rmSync(dirname(configPath), { recursive: true, force: true });
+    process.exit(0);
+  });
+  const status = await readFile("/proc/self/status", "utf8");
+  const hostPid = /^NSpid:\s+(.+)$/m.exec(status)?.[1].split(/\s+/, 1)[0];
+  if (!hostPid) {
+    throw new Error("Failed to resolve host pid from NSpid");
+  }
+  spawn(slirp4netnsPath, ["-c", `--mtu=${tunMtu}`, "--netns-type=pid", hostPid, "tap0"], {
+    stdio: ["ignore", "inherit", "inherit"]
+  });
   await waitFor(100, 100, tap0Exists);
   const mihomo = spawn(mihomoPath, ["-d", dirname(configPath), "-f", configPath], {
     stdio: ["ignore", "inherit", "inherit"]

package/src/bwrap/holder.ts

@@ -1,13 +1,19 @@
 /* eslint-disable no-console, unicorn/no-process-exit -- 独立 CLI 脚本，由 unshare 直接执行 */
 import { spawn } from "node:child_process";
+import { rmSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 
-// 用法：unshare -Urn node holder.ts <config> <mihomo>
+// 用法：unshare -Urnp --fork --kill-child node holder.ts <config> <mihomo> <slirp4netns> <mtu>
+// 本进程是 pid namespace 的 init：无论以何种方式退出（含 SIGKILL），内核都会清理该 pid ns 内的
+// slirp4netns / mihomo，userns/netns 引用随之归零。
 const args = process.argv.slice(2);
 const configPath = args[0];
 const mihomoPath = args[1];
-if (!configPath || !mihomoPath) {
+const slirp4netnsPath = args[2];
+const tunMtu = Number(args[3]);
+if (!configPath || !mihomoPath || !slirp4netnsPath || !tunMtu) {
   process.exit(2);
 }
 
@@ -32,10 +38,31 @@ async function waitFor(
 }
 
 async function main(): Promise<void> {
-  // slirp4netns 由宿主侧 spawn，这里等它建好 tap0
-  await waitFor(100, 100, tap0Exists);
+  // 宿主（pi）进程死亡检测：宿主以任何方式退出（含 SIGKILL）都会关闭它持有的 stdin 写端，
+  // 这里读到 EOF 即自杀（init 退出即触发内核清理整个 pid ns），顺带删除配置目录。
+  process.stdin.resume();
+  process.stdin.on("end", () => {
+    rmSync(dirname(configPath), { recursive: true, force: true });
+    process.exit(0);
+  });
+
+  // 宿主视角 pid（NSpid 第一项）：/proc 挂载是宿主的（-Urnp 不含 -m，宿主视角下
+  // /proc/1 是 systemd 而非本 pid ns 的 init），slirp4netns 的 setns 必须走宿主 /proc
+  const status = await readFile("/proc/self/status", "utf8");
+  const hostPid = /^NSpid:\s+(.+)$/m.exec(status)?.[1].split(/\s+/, 1)[0];
+  if (!hostPid) {
+    throw new Error("Failed to resolve host pid from NSpid");
+  }
+
+  // slirp4netns 提供 egress：本进程已在目标 userns/netns 内，setns 到自身 netns（no-op）；
+  // 日志 inherit 到 holder 的 stdout/stderr，宿主侧诊断（--verbose）可见
+  spawn(slirp4netnsPath, ["-c", `--mtu=${tunMtu}`, "--netns-type=pid", hostPid, "tap0"], {
+    stdio: ["ignore", "inherit", "inherit"],
+  });
 
   // mihomo 日志透传到 holder 的 stdout/stderr，宿主侧监听 "Tun adapter listening" 判定就绪
+  await waitFor(100, 100, tap0Exists);
+
   const mihomo = spawn(mihomoPath, ["-d", dirname(configPath), "-f", configPath], {
     stdio: ["ignore", "inherit", "inherit"],
   });

package/src/bwrap/network-stack.ts

@@ -1,9 +1,10 @@
 import { type ChildProcess, spawn } from "node:child_process";
 import { mkdtemp, readFile, readlink, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
 import { generateMihomoConfig, TUN_MTU } from "./mihomo-config.js";
 
 /** 命令超时错误：name=TimeoutError（对齐标准错误分类），message 保留 timeout:N 格式。 */
@@ -26,8 +27,6 @@ export interface NetworkStackOptions {
    * 因此启动失败时只剩 "exited before mihomo started"，诊断需要它。
    */
   readonly onHolderOutput?: (chunk: string) => void;
-  /** slirp4netns 输出透传；不传时其 stdio 保持 ignore。 */
-  readonly onSlirpOutput?: (chunk: string) => void;
 }
 
 export interface NetworkStackExecOptions {
@@ -50,15 +49,38 @@ const HOLDER_PATH = fileURLToPath(new URL("holder.js", import.meta.url));
 // ip 通常位于 /usr/sbin 或 /sbin，进程默认 PATH 不含它们；node 则依赖宿主完整 PATH
 const SBIN_PATH_SUFFIX = "/usr/local/sbin:/usr/sbin:/sbin";
 
-function killProcess(pid: number | undefined): void {
+function killProcess(pid: number | undefined, signal: NodeJS.Signals = "SIGTERM"): void {
   if (!pid) return;
   try {
-    process.kill(pid, "SIGTERM");
+    process.kill(pid, signal);
   } catch {
     // 已退出
   }
 }
 
+/** 轮询等待进程退出（进程消失即返回）。 */
+async function waitForExit(pid: number, timeoutMs = 2000): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      process.kill(pid, 0);
+    } catch {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+}
+
+/** 读取进程的直接子进程 pid：--kill-child 只转发信号给 fork 的子进程，兜底直接 SIGKILL 用。 */
+async function readChildPids(pid: number): Promise<number[]> {
+  try {
+    const content = await readFile(`/proc/${pid}/task/${pid}/children`, "utf8");
+    return content.trim().split(/\s+/).filter(Boolean).map(Number);
+  } catch {
+    return [];
+  }
+}
+
 /** 读宿主机 /etc/resolv.conf 的全部 IPv4 nameserver，按声明顺序返回。 */
 export async function resolveDnsServers(): Promise<string[]> {
   const content = await readFile("/etc/resolv.conf", "utf8");
@@ -74,7 +96,7 @@ export async function resolveDnsServers(): Promise<string[]> {
   return ipv4;
 }
 
-/** 等待目标进程进入新的 user namespace（unshare 完成），返回后 slirp4netns 才能 setns。 */
+/** 等待目标进程进入新的 user namespace（unshare 完成），返回后命令才能 nsenter 进入。 */
 async function waitForNewUserns(pid: number, timeoutMs = 5000): Promise<void> {
   const self = await readlink("/proc/self/ns/user");
   const deadline = Date.now() + timeoutMs;
@@ -153,13 +175,12 @@ export interface NetworkStack {
 
 interface NetworkStackState {
   holderPid: number;
-  slirpPid: number | undefined;
   directory: string;
 }
 
 /** 兜底：调用方忘记 stop() 时，对象被 GC 回收后 kill 残留进程并清理目录。 */
 const stackFinalizer = new FinalizationRegistry<NetworkStackState>((state) => {
-  killProcess(state.slirpPid);
+  // SIGTERM 经 unshare --kill-child 转发给 init，内核清理 pid ns 内全部进程
   killProcess(state.holderPid);
   void rm(state.directory, { recursive: true, force: true }).catch(() => false);
 });
@@ -176,121 +197,148 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
     mihomoPath,
     slirp4netnsPath,
     onHolderOutput: holderOutput,
-    onSlirpOutput: slirpOutput,
   } = options;
-  const directory = await mkdtemp(join(tmpdir(), "pi-netns-"));
+  // 临时目录放在 agent-dir/tmp（pi 自有临时区），不污染系统 /tmp
+  const directory = await mkdtemp(join(getAgentDir(), "tmp", "pi-netns-"));
   const configPath = join(directory, "mihomo.json");
   const config = generateMihomoConfig({ allowlist, dnsServers });
   await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`);
 
-  const holder = spawn("unshare", ["-Urn", "--", "node", HOLDER_PATH, configPath, mihomoPath], {
-    env: {
-      HOME: process.env.HOME ?? "",
-      PATH: `${process.env.PATH ?? ""}:${SBIN_PATH_SUFFIX}`,
-    },
-    // mihomo 日志经 holder 透传到这里的 stdout/stderr，用于判定就绪
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-  forwardOutput(holder, holderOutput);
-  if (holder.pid === undefined) {
-    throw new Error("Failed to start network namespace holder");
-  }
-  const holderPid = holder.pid;
-  await waitForNewUserns(holderPid);
+  let holder: ChildProcess | undefined;
+  try {
+    // unshare -p --fork：node 成为 pid namespace 的 init，任何方式退出（含 SIGKILL）
+    // 内核都会清理 pid ns 内全部进程（slirp4netns/mihomo），ns 引用随之归零；
+    // --kill-child=SIGTERM：宿主侧 SIGTERM unshare 时转发给 init 走优雅退出
+    holder = spawn(
+      "unshare",
+      [
+        "-Urnp",
+        "--fork",
+        "--kill-child=SIGTERM",
+        "--",
+        "node",
+        HOLDER_PATH,
+        configPath,
+        mihomoPath,
+        slirp4netnsPath,
+        String(TUN_MTU),
+      ],
+      {
+        env: {
+          HOME: process.env.HOME ?? "",
+          PATH: `${process.env.PATH ?? ""}:${SBIN_PATH_SUFFIX}`,
+        },
+        // stdin 保持 pipe：本进程持有写端，进程退出（含 SIGKILL）时内核关闭 fd，
+        // holder 读到 EOF 即自杀（init 退出 → 内核清理 pid ns）
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+    );
+    forwardOutput(holder, holderOutput);
+    if (holder.pid === undefined) {
+      throw new Error("Failed to start network namespace holder");
+    }
+    const holderPid = holder.pid;
+    await waitForNewUserns(holderPid);
 
-  const slirp = spawn(
-    slirp4netnsPath,
-    [
-      "-c",
-      `--mtu=${TUN_MTU}`,
-      `--userns-path=/proc/${holderPid}/ns/user`,
-      "--netns-type=pid",
-      String(holderPid),
-      "tap0",
-    ],
-    // 默认丢弃 slirp4netns 日志；诊断时改为管道转发
-    { stdio: slirpOutput ? ["ignore", "pipe", "pipe"] : "ignore" },
-  );
-  forwardOutput(slirp, slirpOutput);
-  const slirpPid = slirp.pid;
-  await waitForMihomoStarted(holder);
+    await waitForMihomoStarted(holder);
 
-  const state: NetworkStackState = { holderPid, slirpPid, directory };
-  const stack: NetworkStack = {
-    exec: async (execOptions: NetworkStackExecOptions) => {
-      const child = spawn(
-        "nsenter",
-        [
-          "-U",
-          "-n",
-          "--preserve-credentials",
-          "-t",
-          String(holderPid),
-          "--",
-          execOptions.bwrapPath,
-          ...execOptions.bwrapArgs,
-          "--",
-          execOptions.shell,
-          "-lc",
-          execOptions.command,
-        ],
-        {
-          cwd: execOptions.cwd,
-          detached: true,
-          stdio: ["ignore", "pipe", "pipe"],
-          env: execOptions.env,
-        },
-      );
+    const state: NetworkStackState = { holderPid, directory };
+    const stack: NetworkStack = {
+      exec: async (execOptions: NetworkStackExecOptions) => {
+        const child = spawn(
+          "nsenter",
+          [
+            "-U",
+            "-n",
+            "--preserve-credentials",
+            "-t",
+            String(holderPid),
+            "--",
+            execOptions.bwrapPath,
+            ...execOptions.bwrapArgs,
+            "--",
+            execOptions.shell,
+            "-lc",
+            execOptions.command,
+          ],
+          {
+            cwd: execOptions.cwd,
+            detached: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: execOptions.env,
+          },
+        );
 
-      return new Promise<{ exitCode: number | null }>((resolve, reject) => {
-        let timedOut = false;
-        let settled = false;
-        const timeoutHandle = execOptions.timeout
-          ? setTimeout(() => {
-              timedOut = true;
-              killChild(child.pid);
-            }, execOptions.timeout * 1000)
-          : undefined;
-        const onAbort = (): void => {
-          killChild(child.pid);
-        };
+        return new Promise<{ exitCode: number | null }>((resolve, reject) => {
+          let timedOut = false;
+          let settled = false;
+          const timeoutHandle = execOptions.timeout
+            ? setTimeout(() => {
+                timedOut = true;
+                killChild(child.pid);
+              }, execOptions.timeout * 1000)
+            : undefined;
+          const onAbort = (): void => {
+            killChild(child.pid);
+          };
 
-        child.stdout?.on("data", execOptions.onData);
-        child.stderr?.on("data", execOptions.onData);
-        execOptions.signal?.addEventListener("abort", onAbort, { once: true });
+          child.stdout?.on("data", execOptions.onData);
+          child.stderr?.on("data", execOptions.onData);
+          execOptions.signal?.addEventListener("abort", onAbort, { once: true });
 
-        child.once("error", (error) => {
-          if (settled) return;
-          settled = true;
-          reject(error);
-        });
-        child.once("close", (exitCode) => {
-          if (settled) return;
-          settled = true;
-          if (timeoutHandle) clearTimeout(timeoutHandle);
-          execOptions.signal?.removeEventListener("abort", onAbort);
-          // 中断：reject signal.reason（默认是 name=AbortError 的 DOMException）
-          if (execOptions.signal?.aborted) {
-            reject(
-              execOptions.signal.reason instanceof Error
-                ? execOptions.signal.reason
-                : new Error("The operation was aborted"),
-            );
-          } else if (timedOut) {
-            // 超时：name=TimeoutError（对齐标准错误分类）
-            reject(new TimeoutError(execOptions.timeout));
-          } else resolve({ exitCode });
+          child.once("error", (error) => {
+            if (settled) return;
+            settled = true;
+            reject(error);
+          });
+          child.once("close", (exitCode) => {
+            if (settled) return;
+            settled = true;
+            if (timeoutHandle) clearTimeout(timeoutHandle);
+            execOptions.signal?.removeEventListener("abort", onAbort);
+            // 中断：reject signal.reason（默认是 name=AbortError 的 DOMException）
+            if (execOptions.signal?.aborted) {
+              reject(
+                execOptions.signal.reason instanceof Error
+                  ? execOptions.signal.reason
+                  : new Error("The operation was aborted"),
+              );
+            } else if (timedOut) {
+              // 超时：name=TimeoutError（对齐标准错误分类）
+              reject(new TimeoutError(execOptions.timeout));
+            } else resolve({ exitCode });
+          });
         });
-      });
-    },
-    stop: async () => {
-      killProcess(state.slirpPid);
-      killProcess(state.holderPid);
-      await rm(state.directory, { recursive: true, force: true }).catch(() => false);
-    },
-    holderPid,
-    configPath,
-  };
-  stackFinalizer.register(stack, state);
-  return stack;
+      },
+      stop: async () => {
+        const children = await readChildPids(state.holderPid);
+        // SIGTERM unshare → --kill-child 转发 SIGTERM 给 init（pid ns 的 pid 1），
+        // init 优雅停 mihomo 后退出，内核清理 pid ns 内全部进程，ns 引用随之归零
+        killProcess(state.holderPid);
+        await waitForExit(state.holderPid);
+        // 兜底：init 未在超时内退出 → SIGKILL init → 内核清 pid ns
+        for (const pid of children) {
+          killProcess(pid, "SIGKILL");
+        }
+        await rm(state.directory, { recursive: true, force: true }).catch(() => false);
+      },
+      holderPid,
+      configPath,
+    };
+    stackFinalizer.register(stack, state);
+    return stack;
+  } catch (error) {
+    // 失败清理：holder（unshare）的 SIGTERM 经 --kill-child 转发给 init，
+    // init 退出时内核清理 pid ns 内全部进程；调用方拿不到 stack，这里只能靠自己
+    if (holder?.pid) {
+      const children = await readChildPids(holder.pid);
+      killProcess(holder.pid);
+      await waitForExit(holder.pid);
+      for (const pid of children) {
+        killProcess(pid, "SIGKILL");
+      }
+    }
+    await rm(directory, { recursive: true, force: true }).catch(() => false);
+    throw error;
+  }
 }