@trim21/personal-pi-extensions 0.1.553 → 0.1.554

package/package.json

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

package/src/bwrap/runtime.ts

@@ -17,7 +17,7 @@ import { type TObject, Type } from "typebox";
 
 import { type CommandSpec, parseCommand } from "../lib/cli.js";
 import { fenceCodeBlock } from "../lib/markdown.js";
-import { formatDisplayPath, resolveHomePath } from "../lib/path.js";
+import { formatDisplayPath } from "../lib/path.js";
 import { type SelectAction, selectMultiple, selectWithOptionalInput } from "../lib/ui.js";
 import { type ApprovalRule, evaluateBashApproval, matchRule } from "./approval-rules.js";
 import { commandPatternsFor } from "./approval-suggest.js";
@@ -91,7 +91,7 @@ export interface BwrapExecutionRequest {
  */
 export interface BwrapExecutionResult {
   exitCode: number | null;
-  /** 只描述写边界（工作区外能否写）与网络层级（关 / 白名单 / 放开），不含具体域名；未沙箱执行时为 undefined。 */
+  /** 沙箱状态说明（写边界 + 网络层级），失败时由上层工具作为独立信息块附上；未沙箱执行时为 undefined。 */
   sandboxHint: string | undefined;
   /** 截断后的输出（尾部），未截断时为完整输出；空输出为空字符串。 */
   output: string;
@@ -260,13 +260,8 @@ function notifyMode(
   ctx.ui.notify(labels[mode], "info");
 }
 
-/** 沙箱内允许写入的根目录（与沙箱层同基准：相对 workspace 解析 "."、`~` 与相对路径）。 */
-function writableRoots(resolved: ResolvedBwrap, workspace: string): string[] {
-  const writable = [...resolved.writablePaths, ...resolved.extraWritablePaths].map((path) =>
-    resolveHomePath(path, workspace),
-  );
-  return [...new Set(writable)];
-}
+/** 沙箱默认写边界：根只读、工作区可写、.git 只读。不展开用户配置的额外可写路径。 */
+const SANDBOX_WRITE_RULES = "/ is read-only, ./ is writable, ./.git/ is read-only";
 
 /** 网络层级：关 / 只放行白名单 / 完全放开（白名单域名本身不列出，对判断失败无用）。 */
 function describeNetwork(resolved: ResolvedBwrap): string {
@@ -276,49 +271,28 @@ function describeNetwork(resolved: ResolvedBwrap): string {
   return "network access is unrestricted";
 }
 
-export interface SandboxHintInput {
-  /** writablePaths 中 "." 的解析基准，也是可写根目录的显示基准。 */
-  workspace: string;
-  /** 本次命令是否绕过沙箱（Windows、审批通过的全权限、allow-all）。 */
-  unsandboxed: boolean;
-}
-
 /** 命令没经沙箱时沿用 prompt 里的说法，给出在沙盒外重跑的手段。 */
 const SANDBOX_ESCAPE_HATCH =
   "[Sandbox] If the command needs more than that, use the `dangerouslyDisableSandbox` parameter to request unsandboxed execution; the user must approve this request.";
 
 /**
- * 命令失败时附在错误文本后的沙箱状态：写边界（可写根目录、.git 只读）+ 网络层级，
- * 以及在沙盒外重跑的手段。只报层级不列白名单域名。
+ * 命令失败时作为独立信息块附上的沙箱状态：默认写边界 + 网络层级，以及在沙盒外重跑的手段。
+ * 写边界只说沙箱布局（不展开用户配置的可写路径），网络只说层级（不列白名单域名）。
  * 命令没经沙箱（allow-all、审批通过的全权限、Windows）时返回 undefined：
  * 没有沙箱就没什么可提示的。
  */
-export function describeSandbox(
-  resolved: ResolvedBwrap,
-  input: SandboxHintInput,
-): string | undefined {
-  if (input.unsandboxed) return undefined;
-  const roots = writableRoots(resolved, input.workspace);
-  const clauses = [
-    roots.length === 0
-      ? "the filesystem is read-only"
-      : `writes are limited to ${roots.map((path) => formatDisplayPath(input.workspace, path)).join(", ")}`,
-    // .git 只读保护只在工作区本身可写时才有区分度（readonly 下整个文件系统都不可写）
-    ...(roots.includes(input.workspace) ? [".git is read-only"] : []),
-    describeNetwork(resolved),
-  ];
+export function describeSandbox(resolved: ResolvedBwrap, unsandboxed: boolean): string | undefined {
+  if (unsandboxed) return undefined;
+  const writes = resolved.mode === "readonly" ? "the filesystem is read-only" : SANDBOX_WRITE_RULES;
   return [
-    `[Sandbox] This command ran in a sandbox: ${clauses.join("; ")}.`,
+    `[Sandbox] This command ran in a sandbox: ${writes}; ${describeNetwork(resolved)}.`,
     SANDBOX_ESCAPE_HATCH,
   ].join("\n");
 }
 
-/**
- * 把沙箱状态拼到失败文本后（未沙箱执行时保持原文）。失败文本常以换行结尾，
- * 先 trimEnd 保证状态与命令输出之间只有一个空行。
- */
-export function appendSandboxHint(text: string, hint: string | undefined): string {
-  return hint === undefined ? text : `${text.trimEnd()}\n\n${hint}`;
+/** 失败结果里附加的沙箱状态块；未沙箱执行（hint 为 undefined）时没有这一块。 */
+export function sandboxHintBlock(hint: string | undefined): { type: "text"; text: string }[] {
+  return hint === undefined ? [] : [{ type: "text", text: hint }];
 }
 
 export class BwrapRuntime {
@@ -450,7 +424,7 @@ export class BwrapRuntime {
       this.mihomoPath = runtime.mihomoPath;
     }
     // 命令失败时附带的沙箱状态（写边界 + 网络层级），由上层拼进错误文本
-    const sandboxHint = describeSandbox(runtime, { workspace, unsandboxed: local });
+    const sandboxHint = describeSandbox(runtime, local);
     await using output = new BashOutput(request.ctx.sessionManager.getSessionId());
     const { onUpdate } = request;
 

package/src/claude-code/shell.ts

@@ -11,10 +11,10 @@ import {
 import { Type } from "typebox";
 
 import {
-  appendSandboxHint,
   BashInterruptedError,
   type BwrapRuntime,
   createBwrapRuntime,
+  sandboxHintBlock,
 } from "../bwrap/runtime.js";
 import { resolveWorkdir } from "../lib/path.js";
 
@@ -156,25 +156,31 @@ export function registerShellTools(
             const full = text ? `${text}\n\nCommand aborted by user` : "Command aborted by user";
             return { content: [{ type: "text", text: full }], details: undefined };
           }
-          const status = text
+          const full = text
             ? `${text}\n\nCommand timed out after ${timeout} milliseconds`
             : `Command timed out after ${timeout} milliseconds`;
-          throw new Error(appendSandboxHint(status, error.sandboxHint), { cause: error });
+          return {
+            content: [{ type: "text", text: full }, ...sandboxHintBlock(error.sandboxHint)],
+            details: undefined,
+          };
         }
         throw error;
       }
 
-      // 对齐 Claude Code：非 0 退出码视为错误（不做 grep/find 等命令语义化特判，
-      // 任何非 0 都抛错）；错误文本用完整输出（从落盘文件读取，必要时头尾截断）
+      // 对齐 Claude Code：非 0 退出码都算失败（不做 grep/find 等命令语义化特判）。
+      // 失败是命令的正常结果而不是异常：与成功一样 return，文本用完整输出
+      // （从落盘文件读取，必要时头尾截断），沙箱状态另行附一块
       if (result.exitCode !== 0 && result.exitCode !== null) {
         const full = result.fullOutputPath
           ? await readFile(result.fullOutputPath, "utf8")
           : result.output;
-        // 失败时附带沙箱状态：命令可能是被沙箱的写边界或网络限制挡住的
-        throw new Error(
-          appendSandboxHint(formatBashError(result.exitCode, full), result.sandboxHint),
-          { cause: result },
-        );
+        return {
+          content: [
+            { type: "text", text: formatBashError(result.exitCode, full) },
+            ...sandboxHintBlock(result.sandboxHint),
+          ],
+          details: undefined,
+        };
       }
       return formatBashSuccess(result);
     },

package/src/opencode/bash.ts

@@ -5,10 +5,10 @@ import type { ExtensionAPI, TruncationResult } from "@earendil-works/pi-coding-a
 import { Type } from "typebox";
 
 import {
-  appendSandboxHint,
   BashInterruptedError,
   type BwrapRuntime,
   createBwrapRuntime,
+  sandboxHintBlock,
 } from "../bwrap/runtime.js";
 import { resolveWorkdir } from "../lib/path.js";
 
@@ -111,18 +111,18 @@ export default function opencodeBash(
             error.partial.truncation,
             error.partial.fullOutputPath,
           );
-          // 超时附带沙箱状态（可能是网络限制让命令挂住）；中断是用户主动取消，与沙箱无关
           const status =
             error.kind === "timeout"
-              ? appendSandboxHint(
-                  `Command exceeded timeout of ${timeout} ms. Retry with a larger timeout if the command is expected to take longer.`,
-                  error.sandboxHint,
-                )
+              ? `Command exceeded timeout of ${timeout} ms. Retry with a larger timeout if the command is expected to take longer.`
               : "Command aborted by user";
           const full = text ? `${text}\n\n${status}` : status;
-          // 对齐上游 opencode：超时与中断都不抛错，输出与状态文本一起返回
+          // 对齐上游 opencode：超时与中断都不抛错，输出与状态文本一起返回；
+          // 超时可能是沙箱的网络限制导致的，附加沙箱状态（用户中断与沙箱无关）
           return {
-            content: [{ type: "text" as const, text: full }],
+            content: [
+              { type: "text" as const, text: full },
+              ...sandboxHintBlock(error.kind === "timeout" ? error.sandboxHint : undefined),
+            ],
             details: error.kind === "timeout" ? { timeout: true } : {},
           };
         }
@@ -133,15 +133,12 @@ export default function opencodeBash(
       let text = result.output || "(no output)";
       text = appendTruncationNotice(text, result.truncation, result.fullOutputPath);
       const failed = result.exitCode !== 0 && result.exitCode !== null;
-      // 失败时附带沙箱状态：命令可能是被沙箱的写边界或网络限制挡住的
-      const status = appendSandboxHint(
-        `Command exited with code ${result.exitCode}.`,
-        failed ? result.sandboxHint : undefined,
-      );
       return {
         content: [
           { type: "text" as const, text },
-          { type: "text" as const, text: status },
+          { type: "text" as const, text: `Command exited with code ${result.exitCode}.` },
+          // 失败可能是被沙箱的写边界或网络限制挡住的，附一块沙箱状态
+          ...sandboxHintBlock(failed ? result.sandboxHint : undefined),
         ],
         details: {
           exitCode: result.exitCode,