pi-landstrip 0.14.0 → 0.14.1

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);
 }
 
@@ -982,8 +954,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 +991,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 +1040,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 +1201,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);

package/package.json

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