pi-landstrip 0.12.1 → 0.14.1

package/README.md

@@ -3,7 +3,7 @@
 ![pi-landstrip screenshot](screenshot.png)
 
 Landlock-based sandboxing for [pi](https://pi.dev/) using
-[`landstrip`](https://github.com/jarkkojs/landstrip).
+[`landstrip`](https://github.com/landstrip/landstrip).
 
 ## Install
 
@@ -11,7 +11,7 @@ Landlock-based sandboxing for [pi](https://pi.dev/) using
 pi install npm:pi-landstrip
 ```
 
-This installs `pi-landstrip` and its `@jarkkojs/landstrip` dependency, which
+This installs `pi-landstrip` and its `@landstrip/landstrip` dependency, which
 includes platform-specific native binaries for Linux, macOS, and Windows.
 
 On unsupported platforms the extension loads but leaves sandboxing disabled.
@@ -43,5 +43,5 @@ Use `/sandbox` inside Pi to show the active config and toggle sandboxing.
 `pi-landstrip` is licensed under `MIT`. See [LICENSE](LICENSE) for more
 information.
 
-The bundled `@jarkkojs/landstrip` package is licensed under
+The bundled `@landstrip/landstrip` package is licensed under
 `Apache-2.0 AND LGPL-2.1-or-later`.

package/index.ts

@@ -12,7 +12,7 @@ import type {
   ExtensionContext,
 } from '@earendil-works/pi-coding-agent';
 
-import { binaryPath } from '@jarkkojs/landstrip';
+import { binaryPath } from '@landstrip/landstrip';
 
 import { spawn, spawnSync } from 'node:child_process';
 import {
@@ -76,42 +76,22 @@ interface LandstripPolicy {
   filesystem: SandboxFilesystemConfig;
 }
 
-type LandstripErrorReason = 'Other' | 'AccessDenied' | 'LaunchFailed' | 'SetupFailed' | 'Usage';
 type LandstripOperation = 'read' | 'write';
-type LandstripErrorType = 'filesystem' | 'network' | 'platform' | 'launch' | 'encoding';
-
-interface LandstripErrorResponse {
-  reason: LandstripErrorReason;
-  file?: string;
-  operation?: LandstripOperation;
-  program?: string;
-  type?: LandstripErrorType;
-  source?: string;
-  mechanism?: string;
-}
+
+type LandstripTrap =
+  | { kind: 'filesystem'; operation: LandstripOperation; file: string; mechanism: string }
+  | { kind: 'network'; operation: string; target: string; mechanism: string }
+  | { kind: 'launch'; program: string; source: string }
+  | { kind: 'usage'; message: string }
+  | { kind: 'internal'; detail: Record<string, string> };
 
 interface LandstripBashCallbacks {
   onStderr?: (data: Buffer) => void;
   onErrorFd?: (data: Buffer) => void;
 }
 
-const LANDSTRIP_VERSION = [0, 12, 2] as const;
+const LANDSTRIP_VERSION = [0, 14, 5] as const;
 const REQUIRED_LANDSTRIP_VERSION = LANDSTRIP_VERSION.join('.');
-const LANDSTRIP_ERROR_REASONS = new Set<LandstripErrorReason>([
-  'Other',
-  'AccessDenied',
-  'LaunchFailed',
-  'SetupFailed',
-  'Usage',
-]);
-const LANDSTRIP_OPERATIONS = new Set<LandstripOperation>(['read', 'write']);
-const LANDSTRIP_ERROR_TYPES = new Set<LandstripErrorType>([
-  'filesystem',
-  'network',
-  'platform',
-  'launch',
-  'encoding',
-]);
 const SUPPORTED_PLATFORMS = new Set<NodeJS.Platform>(['linux', 'darwin', 'win32']);
 
 const DEFAULT_CONFIG: SandboxConfig = {
@@ -218,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'),
   };
 }
@@ -405,54 +385,16 @@ function normalizePathMatch(value: string, cwd: string): string | null {
   return isPathLike(value) ? normalizeBlockedPath(value, cwd) : null;
 }
 
-function isFilesystemAccessDenied(error: LandstripErrorResponse): boolean {
-  return error.reason === 'AccessDenied' && error.type === 'filesystem';
-}
-
-function isLandstripErrorReason(value: string): value is LandstripErrorReason {
-  return LANDSTRIP_ERROR_REASONS.has(value as LandstripErrorReason);
-}
-
-function isLandstripOperation(value: string): value is LandstripOperation {
-  return LANDSTRIP_OPERATIONS.has(value as LandstripOperation);
-}
-
-function isLandstripErrorType(value: string): value is LandstripErrorType {
-  return LANDSTRIP_ERROR_TYPES.has(value as LandstripErrorType);
-}
+type LandstripFilesystemTrap = Extract<LandstripTrap, { 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 isFilesystemTrap(trap: LandstripTrap): trap is LandstripFilesystemTrap {
+  return trap.kind === 'filesystem';
 }
 
-function extractBlockedPath(output: string, cwd: string, command?: string): string | null {
-  const landstripErrors = parseLandstripErrors(output).filter(isFilesystemAccessDenied);
-  for (const error of landstripErrors) {
-    if (error.file) return normalizeBlockedPath(error.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;
-      }
-    }
+function extractBlockedPath(output: string, cwd: string): string | null {
+  const landstripErrors = parseLandstripTraps(output).filter(isFilesystemTrap);
+  if (landstripErrors.length > 0) {
+    return normalizeBlockedPath(landstripErrors[0].file, cwd);
   }
 
   return extractNativeDeniedPath(output, cwd);
@@ -503,8 +445,8 @@ function extractNativeWriteDeniedPath(output: string, cwd: string): string | nul
 }
 
 function extractBlockedWritePath(output: string, cwd: string): string | null {
-  for (const error of parseLandstripErrors(output).filter(isFilesystemAccessDenied)) {
-    if (error.file && error.operation === 'write') {
+  for (const error of parseLandstripTraps(output).filter(isFilesystemTrap)) {
+    if (error.operation === 'write') {
       return normalizeBlockedPath(error.file, cwd);
     }
   }
@@ -512,67 +454,93 @@ function extractBlockedWritePath(output: string, cwd: string): string | null {
   return extractNativeWriteDeniedPath(output, cwd);
 }
 
-function parseLandstripErrors(output: string): LandstripErrorResponse[] {
-  const errors: LandstripErrorResponse[] = [];
+// 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 {
+  if (!Array.isArray(value) || value.length < length) return null;
+  const head = value.slice(0, length);
+  return head.every((item) => typeof item === 'string') ? (head as string[]) : null;
+}
 
-  for (const line of output.trim().split('\n')) {
-    if (line.length === 0) continue;
+// landstrip emits each trap as a serde externally-tagged enum: a single-key
+// object whose key is the variant name (`Filesystem`, `Network`, `Launch`,
+// `Usage`, `Internal`) and whose value is the variant payload.
+function parseLandstripTrap(obj: Record<string, unknown>): LandstripTrap | null {
+  const fs = stringTuple(obj.Filesystem, 3);
+  if (fs) {
+    const [operation, file, mechanism] = fs;
+    if (operation === 'read' || operation === 'write') {
+      return { kind: 'filesystem', operation, file, mechanism };
+    }
+    return null;
+  }
 
-    try {
-      const parsed: unknown = JSON.parse(line);
-      if (typeof parsed !== 'object' || parsed === null) continue;
-      const obj = parsed as Record<string, unknown>;
+  const net = stringTuple(obj.Network, 3);
+  if (net) {
+    const [operation, target, mechanism] = net;
+    return { kind: 'network', operation, target, mechanism };
+  }
 
-      const reason = obj.reason;
-      if (typeof reason !== 'string' || !isLandstripErrorReason(reason)) continue;
+  const launch = stringTuple(obj.Launch, 2);
+  if (launch) {
+    const [program, source] = launch;
+    return { kind: 'launch', program, source };
+  }
 
-      const error: LandstripErrorResponse = { reason };
+  if (typeof obj.Usage === 'string') {
+    return { kind: 'usage', message: obj.Usage };
+  }
 
-      if (typeof obj.source === 'string') error.source = obj.source;
-      if (typeof obj.file === 'string') error.file = obj.file;
-      if (typeof obj.program === 'string') error.program = obj.program;
+  const internal = obj.Internal;
+  if (typeof internal === 'object' && internal !== null && !Array.isArray(internal)) {
+    const detail: Record<string, string> = {};
+    for (const [key, value] of Object.entries(internal)) {
+      if (typeof value === 'string') detail[key] = value;
+    }
+    return { kind: 'internal', detail };
+  }
 
-      if (typeof obj.operation === 'string' && isLandstripOperation(obj.operation)) {
-        error.operation = obj.operation;
-      }
+  return null;
+}
 
-      if (typeof obj.type === 'string' && isLandstripErrorType(obj.type)) {
-        error.type = obj.type;
-      }
+function parseLandstripTraps(output: string): LandstripTrap[] {
+  const traps: LandstripTrap[] = [];
 
-      if (typeof obj.mechanism === 'string') error.mechanism = obj.mechanism;
+  for (const line of output.trim().split('\n')) {
+    if (line.length === 0) continue;
 
-      errors.push(error);
+    try {
+      const parsed: unknown = JSON.parse(line);
+      if (typeof parsed !== 'object' || parsed === null) continue;
+      const trap = parseLandstripTrap(parsed as Record<string, unknown>);
+      if (trap) traps.push(trap);
     } catch {
       // Ignore non-JSON lines (e.g. stderr from child processes)
     }
   }
 
-  return errors;
+  return traps;
 }
 
-function formatLandstripErrors(errors: LandstripErrorResponse[]): string {
-  return errors
-    .map((err) => {
-      const parts: string[] = [`landstrip: ${err.reason}`];
-
-      if (err.file) {
-        parts.push(` (${err.file})`);
-      }
-      if (err.program) {
-        parts.push(` ${err.program}`);
-      }
-      if (err.type) {
-        parts.push(`:${err.type}`);
-      }
-      if (err.operation) {
-        parts.push(`:${err.operation}`);
-      }
-      if (err.source) {
-        parts.push(`: ${err.source}`);
+function formatLandstripTraps(traps: LandstripTrap[]): string {
+  return traps
+    .map((trap) => {
+      switch (trap.kind) {
+        case 'filesystem':
+          return `landstrip: filesystem ${trap.operation} denied: ${trap.file} (${trap.mechanism})`;
+        case 'network':
+          return `landstrip: network ${trap.operation} denied: ${trap.target} (${trap.mechanism})`;
+        case 'launch':
+          return `landstrip: launch failed: ${trap.program}: ${trap.source}`;
+        case 'usage':
+          return `landstrip: usage error: ${trap.message}`;
+        case 'internal': {
+          const detail = Object.entries(trap.detail)
+            .map(([key, value]) => `${key}=${value}`)
+            .join(', ');
+          return detail ? `landstrip: internal error: ${detail}` : 'landstrip: internal error';
+        }
       }
-
-      return parts.join('');
     })
     .join('\n');
 }
@@ -986,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,
       },
     };
@@ -1023,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> {
@@ -1065,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 {
@@ -1219,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);
@@ -1249,9 +1231,9 @@ export function createLandstripIntegration(
                 if (choice !== 'abort') await applyWriteChoice(choice, blockedPath, cwd);
               }
             } else if (!blockedPath && ctx.hasUI) {
-              const landstripErrors = parseLandstripErrors(errorOutput);
+              const landstripErrors = parseLandstripTraps(errorOutput);
               if (landstripErrors.length > 0) {
-                const formatted = formatLandstripErrors(landstripErrors);
+                const formatted = formatLandstripTraps(landstripErrors);
                 notify(ctx, `Sandbox blocked an operation: ${formatted}`, 'warning');
               }
             }
@@ -1342,15 +1324,15 @@ export function createLandstripIntegration(
         if (retryResult) return retryResult;
       }
 
-      const landstripErrors = parseLandstripErrors(landstripErrorOutput || errorText);
+      const landstripErrors = parseLandstripTraps(landstripErrorOutput || errorText);
       if (landstripErrors.length > 0) {
-        throw new Error(formatLandstripErrors(landstripErrors));
+        throw new Error(formatLandstripTraps(landstripErrors));
       }
       throw error;
     }
-    const landstripErrors = parseLandstripErrors(landstripErrorOutput);
+    const landstripErrors = parseLandstripTraps(landstripErrorOutput);
     if (landstripErrors.length > 0) {
-      const message = formatLandstripErrors(landstripErrors);
+      const message = formatLandstripTraps(landstripErrors);
       result.content.unshift({ type: 'text', text: `\n${message}\n` });
     }
     const blockedPath =
@@ -1428,7 +1410,7 @@ export function createLandstripIntegration(
       sandboxReady = false;
       notify(
         ctx,
-        `landstrip was not found. Reinstall with: npm install @jarkkojs/landstrip`,
+        `landstrip was not found. Reinstall with: npm install @landstrip/landstrip`,
         'error',
       );
       return false;

package/landstrip.d.ts

@@ -1,3 +1,3 @@
-declare module '@jarkkojs/landstrip' {
+declare module '@landstrip/landstrip' {
   function binaryPath(): string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-landstrip",
-  "version": "0.12.1",
+  "version": "0.14.1",
   "description": "Landlock-based sandboxing for pi with interactive permission prompts",
   "keywords": [
     "landstrip",
@@ -11,7 +11,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/jarkkojs/pi-landstrip.git"
+    "url": "git+https://github.com/landstrip/pi-landstrip.git"
   },
   "files": [
     "index.ts",
@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.78.0",
-    "@jarkkojs/landstrip": "^0.12.3"
+    "@landstrip/landstrip": "^0.14.5"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.78.0",