opencode-landstrip 0.15.14 → 0.15.16

package/index.ts

@@ -22,6 +22,8 @@ import {
   loadConfig,
   normalizeOptions,
   parseLandstripTraps,
+  permissionPatterns,
+  permissionType,
   readDiscoveryPort,
 } from './shared.js';
 
@@ -269,23 +271,6 @@ function isBlockedByDenyRead(path: string, config: SandboxConfig, baseDirectory:
   return matchesPattern(path, config.filesystem.denyRead, baseDirectory);
 }
 
-function firstBlockedDomain(
-  command: string,
-  config: SandboxConfig,
-): { domain: string; reason: 'allowedDomains' | 'deniedDomains' } | null {
-  for (const domain of extractDomainsFromCommand(command)) {
-    if (domainMatchesAny(domain, config.network.deniedDomains)) {
-      return { domain, reason: 'deniedDomains' };
-    }
-
-    if (!domainMatchesAny(domain, config.network.allowedDomains)) {
-      return { domain, reason: 'allowedDomains' };
-    }
-  }
-
-  return null;
-}
-
 function evaluateReadPermission(
   path: string,
   config: SandboxConfig,
@@ -754,27 +739,12 @@ const plugin: Plugin = async ({ client, directory }: PluginInput, options?: Plug
   const optionOverrides = normalizeOptions(options);
   const activeBash = new Map<string, BashSandboxState>();
   const notified = new Set<string>();
-  const sessionAllowedReadPaths: string[] = [];
-  const sessionAllowedWritePaths: string[] = [];
-  const sessionAllowedDomains: string[] = [];
   const callAllowances = new Set<string>();
   let enabledNotified = false;
   let sandboxDisabled = false;
   let configuredShell: string | undefined;
   let landstripCheck: { ok: true; version: string } | { ok: false; reason: string } | undefined;
 
-  function getEffectiveAllowRead(config: SandboxConfig): string[] {
-    return [...config.filesystem.allowRead, ...sessionAllowedReadPaths];
-  }
-
-  function getEffectiveAllowWrite(config: SandboxConfig): string[] {
-    return [...config.filesystem.allowWrite, ...sessionAllowedWritePaths];
-  }
-
-  function getEffectiveAllowedDomains(config: SandboxConfig): string[] {
-    return [...config.network.allowedDomains, ...sessionAllowedDomains];
-  }
-
   function allowanceKey(callID: string, kind: SandboxPermissionKind, resource: string): string {
     return `${callID}:${kind}:${resource}`;
   }
@@ -791,8 +761,7 @@ const plugin: Plugin = async ({ client, directory }: PluginInput, options?: Plug
     return callAllowances.has(allowanceKey(callID, decision.kind, decision.resource));
   }
 
-  function enforcePermission(callID: string, decision: SandboxPermissionDecision): void {
-    if (decision.status === 'allow' || hasCallAllowance(callID, decision)) return;
+  function reportBlocked(decision: SandboxPermissionDecision): never {
     client.tui
       ?.showToast?.({
         body: {
@@ -805,6 +774,11 @@ const plugin: Plugin = async ({ client, directory }: PluginInput, options?: Plug
     throw errorWithConfigPaths(directory, decision.message);
   }
 
+  function enforcePermission(callID: string, decision: SandboxPermissionDecision): void {
+    if (decision.status === 'allow' || hasCallAllowance(callID, decision)) return;
+    reportBlocked(decision);
+  }
+
   function pushCommandText(
     input: { sessionID: string },
     output: { parts: unknown[] },
@@ -822,11 +796,11 @@ const plugin: Plugin = async ({ client, directory }: PluginInput, options?: Plug
   function sandboxSummary(config: SandboxConfig): string {
     const { globalPath, projectPath } = getConfigPaths(directory);
     const networkMode = config.network.allowNetwork ? 'unrestricted' : 'proxied';
-    const allowed = getEffectiveAllowedDomains(config).join(', ') || '(none)';
+    const allowed = config.network.allowedDomains.join(', ') || '(none)';
     const denied = config.network.deniedDomains.join(', ') || '(none)';
     const denyRead = config.filesystem.denyRead.join(', ') || '(none)';
-    const allowRead = getEffectiveAllowRead(config).join(', ') || '(none)';
-    const allowWrite = getEffectiveAllowWrite(config).join(', ') || '(none)';
+    const allowRead = config.filesystem.allowRead.join(', ') || '(none)';
+    const allowWrite = config.filesystem.allowWrite.join(', ') || '(none)';
     const denyWrite = config.filesystem.denyWrite.join(', ') || '(none)';
 
     return [
@@ -1050,7 +1024,7 @@ const plugin: Plugin = async ({ client, directory }: PluginInput, options?: Plug
     const callAllowedDomains: string[] = [];
     const effectiveConfig = {
       ...config,
-      network: { ...config.network, allowedDomains: getEffectiveAllowedDomains(config) },
+      network: { ...config.network },
     };
 
     if (!allowNetwork) {
@@ -1114,14 +1088,7 @@ const plugin: Plugin = async ({ client, directory }: PluginInput, options?: Plug
       if (!config) return;
 
       const request = input as Record<string, unknown>;
-      const permission =
-        typeof request.type === 'string'
-          ? request.type
-          : typeof request.permission === 'string'
-            ? request.permission
-            : typeof request.action === 'string'
-              ? request.action
-              : '';
+      const permission = permissionType(request);
       const metadata = isRecord(request.metadata) ? request.metadata : {};
       const tool = isRecord(request.tool) ? request.tool : undefined;
       const callID =
@@ -1130,17 +1097,11 @@ const plugin: Plugin = async ({ client, directory }: PluginInput, options?: Plug
           : typeof tool?.callID === 'string'
             ? tool.callID
             : undefined;
-      const patterns = Array.isArray(request.patterns)
-        ? request.patterns.filter((item): item is string => typeof item === 'string')
-        : typeof request.pattern === 'string'
-          ? [request.pattern]
-          : Array.isArray(request.resources)
-            ? request.resources.filter((item): item is string => typeof item === 'string')
-            : [];
+      const patterns = permissionPatterns(request);
 
       const decisions: SandboxPermissionDecision[] = [];
-      const effectiveAllowRead = getEffectiveAllowRead(config);
-      const effectiveAllowWrite = getEffectiveAllowWrite(config);
+      const effectiveAllowRead = config.filesystem.allowRead;
+      const effectiveAllowWrite = config.filesystem.allowWrite;
 
       if (permission === 'read') {
         for (const pattern of patterns) {
@@ -1189,8 +1150,8 @@ const plugin: Plugin = async ({ client, directory }: PluginInput, options?: Plug
       const config = await activeConfig();
       if (!config) return;
 
-      const effectiveAllowRead = getEffectiveAllowRead(config);
-      const effectiveAllowWrite = getEffectiveAllowWrite(config);
+      const effectiveAllowRead = config.filesystem.allowRead;
+      const effectiveAllowWrite = config.filesystem.allowWrite;
 
       if (input.tool === 'bash') {
         await prepareBash(input.callID, output.args, config);
@@ -1373,23 +1334,12 @@ const plugin: Plugin = async ({ client, directory }: PluginInput, options?: Plug
         const config = await activeConfig();
         if (!config) return;
 
-        const effectiveAllowRead = getEffectiveAllowRead(config);
-        const effectiveAllowWrite = getEffectiveAllowWrite(config);
+        const effectiveAllowRead = config.filesystem.allowRead;
+        const effectiveAllowWrite = config.filesystem.allowWrite;
 
         for (const path of extractCandidatePaths(shellCommand)) {
           const readDecision = evaluateReadPermission(path, config, directory, effectiveAllowRead);
-          if (readDecision.status === 'deny') {
-            client.tui
-              ?.showToast?.({
-                body: {
-                  title: 'Sandbox blocked',
-                  message: readDecision.message.slice(0, 120),
-                  variant: 'error',
-                },
-              })
-              ?.catch?.(() => undefined);
-            throw errorWithConfigPaths(directory, readDecision.message);
-          }
+          if (readDecision.status === 'deny') reportBlocked(readDecision);
 
           const writeDecision = evaluateWritePermission(
             path,
@@ -1397,44 +1347,13 @@ const plugin: Plugin = async ({ client, directory }: PluginInput, options?: Plug
             directory,
             effectiveAllowWrite,
           );
-          if (writeDecision.status === 'deny') {
-            client.tui
-              ?.showToast?.({
-                body: {
-                  title: 'Sandbox blocked',
-                  message: writeDecision.message.slice(0, 120),
-                  variant: 'error',
-                },
-              })
-              ?.catch?.(() => undefined);
-            throw errorWithConfigPaths(directory, writeDecision.message);
-          }
+          if (writeDecision.status === 'deny') reportBlocked(writeDecision);
         }
 
         if (!config.network.allowNetwork) {
-          const effectiveConfig = {
-            ...config,
-            network: { ...config.network, allowedDomains: getEffectiveAllowedDomains(config) },
-          };
-          const blockedDomain = firstBlockedDomain(shellCommand, effectiveConfig);
-          if (blockedDomain) {
-            const reason =
-              blockedDomain.reason === 'deniedDomains'
-                ? 'is blocked by network.deniedDomains'
-                : 'is not in network.allowedDomains';
-            client.tui
-              ?.showToast?.({
-                body: {
-                  title: 'Sandbox blocked',
-                  message: `Network access denied for "${blockedDomain.domain}"`,
-                  variant: 'error',
-                },
-              })
-              ?.catch?.(() => undefined);
-            throw errorWithConfigPaths(
-              directory,
-              `Sandbox: network access denied for "${blockedDomain.domain}" (${reason}).`,
-            );
+          for (const domain of extractDomainsFromCommand(shellCommand)) {
+            const decision = evaluateDomainPermission(domain, config);
+            if (decision.status !== 'allow') reportBlocked(decision);
           }
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-landstrip",
-  "version": "0.15.14",
+  "version": "0.15.16",
   "description": "Landlock-based sandboxing for opencode with landstrip",
   "keywords": [
     "landlock",

package/sandbox.json

@@ -10,7 +10,7 @@
   },
   "filesystem": {
     "denyRead": ["/Users", "/home"],
-    "allowRead": [".", "~/.gitconfig", "/dev/null"],
+    "allowRead": [".", "~/.gitconfig", "~/.config/git/config", "/dev/null"],
     "allowWrite": [".", "/dev/null"],
     "denyWrite": ["**/.env", "**/.env.*", "**/*.pem", "**/*.key"]
   }

package/shared.ts

@@ -48,7 +48,7 @@ export const DEFAULT_CONFIG: SandboxConfig = {
   },
   filesystem: {
     denyRead: ['/Users', '/home'],
-    allowRead: ['.', '~/.gitconfig', '/dev/null'],
+    allowRead: ['.', '~/.gitconfig', '~/.config/git/config', '/dev/null'],
     allowWrite: ['.', '/dev/null'],
     denyWrite: ['**/.env', '**/.env.*', '**/*.pem', '**/*.key'],
   },
@@ -267,6 +267,28 @@ export function permissionPattern(permission: Record<string, unknown>): string |
   return undefined;
 }
 
+/**
+ * Every string pattern a permission carries, in declaration order, read from
+ * `patterns`, `pattern`, or `resources`. The plural complement to
+ * {@link permissionPattern} for callers that must inspect all patterns.
+ */
+export function permissionPatterns(permission: Record<string, unknown>): string[] {
+  const patterns = permission.patterns;
+  if (Array.isArray(patterns))
+    return patterns.filter((item): item is string => typeof item === 'string');
+
+  const pattern = permission.pattern;
+  if (typeof pattern === 'string') return [pattern];
+  if (Array.isArray(pattern))
+    return pattern.filter((item): item is string => typeof item === 'string');
+
+  const resources = permission.resources;
+  if (Array.isArray(resources))
+    return resources.filter((item): item is string => typeof item === 'string');
+
+  return [];
+}
+
 export function permissionLabel(permission: Record<string, unknown>): string {
   const type = permissionType(permission, 'permission');
   const title = typeof permission.title === 'string' ? permission.title : type;