pi-landstrip 0.15.6 → 0.15.8

package/index.ts

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: MIT
 // Copyright (C) Jarkko Sakkinen 2026
 
-/// <reference path="./landstrip.d.ts" />
-
 import type {
   AgentToolResult,
   AgentToolUpdateCallback,
@@ -10,6 +8,7 @@ import type {
   BashToolInput,
   ExtensionAPI,
   ExtensionContext,
+  Theme,
 } from '@earendil-works/pi-coding-agent';
 
 import { binaryPath } from '@landstrip/landstrip';
@@ -69,6 +68,15 @@ interface SandboxConfig {
   filesystem: SandboxFilesystemConfig;
 }
 
+type SandboxFilesystemConfigFile = Partial<SandboxFilesystemConfig>;
+type SandboxNetworkConfigFile = Partial<SandboxNetworkConfig>;
+
+interface SandboxConfigFile {
+  enabled?: boolean;
+  network?: SandboxNetworkConfigFile;
+  filesystem?: SandboxFilesystemConfigFile;
+}
+
 type SandboxConfigScope = 'global' | 'project';
 
 interface LandstripPolicy {
@@ -95,6 +103,7 @@ type LandstripTrap =
 interface LandstripBashCallbacks {
   onStderr?: (data: Buffer) => void;
   onErrorFd?: (data: Buffer) => void;
+  promptOnBlock?: boolean;
 }
 
 const LANDSTRIP_VERSION = [0, 15, 9] as const;
@@ -153,8 +162,8 @@ function loadConfig(cwd: string): SandboxConfig {
   const projectConfigPath = join(cwd, '.pi', 'sandbox.json');
   const globalConfigPath = join(getAgentDir(), 'sandbox.json');
 
-  let globalConfig: Partial<SandboxConfig> = {};
-  let projectConfig: Partial<SandboxConfig> = {};
+  let globalConfig: SandboxConfigFile = {};
+  let projectConfig: SandboxConfigFile = {};
 
   if (existsSync(globalConfigPath)) {
     try {
@@ -180,7 +189,7 @@ function mergeArray(base: string[], override?: string[]): string[] {
   return [...new Set([...base, ...override])];
 }
 
-function deepMerge(base: SandboxConfig, overrides: Partial<SandboxConfig>): SandboxConfig {
+function deepMerge(base: SandboxConfig, overrides: SandboxConfigFile): SandboxConfig {
   const network = overrides.network;
   const filesystem = overrides.filesystem;
 
@@ -210,7 +219,7 @@ function getConfigPaths(cwd: string): { globalPath: string; projectPath: string
   };
 }
 
-function readOrEmptyConfig(configPath: string): Partial<SandboxConfig> {
+function readOrEmptyConfig(configPath: string): SandboxConfigFile {
   if (!existsSync(configPath)) return {};
   try {
     return JSON.parse(readFileSync(configPath, 'utf-8'));
@@ -219,7 +228,7 @@ function readOrEmptyConfig(configPath: string): Partial<SandboxConfig> {
   }
 }
 
-function writeConfigFile(configPath: string, config: Partial<SandboxConfig>): void {
+function writeConfigFile(configPath: string, config: SandboxConfigFile): void {
   mkdirSync(dirname(configPath), { recursive: true });
   writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
 }
@@ -253,7 +262,7 @@ async function addDomainToConfig(configPath: string, domain: string): Promise<vo
       ...config.network,
       allowedDomains: [...existing, domain],
       deniedDomains: config.network?.deniedDomains ?? [],
-    } as SandboxNetworkConfig;
+    };
     writeConfigFile(configPath, config);
   });
 }
@@ -267,7 +276,7 @@ async function addReadPathToConfig(configPath: string, pathToAdd: string): Promi
     config.filesystem = {
       ...config.filesystem,
       allowRead: [...existing, pathToAdd],
-    } as SandboxFilesystemConfig;
+    };
     writeConfigFile(configPath, config);
   });
 }
@@ -281,7 +290,7 @@ async function addWritePathToConfig(configPath: string, pathToAdd: string): Prom
     config.filesystem = {
       ...config.filesystem,
       allowWrite: [...existing, pathToAdd],
-    } as SandboxFilesystemConfig;
+    };
     writeConfigFile(configPath, config);
   });
 }
@@ -362,7 +371,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 +449,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 +586,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 +623,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 +640,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 +679,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;
         },
@@ -821,21 +823,25 @@ function proxyEnv(env: NodeJS.ProcessEnv | undefined, port: number): NodeJS.Proc
   };
 }
 
