@rjshrjndrn/pi-sandbox 0.1.0 → 0.1.2

package/README.md

@@ -31,7 +31,7 @@ When you approve, the parent directory is remembered for the rest of the session
 
 ```bash
 # As a pi package
-pi install @rjshrjndrn/pi-sandbox
+pi install npm:@rjshrjndrn/pi-sandbox
 
 # Or test locally
 pi -e ./pi-sandbox/extensions/index.ts

package/package.json

@@ -1,12 +1,20 @@
 {
   "name": "@rjshrjndrn/pi-sandbox",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Filesystem boundary enforcement for pi — prompts before the agent escapes your project",
-  "keywords": ["pi-package", "pi-extension", "sandbox", "filesystem", "permissions"],
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "sandbox",
+    "filesystem",
+    "permissions"
+  ],
   "license": "MIT",
   "type": "module",
   "pi": {
-    "extensions": ["./extensions"]
+    "extensions": [
+      "./extensions"
+    ]
   },
   "peerDependencies": {
     "@mariozechner/pi-coding-agent": "*",

package/src/boundary.ts

@@ -1,16 +1,20 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent"
+import { execSync } from "node:child_process"
 import { state } from "./state.js"
 
 /**
  * Detect the project filesystem boundary.
  *
- * Runs `git rev-parse --show-toplevel` to find the git worktree root.
- * Falls back to `cwd` if git is not available or the directory is not a git repo.
+ * Tries multiple methods to find the git worktree root:
+ * 1. pi.exec() (preferred, uses pi's exec infrastructure)
+ * 2. child_process.execSync() (fallback, direct OS call)
+ * 3. Falls back to `cwd` if git is not available or not a git repo.
  */
 export async function detectBoundary(
   pi: ExtensionAPI,
   cwd: string
 ): Promise<{ boundary: string; source: "git" | "cwd" }> {
+  // Try pi.exec first
   try {
     const result = await pi.exec("git", ["rev-parse", "--show-toplevel"], {
       timeout: 5000,
@@ -20,8 +24,24 @@ export async function detectBoundary(
       return { boundary: toplevel, source: "git" }
     }
   } catch {
-    // git not available or other error — fall through to CWD
+    // pi.exec may not be available in all contexts — try direct exec
   }
+
+  // Fallback: direct child_process
+  try {
+    const toplevel = execSync("git rev-parse --show-toplevel", {
+      cwd,
+      timeout: 5000,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim()
+    if (toplevel.length > 0) {
+      return { boundary: toplevel, source: "git" }
+    }
+  } catch {
+    // git not available or not a git repo
+  }
+
   return { boundary: cwd, source: "cwd" }
 }
 
@@ -30,13 +50,22 @@ export async function detectBoundary(
  */
 export function registerBoundaryDetection(pi: ExtensionAPI) {
   pi.on("session_start", async (_event, ctx) => {
-    const { boundary, source } = await detectBoundary(pi, ctx.cwd)
-    state.boundary = boundary
+    try {
+      const { boundary, source } = await detectBoundary(pi, ctx.cwd)
+      state.boundary = boundary
 
-    const label =
-      source === "git"
-        ? `🔒 pi-sandbox: boundary set to ${boundary} (git worktree)`
-        : `🔒 pi-sandbox: boundary set to ${boundary} (cwd fallback)`
-    ctx.ui.notify(label, "info")
+      const label =
+        source === "git"
+          ? `🔒 pi-sandbox: boundary set to ${boundary} (git worktree)`
+          : `🔒 pi-sandbox: boundary set to ${boundary} (cwd fallback)`
+      ctx.ui.notify(label, "info")
+    } catch (err) {
+      // Last resort: use cwd as boundary
+      state.boundary = ctx.cwd
+      ctx.ui.notify(
+        `🔒 pi-sandbox: boundary set to ${ctx.cwd} (error fallback: ${err})`,
+        "warning"
+      )
+    }
   })
 }

package/tests/boundary.test.ts

@@ -14,7 +14,7 @@ function mockPiExecThrows() {
 }
 
 describe("detectBoundary", () => {
-  it("returns git worktree root when git succeeds", async () => {
+  it("returns git worktree root when pi.exec succeeds", async () => {
     const pi = mockPi({
       stdout: "/Users/test/project\n",
       stderr: "",
@@ -26,46 +26,50 @@ describe("detectBoundary", () => {
     expect(result.source).toBe("git")
   })
 
-  it("falls back to cwd when git returns non-zero exit code", async () => {
+  it("trims whitespace from git output", async () => {
     const pi = mockPi({
-      stdout: "",
-      stderr: "fatal: not a git repository",
-      code: 128,
+      stdout: "  /Users/test/project  \n",
+      stderr: "",
+      code: 0,
       killed: false,
     })
-    const result = await detectBoundary(pi, "/Users/test/not-a-repo")
-    expect(result.boundary).toBe("/Users/test/not-a-repo")
-    expect(result.source).toBe("cwd")
+    const result = await detectBoundary(pi, "/Users/test/project/src")
+    expect(result.boundary).toBe("/Users/test/project")
+    expect(result.source).toBe("git")
   })
 
-  it("falls back to cwd when git is not available", async () => {
+  it("falls back to execSync when pi.exec fails", async () => {
+    // pi.exec throws, but we're in a real git repo so execSync will find it
     const pi = mockPiExecThrows()
-    const result = await detectBoundary(pi, "/Users/test/no-git")
-    expect(result.boundary).toBe("/Users/test/no-git")
-    expect(result.source).toBe("cwd")
+    const result = await detectBoundary(pi, process.cwd())
+    // Should still detect git via execSync fallback
+    expect(result.source).toBe("git")
+    expect(result.boundary.length).toBeGreaterThan(0)
   })
 
-  it("falls back to cwd when git returns empty stdout", async () => {
+  it("falls back to cwd in a non-git directory", async () => {
     const pi = mockPi({
       stdout: "",
-      stderr: "",
-      code: 0,
+      stderr: "fatal: not a git repository",
+      code: 128,
       killed: false,
     })
-    const result = await detectBoundary(pi, "/Users/test/empty")
-    expect(result.boundary).toBe("/Users/test/empty")
+    // Use /tmp which is not a git repo
+    const result = await detectBoundary(pi, "/tmp")
+    expect(result.boundary).toBe("/tmp")
     expect(result.source).toBe("cwd")
   })
 
-  it("trims whitespace from git output", async () => {
+  it("falls back to cwd when pi.exec returns empty stdout", async () => {
     const pi = mockPi({
-      stdout: "  /Users/test/project  \n",
+      stdout: "",
       stderr: "",
       code: 0,
       killed: false,
     })
-    const result = await detectBoundary(pi, "/Users/test/project/src")
-    expect(result.boundary).toBe("/Users/test/project")
-    expect(result.source).toBe("git")
+    // execSync will also fail in /tmp
+    const result = await detectBoundary(pi, "/tmp")
+    expect(result.boundary).toBe("/tmp")
+    expect(result.source).toBe("cwd")
   })
 })