@trim21/personal-pi-extensions 0.1.444 → 0.1.445

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trim21/personal-pi-extensions",
-  "version": "0.1.444",
+  "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,22 +49,17 @@ 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 {
     // 已退出
   }
 }
 
-/**
- * SIGTERM 后等待进程退出；超时仍未退出则 SIGKILL。
- * holder/slirp 持有 userns/netns 引用，进程不退 ns 就不会释放。
- */
-async function terminateProcess(pid: number | undefined, timeoutMs = 2000): Promise<void> {
-  if (!pid) return;
-  killProcess(pid);
+/** 轮询等待进程退出（进程消失即返回）。 */
+async function waitForExit(pid: number, timeoutMs = 2000): Promise<void> {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     try {
@@ -75,10 +69,15 @@ async function terminateProcess(pid: number | undefined, timeoutMs = 2000): Prom
     }
     await new Promise((resolve) => setTimeout(resolve, 50));
   }
+}
+
+/** 读取进程的直接子进程 pid：--kill-child 只转发信号给 fork 的子进程，兜底直接 SIGKILL 用。 */
+async function readChildPids(pid: number): Promise<number[]> {
   try {
-    process.kill(pid, "SIGKILL");
+    const content = await readFile(`/proc/${pid}/task/${pid}/children`, "utf8");
+    return content.trim().split(/\s+/).filter(Boolean).map(Number);
   } catch {
-    // 已退出
+    return [];
   }
 }
 
@@ -97,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;
@@ -176,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);
 });
@@ -199,24 +197,42 @@ 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`);
 
   let holder: ChildProcess | undefined;
-  let slirp: ChildProcess | undefined;
   try {
-    holder = spawn("unshare", ["-Urn", "--", "node", HOLDER_PATH, configPath, mihomoPath], {
-      env: {
-        HOME: process.env.HOME ?? "",
-        PATH: `${process.env.PATH ?? ""}:${SBIN_PATH_SUFFIX}`,
+    // 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"],
       },
-      // mihomo 日志经 holder 透传到这里的 stdout/stderr，用于判定就绪
-      stdio: ["ignore", "pipe", "pipe"],
-    });
+    );
     forwardOutput(holder, holderOutput);
     if (holder.pid === undefined) {
       throw new Error("Failed to start network namespace holder");
@@ -224,24 +240,9 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
     const holderPid = holder.pid;
     await waitForNewUserns(holderPid);
 
-    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);
 
-    const state: NetworkStackState = { holderPid, slirpPid, directory };
+    const state: NetworkStackState = { holderPid, directory };
     const stack: NetworkStack = {
       exec: async (execOptions: NetworkStackExecOptions) => {
         const child = spawn(
@@ -310,8 +311,15 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
         });
       },
       stop: async () => {
-        await terminateProcess(state.slirpPid);
-        await terminateProcess(state.holderPid);
+        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,
@@ -320,10 +328,16 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
     stackFinalizer.register(stack, state);
     return stack;
   } catch (error) {
-    // 失败清理：holder/slirp 持有 userns/netns 引用，不 kill 就会锁住 namespace；
-    // 调用方（runInSandbox）拿不到 stack，这里的清理只能靠自己
-    if (slirp?.pid) await terminateProcess(slirp.pid);
-    if (holder?.pid) await terminateProcess(holder.pid);
+    // 失败清理：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;
   }