pi-landstrip 0.3.0 → 0.3.2

package/index.ts

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 // Copyright (C) Jarkko Sakkinen 2026
 
+/// <reference path="./landstrip.d.ts" />
+
 import type {
   AgentToolResult,
   AgentToolUpdateCallback,
@@ -72,12 +74,11 @@ interface LandstripErrorResponse {
   category: 'policy' | 'tool' | 'platform' | 'system';
   file?: string;
   program?: string;
-  target?: 'filesystem' | 'network' | 'platform';
-  kind?: 'launch' | 'encoding';
+  type?: 'filesystem' | 'network' | 'platform' | 'launch' | 'encoding';
   message: string;
 }
 
-const LANDSTRIP_VERSION = [0, 9, 2] as const;
+const LANDSTRIP_VERSION = [0, 9, 5] as const;
 const SUPPORTED_PLATFORMS = new Set<NodeJS.Platform>(['linux', 'darwin', 'win32']);
 
 const DEFAULT_CONFIG: SandboxConfig = {
@@ -353,6 +354,9 @@ function parseLandstripErrors(output: string): LandstripErrorResponse[] {
         parsed !== null &&
         typeof parsed.category === 'string' &&
         ['policy', 'tool', 'platform', 'system'].includes(parsed.category) &&
+        (parsed.type === undefined ||
+          (typeof parsed.type === 'string' &&
+            ['filesystem', 'network', 'platform', 'launch', 'encoding'].includes(parsed.type))) &&
         typeof parsed.message === 'string' &&
         parsed.message.length > 0
       ) {
@@ -371,14 +375,14 @@ function formatLandstripErrors(errors: LandstripErrorResponse[]): string {
     .map((err) => {
       const parts: string[] = [`landstrip: ${err.category}`];
 
-      if (err.target) {
-        parts.push(`(${err.target})`);
+      if (err.file) {
+        parts.push(` (${err.file})`);
       }
       if (err.program) {
         parts.push(` ${err.program}`);
       }
-      if (err.kind) {
-        parts.push(`:${err.kind}`);
+      if (err.type) {
+        parts.push(`:${err.type}`);
       }
       parts.push(`: ${err.message}`);
 
@@ -591,16 +595,33 @@ function pipeSockets(client: Socket, upstream: Socket, initialData?: Buffer): vo
   upstream.pipe(client);
 }
 
+type LandstripBashTool = ReturnType<typeof createBashToolDefinition>;
+
+export interface LandstripIntegrationOptions {
+  registerBashTool?: boolean;
+  cwd?: string;
+}
+
+export interface LandstripIntegration {
+  createBashTool(cwd: string, ctx?: ExtensionContext): LandstripBashTool;
+  register(pi: ExtensionAPI): void;
+}
+
 export default function (pi: ExtensionAPI) {
-  pi.registerFlag('no-sandbox', {
-    description: 'Disable landstrip sandboxing for bash commands',
-    type: 'boolean',
-    default: false,
-  });
+  createLandstripIntegration().register(pi);
+}
+
+export function createLandstripIntegration(
+  options: LandstripIntegrationOptions = {},
+): LandstripIntegration {
+  const shouldRegisterBashTool = options.registerBashTool ?? true;
+  const localCwd = options.cwd ?? process.cwd();
 
-  const localCwd = process.cwd();
-  const userShellPath = SettingsManager.create(localCwd).getShellPath();
-  const localBash = createBashToolDefinition(localCwd, { shellPath: userShellPath });
+  function createPlainBashTool(cwd: string): LandstripBashTool {
+    return createBashToolDefinition(cwd, {
+      shellPath: SettingsManager.create(cwd).getShellPath(),
+    });
+  }
 
   let sandboxEnabled = false;
   let sandboxReady = false;
@@ -828,12 +849,15 @@ export default function (pi: ExtensionAPI) {
     });
   }
 
-  function createLandstripBashOps(ctx: ExtensionContext): BashOperations {
+  function createLandstripBashOps(
+    ctx: ExtensionContext,
+    onStderr: (data: Buffer) => void = () => {},
+  ): BashOperations {
     return {
       async exec(command, cwd, { onData, signal, timeout, env }) {
         if (!existsSync(cwd)) throw new Error(`Working directory does not exist: ${cwd}`);
 
-        const { shell, args } = getShellConfig(userShellPath);
+        const { shell, args } = getShellConfig(SettingsManager.create(cwd).getShellPath());
         const proxy = await startProxy(ctx, cwd);
         const policy = writePolicyFile(cwd, proxy.port);
         const landstripArgs = ['-p', policy.path, shell, ...args, command];
@@ -881,7 +905,10 @@ export default function (pi: ExtensionAPI) {
 
           signal?.addEventListener('abort', onAbort, { once: true });
           child.stdout?.on('data', onData);
-          child.stderr?.on('data', onData);
+          child.stderr?.on('data', (data: Buffer) => {
+            onStderr(data);
+            onData(data);
+          });
 
           child.on('error', (error) => {
             cleanup();
@@ -910,18 +937,30 @@ export default function (pi: ExtensionAPI) {
     onUpdate: AgentToolUpdateCallback<BashToolDetails | undefined> | undefined,
     ctx: ExtensionContext,
   ): Promise<AgentToolResult<BashToolDetails | undefined>> {
-    const sandboxedBash = createBashToolDefinition(localCwd, {
-      operations: createLandstripBashOps(ctx),
-      shellPath: userShellPath,
+    let landstripStderr = '';
+    const sandboxedBash = createBashToolDefinition(ctx.cwd, {
+      operations: createLandstripBashOps(ctx, (data) => {
+        landstripStderr += data.toString('utf8');
+      }),
+      shellPath: SettingsManager.create(ctx.cwd).getShellPath(),
     });
 
     const run = () => sandboxedBash.execute(id, params, signal, onUpdate, ctx);
-    const result = await run();
+    let result: AgentToolResult<BashToolDetails | undefined>;
+    try {
+      result = await run();
+    } catch (error) {
+      const landstripErrors = parseLandstripErrors(landstripStderr);
+      if (landstripErrors.length > 0) {
+        throw new Error(formatLandstripErrors(landstripErrors));
+      }
+      throw error;
+    }
     const outputText = result.content
       .filter((content) => content.type === 'text')
       .map((content) => content.text)
       .join('\n');
-    const landstripErrors = parseLandstripErrors(outputText);
+    const landstripErrors = parseLandstripErrors(landstripStderr);
     if (landstripErrors.length > 0) {
       const message = formatLandstripErrors(landstripErrors);
       result.content.unshift({ type: 'text', text: `\n${message}\n` });
@@ -1010,7 +1049,7 @@ export default function (pi: ExtensionAPI) {
     if (!hasMinimumVersion(version, LANDSTRIP_VERSION)) {
       sandboxEnabled = false;
       sandboxReady = false;
-      ctx.ui.notify(`landstrip 0.9.2 or newer is required; found: ${version}`, 'error');
+      ctx.ui.notify(`landstrip 0.9.5 or newer is required; found: ${version}`, 'error');
       return false;
     }
 
@@ -1021,178 +1060,201 @@ export default function (pi: ExtensionAPI) {
     return true;
   }
 
-  pi.registerTool({
-    ...localBash,
-    label: 'bash (landstrip)',
-    async execute(id, params, signal, onUpdate, ctx) {
-      if (!sandboxEnabled || !sandboxReady)
-        return localBash.execute(id, params, signal, onUpdate, ctx);
-
-      return runBashWithOptionalRetry(id, params, signal, onUpdate, ctx);
-    },
-  });
+  function createBashTool(cwd: string, ctx?: ExtensionContext): LandstripBashTool {
+    const localBash = createPlainBashTool(cwd);
 
-  pi.on('user_bash', async (event, ctx) => {
-    if (!sandboxEnabled || !sandboxReady) return;
-    if (!loadConfig(ctx.cwd).enabled) return;
-
-    const blockedDomain = await preflightCommandDomains(event.command, ctx);
-    if (blockedDomain) {
-      return {
-        result: {
-          output: `Blocked: "${blockedDomain}" is not allowed by the sandbox. Use /sandbox to review your config.`,
-          exitCode: 1,
-          cancelled: false,
-          truncated: false,
-        },
-      };
-    }
+    return {
+      ...localBash,
+      label: 'bash (landstrip)',
+      async execute(id, params, signal, onUpdate, callCtx) {
+        const effectiveCtx = callCtx ?? ctx;
+        if (!sandboxEnabled || !sandboxReady || !effectiveCtx)
+          return localBash.execute(id, params, signal, onUpdate, effectiveCtx);
+
+        return runBashWithOptionalRetry(id, params, signal, onUpdate, effectiveCtx);
+      },
+    };
+  }
 
-    return { operations: createLandstripBashOps(ctx) };
-  });
+  function register(pi: ExtensionAPI): void {
+    const maybePi = pi as ExtensionAPI & {
+      getFlag?: (name: string) => unknown;
+      registerCommand?: ExtensionAPI['registerCommand'];
+      registerFlag?: ExtensionAPI['registerFlag'];
+    };
 
-  pi.on('tool_call', async (event, ctx) => {
-    if (!sandboxEnabled) return;
+    maybePi.registerFlag?.('no-sandbox', {
+      description: 'Disable landstrip sandboxing for bash commands',
+      type: 'boolean',
+      default: false,
+    });
 
-    const config = loadConfig(ctx.cwd);
-    if (!config.enabled) return;
+    if (shouldRegisterBashTool) pi.registerTool(createBashTool(localCwd));
 
-    const { globalPath, projectPath } = getConfigPaths(ctx.cwd);
+    pi.on('user_bash', async (event, ctx) => {
+      if (!sandboxEnabled || !sandboxReady) return;
+      if (!loadConfig(ctx.cwd).enabled) return;
 
-    if (sandboxReady && isToolCallEventType('bash', event)) {
-      const blockedDomain = await preflightCommandDomains(event.input.command, ctx);
+      const blockedDomain = await preflightCommandDomains(event.command, ctx);
       if (blockedDomain) {
         return {
-          block: true,
-          reason: `Network access to "${blockedDomain}" is blocked by the sandbox.`,
+          result: {
+            output: `Blocked: "${blockedDomain}" is not allowed by the sandbox. Use /sandbox to review your config.`,
+            exitCode: 1,
+            cancelled: false,
+            truncated: false,
+          },
         };
       }
-    }
 
-    if (isToolCallEventType('read', event)) {
-      const filePath = canonicalizePath(event.input.path);
-      if (!matchesPattern(filePath, getEffectiveAllowRead(ctx.cwd))) {
-        const choice = await promptReadBlock(ctx, filePath);
-        if (choice === 'abort') {
+      return { operations: createLandstripBashOps(ctx) };
+    });
+
+    pi.on('tool_call', async (event, ctx) => {
+      if (!sandboxEnabled) return;
+
+      const config = loadConfig(ctx.cwd);
+      if (!config.enabled) return;
+
+      const { globalPath, projectPath } = getConfigPaths(ctx.cwd);
+
+      if (sandboxReady && isToolCallEventType('bash', event)) {
+        const blockedDomain = await preflightCommandDomains(event.input.command, ctx);
+        if (blockedDomain) {
           return {
             block: true,
-            reason: `Sandbox: read access denied for "${filePath}"`,
+            reason: `Network access to "${blockedDomain}" is blocked by the sandbox.`,
           };
         }
-        await applyReadChoice(choice, filePath, ctx.cwd);
       }
-    }
 
-    if (isToolCallEventType('write', event) || isToolCallEventType('edit', event)) {
-      const filePath = canonicalizePath((event.input as { path: string }).path);
-
-      if (matchesPattern(filePath, config.filesystem.denyWrite)) {
-        return {
-          block: true,
-          reason:
-            `Sandbox: write access denied for "${filePath}" (in denyWrite). ` +
-            `To change this, edit denyWrite in:\n  ${projectPath}\n  ${globalPath}`,
-        };
+      if (isToolCallEventType('read', event)) {
+        const filePath = canonicalizePath(event.input.path);
+        if (!matchesPattern(filePath, getEffectiveAllowRead(ctx.cwd))) {
+          const choice = await promptReadBlock(ctx, filePath);
+          if (choice === 'abort') {
+            return {
+              block: true,
+              reason: `Sandbox: read access denied for "${filePath}"`,
+            };
+          }
+          await applyReadChoice(choice, filePath, ctx.cwd);
+        }
       }
 
-      if (shouldPromptForWrite(filePath, getEffectiveAllowWrite(ctx.cwd), matchesPattern)) {
-        const choice = await promptWriteBlock(ctx, filePath);
-        if (choice === 'abort') {
+      if (isToolCallEventType('write', event) || isToolCallEventType('edit', event)) {
+        const filePath = canonicalizePath((event.input as { path: string }).path);
+
+        if (matchesPattern(filePath, config.filesystem.denyWrite)) {
           return {
             block: true,
-            reason: `Sandbox: write access denied for "${filePath}" (not in allowWrite)`,
+            reason:
+              `Sandbox: write access denied for "${filePath}" (in denyWrite). ` +
+              `To change this, edit denyWrite in:\n  ${projectPath}\n  ${globalPath}`,
           };
         }
-        await applyWriteChoice(choice, filePath, ctx.cwd);
-      }
-    }
-  });
 
-  pi.on('session_start', async (_event, ctx) => {
-    const noSandbox = pi.getFlag('no-sandbox') as boolean;
-
-    if (noSandbox) {
-      sandboxEnabled = false;
-      sandboxReady = false;
-      ctx.ui.notify('Sandbox disabled via --no-sandbox', 'warning');
-      return;
-    }
-
-    const config = loadConfig(ctx.cwd);
-    if (!config.enabled) {
-      sandboxEnabled = false;
-      sandboxReady = false;
-      ctx.ui.notify('Sandbox disabled via config', 'info');
-      return;
-    }
+        if (shouldPromptForWrite(filePath, getEffectiveAllowWrite(ctx.cwd), matchesPattern)) {
+          const choice = await promptWriteBlock(ctx, filePath);
+          if (choice === 'abort') {
+            return {
+              block: true,
+              reason: `Sandbox: write access denied for "${filePath}" (not in allowWrite)`,
+            };
+          }
+          await applyWriteChoice(choice, filePath, ctx.cwd);
+        }
+      }
+    });
 
-    enableSandbox(ctx);
-  });
+    pi.on('session_start', async (_event, ctx) => {
+      const noSandbox = maybePi.getFlag?.('no-sandbox') as boolean;
 
-  pi.registerCommand('sandbox-enable', {
-    description: 'Enable the landstrip sandbox for this session',
-    handler: async (_args, ctx) => {
-      if (sandboxEnabled) {
-        ctx.ui.notify('Sandbox is already enabled', 'info');
+      if (noSandbox) {
+        sandboxEnabled = false;
+        sandboxReady = false;
+        ctx.ui.notify('Sandbox disabled via --no-sandbox', 'warning');
         return;
       }
 
-      if (enableSandbox(ctx)) ctx.ui.notify('Sandbox enabled', 'info');
-    },
-  });
-
-  pi.registerCommand('sandbox-disable', {
-    description: 'Disable the landstrip sandbox for this session',
-    handler: async (_args, ctx) => {
-      if (!sandboxEnabled) {
-        ctx.ui.notify('Sandbox is already disabled', 'info');
+      const config = loadConfig(ctx.cwd);
+      if (!config.enabled) {
+        sandboxEnabled = false;
+        sandboxReady = false;
+        ctx.ui.notify('Sandbox disabled via config', 'info');
         return;
       }
 
-      sandboxEnabled = false;
-      sandboxReady = false;
-      ctx.ui.setStatus('sandbox', '');
-      ctx.ui.notify('Sandbox disabled', 'info');
-    },
-  });
+      enableSandbox(ctx);
+    });
 
-  pi.registerCommand('sandbox', {
-    description: 'Show sandbox configuration',
-    handler: async (_args, ctx) => {
-      if (!sandboxEnabled) {
-        ctx.ui.notify('Sandbox is disabled', 'info');
-        return;
-      }
+    maybePi.registerCommand?.('sandbox-enable', {
+      description: 'Enable the landstrip sandbox for this session',
+      handler: async (_args, ctx) => {
+        if (sandboxEnabled) {
+          ctx.ui.notify('Sandbox is already enabled', 'info');
+          return;
+        }
 
-      const config = loadConfig(ctx.cwd);
-      const { globalPath, projectPath } = getConfigPaths(ctx.cwd);
-      const lines = [
-        'Sandbox Configuration',
-        `  Project config: ${projectPath}`,
-        `  Global config:  ${globalPath}`,
-        `  landstrip:      ${binaryPath()}`,
-        '',
-        'Network (bash through HTTP proxy):',
-        `  Allowed domains: ${config.network.allowedDomains.join(', ') || '(none)'}`,
-        `  Denied domains:  ${config.network.deniedDomains.join(', ') || '(none)'}`,
-        ...(sessionAllowedDomains.length > 0
-          ? [`  Session allowed: ${sessionAllowedDomains.join(', ')}`]
-          : []),
-        '',
-        'Filesystem (bash + read/write/edit tools):',
-        `  Deny Read:   ${config.filesystem.denyRead.join(', ') || '(none)'}`,
-        `  Allow Read:  ${config.filesystem.allowRead.join(', ') || '(none)'}`,
-        `  Allow Write: ${config.filesystem.allowWrite.join(', ') || '(none)'}`,
-        `  Deny Write:  ${config.filesystem.denyWrite.join(', ') || '(none)'}`,
-        ...(sessionAllowedReadPaths.length > 0
-          ? [`  Session read:  ${sessionAllowedReadPaths.join(', ')}`]
-          : []),
-        ...(sessionAllowedWritePaths.length > 0
-          ? [`  Session write: ${sessionAllowedWritePaths.join(', ')}`]
-          : []),
-      ];
-
-      ctx.ui.notify(lines.join('\n'), 'info');
-    },
-  });
+        if (enableSandbox(ctx)) ctx.ui.notify('Sandbox enabled', 'info');
+      },
+    });
+
+    maybePi.registerCommand?.('sandbox-disable', {
+      description: 'Disable the landstrip sandbox for this session',
+      handler: async (_args, ctx) => {
+        if (!sandboxEnabled) {
+          ctx.ui.notify('Sandbox is already disabled', 'info');
+          return;
+        }
+
+        sandboxEnabled = false;
+        sandboxReady = false;
+        ctx.ui.setStatus('sandbox', '');
+        ctx.ui.notify('Sandbox disabled', 'info');
+      },
+    });
+
+    maybePi.registerCommand?.('sandbox', {
+      description: 'Show sandbox configuration',
+      handler: async (_args, ctx) => {
+        if (!sandboxEnabled) {
+          ctx.ui.notify('Sandbox is disabled', 'info');
+          return;
+        }
+
+        const config = loadConfig(ctx.cwd);
+        const { globalPath, projectPath } = getConfigPaths(ctx.cwd);
+        const lines = [
+          'Sandbox Configuration',
+          `  Project config: ${projectPath}`,
+          `  Global config:  ${globalPath}`,
+          `  landstrip:      ${binaryPath()}`,
+          '',
+          'Network (bash through HTTP proxy):',
+          `  Allowed domains: ${config.network.allowedDomains.join(', ') || '(none)'}`,
+          `  Denied domains:  ${config.network.deniedDomains.join(', ') || '(none)'}`,
+          ...(sessionAllowedDomains.length > 0
+            ? [`  Session allowed: ${sessionAllowedDomains.join(', ')}`]
+            : []),
+          '',
+          'Filesystem (bash + read/write/edit tools):',
+          `  Deny Read:   ${config.filesystem.denyRead.join(', ') || '(none)'}`,
+          `  Allow Read:  ${config.filesystem.allowRead.join(', ') || '(none)'}`,
+          `  Allow Write: ${config.filesystem.allowWrite.join(', ') || '(none)'}`,
+          `  Deny Write:  ${config.filesystem.denyWrite.join(', ') || '(none)'}`,
+          ...(sessionAllowedReadPaths.length > 0
+            ? [`  Session read:  ${sessionAllowedReadPaths.join(', ')}`]
+            : []),
+          ...(sessionAllowedWritePaths.length > 0
+            ? [`  Session write: ${sessionAllowedWritePaths.join(', ')}`]
+            : []),
+        ];
+
+        ctx.ui.notify(lines.join('\n'), 'info');
+      },
+    });
+  }
+
+  return { createBashTool, register };
 }

package/landstrip.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-landstrip",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Landlock-based sandboxing for pi with interactive permission prompts",
   "keywords": [
     "landstrip",
@@ -15,6 +15,7 @@
   },
   "files": [
     "index.ts",
+    "landstrip.d.ts",
     "README.md",
     "sandbox.json"
   ],
@@ -30,7 +31,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.78.0",
-    "@jarkkojs/landstrip": "^0.9.2"
+    "@jarkkojs/landstrip": "^0.9.5"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.78.0",