@trim21/personal-pi-extensions 0.1.444 → 0.1.446

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trim21/personal-pi-extensions",
-  "version": "0.1.444",
+  "version": "0.1.446",
   "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,12 +1,15 @@
 import { spawn } from "node:child_process";
-import { dirname } from "node:path";
+import { readFile } from "node:fs/promises";
 import { setTimeout as sleep } from "node:timers/promises";
 const args = process.argv.slice(2);
-const configPath = args[0];
+const configBase64 = args[0];
 const mihomoPath = args[1];
-if (!configPath || !mihomoPath) {
+const slirp4netnsPath = args[2];
+const tunMtu = Number(args[3]);
+if (!configBase64 || !mihomoPath || !slirp4netnsPath || !tunMtu) {
   process.exit(2);
 }
+process.chdir("/");
 function tap0Exists() {
   return new Promise((resolve) => {
     const child = spawn("ip", ["link", "show", "tap0"], { stdio: "ignore" });
@@ -22,8 +25,18 @@ async function waitFor(attempts, delayMs, predicate) {
   return false;
 }
 async function main() {
+  process.stdin.resume();
+  process.stdin.on("end", () => 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], {
+  const mihomo = spawn(mihomoPath, ["-config", configBase64], {
     stdio: ["ignore", "inherit", "inherit"]
   });
   const stop = () => {

package/src/bwrap/holder.ts

@@ -1,16 +1,23 @@
 /* eslint-disable no-console, unicorn/no-process-exit -- 独立 CLI 脚本，由 unshare 直接执行 */
 import { spawn } from "node:child_process";
-import { dirname } from "node:path";
+import { readFile } from "node:fs/promises";
 import { setTimeout as sleep } from "node:timers/promises";
 
-// 用法：unshare -Urn node holder.ts <config> <mihomo>
+// 用法：unshare -Urnp --fork --kill-child node holder.ts <config-base64> <mihomo> <slirp4netns> <mtu>
+// 本进程是 pid namespace 的 init：无论以何种方式退出（含 SIGKILL），内核都会清理该 pid ns 内的
+// slirp4netns / mihomo，userns/netns 引用随之归零。
 const args = process.argv.slice(2);
-const configPath = args[0];
+const configBase64 = args[0];
 const mihomoPath = args[1];
-if (!configPath || !mihomoPath) {
+const slirp4netnsPath = args[2];
+const tunMtu = Number(args[3]);
+if (!configBase64 || !mihomoPath || !slirp4netnsPath || !tunMtu) {
   process.exit(2);
 }
 
+// mihomo 不写工作目录（配置经 -config 直传），切到根目录防止在宿主 cwd 意外落盘
+process.chdir("/");
+
 function tap0Exists(): Promise<boolean> {
   return new Promise((resolve) => {
     const child = spawn("ip", ["link", "show", "tap0"], { stdio: "ignore" });
@@ -32,11 +39,29 @@ 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", () => 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" 判定就绪
-  const mihomo = spawn(mihomoPath, ["-d", dirname(configPath), "-f", configPath], {
+  await waitFor(100, 100, tap0Exists);
+
+  const mihomo = spawn(mihomoPath, ["-config", configBase64], {
     stdio: ["ignore", "inherit", "inherit"],
   });
 

package/src/bwrap/network-stack.ts

@@ -1,9 +1,8 @@
 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 { readFile, readlink } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 
+import { forEachLine } from "../lib/proc.js";
 import { generateMihomoConfig, TUN_MTU } from "./mihomo-config.js";
 
 /** 命令超时错误：name=TimeoutError（对齐标准错误分类），message 保留 timeout:N 格式。 */
@@ -26,8 +25,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 +47,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 +67,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 +94,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;
@@ -121,16 +118,23 @@ function waitForMihomoStarted(holder: ChildProcess, timeoutMs = 20000): Promise<
       settled = true;
       reject(new Error("Timed out waiting for mihomo to start"));
     }, timeoutMs);
-    const onData = (data: Buffer): void => {
+    const onReady = (): void => {
       if (settled) return;
-      if (data.toString().includes("Tun adapter listening")) {
-        settled = true;
-        clearTimeout(timer);
-        resolve();
-      }
+      settled = true;
+      clearTimeout(timer);
+      resolve();
     };
-    holder.stdout?.on("data", onData);
-    holder.stderr?.on("data", onData);
+    // 按行扫描：mihomo 日志行可能跨 data chunk，由 forEachLine 负责拼接
+    for (const stream of [holder.stdout, holder.stderr]) {
+      if (stream) {
+        // 不提前停止：holder 生命周期内持续消费输出，避免流无消费者触发背压
+        void forEachLine(stream, (line) => {
+          if (line.includes("Tun adapter listening")) onReady();
+        }).catch(() => {
+          // 就绪判定由超时与 holder exit 兜底，流的 error 忽略
+        });
+      }
+    }
     holder.once("exit", (code) => {
       if (settled) return;
       settled = true;
@@ -170,21 +174,16 @@ export interface NetworkStack {
   stop(): Promise<void>;
   /** holder pid：可 `nsenter -U -n --preserve-credentials -t <pid>` 手动进入该 netns 排查。 */
   readonly holderPid: number;
-  /** 生成的 mihomo 配置路径（stop() 后随临时目录一起删除）。 */
-  readonly configPath: string;
 }
 
 interface NetworkStackState {
   holderPid: number;
-  slirpPid: number | undefined;
-  directory: string;
 }
 
-/** 兜底：调用方忘记 stop() 时，对象被 GC 回收后 kill 残留进程并清理目录。 */
+/** 兜底：调用方忘记 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 +198,40 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
     mihomoPath,
     slirp4netnsPath,
     onHolderOutput: holderOutput,
-    onSlirpOutput: slirpOutput,
   } = options;
-  const directory = await mkdtemp(join(tmpdir(), "pi-netns-"));
-  const configPath = join(directory, "mihomo.json");
+  // mihomo 支持 -config 直接接收 base64 配置，无需写配置文件中转
   const config = generateMihomoConfig({ allowlist, dnsServers });
-  await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`);
+  const configBase64 = Buffer.from(JSON.stringify(config)).toString("base64");
 
   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,
+        configBase64,
+        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 +239,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 };
     const stack: NetworkStack = {
       exec: async (execOptions: NetworkStackExecOptions) => {
         const child = spawn(
@@ -310,21 +310,31 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
         });
       },
       stop: async () => {
-        await terminateProcess(state.slirpPid);
-        await terminateProcess(state.holderPid);
-        await rm(state.directory, { recursive: true, force: true }).catch(() => false);
+        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");
+        }
       },
       holderPid,
-      configPath,
     };
     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);
-    await rm(directory, { recursive: true, force: true }).catch(() => false);
+    // 失败清理：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");
+      }
+    }
     throw error;
   }
 }

package/src/lib/proc.ts

@@ -0,0 +1,20 @@
+/**
+ * 按行消费输出流：data 事件按 buffer 边界切分，行可能跨多个 chunk，
+ * 这里拼接缓冲后按 \n 逐行回调（回调不含换行符）。
+ * 回调返回 false 可提前停止消费；流的 error 会以 rejection 形式抛出。
+ */
+export async function forEachLine(
+  stream: NodeJS.ReadableStream,
+  callback: (line: string) => boolean | void,
+): Promise<void> {
+  let buffer = "";
+  for await (const chunk of stream) {
+    buffer += chunk.toString();
+    let newline: number;
+    while ((newline = buffer.indexOf("\n")) !== -1) {
+      const line = buffer.slice(0, newline);
+      buffer = buffer.slice(newline + 1);
+      if (callback(line) === false) return;
+    }
+  }
+}