opencode-landstrip 0.17.34 → 0.17.35

package/index.ts

@@ -15,7 +15,7 @@ import {
   type Socket,
 } from 'node:net';
 import { homedir, tmpdir } from 'node:os';
-import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+import { basename, dirname, isAbsolute, join, parse, resolve, sep } from 'node:path';
 import { URL } from 'node:url';
 
 import {
@@ -138,9 +138,16 @@ function canonicalizeGlobPath(pattern: string, baseDirectory: string): string {
   const wildcardIndex = abs.indexOf('*');
   if (wildcardIndex === -1) return canonicalizePath(abs, baseDirectory);
 
-  const prefixEnd = abs.lastIndexOf('/', wildcardIndex);
-  const prefix = prefixEnd === 0 ? '/' : abs.slice(0, prefixEnd);
-  return canonicalizePath(prefix, baseDirectory) + abs.slice(prefixEnd);
+  const prefixEnd = abs.lastIndexOf(sep, wildcardIndex);
+  const root = parse(abs).root;
+  const wildcardAtRoot = prefixEnd < root.length;
+  const prefix = wildcardAtRoot ? root : abs.slice(0, prefixEnd);
+  const suffixStart = wildcardAtRoot ? root.length : prefixEnd;
+  return canonicalizePath(prefix, baseDirectory) + abs.slice(suffixStart);
+}
+
+function normalizePathForMatch(filePath: string): string {
+  return process.platform === 'win32' ? filePath.replaceAll('\\', '/').toLowerCase() : filePath;
 }
 
 const globRegExpCache = new Map<string, RegExp>();
@@ -192,17 +199,17 @@ function pathDepth(absolutePath: string): number {
 // none match. A glob is anchored to the whole path, so it ranks at the path's
 // own depth; a literal pattern ranks at the depth of the prefix it covers.
 function matchDepth(filePath: string, patterns: string[], baseDirectory: string): number {
-  const abs = canonicalizePath(filePath, baseDirectory);
+  const abs = normalizePathForMatch(canonicalizePath(filePath, baseDirectory));
   let depth = -1;
 
   for (const pattern of patterns) {
     if (pattern.includes('*')) {
-      const absPattern = canonicalizeGlobPath(pattern, baseDirectory);
+      const absPattern = normalizePathForMatch(canonicalizeGlobPath(pattern, baseDirectory));
       if (globToRegExp(absPattern).test(abs)) depth = Math.max(depth, pathDepth(abs));
     } else {
-      const absPattern = canonicalizePath(pattern, baseDirectory);
-      const sep = absPattern.endsWith('/') ? '' : '/';
-      if (abs === absPattern || abs.startsWith(absPattern + sep)) {
+      const absPattern = normalizePathForMatch(canonicalizePath(pattern, baseDirectory));
+      const separator = absPattern.endsWith('/') ? '' : '/';
+      if (abs === absPattern || abs.startsWith(absPattern + separator)) {
         depth = Math.max(depth, pathDepth(absPattern));
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-landstrip",
-  "version": "0.17.34",
+  "version": "0.17.35",
   "description": "Landlock-based sandboxing for opencode with landstrip",
   "keywords": [
     "landlock",
@@ -48,7 +48,7 @@
     "ci:test": "npm test"
   },
   "dependencies": {
-    "@landstrip/landstrip": "^0.17.34",
+    "@landstrip/landstrip": "^0.17.35",
     "@opentui/solid": ">=0.3.4",
     "solid-js": "1.9.12"
   },

package/shared.ts

@@ -15,7 +15,7 @@ import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
+import { dirname, isAbsolute, join, relative, sep } from 'node:path';
 
 export interface SandboxFilesystemConfig {
   denyRead: string[];
@@ -61,9 +61,8 @@ const LANDSTRIP_PACKAGE_NAMES = new Set([
 // is approved for the broadest reasonable ancestor (e.g. `~/.cargo`, not each
 // subcrate file), so a single approval covers sibling files under the same tree.
 export function pathUnderDirectory(filePath: string, dir: string): boolean {
-  if (filePath === dir) return true;
-  const sep = dir.endsWith('/') ? '' : '/';
-  return filePath.startsWith(dir + sep);
+  const child = relative(dir, filePath);
+  return child === '' || (!isAbsolute(child) && child !== '..' && !child.startsWith(`..${sep}`));
 }
 
 export function sessionAllows(prefixes: Set<string>, filePath: string): boolean {
@@ -81,25 +80,32 @@ export function sessionAllows(prefixes: Set<string>, filePath: string): boolean
 export function sessionScopeFor(filePath: string, baseDirectory: string): string {
   const dir = dirname(filePath);
   const home = homedir();
-  const boundaries = new Set<string>();
-  if (home) boundaries.add(home);
+  const homeBoundaries = new Set<string>([home]);
   try {
-    const realHome = realpathSync.native(home);
-    if (realHome) boundaries.add(realHome);
+    homeBoundaries.add(realpathSync.native(home));
   } catch {
     // $HOME not resolvable — fall back to the raw value only.
   }
 
-  for (const boundary of boundaries) {
+  for (const boundary of homeBoundaries) {
     if (pathUnderDirectory(dir, boundary)) {
-      const rest = dir.slice(boundary.length).replace(/^\/+/, '');
-      const first = rest.split('/')[0];
+      const first = relative(boundary, dir).split(sep)[0];
       if (!first) return filePath;
-      return boundary.endsWith('/') ? boundary + first : `${boundary}/${first}`;
+      return join(boundary, first);
     }
   }
 
-  if (pathUnderDirectory(dir, baseDirectory)) return baseDirectory;
+  const projectBoundaries = new Set<string>([baseDirectory]);
+  try {
+    projectBoundaries.add(realpathSync.native(baseDirectory));
+  } catch {
+    // Project directory not resolvable — fall back to the raw value only.
+  }
+
+  for (const boundary of projectBoundaries) {
+    if (pathUnderDirectory(dir, boundary)) return boundary;
+  }
+
   return dir;
 }