pi-landstrip 0.11.8 → 0.11.10

package/README.md

@@ -23,21 +23,20 @@ Project config takes precedence.
 
 See [`sandbox.json`](./sandbox.json) for a starter config.
 
-Use Pi settings to toggle sandboxing:
+Use sandbox config to toggle sandboxing:
 
 ```json
 {
-  "landstrip": {
-    "enabled": false
-  }
+  "enabled": false
 }
 ```
 
-Project Pi settings override global Pi settings.
+Project config overrides global config.
+The `/sandbox` UI updates the project config when present, otherwise the global config.
 
 ## Usage
 
-Use `/sandbox` inside Pi to show the active config.
+Use `/sandbox` inside Pi to show the active config and toggle sandboxing.
 
 ## License
 

package/index.ts

@@ -62,11 +62,7 @@ interface SandboxConfig {
   filesystem: SandboxFilesystemConfig;
 }
 
-interface PiLandstripSettings {
-  landstrip?: {
-    enabled?: boolean;
-  };
-}
+type SandboxConfigScope = 'global' | 'project';
 
 interface LandstripPolicy {
   network: {
@@ -190,14 +186,6 @@ function loadConfig(cwd: string): SandboxConfig {
   return deepMerge(deepMerge(DEFAULT_CONFIG, globalConfig), projectConfig);
 }
 
-function isSandboxEnabledInPiSettings(cwd: string): boolean {
-  const settings = SettingsManager.create(cwd);
-  const globalSettings = settings.getGlobalSettings() as PiLandstripSettings;
-  const projectSettings = settings.getProjectSettings() as PiLandstripSettings;
-
-  return projectSettings.landstrip?.enabled ?? globalSettings.landstrip?.enabled ?? true;
-}
-
 function mergeArray(base: string[], override?: string[]): string[] {
   if (!override) return base;
   return [...new Set([...base, ...override])];
@@ -247,6 +235,25 @@ function writeConfigFile(configPath: string, config: Partial<SandboxConfig>): vo
   writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
 }
 
+function getSandboxConfigWriteTarget(cwd: string): { scope: SandboxConfigScope; path: string } {
+  const { globalPath, projectPath } = getConfigPaths(cwd);
+  const projectConfig = readOrEmptyConfig(projectPath);
+
+  if (projectConfig.enabled !== undefined) return { scope: 'project', path: projectPath };
+  return { scope: 'global', path: globalPath };
+}
+
+async function setSandboxConfigEnabled(cwd: string, enabled: boolean): Promise<SandboxConfigScope> {
+  const { scope, path } = getSandboxConfigWriteTarget(cwd);
+  await withFileMutationQueue(path, async () => {
+    const config = readOrEmptyConfig(path);
+    config.enabled = enabled;
+    writeConfigFile(path, config);
+  });
+
+  return scope;
+}
+
 async function addDomainToConfig(configPath: string, domain: string): Promise<void> {
   await withFileMutationQueue(configPath, async () => {
     const config = readOrEmptyConfig(configPath);
@@ -1457,11 +1464,6 @@ export function createLandstripIntegration(
       return false;
     }
 
-    if (!isSandboxEnabledInPiSettings(ctx.cwd)) {
-      disableSandbox(ctx);
-      return false;
-    }
-
     const config = loadConfig(ctx.cwd);
     if (!config.enabled) {
       disableSandbox(ctx);
@@ -1592,12 +1594,6 @@ export function createLandstripIntegration(
         return;
       }
 
-      if (!isSandboxEnabledInPiSettings(ctx.cwd)) {
-        disableSandbox(ctx);
-        notify(ctx, 'Sandbox disabled via pi settings', 'info');
-        return;
-      }
-
       const config = loadConfig(ctx.cwd);
       if (!config.enabled) {
         disableSandbox(ctx);
@@ -1610,12 +1606,8 @@ export function createLandstripIntegration(
     maybePi.registerCommand?.('sandbox', {
       description: 'Show sandbox configuration',
       handler: async (_args, ctx) => {
-        if (!sandboxEnabled) {
-          notify(ctx, 'Sandbox is disabled', 'info');
-          return;
-        }
+        let config = loadConfig(ctx.cwd);
 
-        const config = loadConfig(ctx.cwd);
         const { globalPath, projectPath } = getConfigPaths(ctx.cwd);
 
         if (!ctx.hasUI) return;
@@ -1627,6 +1619,13 @@ export function createLandstripIntegration(
             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)' };
+              if (!config.enabled) return { color: 'warning', label: 'Disabled' };
+              if (!sandboxEnabled || !sandboxReady) return { color: 'warning', label: 'Inactive' };
+              return { color: 'success', label: 'Active' };
+            }
+
             function boolVal(v: boolean): string {
               return v ? theme.fg('warning', 'yes') : theme.fg('success', 'no');
             }
@@ -1639,120 +1638,110 @@ export function createLandstripIntegration(
 
             return {
               render(width: number): string[] {
-                const innerW = width - 4;
+                const innerW = Math.max(1, width - 4);
                 const border = borderFg('│');
-                const row = (c: string) => makeRow(c, innerW, border);
+                const row = (content: string) => makeRow(content, innerW, border);
                 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('─╮')}`;
+                }
 
-                // Top border
-                const title = accent(' Sandbox Configuration ');
-                const topFill = borderFg('─'.repeat(Math.max(0, width - 4 - visibleWidth(title))));
-                lines.push(`${borderFg('╭─')}${title}${topFill}${borderFg('─╮')}`);
+                function section(titleText: string, detail?: string): void {
+                  lines.push(row(''));
+                  lines.push(row(`${accent(titleText)}${detail ? dim(` · ${detail}`) : ''}`));
+                }
 
-                // Status
-                const statusDot = theme.fg('success', '●');
-                const pathSnippet = text(truncateToWidth(binaryPath(), Math.max(20, innerW - 27)));
-                lines.push(
-                  row(
-                    `  ${statusDot} ${text('Active')}  ${dim('·')}  ${muted('landstrip:')} ${pathSnippet}`,
-                  ),
-                );
+                function item(label: string, value: string): void {
+                  lines.push(row(`  ${dim('•')} ${muted(label.padEnd(13))} ${value}`));
+                }
 
-                // Config files
-                lines.push(row(`  ${dim('Config files:')}`));
-                lines.push(row(`    ${dim('project')} ${text(projectPath)}`));
-                lines.push(row(`    ${dim('global')}  ${text(globalPath)}`));
+                function listValue(values: string[], maxWidth: number): string {
+                  const value = values.join(', ') || 'none';
+                  return text(truncateToWidth(value, Math.max(10, maxWidth)));
+                }
 
-                // Network section
-                lines.push(row(''));
-                lines.push(row(`${'─'.repeat(innerW)}`));
-                const netMode = config.network.allowNetwork ? ' (unrestricted)' : ' (proxied)';
-                lines.push(row(`  ${accent('Network')}${dim(netMode)}`));
-                lines.push(
-                  row(
-                    `  ${dim('•')} ${muted('Allow network:')} ${boolVal(config.network.allowNetwork)}`,
-                  ),
-                );
-                const domainsStr = config.network.allowedDomains.join(', ') || '(none)';
-                lines.push(
-                  row(
-                    `  ${dim('•')} ${muted('Allowed:')} ${text(truncateToWidth(domainsStr, Math.max(10, innerW - 15)))}`,
-                  ),
-                );
-                const denyStr = config.network.deniedDomains.join(', ') || '(none)';
+                lines.push(topBorder('Sandbox'));
+
+                const statusDot = theme.fg(status.color, '●');
+                const pathSnippet = text(truncateToWidth(binaryPath(), Math.max(20, innerW - 28)));
                 lines.push(
                   row(
-                    `  ${dim('•')} ${muted('Denied:')} ${text(truncateToWidth(denyStr, Math.max(10, innerW - 14)))}`,
+                    `${statusDot} ${text(status.label)} ${dim('·')} persisted ${toggleValue} ${dim('·')} ${muted('landstrip')} ${pathSnippet}`,
                   ),
                 );
-                if (sessionAllowedDomains.length > 0) {
-                  lines.push(
-                    row(
-                      `  ${dim('•')} ${muted('Session:')} ${theme.fg('accent', sessionAllowedDomains.join(', '))}`,
-                    ),
-                  );
+
+                section('Config');
+                item('project', text(projectPath));
+                item('global', text(globalPath));
+
+                const netMode = config.network.allowNetwork ? 'unrestricted' : 'proxied';
+                section('Network', netMode);
+                item('allow network', boolVal(config.network.allowNetwork));
+                item('allowed', listValue(config.network.allowedDomains, innerW - 17));
+                item('denied', listValue(config.network.deniedDomains, innerW - 17));
+                if (sessionAllowedDomains.length > 0)
+                  item('session', theme.fg('accent', sessionAllowedDomains.join(', ')));
+
+                section('Filesystem');
+                item('deny read', listValue(config.filesystem.denyRead, innerW - 17));
+                item('allow read', listValue(config.filesystem.allowRead, innerW - 17));
+                item('allow write', listValue(config.filesystem.allowWrite, innerW - 17));
+                item('deny write', listValue(config.filesystem.denyWrite, innerW - 17));
+
+                if (sessionAllowedReadPaths.length > 0 || sessionAllowedWritePaths.length > 0) {
+                  section('Session grants');
+                  if (sessionAllowedReadPaths.length > 0)
+                    item('read', theme.fg('accent', sessionAllowedReadPaths.join(', ')));
+                  if (sessionAllowedWritePaths.length > 0)
+                    item('write', theme.fg('accent', sessionAllowedWritePaths.join(', ')));
                 }
 
-                // Filesystem section
                 lines.push(row(''));
-                lines.push(row(`${'─'.repeat(innerW)}`));
-                lines.push(row(`  ${accent('Filesystem')}`));
-                const denyReadStr = config.filesystem.denyRead.join(', ') || '(none)';
                 lines.push(
                   row(
-                    `  ${dim('•')} ${muted('Deny read:')} ${text(truncateToWidth(denyReadStr, Math.max(10, innerW - 16)))}`,
+                    `${dim('t')} ${muted('toggle persisted setting')}  ${dim('esc')} ${muted('close')}`,
                   ),
                 );
-                const allowReadStr = config.filesystem.allowRead.join(', ') || '(none)';
                 lines.push(
-                  row(
-                    `  ${dim('•')} ${muted('Allow read:')} ${text(truncateToWidth(allowReadStr, Math.max(10, innerW - 17)))}`,
-                  ),
-                );
-                const allowWriteStr = config.filesystem.allowWrite.join(', ') || '(none)';
-                lines.push(
-                  row(
-                    `  ${dim('•')} ${muted('Allow write:')} ${text(truncateToWidth(allowWriteStr, Math.max(10, innerW - 18)))}`,
-                  ),
-                );
-                const denyWriteStr = config.filesystem.denyWrite.join(', ') || '(none)';
-                lines.push(
-                  row(
-                    `  ${dim('•')} ${muted('Deny write:')} ${text(truncateToWidth(denyWriteStr, Math.max(10, innerW - 17)))}`,
-                  ),
+                  `${borderFg('╰')}${borderFg('─'.repeat(Math.max(0, width - 2)))}${borderFg('╯')}`,
                 );
 
-                // Session allowances
-                if (sessionAllowedReadPaths.length > 0 || sessionAllowedWritePaths.length > 0) {
-                  lines.push(row(''));
-                  if (sessionAllowedReadPaths.length > 0) {
-                    lines.push(
-                      row(
-                        `  ${dim('•')} ${muted('Session read:')} ${theme.fg('accent', sessionAllowedReadPaths.join(', '))}`,
-                      ),
-                    );
-                  }
-                  if (sessionAllowedWritePaths.length > 0) {
-                    lines.push(
-                      row(
-                        `  ${dim('•')} ${muted('Session write:')} ${theme.fg('accent', sessionAllowedWritePaths.join(', '))}`,
-                      ),
-                    );
-                  }
-                }
-
-                // Footer
-                lines.push(row(''));
-                lines.push(row(`  ${dim('esc')} ${muted('or any key to close')}`));
-
-                // Bottom border
-                lines.push(`${borderFg('╰')}${borderFg('─'.repeat(width - 2))}${borderFg('╯')}`);
-
                 return lines;
               },
 
-              handleInput(): void {
-                done(undefined);
+              handleInput(data: string): void {
+                if (data !== 't' && data !== 'T') {
+                  done(undefined);
+                  return;
+                }
+
+                void (async () => {
+                  const enabled = !config.enabled;
+                  const scope = await setSandboxConfigEnabled(ctx.cwd, enabled);
+                  config = loadConfig(ctx.cwd);
+
+                  if (!enabled) {
+                    disableSandbox(ctx);
+                    notify(ctx, `Sandbox disabled in ${scope} config`, 'info');
+                  } else if (noSandboxFlag) {
+                    notify(ctx, 'Sandbox remains disabled via --no-sandbox', 'warning');
+                  } else if (!config.enabled) {
+                    notify(ctx, 'Sandbox remains disabled via config', 'info');
+                  } else if (enableSandbox(ctx)) {
+                    notify(ctx, `Sandbox enabled in ${scope} config`, 'info');
+                  }
+
+                  tui.requestRender();
+                })().catch((error: unknown) => {
+                  notify(ctx, `Could not update config: ${error}`, 'error');
+                });
               },
 
               invalidate(): void {},

package/package.json

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