pi-landstrip 0.14.0 → 0.14.2

package/index.ts

@@ -90,7 +90,7 @@ interface LandstripBashCallbacks {
   onErrorFd?: (data: Buffer) => void;
 }
 
-const LANDSTRIP_VERSION = [0, 14, 2] as const;
+const LANDSTRIP_VERSION = [0, 14, 5] as const;
 const REQUIRED_LANDSTRIP_VERSION = LANDSTRIP_VERSION.join('.');
 const SUPPORTED_PLATFORMS = new Set<NodeJS.Platform>(['linux', 'darwin', 'win32']);
 
@@ -198,7 +198,7 @@ function deepMerge(base: SandboxConfig, overrides: Partial<SandboxConfig>): Sand
 
 function getConfigPaths(cwd: string): { globalPath: string; projectPath: string } {
   return {
-    globalPath: join(homedir(), '.pi', 'agent', 'sandbox.json'),
+    globalPath: join(getAgentDir(), 'sandbox.json'),
     projectPath: join(cwd, '.pi', 'sandbox.json'),
   };
 }
@@ -391,40 +391,12 @@ function isFilesystemTrap(trap: LandstripTrap): trap is LandstripFilesystemTrap
   return trap.kind === 'filesystem';
 }
 
-function extractCandidatePaths(command: string): string[] {
-  const paths: string[] = [];
-  // Split on whitespace, preserving quoted strings minimally
-  const tokens = command.match(/[^\s"']+|"[^"]*"|'[^']*'/g) ?? [];
-  for (const token of tokens) {
-    const clean = token.replace(/^["']|["']$/g, '').replace(/[,;]$/, '');
-    if (isPathLike(clean)) {
-      paths.push(clean);
-    }
-  }
-  return paths;
-}
-
-function extractBlockedPath(output: string, cwd: string, command?: string): string | null {
+function extractBlockedPath(output: string, cwd: string): string | null {
   const landstripErrors = parseLandstripTraps(output).filter(isFilesystemTrap);
   if (landstripErrors.length > 0) {
     return normalizeBlockedPath(landstripErrors[0].file, cwd);
   }
 
-  // If landstrip reported an error but without a file field, try to
-  // extract the blocked path from the command itself.
-  if (landstripErrors.length > 0 && command) {
-    const config = loadConfig(cwd);
-    for (const candidate of extractCandidatePaths(command)) {
-      const resolved = normalizeBlockedPath(candidate, cwd);
-      if (
-        matchesPattern(resolved, config.filesystem.denyRead) ||
-        !matchesPattern(resolved, config.filesystem.allowRead)
-      ) {
-        return resolved;
-      }
-    }
-  }
-
   return extractNativeDeniedPath(output, cwd);
 }
 
@@ -482,6 +454,16 @@ function extractBlockedWritePath(output: string, cwd: string): string | null {
   return extractNativeWriteDeniedPath(output, cwd);
 }
 
+function extractBlockedReadPath(output: string, cwd: string): string | null {
+  for (const error of parseLandstripTraps(output).filter(isFilesystemTrap)) {
+    if (error.operation === 'read') {
+      return normalizeBlockedPath(error.file, cwd);
+    }
+  }
+
+  return extractNativeDeniedPath(output, cwd);
+}
+
 // Returns the first `length` elements of a string tuple, or null if `value` is
 // not an array of at least that many strings.
 function stringTuple(value: unknown, length: number): string[] | null {
@@ -982,8 +964,8 @@ export function createLandstripIntegration(
       },
       filesystem: {
         denyRead: config.filesystem.denyRead,
-        allowRead: [...config.filesystem.allowRead, ...sessionAllowedReadPaths],
-        allowWrite: [...config.filesystem.allowWrite, ...sessionAllowedWritePaths],
+        allowRead: getEffectiveAllowRead(cwd),
+        allowWrite: getEffectiveAllowWrite(cwd),
         denyWrite: config.filesystem.denyWrite,
       },
     };
@@ -1019,10 +1001,17 @@ export function createLandstripIntegration(
         return;
       }
 
+      let settled = false;
       const upstream = connectNet(endpoint.port, endpoint.host, () => {
+        settled = true;
         client.write('HTTP/1.1 200 Connection Established\r\n\r\n');
         pipeSockets(client, upstream, rest);
       });
+      upstream.once('error', () => {
+        if (settled) return;
+        settled = true;
+        denyProxyRequest(client, '502 Bad Gateway');
+      });
     }
 
     async function handleHttp(client: Socket, headerText: string, rest: Buffer): Promise<void> {
@@ -1061,10 +1050,17 @@ export function createLandstripIntegration(
       const rewrittenHeader = lines
         .filter((line) => !line.toLowerCase().startsWith('proxy-connection:'))
         .join('\r\n');
+      let settled = false;
       const upstream = connectNet(port, url.hostname, () => {
+        settled = true;
         upstream.write(`${rewrittenHeader}\r\n\r\n`);
         pipeSockets(client, upstream, rest);
       });
+      upstream.once('error', () => {
+        if (settled) return;
+        settled = true;
+        denyProxyRequest(client, '502 Bad Gateway');
+      });
     }
 
     function handleClient(client: Socket): void {
@@ -1215,8 +1211,8 @@ export function createLandstripIntegration(
             const errorOutput = errorFdAcc || stderrAcc;
 
             const blockedPath =
-              extractBlockedPath(errorOutput, cwd, command) ??
-              (errorFdAcc ? extractBlockedPath(stderrAcc, cwd, command) : null);
+              extractBlockedPath(errorOutput, cwd) ??
+              (errorFdAcc ? extractBlockedPath(stderrAcc, cwd) : null);
             const blockedWritePath =
               extractBlockedWritePath(errorOutput, cwd) ??
               (errorFdAcc ? extractBlockedWritePath(stderrAcc, cwd) : null);
@@ -1324,17 +1320,54 @@ export function createLandstripIntegration(
       return run();
     };
 
+    const retryWithReadAccess = async (
+      blockedPath: string,
+    ): Promise<AgentToolResult<BashToolDetails | undefined> | null> => {
+      if (!ctx.hasUI) return null;
+
+      if (!matchesPattern(blockedPath, getEffectiveAllowRead(ctx.cwd))) {
+        const config = loadConfig(ctx.cwd);
+        const choice = await promptReadBlock(
+          ctx,
+          blockedPath,
+          matchesPattern(blockedPath, config.filesystem.denyRead)
+            ? 'denyRead overrides allowRead'
+            : undefined,
+        );
+        if (choice === 'abort') return null;
+        await applyReadChoice(choice, blockedPath, ctx.cwd);
+      }
+
+      onUpdate?.({
+        content: [
+          { type: 'text', text: `\n--- Read access granted for "${blockedPath}", retrying ---\n` },
+        ],
+        details: {},
+      });
+      landstripErrorOutput = '';
+      stderrOutput = '';
+      return run();
+    };
+
     let result: AgentToolResult<BashToolDetails | undefined>;
     try {
       result = await run();
     } catch (error) {
       const errorText = error instanceof Error ? error.message : String(error);
       const fallbackOutput = `${stderrOutput}\n${errorText}`;
-      const blockedPath =
+      const blockedWritePath =
         extractBlockedWritePath(landstripErrorOutput, ctx.cwd) ??
         extractBlockedWritePath(fallbackOutput, ctx.cwd);
-      if (blockedPath) {
-        const retryResult = await retryWithWriteAccess(blockedPath);
+      if (blockedWritePath) {
+        const retryResult = await retryWithWriteAccess(blockedWritePath);
+        if (retryResult) return retryResult;
+      }
+
+      const blockedReadPath =
+        extractBlockedReadPath(landstripErrorOutput, ctx.cwd) ??
+        extractBlockedReadPath(fallbackOutput, ctx.cwd);
+      if (blockedReadPath) {
+        const retryResult = await retryWithReadAccess(blockedReadPath);
         if (retryResult) return retryResult;
       }
 
@@ -1349,12 +1382,20 @@ export function createLandstripIntegration(
       const message = formatLandstripTraps(landstripErrors);
       result.content.unshift({ type: 'text', text: `\n${message}\n` });
     }
-    const blockedPath =
+    const blockedWritePath =
       extractBlockedWritePath(landstripErrorOutput, ctx.cwd) ??
       extractBlockedWritePath(stderrOutput, ctx.cwd);
-    if (!blockedPath) return result;
+    if (blockedWritePath) {
+      const retryResult = await retryWithWriteAccess(blockedWritePath);
+      if (retryResult) return retryResult;
+    }
+
+    const blockedReadPath =
+      extractBlockedReadPath(landstripErrorOutput, ctx.cwd) ??
+      extractBlockedReadPath(stderrOutput, ctx.cwd);
+    if (!blockedReadPath) return result;
 
-    const retryResult = await retryWithWriteAccess(blockedPath);
+    const retryResult = await retryWithReadAccess(blockedReadPath);
     return retryResult ?? result;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-landstrip",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "description": "Landlock-based sandboxing for pi with interactive permission prompts",
   "keywords": [
     "landstrip",