+function parseProxyPort(value: string | undefined, defaultPort: number): number | null {
+  const rawPort = value ?? String(defaultPort);
+  if (!/^\d+$/.test(rawPort)) return null;
+
+  const port = Number(rawPort);
+  return port >= 1 && port <= 65535 ? port : null;
+}
+
 function splitHostPort(target: string, defaultPort: number): { host: string; port: number } | null {
-  const bracketMatch = target.match(/^\[([^\]]+)\](?::(\d+))?$/);
+  const bracketMatch = target.match(/^\[([^\]]+)\](?::(.*))?$/);
   if (bracketMatch) {
-    return {
-      host: bracketMatch[1],
-      port: bracketMatch[2] ? Number(bracketMatch[2]) : defaultPort,
-    };
+    const port = parseProxyPort(bracketMatch[2], defaultPort);
+    return port === null ? null : { host: bracketMatch[1], port };
   }
 
   const lastColon = target.lastIndexOf(':');
   if (lastColon > -1 && target.indexOf(':') === lastColon) {
-    return {
-      host: target.slice(0, lastColon),
-      port: Number(target.slice(lastColon + 1)),
-    };
+    const port = parseProxyPort(target.slice(lastColon + 1), defaultPort);
+    return port === null ? null : { host: target.slice(0, lastColon), port };
   }
 
   return { host: target, port: defaultPort };
@@ -858,20 +864,28 @@ function pipeSockets(client: Socket, upstream: Socket, initialData?: Buffer): vo
 
 type LandstripBashTool = ReturnType<typeof createBashToolDefinition>;
 
+/** Options for creating a landstrip sandbox integration. */
 export interface LandstripIntegrationOptions {
+  /** Register a sandboxed bash tool when the integration is registered. */
   registerBashTool?: boolean;
+  /** Working directory used when registering the default bash tool. */
   cwd?: string;
 }
 
+/** Landstrip sandbox integration hooks for Pi. */
 export interface LandstripIntegration {
+  /** Create a bash tool definition that runs commands through landstrip when enabled. */
   createBashTool(cwd: string, ctx?: ExtensionContext): LandstripBashTool;
+  /** Register the integration's tools, events, flags, and commands with Pi. */
   register(pi: ExtensionAPI): void;
 }
 
+/** Register the landstrip extension with Pi. */
 export default function (pi: ExtensionAPI) {
   createLandstripIntegration().register(pi);
 }
 
+/** Create a landstrip integration for registration or custom embedding. */
 export function createLandstripIntegration(
   options: LandstripIntegrationOptions = {},
 ): LandstripIntegration {
@@ -896,18 +910,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 +963,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 +985,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,
       },
     };
@@ -1045,7 +1056,13 @@ export function createLandstripIntegration(
           denyProxyRequest(client, '400 Bad Request');
           return;
         }
-        url = new URL(`http://${host}${rawTarget}`);
+
+        try {
+          url = new URL(`http://${host}${rawTarget}`);
+        } catch {
+          denyProxyRequest(client, '400 Bad Request');
+          return;
+        }
       }
 
       if (!(await ensureDomainAllowed(ctx, url.hostname, cwd))) {
@@ -1053,7 +1070,12 @@ export function createLandstripIntegration(
         return;
       }
 
-      const port = Number(url.port || (url.protocol === 'https:' ? 443 : 80));
+      const defaultPort = url.protocol === 'https:' ? 443 : 80;
+      const port = parseProxyPort(url.port || undefined, defaultPort);
+      if (port === null) {
+        denyProxyRequest(client, '400 Bad Request');
+        return;
+      }
       const path = `${url.pathname}${url.search}` || '/';
       lines[0] = `${method} ${path} ${version}`;
 
@@ -1219,7 +1241,6 @@ export function createLandstripIntegration(
             }
 
             signal?.addEventListener('abort', onAbort, { once: true });
-            const resolvedQueryIds = new Set<number>();
             let stderrAcc = '';
             let errorFdAcc = '';
 
@@ -1232,109 +1253,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 +1362,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 +1394,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 +1630,7 @@ export function createLandstripIntegration(
         }
       }
 
-      return { operations: createLandstripBashOps(ctx) };
+      return { operations: createLandstripBashOps(ctx, { promptOnBlock: true }) };
     });
 
     pi.on('tool_call', async (event, ctx) => {
@@ -1672,7 +1654,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 +1678,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 +1724,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 +1736,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 +1760,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 +1802,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.8",
   "description": "Landlock-based sandboxing for pi with interactive permission prompts",
   "keywords": [
     "landstrip",