pi-landstrip 0.15.6 → 0.15.7

package/index.ts

@@ -10,6 +10,7 @@ import type {
   BashToolInput,
   ExtensionAPI,
   ExtensionContext,
+  Theme,
 } from '@earendil-works/pi-coding-agent';
 
 import { binaryPath } from '@landstrip/landstrip';
@@ -95,6 +96,7 @@ type LandstripTrap =
 interface LandstripBashCallbacks {
   onStderr?: (data: Buffer) => void;
   onErrorFd?: (data: Buffer) => void;
+  promptOnBlock?: boolean;
 }
 
 const LANDSTRIP_VERSION = [0, 15, 9] as const;
@@ -362,7 +364,9 @@ function matchesPattern(filePath: string, patterns: string[]): boolean {
     const absPattern = pattern.includes('*') ? expandPath(pattern) : canonicalizePath(pattern);
 
     if (pattern.includes('*')) {
-      const escaped = absPattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+      const escaped = absPattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*\/|\*\*|\*/g, (token) => (token === '**/' ? '(?:.*/)?' : '.*'));
       return new RegExp(`^${escaped}$`).test(abs);
     }
 
@@ -438,11 +442,6 @@ function extractNativeWriteDeniedPath(output: string, cwd: string): string | nul
   );
   if (match) return normalizePathMatch(match[1], cwd);
 
-  match = output.match(
-    /(?:\/bin\/bash|bash|sh): (?:line \d+: )?([^:\n]+): (?:Operation not permitted|Permission denied)/,
-  );
-  if (match) return normalizePathMatch(match[1], cwd);
-
   match = output.match(
     /^[a-zA-Z0-9_-]+: cannot create(?: directory)? '?([^'\n]+?)'?(?: for writing)?: (?:Operation not permitted|Permission denied)$/m,
   );
@@ -580,6 +579,25 @@ function setTuiStatus(ctx: ExtensionContext, key: string, value: string | undefi
   ctx.ui.setStatus(key, value);
 }
 
