@trim21/personal-pi-extensions 0.0.431 → 0.0.433

package/package.json

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

package/src/bwrap/core.ts

@@ -11,7 +11,12 @@ import { Value } from "typebox/value";
 import { parseWithSchema } from "../lib/parse-with-schema.js";
 import { expandHome } from "../lib/path.js";
 import { type ApprovalRule } from "./approval-rules.js";
-import { type NetworkStack, resolveDnsServers, startNetworkStack } from "./network-stack.js";
+import {
+  type NetworkStack,
+  resolveDnsServers,
+  startNetworkStack,
+  TimeoutError,
+} from "./network-stack.js";
 
 const PROTECTED_DIRS = [".pi", ".agent"];
 
@@ -40,7 +45,7 @@ const bwrapConfigProperties = {
   networkAllowlist: Type.Array(
     Type.String({ description: "允许直连的域名 / IP / CIDR，可带 :port" }),
   ),
-  singBoxPath: Type.Optional(Type.String()),
+  mihomoPath: Type.Optional(Type.String()),
   slirp4netnsPath: Type.Optional(Type.String()),
   approvalRules: Type.Optional(
     Type.Array(
@@ -78,9 +83,9 @@ export interface ResolvedBwrap {
   /** 沙箱内隐藏的路径：以 / 结尾为目录（挂空 tmpfs），否则为文件（--ro-bind-try /dev/null）。 */
   denyPaths: string[];
   extraArgs: string[];
-  /** 允许直连的域名 / IP / IP:port 白名单（非空 = 启用 sing-box 网络过滤）。 */
+  /** 允许直连的域名 / IP / IP:port 白名单（非空 = 启用 mihomo 网络过滤）。 */
   networkAllowlist: string[];
-  singBoxPath?: string;
+  mihomoPath?: string;
   slirp4netnsPath?: string;
   /** 全权限执行的自动审批规则（allow/deny 命令模式）。 */
   approvalRules: ApprovalRule[];
@@ -104,7 +109,7 @@ export function resolveBwrap(config: BwrapConfig): ResolvedBwrap {
     denyPaths: config.denyPaths ?? [],
     extraArgs: config.extraArgs ?? [],
     networkAllowlist: config.networkAllowlist ?? [],
-    singBoxPath: config.singBoxPath,
+    mihomoPath: config.mihomoPath,
     slirp4netnsPath: config.slirp4netnsPath,
     approvalRules: config.approvalRules ?? [],
   };
@@ -147,7 +152,7 @@ function deepMerge(base: BwrapConfig, overrides: Partial<BwrapConfig>): BwrapCon
     denyPaths: overrides.denyPaths ?? base.denyPaths,
     extraArgs: overrides.extraArgs ?? base.extraArgs,
     networkAllowlist: overrides.networkAllowlist ?? base.networkAllowlist,
-    singBoxPath: overrides.singBoxPath ?? base.singBoxPath,
+    mihomoPath: overrides.mihomoPath ?? base.mihomoPath,
     slirp4netnsPath: overrides.slirp4netnsPath ?? base.slirp4netnsPath,
     approvalRules: [...(base.approvalRules ?? []), ...(overrides.approvalRules ?? [])],
   };
@@ -234,16 +239,16 @@ function findCommandInPath(name: string, hint: string): string {
   throw new Error(hint);
 }
 
-export function findSingBox(override?: string): string {
+export function findMihomo(override?: string): string {
   if (override) {
     if (!existsSync(override)) {
-      throw new Error(`sing-box not found at configured path: ${override}`);
+      throw new Error(`mihomo not found at configured path: ${override}`);
     }
     return override;
   }
   return findCommandInPath(
-    "sing-box",
-    "sing-box not found in PATH. Install it from https://sing-box.sagernet.org/",
+    "mihomo",
+    "mihomo not found in PATH. Install it from https://github.com/MetaCubeX/mihomo",
   );
 }
 
@@ -378,7 +383,7 @@ export async function createNetworkStack(
   return startNetworkStack({
     allowlist: resolved.networkAllowlist,
     dnsServers: await resolveDnsServers(),
-    singBoxPath: findSingBox(resolved.singBoxPath),
+    mihomoPath: findMihomo(resolved.mihomoPath),
     slirp4netnsPath: findSlirp4netns(resolved.slirp4netnsPath),
   });
 }
@@ -399,7 +404,8 @@ export function createBwrapBashOperations(
       await fsAccess(cwd, constants.F_OK).catch(() => {
         throw new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`);
       });
-      if (signal?.aborted) throw new Error("aborted");
+      // 已中断（signal.reason 是 name=AbortError 的 DOMException）：直接抛，不再执行
+      signal?.throwIfAborted();
 
       // 干净环境：不继承父进程 env/PATH，由 bash -lc 从 /etc/profile 与用户 profile 重建
       const home = process.env.HOME;
@@ -470,9 +476,17 @@ export function createBwrapBashOperations(
         child.once("close", (exitCode) => {
           if (timeoutHandle) clearTimeout(timeoutHandle);
           signal?.removeEventListener("abort", onAbort);
-          if (signal?.aborted) reject(new Error("aborted"));
-          else if (timedOut) reject(new Error(`timeout:${timeout}`));
-          else resolve({ exitCode });
+          // 中断：reject signal.reason（默认是 name=AbortError 的 DOMException）
+          if (signal?.aborted) {
+            reject(
+              signal.reason instanceof Error
+                ? signal.reason
+                : new Error("The operation was aborted"),
+            );
+          } else if (timedOut) {
+            // 超时：name=TimeoutError（对齐标准错误分类）
+            reject(new TimeoutError(timeout));
+          } else resolve({ exitCode });
         });
       });
     },

package/src/bwrap/holder.js

@@ -1,9 +1,10 @@
 import { spawn } from "node:child_process";
+import { dirname } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 const args = process.argv.slice(2);
 const configPath = args[0];
-const singBoxPath = args[1];
-if (!configPath || !singBoxPath) {
+const mihomoPath = args[1];
+if (!configPath || !mihomoPath) {
   process.exit(2);
 }
 function tap0Exists() {
@@ -22,12 +23,11 @@ async function waitFor(attempts, delayMs, predicate) {
 }
 async function main() {
   await waitFor(100, 100, tap0Exists);
-  const singbox = spawn(singBoxPath, ["run", "-c", configPath], {
-    env: { ...process.env, ENABLE_DEPRECATED_MISSING_DOMAIN_RESOLVER: "true" },
+  const mihomo = spawn(mihomoPath, ["-d", dirname(configPath), "-f", configPath], {
     stdio: ["ignore", "inherit", "inherit"]
   });
   const stop = () => {
-    singbox.kill("SIGTERM");
+    mihomo.kill("SIGTERM");
   };
   process.on("SIGTERM", () => {
     stop();
@@ -37,7 +37,7 @@ async function main() {
     stop();
     process.exit(0);
   });
-  await new Promise((resolve) => singbox.once("exit", () => resolve()));
+  await new Promise((resolve) => mihomo.once("exit", () => resolve()));
 }
 try {
   await main();

package/src/bwrap/holder.ts

@@ -1,12 +1,13 @@
 /* eslint-disable no-console, unicorn/no-process-exit -- 独立 CLI 脚本，由 unshare 直接执行 */
 import { spawn } from "node:child_process";
+import { dirname } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 
-// 用法：unshare -Urn node holder.ts <config> <singbox>
+// 用法：unshare -Urn node holder.ts <config> <mihomo>
 const args = process.argv.slice(2);
 const configPath = args[0];
-const singBoxPath = args[1];
-if (!configPath || !singBoxPath) {
+const mihomoPath = args[1];
+if (!configPath || !mihomoPath) {
   process.exit(2);
 }
 
@@ -34,14 +35,13 @@ async function main(): Promise<void> {
   // slirp4netns 由宿主侧 spawn，这里等它建好 tap0
   await waitFor(100, 100, tap0Exists);
 
-  // sing-box 日志透传到 holder 的 stdout/stderr，宿主侧监听 "sing-box started" 判定就绪
-  const singbox = spawn(singBoxPath, ["run", "-c", configPath], {
-    env: { ...process.env, ENABLE_DEPRECATED_MISSING_DOMAIN_RESOLVER: "true" },
+  // mihomo 日志透传到 holder 的 stdout/stderr，宿主侧监听 "Tun adapter listening" 判定就绪
+  const mihomo = spawn(mihomoPath, ["-d", dirname(configPath), "-f", configPath], {
     stdio: ["ignore", "inherit", "inherit"],
   });
 
   const stop = (): void => {
-    singbox.kill("SIGTERM");
+    mihomo.kill("SIGTERM");
   };
   process.on("SIGTERM", () => {
     stop();
@@ -52,7 +52,7 @@ async function main(): Promise<void> {
     process.exit(0);
   });
 
-  await new Promise<void>((resolve) => singbox.once("exit", () => resolve()));
+  await new Promise<void>((resolve) => mihomo.once("exit", () => resolve()));
 }
 
 try {

package/src/bwrap/mihomo-config.ts

@@ -0,0 +1,183 @@
+const FAKEIP_RANGE = "198.18.0.1/16";
+const TUN_MTU = 1500;
+
+export interface MihomoConfigOptions {
+  /** 允许直连的条目列表（域名 / IP / CIDR，可带 :port；空列表 = 默认拒绝一切出网）。 */
+  readonly allowlist: readonly string[];
+  /** 真实 DNS 服务器地址列表（IPv4，UDP 53），按顺序 fallback，至少一个。 */
+  readonly dnsServers: readonly string[];
+}
+
+interface AllowlistEntry {
+  readonly host: string;
+  readonly port?: number;
+}
+
+/** mihomo 配置以 JSON 序列化输出（JSON 是 YAML 子集，-f 加载无差别）。 */
+export interface MihomoConfig {
+  "mixed-port": 0;
+  mode: "rule";
+  "log-level": "info";
+  ipv6: false;
+  dns: {
+    enable: true;
+    ipv6: false;
+    "enhanced-mode": "fake-ip";
+    "fake-ip-range": string;
+    nameserver: string[];
+    "default-nameserver": string[];
+    "fake-ip-filter"?: string[];
+  };
+  tun: {
+    enable: true;
+    stack: "mixed";
+    mtu: number;
+    "auto-route": true;
+    "strict-route": true;
+    "auto-detect-interface": true;
+    "dns-hijack": string[];
+  };
+  rules: string[];
+}
+
+const IPV4_PATTERN = /^\d{1,3}(?:\.\d{1,3}){3}(?:\/\d{1,2})?$/;
+/** 合法 DNS 主机名（标签 1-63 字符，字母数字加连字符，不得以连字符开头/结尾）。 */
+const DOMAIN_PATTERN =
+  /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)*[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/;
+/** IP/CIDR 的字符集校验（IPv4/IPv6），防止非法字符进入规则。 */
+const IP_CHARS_PATTERN = /^[0-9a-fA-F:.]+(?:\/\d{1,3})?$/;
+
+function isIp(host: string): boolean {
+  return IPV4_PATTERN.test(host) || host.includes(":");
+}
+
+/** 单 IP 补掩码为 CIDR（IPv4 /32、IPv6 /128），带掩码原样返回。 */
+function toCidr(host: string): string {
+  if (host.includes("/")) return host;
+  return host.includes(":") ? `${host}/128` : `${host}/32`;
+}
+
+function parsePort(value: string): number {
+  const port = Number(value);
+  if (!Number.isSafeInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid port "${value}"`);
+  }
+  return port;
+}
+
+/**
+ * 解析 allowlist 条目：域名 / IPv4 / CIDR，可带 :port；IPv6 必须用 [] 包裹
+ * （如 `[::1]:80`），裸 IPv6 会报错提示补方括号。
+ */
+function parseAllowlistEntry(entry: string): AllowlistEntry {
+  let host: string;
+  let port: number | undefined;
+  if (entry.startsWith("[")) {
+    const match = /^\[(.+)\](?::(\d+))?$/.exec(entry);
+    if (match?.[1] === undefined) throw new Error(`Invalid allowlist entry "${entry}"`);
+    host = match[1];
+    port = match[2] === undefined ? undefined : parsePort(match[2]);
+  } else {
+    const colon = entry.lastIndexOf(":");
+    if (colon === -1) {
+      if (entry.length === 0) throw new Error(`Invalid allowlist entry ""`);
+      host = entry;
+    } else {
+      const portPart = entry.slice(colon + 1);
+      if (!/^\d+$/.test(portPart)) throw new Error(`Invalid allowlist entry "${entry}"`);
+      host = entry.slice(0, colon);
+      if (host.length === 0) throw new Error(`Invalid allowlist entry "${entry}"`);
+      if (host.includes(":")) {
+        throw new Error(`IPv6 addresses must be wrapped in brackets, e.g. "[${host}]:${portPart}"`);
+      }
+      port = parsePort(portPart);
+    }
+  }
+  if (isIp(host)) {
+    if (!IP_CHARS_PATTERN.test(host)) throw new Error(`Invalid allowlist entry "${entry}"`);
+  } else if (!DOMAIN_PATTERN.test(host)) {
+    throw new Error(`Invalid allowlist entry "${entry}"`);
+  }
+  return { host, port };
+}
+
+/** IP 条目的 mihomo 规则（IPv6 用 IP-CIDR6；no-resolve 跳过反向解析）。 */
+function ipRule(host: string): string {
+  const cidr = toCidr(host);
+  const kind = cidr.includes(":") ? "IP-CIDR6" : "IP-CIDR";
+  return `${kind},${cidr},DIRECT,no-resolve`;
+}
+
+interface BuiltRules {
+  rules: string[];
+  fakeIpFilter: string[];
+}
+
+/**
+ * allowlist 条目 → mihomo 规则：
+ * - 域名（含 :port 条目里的域名）进 fake-ip-filter，真实解析避免 DIRECT 出站
+ *   拿到 fakeip 再进 TUN 形成环（loopback detector 会拒绝）；
+ * - 无端口条目直接匹配；带端口条目用 AND 组合（域名/IP + DST-PORT）精确放行；
+ * - 最后以 MATCH,REJECT 兜底实现 deny-by-default。
+ */
+function buildRules(allowlist: readonly string[]): BuiltRules {
+  const rules: string[] = [];
+  const fakeIpFilter: string[] = [];
+  for (const entry of allowlist) {
+    const { host, port } = parseAllowlistEntry(entry);
+    if (!isIp(host)) {
+      fakeIpFilter.push(`+.${host}`);
+      if (port === undefined) {
+        rules.push(`DOMAIN-SUFFIX,${host},DIRECT`);
+      } else {
+        rules.push(`AND,(DOMAIN-SUFFIX,${host},DIRECT),(DST-PORT,${port},DIRECT),DIRECT`);
+      }
+    } else if (port === undefined) {
+      rules.push(ipRule(host));
+    } else {
+      rules.push(`AND,(${ipRule(host)}),(DST-PORT,${port},DIRECT),DIRECT`);
+    }
+  }
+  rules.push("MATCH,REJECT");
+  return { rules, fakeIpFilter };
+}
+
+/**
+ * 生成 mihomo（Clash Meta）配置对象：TUN + fakeip + deny-by-default allowlist。
+ *
+ * - auto-detect-interface 让 mihomo 出站绑定 slirp4netns 的 tap0，否则它自己的
+ *   DNS 查询会被 auto_route 送回 TUN 形成环；
+ * - allowlist 域名走 fake-ip-filter 真实解析（见 buildRules 注释）。
+ */
+export function generateMihomoConfig(options: MihomoConfigOptions): MihomoConfig {
+  const { allowlist, dnsServers } = options;
+  if (dnsServers.length === 0) {
+    throw new Error("At least one DNS server is required");
+  }
+  const { rules, fakeIpFilter } = buildRules(allowlist);
+  return {
+    "mixed-port": 0,
+    mode: "rule",
+    "log-level": "info",
+    ipv6: false,
+    dns: {
+      enable: true,
+      ipv6: false,
+      "enhanced-mode": "fake-ip",
+      "fake-ip-range": FAKEIP_RANGE,
+      nameserver: [...dnsServers],
+      "default-nameserver": [...dnsServers],
+      ...(fakeIpFilter.length > 0 && { "fake-ip-filter": fakeIpFilter }),
+    },
+    tun: {
+      enable: true,
+      stack: "mixed",
+      mtu: TUN_MTU,
+      "auto-route": true,
+      "strict-route": true,
+      "auto-detect-interface": true,
+      "dns-hijack": ["any:53"],
+    },
+    rules,
+  };
+}

package/src/bwrap/network-stack.ts

@@ -4,14 +4,22 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { generateSingboxConfig } from "./singbox-config.js";
+import { generateMihomoConfig } from "./mihomo-config.js";
+
+/** 命令超时错误：name=TimeoutError（对齐标准错误分类），message 保留 timeout:N 格式。 */
+export class TimeoutError extends Error {
+  constructor(timeout: number | undefined) {
+    super(`timeout:${timeout}`);
+    this.name = "TimeoutError";
+  }
+}
 
 export interface NetworkStackOptions {
   /** 允许直连的域名 / IP:port 列表（每次命令从配置重新读取）。 */
   readonly allowlist: readonly string[];
   /** 真实 DNS 服务器列表，按顺序 fallback。 */
   readonly dnsServers: readonly string[];
-  readonly singBoxPath: string;
+  readonly mihomoPath: string;
   readonly slirp4netnsPath: string;
 }
 
@@ -72,18 +80,18 @@ async function waitForNewUserns(pid: number, timeoutMs = 5000): Promise<void> {
   throw new Error("Timed out waiting for sandbox network namespace");
 }
 
-/** 监听 holder 的 stdout/stderr（sing-box 日志透传），以 "sing-box started" 作为就绪标志。 */
-function waitForSingboxStarted(holder: ChildProcess, timeoutMs = 20000): Promise<void> {
+/** 监听 holder 的 stdout/stderr（mihomo 日志透传），以 "Tun adapter listening" 作为就绪标志。 */
+function waitForMihomoStarted(holder: ChildProcess, timeoutMs = 20000): Promise<void> {
   return new Promise((resolve, reject) => {
     let settled = false;
     const timer = setTimeout(() => {
       if (settled) return;
       settled = true;
-      reject(new Error("Timed out waiting for sing-box to start"));
+      reject(new Error("Timed out waiting for mihomo to start"));
     }, timeoutMs);
     const onData = (data: Buffer): void => {
       if (settled) return;
-      if (data.toString().includes("sing-box started")) {
+      if (data.toString().includes("Tun adapter listening")) {
         settled = true;
         clearTimeout(timer);
         resolve();
@@ -95,7 +103,7 @@ function waitForSingboxStarted(holder: ChildProcess, timeoutMs = 20000): Promise
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      reject(new Error(`Sandbox holder exited before sing-box started (code ${code})`));
+      reject(new Error(`Sandbox holder exited before mihomo started (code ${code})`));
     });
   });
 }
@@ -132,22 +140,23 @@ const stackFinalizer = new FinalizationRegistry<NetworkStackState>((state) => {
 });
 
 /**
- * 启动网络栈：holder 进程持有 netns（内部跑 sing-box 的
+ * 启动网络栈：holder 进程持有 netns（内部跑 mihomo 的
  * TUN + fakeip + deny-by-default），slirp4netns 提供 egress。返回前
- * netns/sing-box/slirp4netns 均已就绪，命令通过 nsenter 进入该 netns 执行。
+ * netns/mihomo/slirp4netns 均已就绪，命令通过 nsenter 进入该 netns 执行。
  */
 export async function startNetworkStack(options: NetworkStackOptions): Promise<NetworkStack> {
-  const { allowlist, dnsServers, singBoxPath, slirp4netnsPath } = options;
+  const { allowlist, dnsServers, mihomoPath, slirp4netnsPath } = options;
   const directory = await mkdtemp(join(tmpdir(), "pi-netns-"));
-  const configPath = join(directory, "singbox.json");
-  await writeFile(configPath, generateSingboxConfig({ allowlist, dnsServers }));
+  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, singBoxPath], {
+  const holder = spawn("unshare", ["-Urn", "--", "node", HOLDER_PATH, configPath, mihomoPath], {
     env: {
       HOME: process.env.HOME ?? "",
       PATH: `${process.env.PATH ?? ""}:${SBIN_PATH_SUFFIX}`,
     },
-    // sing-box 日志经 holder 透传到这里的 stdout/stderr，用于判定就绪
+    // mihomo 日志经 holder 透传到这里的 stdout/stderr，用于判定就绪
     stdio: ["ignore", "pipe", "pipe"],
   });
   if (holder.pid === undefined) {
@@ -168,7 +177,7 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
     { stdio: "ignore" },
   );
   const slirpPid = slirp.pid;
-  await waitForSingboxStarted(holder);
+  await waitForMihomoStarted(holder);
 
   const state: NetworkStackState = { holderPid, slirpPid, directory };
   const stack: NetworkStack = {
@@ -224,9 +233,17 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
           settled = true;
           if (timeoutHandle) clearTimeout(timeoutHandle);
           execOptions.signal?.removeEventListener("abort", onAbort);
-          if (execOptions.signal?.aborted) reject(new Error("aborted"));
-          else if (timedOut) reject(new Error(`timeout:${execOptions.timeout}`));
-          else resolve({ exitCode });
+          // 中断：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 });
         });
       });
     },

package/src/bwrap/runtime.ts

@@ -108,6 +108,35 @@ export interface BwrapExecutionResult {
   truncation: TruncationResult;
 }
 
+/**
+ * 超时/中断时命令终止前已捕获的部分输出快照（截断后的文本 + 落盘信息）。
+ * 展示格式（输出在前、状态在最后）由上层 Bash 工具按各自风格拼接。
+ */
+export interface BashExecutionPartial {
+  output: string;
+  truncation: TruncationResult;
+  fullOutputPath?: string;
+}
+
+/** 命令超时或中断（abort signal）时抛出的错误，携带部分输出供上层展示。 */
+export class BashInterruptedError extends Error {
+  readonly kind: "timeout" | "aborted";
+  readonly partial: BashExecutionPartial;
+
+  constructor(
+    kind: "timeout" | "aborted",
+    message: string,
+    partial: BashExecutionPartial,
+    cause: unknown,
+  ) {
+    super(message, { cause });
+    this.kind = kind;
+    this.partial = partial;
+    // 对齐标准错误分类：中断=AbortError（用户取消），超时=TimeoutError
+    this.name = kind === "aborted" ? "AbortError" : "TimeoutError";
+  }
+}
+
 function escapeHtml(text: string): string {
   return text
     .replaceAll("&", "&")
@@ -402,35 +431,35 @@ export class BwrapRuntime {
         signal: request.signal,
         timeout: request.timeout,
       });
-      await output.close();
-      const truncation = truncateTail(output.tailText());
-      // 未截断：完整输出已直接返回给模型，临时文件没有用途，删掉避免
-      // agent-dir/tmp 堆积无主文件（删除失败只残留文件，不影响命令结果）
-      if (!truncation.truncated && output.filePath) {
-        try {
-          await unlink(output.filePath);
-        } catch {
-          // 删除失败（如沙箱只读）：best-effort，命令结果不受影响
-        }
-        output.filePath = undefined;
-      }
+      const partial = await this.finalizeOutput(output);
       return {
         exitCode,
-        output: truncation.content,
-        ...(output.filePath && { fullOutputPath: output.filePath }),
-        // 用精确统计值覆盖尾部缓冲的估算（提示文本的行数/字节数要准确）
-        truncation: { ...truncation, ...output.stats },
+        output: partial.output,
+        ...(partial.fullOutputPath && { fullOutputPath: partial.fullOutputPath }),
+        truncation: partial.truncation,
       };
     } catch (error) {
-      // 底层统一把超时/中断转成可读文案（对齐 pi 内置 bash 工具）
-      if (error instanceof Error && error.message.startsWith("timeout:")) {
-        throw new Error(
+      // 超时/中断：把命令终止前已捕获的输出附在错误上（文本 + 落盘路径），
+      // 展示时输出在前、状态在最后（对齐 pi 内置 bash），避免只报超时丢输出
+      // 超时识别：优先 name=TimeoutError（对齐标准错误分类），
+      // 兼容 pi local ops 抛的 `timeout:N`（name=Error）
+      if (
+        error instanceof Error &&
+        (error.name === "TimeoutError" || error.message.startsWith("timeout:"))
+      ) {
+        const partial = await this.finalizeOutput(output);
+        throw new BashInterruptedError(
+          "timeout",
           `Command timed out after ${error.message.slice("timeout:".length)} seconds`,
-          { cause: error },
+          partial,
+          error,
         );
       }
-      if (error instanceof Error && error.message === "aborted") {
-        throw new Error("Command aborted", { cause: error });
+      // 中断识别：优先 name=AbortError（throwIfAborted/signal.reason），
+      // 兼容 pi local ops 抛的 new Error("aborted")
+      if (error instanceof Error && (error.name === "AbortError" || error.message === "aborted")) {
+        const partial = await this.finalizeOutput(output);
+        throw new BashInterruptedError("aborted", "Command aborted", partial, error);
       }
       throw error;
     } finally {
@@ -439,6 +468,28 @@ export class BwrapRuntime {
     }
   }
 
+  /** 关闭输出流并返回截断后的快照；未截断时删除临时文件（成功与超时/中断路径共用）。 */
+  private async finalizeOutput(output: BashOutput): Promise<BashExecutionPartial> {
+    await output.close();
+    const truncation = truncateTail(output.tailText());
+    // 未截断：完整输出已直接返回给模型，临时文件没有用途，删掉避免
+    // agent-dir/tmp 堆积无主文件（删除失败只残留文件，不影响命令结果）
+    if (!truncation.truncated && output.filePath) {
+      try {
+        await unlink(output.filePath);
+      } catch {
+        // 删除失败（如沙箱只读）：best-effort，命令结果不受影响
+      }
+      output.filePath = undefined;
+    }
+    return {
+      output: truncation.content,
+      ...(output.filePath && { fullOutputPath: output.filePath }),
+      // 用精确统计值覆盖尾部缓冲的估算（提示文本的行数/字节数要准确）
+      truncation: { ...truncation, ...output.stats },
+    };
+  }
+
   private resolve(ctx: Pick<ExtensionContext, "cwd" | "hasUI">): ResolvedBwrap {
     const config = loadBwrapConfig(ctx.cwd);
     if (!ctx.hasUI) return resolveHeadlessBwrap(config);

package/src/claude-code/common.ts

@@ -53,10 +53,6 @@ export function toRelativePath(filePath: string, cwd: string): string {
   return relativePath.startsWith("..") ? filePath : relativePath;
 }
 
-export function throwIfAborted(signal: AbortSignal | undefined): void {
-  if (signal?.aborted) throw new Error("Operation aborted");
-}
-
 export function snapshotsEqual(left: FileSnapshot, right: FileSnapshot): boolean {
   return left.digest === right.digest;
 }

package/src/claude-code/files.ts

@@ -27,7 +27,6 @@ import {
   type FileSnapshot,
   requireAbsolutePath,
   snapshotsEqual,
-  throwIfAborted,
 } from "./common.js";
 import { convertLeadingTabsToSpaces, findActualString, preserveQuoteStyle } from "./edit-utils.js";
 
@@ -256,7 +255,7 @@ export function registerFileTools(
       { additionalProperties: false },
     ),
     async execute(_id, params, signal, _onUpdate, ctx) {
-      throwIfAborted(signal);
+      signal?.throwIfAborted();
       const filePath = requireAbsolutePath(params.file_path);
       if (
         params.offset !== undefined &&
@@ -280,7 +279,7 @@ export function registerFileTools(
         }
         throw error;
       }
-      throwIfAborted(signal);
+      signal?.throwIfAborted();
 
       const extension = extname(filePath).toLowerCase();
       if (extension === ".pdf") {
@@ -392,7 +391,7 @@ export function registerFileTools(
       { additionalProperties: false },
     ),
     async execute(_id, params, signal, _onUpdate, ctx) {
-      throwIfAborted(signal);
+      signal?.throwIfAborted();
       const filePath = requireAbsolutePath(params.file_path);
       await guardWriteAccess(ctx, {
         toolName: "Edit",
@@ -438,7 +437,7 @@ export function registerFileTools(
               const key = await readStateKey(filePath);
               state.reads.set(key, snapshot);
               const diff = generateDiffString("", convertLeadingTabsToSpaces(newString));
-              throwIfAborted(signal);
+              signal?.throwIfAborted();
               const {
                 text: diagnosticText,
                 errorCount,
@@ -495,7 +494,7 @@ export function registerFileTools(
             const key = await readStateKey(filePath);
             requireCurrentRead(state, key, filePath, content);
             await access(filePath, constants.R_OK | constants.W_OK);
-            throwIfAborted(signal);
+            signal?.throwIfAborted();
             const original = content.toString("utf8");
 
             // CRLF 规范化后匹配（old_string 不需要带 \r），写回时恢复原行尾
@@ -541,7 +540,7 @@ export function registerFileTools(
             const text = replaceAll
               ? `The file ${filePath} has been updated. All occurrences were successfully replaced.`
               : `The file ${filePath} has been updated successfully.`;
-            throwIfAborted(signal);
+            signal?.throwIfAborted();
             const {
               text: diagnosticText,
               errorCount,
@@ -602,7 +601,7 @@ export function registerFileTools(
       { additionalProperties: false },
     ),
     async execute(_id, params, signal, _onUpdate, ctx) {
-      throwIfAborted(signal);
+      signal?.throwIfAborted();
       const filePath = requireAbsolutePath(params.file_path);
       await guardWriteAccess(ctx, {
         toolName: "Write",
@@ -628,7 +627,7 @@ export function registerFileTools(
                 throw error;
               }
             }
-            throwIfAborted(signal);
+            signal?.throwIfAborted();
             await mkdir(dirname(filePath), { recursive: true });
             await writeFile(filePath, params.content, "utf8");
             const snapshot = snapshotOf(params.content);
@@ -640,7 +639,7 @@ export function registerFileTools(
               original === undefined
                 ? `File created successfully at: ${filePath}`
                 : `The file ${filePath} has been updated successfully.`;
-            throwIfAborted(signal);
+            signal?.throwIfAborted();
             const {
               text: diagnosticText,
               errorCount,

package/src/claude-code/glob.ts

@@ -15,7 +15,7 @@ import { promisify } from "node:util";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
-import { searchRoot, suggestPathUnderCwd, throwIfAborted, toRelativePath } from "./common.js";
+import { searchRoot, suggestPathUnderCwd, toRelativePath } from "./common.js";
 
 const GLOB_RESULT_LIMIT = 100;
 
@@ -58,7 +58,7 @@ export async function globFiles(
   cwd: string,
   signal?: AbortSignal,
 ): Promise<{ files: string[]; truncated: boolean }> {
-  throwIfAborted(signal);
+  signal?.throwIfAborted();
   let searchDir = cwd;
   let searchPattern = pattern;
   if (isAbsolute(pattern)) {
@@ -87,7 +87,6 @@ export async function globFiles(
     });
     stdout = result.stdout;
   } catch (error) {
-    if (signal?.aborted) throwIfAborted(signal);
     // rg exit code 1 = 搜索完成但无匹配，对齐 Claude Code 的 ripGrep（正常空结果）
     const code = (error as { code?: unknown }).code;
     if (code === 1) return { files: [], truncated: false };

package/src/claude-code/grep.ts

@@ -17,7 +17,7 @@ import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
 
-import { searchRoot, suggestPathUnderCwd, throwIfAborted, toRelativePath } from "./common.js";
+import { searchRoot, suggestPathUnderCwd, toRelativePath } from "./common.js";
 
 const GREP_OUTPUT_MODES = ["content", "files_with_matches", "count"] as const;
 
@@ -272,7 +272,7 @@ export function registerGrepTool(pi: ExtensionAPI): void {
         }
       }
       const result = await pi.exec("rg", buildGrepArguments(params, ctx.cwd), { signal });
-      throwIfAborted(signal);
+      signal?.throwIfAborted();
       if (result.code !== 0 && result.code !== 1) {
         throw new Error(result.stderr.trim() || `ripgrep exited with code ${result.code}`);
       }

package/src/claude-code/session-tools.ts

@@ -193,7 +193,7 @@ export function registerSessionTools(pi: ExtensionAPI): void {
       if (!ctx.hasUI) throw new Error("Cannot ask questions: interactive UI is not available");
       const answers: Record<string, string> = {};
       for (const question of params.questions) {
-        if (signal?.aborted) throw new Error("Operation aborted");
+        signal?.throwIfAborted();
         answers[question.question] = question.multiSelect
           ? await askMultiple(question, ctx, signal)
           : await askSingle(question, ctx, signal);

package/src/claude-code/shell.ts

@@ -6,10 +6,11 @@ import {
   type BashToolDetails,
   type ExtensionAPI,
   formatSize,
+  type TruncationResult,
 } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
-import { type BwrapRuntime, createBwrapRuntime } from "../bwrap/runtime.js";
+import { BashInterruptedError, type BwrapRuntime, createBwrapRuntime } from "../bwrap/runtime.js";
 import { resolveWorkdir } from "../lib/path.js";
 
 const DEFAULT_TIMEOUT_MS = 120_000;
@@ -36,6 +37,25 @@ function formatBashError(exitCode: number | null, output: string): string {
   );
 }
 
+/** 输出被截断时附加的 `[Showing lines...]` 提示（成功、超时、中断路径共用）。 */
+function appendTruncationNotice(
+  text: string,
+  truncation: TruncationResult,
+  fullOutputPath: string | undefined,
+): string {
+  if (!fullOutputPath || !truncation.truncated) return text;
+  const startLine = truncation.totalLines - truncation.outputLines + 1;
+  const endLine = truncation.totalLines;
+  if (truncation.lastLinePartial) {
+    const lastLineSize = formatSize(text.length - text.lastIndexOf("\n", text.length - 2) - 1);
+    return `${text}\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${fullOutputPath}]`;
+  }
+  if (truncation.truncatedBy === "lines") {
+    return `${text}\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${fullOutputPath}]`;
+  }
+  return `${text}\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(truncation.maxBytes)} limit). Full output: ${fullOutputPath}]`;
+}
+
 /**
  * 成功路径：消费 runtime 的截断结果（输出已由 runtime 截断并落盘），
  * 截断时追加 `[Showing lines X-Y of N. Full output: path]` 提示。
@@ -46,21 +66,7 @@ export function formatBashSuccess(result: Awaited<ReturnType<BwrapRuntime["execu
   details: BashToolDetails | undefined;
 } {
   const { output, truncation, fullOutputPath } = result;
-  let text = output || "(no output)";
-  if (fullOutputPath && truncation.truncated) {
-    const startLine = truncation.totalLines - truncation.outputLines + 1;
-    const endLine = truncation.totalLines;
-    if (truncation.lastLinePartial) {
-      const lastLineSize = formatSize(
-        output.length - output.lastIndexOf("\n", output.length - 2) - 1,
-      );
-      text += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${fullOutputPath}]`;
-    } else if (truncation.truncatedBy === "lines") {
-      text += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${fullOutputPath}]`;
-    } else {
-      text += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(truncation.maxBytes)} limit). Full output: ${fullOutputPath}]`;
-    }
-  }
+  const text = appendTruncationNotice(output || "(no output)", truncation, fullOutputPath);
   return {
     content: [{ type: "text", text }],
     details: fullOutputPath && truncation.truncated ? { truncation, fullOutputPath } : undefined,
@@ -133,13 +139,24 @@ export function registerShellTools(
         });
       } catch (error) {
         if (!(error instanceof Error)) throw error;
-        const timeoutMatch = /Command timed out after [\d.]+ seconds/.exec(error.message);
-        const message = timeoutMatch
-          ? error.message.slice(0, timeoutMatch.index) +
-            `Command timed out after ${timeout} milliseconds` +
-            error.message.slice(timeoutMatch.index + timeoutMatch[0].length)
-          : error.message;
-        throw new Error(message, { cause: error });
+        if (error instanceof BashInterruptedError) {
+          // 输出在前（必要时带截断提示），状态文本在最后
+          const text = appendTruncationNotice(
+            error.partial.output || "",
+            error.partial.truncation,
+            error.partial.fullOutputPath,
+          );
+          if (error.kind === "aborted") {
+            // 用户取消：直接返回已捕获的输出，不抛错
+            const full = text ? `${text}\n\nCommand aborted` : "Command aborted";
+            return { content: [{ type: "text", text: full }], details: undefined };
+          }
+          const full = text
+            ? `${text}\n\nCommand timed out after ${timeout} milliseconds`
+            : `Command timed out after ${timeout} milliseconds`;
+          throw new Error(full, { cause: error });
+        }
+        throw error;
       }
 
       // 对齐 Claude Code：非 0 退出码视为错误（不做 grep/find 等命令语义化特判，

package/src/lib/path.ts

@@ -61,7 +61,7 @@ export function formatDisplayPath(cwd: string, filePath: string): string {
 }
 
 /** subtitle 中路径的最大显示长度，超过时退化为 `parent/basename`。 */
-export const MAX_SUBTITLE_PATH_LENGTH = 20;
+export const MAX_SUBTITLE_PATH_LENGTH = 30;
 
 function shortenSubtitlePath(filePath: string, display: string): string {
   if (display.length <= MAX_SUBTITLE_PATH_LENGTH) return display;

package/src/opencode/bash.ts

@@ -1,10 +1,10 @@
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, TruncationResult } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
-import { type BwrapRuntime, createBwrapRuntime } from "../bwrap/runtime.js";
+import { BashInterruptedError, type BwrapRuntime, createBwrapRuntime } from "../bwrap/runtime.js";
 import { resolveWorkdir } from "../lib/path.js";
 
 const DEFAULT_TIMEOUT_MS = 120_000;
@@ -16,6 +16,18 @@ const CAPTURE_TRUNCATED_NOTICE = "[output capture truncated at the in-memory saf
 /** Bash tool guidance, kept in markdown so it reads like documentation. */
 const BASH_PROMPT = readFileSync(fileURLToPath(new URL("bash.md", import.meta.url)), "utf8").trim();
 
+/** opencode 风格截断提示（成功、超时、中断路径共用）。 */
+function appendTruncationNotice(
+  text: string,
+  truncation: TruncationResult,
+  fullOutputPath: string | undefined,
+): string {
+  if (!truncation.truncated) return text;
+  let out = `${text}\n\n${CAPTURE_TRUNCATED_NOTICE}`;
+  if (fullOutputPath) out += `\nFull output: ${fullOutputPath}`;
+  return out;
+}
+
 /**
  * 对齐上游 opencode（packages/core/src/tool/bash.ts）：
  * 命令失败（非 0 退出码）与超时都不抛错，输出与状态文本一起返回，
@@ -89,17 +101,21 @@ export default function opencodeBash(
         });
       } catch (error) {
         if (!(error instanceof Error)) throw error;
-        // 对齐上游 opencode：超时不抛错，返回提示文本（丢弃部分输出）
-        if (/Command timed out after [\d.]+ seconds/.test(error.message)) {
+        if (error instanceof BashInterruptedError) {
+          const text = appendTruncationNotice(
+            error.partial.output || "",
+            error.partial.truncation,
+            error.partial.fullOutputPath,
+          );
+          const status =
+            error.kind === "timeout"
+              ? `Command exceeded timeout of ${timeout} ms. Retry with a larger timeout if the command is expected to take longer.`
+              : "Command aborted";
+          const full = text ? `${text}\n\n${status}` : status;
+          // 对齐上游 opencode：超时与中断都不抛错，输出与状态文本一起返回
           return {
-            content: [
-              {
-                type: "text" as const,
-                text: `Command exceeded timeout of ${timeout} ms. Retry with a larger timeout if the command is expected to take longer.`,
-              },
-              { type: "text" as const, text: "Command timed out before completion." },
-            ],
-            details: { timeout: true },
+            content: [{ type: "text" as const, text: full }],
+            details: error.kind === "timeout" ? { timeout: true } : {},
           };
         }
         throw error;
@@ -107,10 +123,7 @@ export default function opencodeBash(
 
       // 命令失败（非 0 退出码）不抛错：输出与状态文本一起返回
       let text = result.output || "(no output)";
-      if (result.truncation.truncated) {
-        text += `\n\n${CAPTURE_TRUNCATED_NOTICE}`;
-        if (result.fullOutputPath) text += `\nFull output: ${result.fullOutputPath}`;
-      }
+      text = appendTruncationNotice(text, result.truncation, result.fullOutputPath);
       return {
         content: [
           { type: "text" as const, text },

package/src/bwrap/singbox-config.ts

@@ -1,164 +0,0 @@
-const FAKEIP_RANGE = "198.18.0.0/15";
-const TUN_ADDRESS = "198.18.0.1/16";
-const EGRESS_INTERFACE = "tap0";
-
-export interface SingboxConfigOptions {
-  /** 允许直连的条目列表（域名 / IP / CIDR，可带 :port；空列表 = 默认拒绝一切出网）。 */
-  readonly allowlist: readonly string[];
-  /** 真实 DNS 服务器地址列表（IPv4，UDP 53），按顺序 fallback，至少一个。 */
-  readonly dnsServers: readonly string[];
-}
-
-interface AllowlistEntry {
-  readonly host: string;
-  readonly port?: number;
-}
-
-interface AllowlistRule {
-  readonly domain?: readonly string[];
-  readonly ip_cidr?: readonly string[];
-  readonly port?: readonly number[];
-  readonly outbound: "direct";
-}
-
-const IPV4_PATTERN = /^\d{1,3}(?:\.\d{1,3}){3}(?:\/\d{1,2})?$/;
-
-function isIp(host: string): boolean {
-  return IPV4_PATTERN.test(host) || host.includes(":");
-}
-
-/** 单 IP 补掩码为 CIDR（IPv4 /32、IPv6 /128），带掩码原样返回。 */
-function toCidr(host: string): string {
-  if (host.includes("/")) return host;
-  return host.includes(":") ? `${host}/128` : `${host}/32`;
-}
-
-function parsePort(value: string): number {
-  const port = Number(value);
-  if (!Number.isSafeInteger(port) || port < 1 || port > 65535) {
-    throw new Error(`Invalid port "${value}"`);
-  }
-  return port;
-}
-
-/**
- * 解析 allowlist 条目：域名 / IPv4 / CIDR，可带 :port；IPv6 必须用 [] 包裹
- * （如 `[::1]:80`），裸 IPv6 会报错提示补方括号。
- */
-function parseAllowlistEntry(entry: string): AllowlistEntry {
-  if (entry.startsWith("[")) {
-    const match = /^\[(.+)\](?::(\d+))?$/.exec(entry);
-    if (match?.[1] === undefined) throw new Error(`Invalid allowlist entry "${entry}"`);
-    return { host: match[1], port: match[2] === undefined ? undefined : parsePort(match[2]) };
-  }
-  const colon = entry.lastIndexOf(":");
-  if (colon === -1) {
-    if (entry.length === 0) throw new Error(`Invalid allowlist entry ""`);
-    return { host: entry };
-  }
-  const portPart = entry.slice(colon + 1);
-  if (!/^\d+$/.test(portPart)) throw new Error(`Invalid allowlist entry "${entry}"`);
-  const host = entry.slice(0, colon);
-  if (host.length === 0) throw new Error(`Invalid allowlist entry "${entry}"`);
-  if (host.includes(":")) {
-    throw new Error(`IPv6 addresses must be wrapped in brackets, e.g. "[${host}]:${portPart}"`);
-  }
-  return { host, port: parsePort(portPart) };
-}
-
-function buildAllowlistRules(allowlist: readonly string[]): AllowlistRule[] {
-  const noPortDomains: string[] = [];
-  const noPortIps: string[] = [];
-  const byPort = new Map<number, { domains: string[]; ips: string[] }>();
-  for (const entry of allowlist) {
-    const { host, port } = parseAllowlistEntry(entry);
-    if (port === undefined) {
-      (isIp(host) ? noPortIps : noPortDomains).push(host);
-    } else {
-      const bucket = byPort.get(port) ?? { domains: [], ips: [] };
-      (isIp(host) ? bucket.ips : bucket.domains).push(host);
-      byPort.set(port, bucket);
-    }
-  }
-  const rules: AllowlistRule[] = [];
-  if (noPortDomains.length > 0) rules.push({ domain: noPortDomains, outbound: "direct" });
-  if (noPortIps.length > 0) {
-    rules.push({ ip_cidr: noPortIps.map((host) => toCidr(host)), outbound: "direct" });
-  }
-  for (const [port, bucket] of byPort) {
-    rules.push({
-      outbound: "direct",
-      port: [port],
-      ...(bucket.domains.length > 0 && { domain: bucket.domains }),
-      ...(bucket.ips.length > 0 && { ip_cidr: bucket.ips.map((host) => toCidr(host)) }),
-    });
-  }
-  return rules;
-}
-
-/**
- * 生成 sing-box 1.13 配置：TUN + fakeip + deny-by-default allowlist。
- *
- * - 出站绑定到 slirp4netns 的 tap0，避免 auto_route 把 sing-box 自身出站
- *   流量（尤其 DNS 解析）重新路由回 TUN 形成环。
- * - 真实解析不设 domain_resolver（它只接受单个 server 且绕过规则），而是
- *   用 DNS rules 的顺序 fallback 链：前 N-1 个 nameserver 带 ip_accept_any
- *   过滤（响应不合格时落到下一条），最后一个作为 dns.final 兜底。
- *   该用法在 1.13 已标记 deprecated，运行需设置
- *   ENABLE_DEPRECATED_MISSING_DOMAIN_RESOLVER=true。
- */
-export function generateSingboxConfig(options: SingboxConfigOptions): string {
-  const { allowlist, dnsServers } = options;
-  const lastServer = dnsServers.at(-1);
-  if (!lastServer) {
-    throw new Error("At least one DNS server is required");
-  }
-  const config = {
-    log: { level: "info", timestamp: false },
-    dns: {
-      servers: [
-        ...dnsServers.map((server, index) => ({
-          type: "udp",
-          tag: `remote-${index}`,
-          server,
-          server_port: 53,
-        })),
-        { type: "fakeip", tag: "fakeip", inet4_range: FAKEIP_RANGE },
-      ],
-      rules: [
-        { query_type: ["A", "AAAA"], server: "fakeip" },
-        ...dnsServers.slice(0, -1).map((_, index) => ({
-          server: `remote-${index}`,
-          ip_accept_any: true,
-        })),
-      ],
-      final: `remote-${dnsServers.length - 1}`,
-      strategy: "prefer_ipv4",
-      independent_cache: true,
-    },
-    inbounds: [
-      {
-        type: "tun",
-        tag: "tun-in",
-        stack: "gvisor",
-        address: [TUN_ADDRESS],
-        auto_route: true,
-        strict_route: true,
-      },
-    ],
-    outbounds: [
-      { type: "direct", tag: "direct" },
-      { type: "block", tag: "block" },
-    ],
-    route: {
-      default_interface: EGRESS_INTERFACE,
-      final: "block",
-      rules: [
-        { action: "sniff" },
-        { protocol: "dns", action: "hijack-dns" },
-        ...buildAllowlistRules(allowlist),
-      ],
-    },
-  };
-  return `${JSON.stringify(config, null, 2)}\n`;
-}