@trim21/personal-pi-extensions 0.0.424 → 0.0.426

package/package.json

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

package/src/bwrap/core.ts

@@ -9,6 +9,7 @@ import { type BashOperations, getAgentDir, getShellConfig } from "@earendil-work
 import { type Static, Type } from "typebox";
 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";
@@ -32,7 +33,9 @@ const bwrapConfigProperties = {
   extraWritablePaths: Type.Array(Type.String()),
   tmpfsPaths: Type.Array(Type.String()),
   extraArgs: Type.Array(Type.String()),
-  networkAllowlist: Type.Array(Type.String()),
+  networkAllowlist: Type.Array(
+    Type.String({ description: "允许直连的域名 / IP / CIDR，可带 :port" }),
+  ),
   singBoxPath: Type.Optional(Type.String()),
   slirp4netnsPath: Type.Optional(Type.String()),
   approvalRules: Type.Optional(
@@ -42,18 +45,20 @@ const bwrapConfigProperties = {
           action: StringEnum(["allow", "deny"] as const),
           pattern: Type.String({ description: '命令模式，如 "git push *"、"npm install *"' }),
         },
-        { additionalProperties: false },
+        { additionalProperties: true },
       ),
     ),
   ),
 };
 
+// 配置文件容忍未知字段：schema 之外的字段（如新版本扩展新增的配置）会被忽略，
+// 避免整个 bwrap 配置因单个未知字段失效；已声明字段仍做类型/取值校验。
 export const bwrapConfigSchema = Type.Object(bwrapConfigProperties, {
-  additionalProperties: false,
+  additionalProperties: true,
 });
 
 export const bwrapConfigFileSchema = Type.Partial(bwrapConfigSchema, {
-  additionalProperties: false,
+  additionalProperties: true,
 });
 
 export type BwrapConfig = Static<typeof bwrapConfigSchema>;
@@ -68,7 +73,7 @@ export interface ResolvedBwrap {
   extraWritablePaths: string[];
   tmpfsPaths: string[];
   extraArgs: string[];
-  /** per-domain 过滤的允许域名（非空 = 启用 sing-box 网络过滤）。 */
+  /** 允许直连的域名 / IP / IP:port 白名单（非空 = 启用 sing-box 网络过滤）。 */
   networkAllowlist: string[];
   singBoxPath?: string;
   slirp4netnsPath?: string;
@@ -151,9 +156,10 @@ function parseBwrapConfigFile(path: string): BwrapConfigFile {
     throw new Error(`Invalid bwrap configuration at ${path}: ${String(error)}`, { cause: error });
   }
   try {
-    return Value.Parse(bwrapConfigFileSchema, raw);
+    return parseWithSchema(bwrapConfigFileSchema, raw);
   } catch (error) {
-    throw new Error(`Invalid bwrap configuration at ${path}: ${String(error)}`, { cause: error });
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid bwrap configuration at ${path}: ${detail}`, { cause: error });
   }
 }
 

package/src/bwrap/holder.js

@@ -49,7 +49,6 @@ async function main() {
       return false;
     }
   });
-  await sleep(4e3);
   await writeFile(readyFile, "");
   await new Promise((resolve) => singbox.once("exit", () => resolve()));
 }

package/src/bwrap/holder.ts

@@ -55,8 +55,7 @@ async function main(): Promise<void> {
     process.exit(0);
   });
 
-  // tun0 设备在 sing-box 启动早期就创建，但 gvisor 栈初始化仍需时间；
-  // 以 "sing-box started" 日志作为进程就绪标志，再等待栈初始化完成
+  // 以 "sing-box started" 日志作为就绪标志（TUN 与 gvisor 数据面此时已可用）
   await waitFor(200, 100, async () => {
     try {
       const log = await readFile(logPath, "utf8");
@@ -65,7 +64,6 @@ async function main(): Promise<void> {
       return false;
     }
   });
-  await sleep(4000);
   await writeFile(readyFile, "");
 
   await new Promise<void>((resolve) => singbox.once("exit", () => resolve()));

package/src/bwrap/network-stack.ts

@@ -7,7 +7,7 @@ import { fileURLToPath } from "node:url";
 import { generateSingboxConfig } from "./singbox-config.js";
 
 export interface NetworkStackOptions {
-  /** 允许直连的域名列表（session 启动时固定，reload 才会重新加载）。 */
+  /** 允许直连的域名 / IP:port 列表（session 启动时固定，reload 才会重新加载）。 */
   readonly allowlist: readonly string[];
   /** 真实 DNS 服务器列表，按顺序 fallback。 */
   readonly dnsServers: readonly string[];

package/src/bwrap/runtime.ts

@@ -232,7 +232,7 @@ function notifyMode(
     "allow-all": "allow-all: sandbox off, network on",
     "workspace-write": "workspace-write: sandbox on, network off",
     "allow-net": "allow-net: sandbox on, network on, workspace writable",
-    "net-allowlist": "net-allowlist: sandbox on, network filtered by domain allowlist",
+    "net-allowlist": "net-allowlist: sandbox on, network filtered by allowlist",
     readonly: "readonly: sandbox on, network off, read-only fs",
   };
   ctx.ui.notify(labels[mode], "info");
@@ -672,7 +672,7 @@ export class BwrapRuntime {
       "bwrap-net-allowlist": {
         name: "bwrap-net-allowlist",
         usage: "",
-        description: "Sandbox on, network filtered by domain allowlist, workspace writable",
+        description: "Sandbox on, network filtered by allowlist, workspace writable",
         flags: Type.Object({}),
       },
       "bwrap-readonly": {

package/src/bwrap/singbox-config.ts

@@ -3,12 +3,99 @@ 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。
  *
@@ -69,7 +156,7 @@ export function generateSingboxConfig(options: SingboxConfigOptions): string {
       rules: [
         { action: "sniff" },
         { protocol: "dns", action: "hijack-dns" },
-        ...(allowlist.length > 0 ? [{ domain: [...allowlist], outbound: "direct" }] : []),
+        ...buildAllowlistRules(allowlist),
       ],
     },
   };

package/src/lib/parse-with-schema.ts

@@ -0,0 +1,21 @@
+import type { Static, TSchema } from "typebox";
+import Value, { ParseError } from "typebox/value";
+
+/**
+ * 用 typebox schema 解析 value。成功返回解析结果；失败抛带字段路径的 Error
+ * （Value.Parse 的 ParseError 错误详情在 cause.errors，默认 message 只有
+ * "Parse"，这里拼成可读信息，供调用方包装上下文如配置文件路径）。
+ */
+export function parseWithSchema<T extends TSchema>(schema: T, value: unknown): Static<T> {
+  try {
+    return Value.Parse(schema, value);
+  } catch (error) {
+    if (error instanceof ParseError) {
+      const details = error.cause.errors
+        .map((e) => `${e.instancePath || "(root)"}: ${e.message}`)
+        .join("; ");
+      throw new Error(details, { cause: error });
+    }
+    throw error;
+  }
+}