+function boxTop(theme: Theme, width: number, title: string): string {
+  const label = theme.fg('accent', ` ${title} `);
+  const fill = theme.fg('border', '─'.repeat(Math.max(0, width - 4 - visibleWidth(label))));
+  return `${theme.fg('border', '╭─')}${label}${fill}${theme.fg('border', '─╮')}`;
+}
+
+function boxRow(theme: Theme, width: number, content = ''): string {
+  const innerW = Math.max(1, width - 4);
+  const border = theme.fg('border', '│');
+  const line = truncateToWidth(content, innerW);
+  const pad = Math.max(0, innerW - visibleWidth(line));
+  return `${border} ${line}${' '.repeat(pad)} ${border}`;
+}
+
+function boxBottom(theme: Theme, width: number): string {
+  const border = (s: string) => theme.fg('border', s);
+  return `${border('╰')}${border('─'.repeat(Math.max(0, width - 2)))}${border('╯')}`;
+}
+
 async function showPermissionPrompt(
   ctx: ExtensionContext,
   title: string,
@@ -598,28 +616,14 @@ async function showPermissionPrompt(
 
       return {
         render(width: number): string[] {
-          const innerW = width - 4;
+          const innerW = Math.max(1, width - 4);
           const lines: string[] = [];
-          const border = theme.fg('border', '│');
           const dim = (s: string) => theme.fg('dim', s);
-          const borderFg = (s: string) => theme.fg('border', s);
-
-          // Top border with title
-          const label = ' Sandbox ';
-          const topLeft = borderFg('╭─');
-          const topRight = borderFg('─╮');
-          const topFill = borderFg('─'.repeat(Math.max(0, width - 4 - visibleWidth(label))));
-          lines.push(`${topLeft}${theme.fg('accent', label)}${topFill}${topRight}`);
-
-          // Blank spacing
-          lines.push(`${border} ${' '.repeat(innerW)} ${border}`);
 
-          // Title line
-          const titleText = truncateToWidth(theme.fg('warning', title), innerW);
-          const titlePad = Math.max(0, innerW - visibleWidth(titleText));
-          lines.push(`${border} ${titleText}${' '.repeat(titlePad)} ${border}`);
-
-          lines.push(`${border} ${' '.repeat(innerW)} ${border}`);
+          lines.push(boxTop(theme, width, 'Sandbox'));
+          lines.push(boxRow(theme, width));
+          lines.push(boxRow(theme, width, theme.fg('warning', title)));
+          lines.push(boxRow(theme, width));
 
           // Options
           for (let i = 0; i < options.length; i++) {
@@ -629,11 +633,11 @@ async function showPermissionPrompt(
 
             // Section divider before the permanent options (index 2 and 3)
             if (i === 2) {
-              lines.push(`${border} ${' '.repeat(innerW)} ${border}`);
+              lines.push(boxRow(theme, width));
               const secLabel = ' Permanent ';
               const secDash = '─'.repeat(Math.max(0, innerW - visibleWidth(secLabel)));
-              lines.push(`${border} ${dim(secDash + secLabel)} ${border}`);
-              lines.push(`${border} ${' '.repeat(innerW)} ${border}`);
+              lines.push(boxRow(theme, width, dim(secDash + secLabel)));
+              lines.push(boxRow(theme, width));
             }
 
             // Key badge
@@ -668,25 +672,16 @@ async function showPermissionPrompt(
             }
 
             const fullLine = ` ${cursor} ${keyBadge} ${label}${hint}`;
-            const line = truncateToWidth(fullLine, innerW);
-            const pad = Math.max(0, innerW - visibleWidth(line));
-            lines.push(`${border} ${line}${' '.repeat(pad)} ${border}`);
+            lines.push(boxRow(theme, width, fullLine));
           }
 
           // Footer
-          lines.push(`${border} ${' '.repeat(innerW)} ${border}`);
+          lines.push(boxRow(theme, width));
           const footerText = pendingAction
             ? '↑↓ navigate  enter confirm  esc cancel'
             : '↑↓ navigate  enter select  esc dismiss';
-          const footerLine = dim(footerText);
-          const footerPad = Math.max(0, innerW - visibleWidth(footerLine));
-          lines.push(`${border} ${footerLine}${' '.repeat(footerPad)} ${border}`);
-
-          // Bottom border
-          const botLeft = borderFg('╰');
-          const botRight = borderFg('╯');
-          const botFill = borderFg('─'.repeat(width - 2));
-          lines.push(`${botLeft}${botFill}${botRight}`);
+          lines.push(boxRow(theme, width, dim(footerText)));
+          lines.push(boxBottom(theme, width));
 
           return lines;
         },
@@ -896,18 +891,15 @@ export function createLandstripIntegration(
     sessionAllowedWritePaths.length = 0;
   }
 
-  function getEffectiveAllowedDomains(cwd: string): string[] {
-    const config = loadConfig(cwd);
+  function getEffectiveAllowedDomains(config: SandboxConfig): string[] {
     return [...config.network.allowedDomains, ...sessionAllowedDomains];
   }
 
-  function getEffectiveAllowRead(cwd: string): string[] {
-    const config = loadConfig(cwd);
+  function getEffectiveAllowRead(config: SandboxConfig): string[] {
     return [...config.filesystem.allowRead, ...sessionAllowedReadPaths];
   }
 
-  function getEffectiveAllowWrite(cwd: string): string[] {
-    const config = loadConfig(cwd);
+  function getEffectiveAllowWrite(config: SandboxConfig): string[] {
     return [...config.filesystem.allowWrite, ...sessionAllowedWritePaths];
   }
 
@@ -952,7 +944,7 @@ export function createLandstripIntegration(
     const config = loadConfig(cwd);
 
     if (domainMatchesAny(domain, config.network.deniedDomains)) return false;
-    if (domainMatchesAny(domain, getEffectiveAllowedDomains(cwd))) return true;
+    if (domainMatchesAny(domain, getEffectiveAllowedDomains(config))) return true;
 
     const choice = await promptDomainBlock(ctx, domain);
     if (choice === 'abort') return false;
@@ -974,8 +966,8 @@ export function createLandstripIntegration(
       },
       filesystem: {
         denyRead: config.filesystem.denyRead,
-        allowRead: getEffectiveAllowRead(cwd),
-        allowWrite: getEffectiveAllowWrite(cwd),
+        allowRead: getEffectiveAllowRead(config),
+        allowWrite: getEffectiveAllowWrite(config),
         denyWrite: config.filesystem.denyWrite,
       },
     };
@@ -1219,7 +1211,6 @@ export function createLandstripIntegration(
             }
 
             signal?.addEventListener('abort', onAbort, { once: true });
-            const resolvedQueryIds = new Set<number>();
             let stderrAcc = '';
             let errorFdAcc = '';
 
@@ -1232,109 +1223,70 @@ export function createLandstripIntegration(
             trapSocket.on('data', (data: Buffer) => {
               errorFdAcc += data.toString('utf8');
               callbacks.onErrorFd?.(data);
-              // Process query traps in real-time.
-              if (ctx.hasUI) {
-                const traps = parseLandstripTraps(errorFdAcc);
-                for (const trap of traps) {
-                  if (
-                    trap.kind === 'filesystem' &&
-                    (trap.operation === 'write' || trap.operation === 'read') &&
-                    'state' in trap &&
-                    (trap as any).state === 'query' &&
-                    'query_id' in trap
-                  ) {
-                    const queryId = (trap as any).query_id as number;
-                    if (!resolvedQueryIds.has(queryId)) {
-                      resolvedQueryIds.add(queryId);
-                      handleFsQuery(trapSocket, queryId, trap.operation, trap.file, cwd, ctx).catch(
-                        () => {},
-                      );
-                    }
-                  }
-                }
-              }
             });
 
-            async function handleFsQuery(
-              socket: NetSocket,
-              queryId: number,
-              operation: 'read' | 'write',
-              file: string,
-              cwd: string,
-              ctx: ExtensionContext,
-            ): Promise<void> {
-              const choice =
-                operation === 'read'
-                  ? await promptReadBlock(ctx, file)
-                  : await promptWriteBlock(ctx, file);
-              if (choice !== 'abort') {
-                if (operation === 'read') await applyReadChoice(choice, file, cwd);
-                else await applyWriteChoice(choice, file, cwd);
-              }
-              const action = choice === 'abort' ? 'deny' : 'allow';
-              const response = JSON.stringify({ query_id: queryId, action }) + '\n';
-              if (!socket.destroyed) {
-                socket.write(response);
-              }
-            }
-
             child.on('error', (error) => {
               cleanup();
               reject(error);
             });
 
-            child.on('close', async (code) => {
-              cleanup();
-              if (signal?.aborted) {
-                reject(new Error('aborted'));
-                return;
-              }
-              if (timedOut) {
-                reject(new Error(`timeout:${timeout}`));
-                return;
-              }
-
-              const errorOutput = errorFdAcc || stderrAcc;
-
-              const blockedPath =
-                extractBlockedPath(errorOutput, cwd) ??
-                (errorFdAcc ? extractBlockedPath(stderrAcc, cwd) : null);
-              const blockedWritePath =
-                extractBlockedWritePath(errorOutput, cwd) ??
-                (errorFdAcc ? extractBlockedWritePath(stderrAcc, cwd) : null);
-              if (blockedPath && ctx.hasUI) {
-                const config = loadConfig(cwd);
-                const isDeniedByDenyRead = matchesPattern(blockedPath, config.filesystem.denyRead);
-                const isReadAllowed = matchesPattern(blockedPath, getEffectiveAllowRead(cwd));
-                const isWriteAllowed = !shouldPromptForWrite(
-                  blockedPath,
-                  getEffectiveAllowWrite(cwd),
-                  matchesPattern,
-                );
+            child.on('close', (code) => {
+              void (async () => {
+                cleanup();
+                if (signal?.aborted) {
+                  reject(new Error('aborted'));
+                  return;
+                }
+                if (timedOut) {
+                  reject(new Error(`timeout:${timeout}`));
+                  return;
+                }
 
-                if (blockedWritePath === blockedPath && !isWriteAllowed) {
-                  const choice = await promptWriteBlock(ctx, blockedPath);
-                  if (choice !== 'abort') await applyWriteChoice(choice, blockedPath, cwd);
-                } else if (isDeniedByDenyRead || !isReadAllowed) {
-                  const choice = await promptReadBlock(
-                    ctx,
+                const errorOutput = errorFdAcc || stderrAcc;
+
+                const blockedPath =
+                  extractBlockedPath(errorOutput, cwd) ??
+                  (errorFdAcc ? extractBlockedPath(stderrAcc, cwd) : null);
+                const blockedWritePath =
+                  extractBlockedWritePath(errorOutput, cwd) ??
+                  (errorFdAcc ? extractBlockedWritePath(stderrAcc, cwd) : null);
+                if (blockedPath && ctx.hasUI && callbacks.promptOnBlock) {
+                  const config = loadConfig(cwd);
+                  const isDeniedByDenyRead = matchesPattern(
                     blockedPath,
-                    isDeniedByDenyRead ? 'granting allowRead will override it' : undefined,
+                    config.filesystem.denyRead,
                   );
-                  if (choice !== 'abort') await applyReadChoice(choice, blockedPath, cwd);
-                } else if (!isWriteAllowed) {
-                  const choice = await promptWriteBlock(ctx, blockedPath);
-                  if (choice !== 'abort') await applyWriteChoice(choice, blockedPath, cwd);
-                }
-              } else if (!blockedPath && ctx.hasUI) {
-                const landstripErrors = parseLandstripTraps(errorOutput);
-                if (landstripErrors.length > 0) {
-                  const formatted = formatLandstripTraps(landstripErrors);
-                  notify(ctx, `Sandbox blocked an operation: ${formatted}`, 'warning');
+                  const isReadAllowed = matchesPattern(blockedPath, getEffectiveAllowRead(config));
+                  const isWriteAllowed = !shouldPromptForWrite(
+                    blockedPath,
+                    getEffectiveAllowWrite(config),
+                    matchesPattern,
+                  );
+
+                  if (blockedWritePath === blockedPath && !isWriteAllowed) {
+                    const choice = await promptWriteBlock(ctx, blockedPath);
+                    if (choice !== 'abort') await applyWriteChoice(choice, blockedPath, cwd);
+                  } else if (isDeniedByDenyRead || !isReadAllowed) {
+                    const choice = await promptReadBlock(
+                      ctx,
+                      blockedPath,
+                      isDeniedByDenyRead ? 'granting allowRead will override it' : undefined,
+                    );
+                    if (choice !== 'abort') await applyReadChoice(choice, blockedPath, cwd);
+                  } else if (!isWriteAllowed) {
+                    const choice = await promptWriteBlock(ctx, blockedPath);
+                    if (choice !== 'abort') await applyWriteChoice(choice, blockedPath, cwd);
+                  }
+                } else if (!blockedPath && ctx.hasUI) {
+                  const landstripErrors = parseLandstripTraps(errorOutput);
+                  if (landstripErrors.length > 0) {
+                    const formatted = formatLandstripTraps(landstripErrors);
+                    notify(ctx, `Sandbox blocked an operation: ${formatted}`, 'warning');
+                  }
                 }
-              }
 
-              resolvePromise({ exitCode: code });
+                resolvePromise({ exitCode: code });
+              })().catch(reject);
             });
           })().catch(reject);
         });
@@ -1380,7 +1332,7 @@ export function createLandstripIntegration(
         return null;
       }
 
-      if (shouldPromptForWrite(blockedPath, getEffectiveAllowWrite(ctx.cwd), matchesPattern)) {
+      if (shouldPromptForWrite(blockedPath, getEffectiveAllowWrite(config), matchesPattern)) {
         const choice = await promptWriteBlock(ctx, blockedPath);
         if (choice === 'abort') return null;
         await applyWriteChoice(choice, blockedPath, ctx.cwd);
@@ -1412,8 +1364,8 @@ export function createLandstripIntegration(
     ): Promise<AgentToolResult<BashToolDetails | undefined> | null> => {
       if (!ctx.hasUI) return null;
 
-      if (!matchesPattern(blockedPath, getEffectiveAllowRead(ctx.cwd))) {
-        const config = loadConfig(ctx.cwd);
+      const config = loadConfig(ctx.cwd);
+      if (!matchesPattern(blockedPath, getEffectiveAllowRead(config))) {
         const choice = await promptReadBlock(
           ctx,
           blockedPath,
@@ -1648,7 +1600,7 @@ export function createLandstripIntegration(
         }
       }
 
-      return { operations: createLandstripBashOps(ctx) };
+      return { operations: createLandstripBashOps(ctx, { promptOnBlock: true }) };
     });
 
     pi.on('tool_call', async (event, ctx) => {
@@ -1672,7 +1624,7 @@ export function createLandstripIntegration(
 
       if (isToolCallEventType('read', event)) {
         const filePath = canonicalizePath(event.input.path);
-        if (!matchesPattern(filePath, getEffectiveAllowRead(ctx.cwd))) {
+        if (!matchesPattern(filePath, getEffectiveAllowRead(config))) {
           const choice = await promptReadBlock(ctx, filePath);
           if (choice === 'abort') {
             return {
@@ -1696,7 +1648,7 @@ export function createLandstripIntegration(
           };
         }
 
-        if (shouldPromptForWrite(filePath, getEffectiveAllowWrite(ctx.cwd), matchesPattern)) {
+        if (shouldPromptForWrite(filePath, getEffectiveAllowWrite(config), matchesPattern)) {
           const choice = await promptWriteBlock(ctx, filePath);
           if (choice === 'abort') {
             return {
@@ -1742,7 +1694,6 @@ export function createLandstripIntegration(
             const muted = (s: string) => theme.fg('muted', s);
             const accent = (s: string) => theme.fg('accent', s);
             const text = (s: string) => theme.fg('text', s);
-            const borderFg = (s: string) => theme.fg('border', s);
 
             function sandboxStatus(): { color: 'success' | 'warning'; label: string } {
               if (noSandboxFlag) return { color: 'warning', label: 'Disabled (--no-sandbox)' };
@@ -1755,29 +1706,16 @@ export function createLandstripIntegration(
               return v ? theme.fg('warning', 'yes') : theme.fg('success', 'no');
             }
 
-            function makeRow(content: string, innerW: number, border: string): string {
-              const line = truncateToWidth(content, innerW);
-              const pad = Math.max(0, innerW - visibleWidth(line));
-              return `${border} ${line}${' '.repeat(pad)} ${border}`;
-            }
-
             return {
               render(width: number): string[] {
                 const innerW = Math.max(1, width - 4);
-                const border = borderFg('│');
-                const row = (content: string) => makeRow(content, innerW, border);
+                const row = (content = '') => boxRow(theme, width, content);
                 const lines: string[] = [];
                 const status = sandboxStatus();
                 const toggleValue = config.enabled
                   ? theme.fg('success', 'enabled')
                   : theme.fg('warning', 'disabled');
 
-                function topBorder(titleText: string): string {
-                  const title = accent(` ${titleText} `);
-                  const fill = borderFg('─'.repeat(Math.max(0, width - 4 - visibleWidth(title))));
-                  return `${borderFg('╭─')}${title}${fill}${borderFg('─╮')}`;
-                }
-
                 function section(titleText: string, detail?: string): void {
                   lines.push(row(''));
                   lines.push(row(`${accent(titleText)}${detail ? dim(` · ${detail}`) : ''}`));
@@ -1792,7 +1730,7 @@ export function createLandstripIntegration(
                   return text(truncateToWidth(value, Math.max(10, maxWidth)));
                 }
 
-                lines.push(topBorder('Sandbox'));
+                lines.push(boxTop(theme, width, 'Sandbox'));
 
                 const statusDot = theme.fg(status.color, '●');
                 const pathSnippet = text(truncateToWidth(binaryPath(), Math.max(20, innerW - 28)));
@@ -1834,9 +1772,7 @@ export function createLandstripIntegration(
                     `${dim('t')} ${muted('toggle persisted setting')}  ${dim('esc')} ${muted('close')}`,
                   ),
                 );
-                lines.push(
-                  `${borderFg('╰')}${borderFg('─'.repeat(Math.max(0, width - 2)))}${borderFg('╯')}`,
-                );
+                lines.push(boxBottom(theme, width));
 
                 return lines;
               },

package/package.json

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