shell-dsl 0.0.4 → 0.0.5

package/README.md

@@ -31,6 +31,7 @@ bun add shell-dsl memfs
 
 - **Sandboxed execution** — No host OS access; all commands run in-process
 - **Virtual filesystem** — Uses memfs for complete isolation from the real filesystem
+- **Real filesystem** — Optional sandboxed access to real files with path containment and permissions
 - **Explicit command registry** — Only registered commands can execute
 - **Automatic escaping** — Interpolated values are escaped by default for safety
 - **POSIX-inspired syntax** — Pipes, redirects, control flow operators, and more
@@ -509,6 +510,86 @@ interface VirtualFS {
 }
 ```
 
+## Real Filesystem Access
+
+For scenarios where you need to access the real filesystem with sandboxing, use `FileSystem` or `ReadOnlyFileSystem`:
+
+```ts
+import { createShellDSL, FileSystem } from "shell-dsl";
+import { builtinCommands } from "shell-dsl/commands";
+
+// Mount a directory with permission rules
+const fs = new FileSystem("./project", {
+  ".env": "excluded",           // Cannot read or write
+  ".git/**": "excluded",        // Block entire directory
+  "config/**": "read-only",     // Can read, cannot write
+  "src/**": "read-write",       // Full access (default)
+});
+
+const sh = createShellDSL({
+  fs,
+  cwd: "/",
+  env: {},
+  commands: builtinCommands,
+});
+
+await sh`cat /src/index.ts`.text();      // Works
+await sh`cat /.env`.text();              // Throws: excluded
+await sh`echo "x" > /config/app.json`;   // Throws: read-only
+```
+
+### Permission Types
+
+| Permission | Read | Write |
+|------------|------|-------|
+| `"read-write"` | Yes | Yes |
+| `"read-only"` | Yes | No |
+| `"excluded"` | No | No |
+
+### Rule Specificity
+
+When multiple rules match, the most specific wins:
+
+1. More path segments: `a/b/c` beats `a/b`
+2. Literal beats wildcard: `config/app.json` beats `config/*`
+3. Single wildcard beats double: `src/*` beats `src/**`
+
+```ts
+const fs = new FileSystem("./project", {
+  "**": "read-only",              // Default: read-only
+  "src/**": "read-write",         // Override for src/
+  "src/generated/**": "excluded", // But not generated files
+});
+```
+
+### ReadOnlyFileSystem
+
+Convenience class that defaults all paths to read-only:
+
+```ts
+import { ReadOnlyFileSystem } from "shell-dsl";
+
+const fs = new ReadOnlyFileSystem("./docs");
+
+// All writes blocked by default
+await fs.writeFile("/file.txt", "x");  // Throws: read-only
+
+// Can still exclude or allow specific paths
+const fs2 = new ReadOnlyFileSystem("./docs", {
+  "drafts/**": "read-write",  // Allow writes here
+  ".internal/**": "excluded", // Block completely
+});
+```
+
+### Full System Access
+
+Omit the mount path for unrestricted access, but this is the same as just passing `fs` from `node:fs`:
+
+```ts
+const fs = new FileSystem();  // Full filesystem access same as fs from node:fs
+```
+
+
 ## Low-Level API
 
 For advanced use cases (custom tooling, AST inspection):
@@ -570,6 +651,9 @@ import type {
   ExecResult,
   ShellConfig,
   RawValue,
+  Permission,
+  PermissionRules,
+  UnderlyingFS,
 } from "shell-dsl";
 ```
 

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "shell-dsl",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "type": "commonjs"
 }

package/dist/cjs/src/fs/index.cjs

@@ -29,9 +29,13 @@ var __export = (target, all) => {
 // src/fs/index.ts
 var exports_fs = {};
 __export(exports_fs, {
-  createVirtualFS: () => import_memfs_adapter.createVirtualFS
+  createVirtualFS: () => import_memfs_adapter.createVirtualFS,
+  ReadOnlyFileSystem: () => import_readonly_fs.ReadOnlyFileSystem,
+  FileSystem: () => import_real_fs.FileSystem
 });
 module.exports = __toCommonJS(exports_fs);
 var import_memfs_adapter = require("./memfs-adapter.cjs");
+var import_real_fs = require("./real-fs.cjs");
+var import_readonly_fs = require("./readonly-fs.cjs");
 
-//# debugId=EFC1FC4A0309E57D64756E2164756E21
+//# debugId=AC77355F139E98D864756E2164756E21

package/dist/cjs/src/fs/index.cjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../../src/fs/index.ts"],
   "sourcesContent": [
-    "export { createVirtualFS } from \"./memfs-adapter.cjs\";\n"
+    "export { createVirtualFS } from \"./memfs-adapter.cjs\";\nexport { FileSystem, type Permission, type PermissionRules, type UnderlyingFS } from \"./real-fs.cjs\";\nexport { ReadOnlyFileSystem } from \"./readonly-fs.cjs\";\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAgC,IAAhC;",
-  "debugId": "EFC1FC4A0309E57D64756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAgC,IAAhC;AACqF,IAArF;AACmC,IAAnC;",
+  "debugId": "AC77355F139E98D864756E2164756E21",
   "names": []
 }

package/dist/cjs/src/fs/readonly-fs.cjs

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/fs/readonly-fs.ts
+var exports_readonly_fs = {};
+__export(exports_readonly_fs, {
+  ReadOnlyFileSystem: () => ReadOnlyFileSystem
+});
+module.exports = __toCommonJS(exports_readonly_fs);
+var import_real_fs = require("./real-fs.cjs");
+
+class ReadOnlyFileSystem extends import_real_fs.FileSystem {
+  constructor(mountPath, permissions, fs) {
+    const mergedPermissions = {
+      "**": "read-only",
+      ...permissions
+    };
+    super(mountPath, mergedPermissions, fs);
+  }
+}
+
+//# debugId=EA698A711F5E3A5564756E2164756E21

package/dist/cjs/src/fs/readonly-fs.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/fs/readonly-fs.ts"],
+  "sourcesContent": [
+    "import { FileSystem, type PermissionRules, type UnderlyingFS } from \"./real-fs.cjs\";\n\nexport class ReadOnlyFileSystem extends FileSystem {\n  constructor(mountPath?: string, permissions?: PermissionRules, fs?: UnderlyingFS) {\n    // Merge user permissions with base read-only rule\n    const mergedPermissions: PermissionRules = {\n      \"**\": \"read-only\",\n      ...permissions,\n    };\n    super(mountPath, mergedPermissions, fs);\n  }\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAoE,IAApE;AAAA;AAEO,MAAM,2BAA2B,0BAAW;AAAA,EACjD,WAAW,CAAC,WAAoB,aAA+B,IAAmB;AAAA,IAEhF,MAAM,oBAAqC;AAAA,MACzC,MAAM;AAAA,SACH;AAAA,IACL;AAAA,IACA,MAAM,WAAW,mBAAmB,EAAE;AAAA;AAE1C;",
+  "debugId": "EA698A711F5E3A5564756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/fs/real-fs.cjs

@@ -0,0 +1,311 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/fs/real-fs.ts
+var exports_real_fs = {};
+__export(exports_real_fs, {
+  FileSystem: () => FileSystem
+});
+module.exports = __toCommonJS(exports_real_fs);
+var path = __toESM(require("path"));
+var nodeFs = __toESM(require("node:fs/promises"));
+var defaultFS = { promises: nodeFs };
+
+class FileSystem {
+  mountBase;
+  rules;
+  underlyingFs;
+  constructor(mountPath, permissions, fs) {
+    this.mountBase = mountPath ? path.resolve(mountPath) : null;
+    this.rules = this.compileRules(permissions ?? {});
+    this.underlyingFs = fs ?? defaultFS;
+  }
+  compileRules(permissions) {
+    return Object.entries(permissions).map(([pattern, permission]) => ({
+      pattern,
+      permission,
+      specificity: this.calculateSpecificity(pattern)
+    })).sort((a, b) => b.specificity - a.specificity);
+  }
+  calculateSpecificity(pattern) {
+    const segments = pattern.split("/").filter(Boolean);
+    let score = segments.length * 1000;
+    for (const seg of segments) {
+      if (seg === "**")
+        score += 0;
+      else if (seg.includes("*"))
+        score += 1;
+      else
+        score += 10;
+    }
+    return score;
+  }
+  getPermission(virtualPath) {
+    const normalized = virtualPath.replace(/^\/+/, "");
+    for (const rule of this.rules) {
+      if (this.matchGlob(rule.pattern, normalized)) {
+        return rule.permission;
+      }
+    }
+    return "read-write";
+  }
+  matchGlob(pattern, filePath) {
+    const regex = pattern.split("/").map((seg) => {
+      if (seg === "**")
+        return ".*";
+      return seg.replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+    }).join("/");
+    return new RegExp(`^${regex}$`).test(filePath);
+  }
+  checkPermission(virtualPath, operation) {
+    const perm = this.getPermission(virtualPath);
+    if (perm === "excluded") {
+      throw new Error(`Access denied: "${virtualPath}" is excluded`);
+    }
+    if (operation === "write" && perm === "read-only") {
+      throw new Error(`Access denied: "${virtualPath}" is read-only`);
+    }
+  }
+  resolveSafePath(virtualPath) {
+    if (this.mountBase === null) {
+      return path.resolve(virtualPath);
+    }
+    const segments = virtualPath.split("/").filter(Boolean);
+    let depth = 0;
+    for (const seg of segments) {
+      if (seg === "..") {
+        depth--;
+        if (depth < 0) {
+          throw new Error(`Path traversal blocked: "${virtualPath}" escapes mount point`);
+        }
+      } else if (seg !== ".") {
+        depth++;
+      }
+    }
+    const normalized = path.normalize(virtualPath);
+    const relativePath = normalized.startsWith("/") ? normalized.slice(1) : normalized;
+    const realPath = path.join(this.mountBase, relativePath);
+    const resolved = path.resolve(realPath);
+    if (!resolved.startsWith(this.mountBase + path.sep) && resolved !== this.mountBase) {
+      throw new Error(`Path traversal blocked: "${virtualPath}" escapes mount point`);
+    }
+    return resolved;
+  }
+  async readFile(filePath) {
+    this.checkPermission(filePath, "read");
+    const realPath = this.resolveSafePath(filePath);
+    const content = await this.underlyingFs.promises.readFile(realPath);
+    return Buffer.from(content);
+  }
+  async readdir(dirPath) {
+    this.checkPermission(dirPath, "read");
+    const realPath = this.resolveSafePath(dirPath);
+    const entries = await this.underlyingFs.promises.readdir(realPath);
+    return entries.map(String);
+  }
+  async stat(filePath) {
+    this.checkPermission(filePath, "read");
+    const realPath = this.resolveSafePath(filePath);
+    const stats = await this.underlyingFs.promises.stat(realPath);
+    return {
+      isFile: () => stats.isFile(),
+      isDirectory: () => stats.isDirectory(),
+      size: stats.size,
+      mtime: stats.mtime
+    };
+  }
+  async exists(filePath) {
+    try {
+      this.checkPermission(filePath, "read");
+      const realPath = this.resolveSafePath(filePath);
+      await this.underlyingFs.promises.stat(realPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async writeFile(filePath, data) {
+    this.checkPermission(filePath, "write");
+    const realPath = this.resolveSafePath(filePath);
+    await this.underlyingFs.promises.writeFile(realPath, data);
+  }
+  async appendFile(filePath, data) {
+    this.checkPermission(filePath, "write");
+    const realPath = this.resolveSafePath(filePath);
+    await this.underlyingFs.promises.appendFile(realPath, data);
+  }
+  async mkdir(dirPath, opts) {
+    this.checkPermission(dirPath, "write");
+    const realPath = this.resolveSafePath(dirPath);
+    await this.underlyingFs.promises.mkdir(realPath, opts);
+  }
+  async rm(filePath, opts) {
+    this.checkPermission(filePath, "write");
+    const realPath = this.resolveSafePath(filePath);
+    await this.underlyingFs.promises.rm(realPath, opts);
+  }
+  resolve(...paths) {
+    return path.resolve("/", ...paths);
+  }
+  dirname(filePath) {
+    return path.dirname(filePath);
+  }
+  basename(filePath) {
+    return path.basename(filePath);
+  }
+  async glob(pattern, opts) {
+    const cwd = opts?.cwd ?? "/";
+    this.checkPermission(cwd, "read");
+    const matches = await this.expandGlob(pattern, cwd);
+    return matches.filter((p) => this.getPermission(p) !== "excluded").sort();
+  }
+  async expandGlob(pattern, cwd) {
+    const patterns = this.expandBraces(pattern);
+    const allMatches = [];
+    for (const pat of patterns) {
+      const matches = await this.matchPattern(pat, cwd);
+      allMatches.push(...matches);
+    }
+    return [...new Set(allMatches)].sort();
+  }
+  expandBraces(pattern) {
+    const braceMatch = pattern.match(/\{([^{}]+)\}/);
+    if (!braceMatch)
+      return [pattern];
+    const before = pattern.slice(0, braceMatch.index);
+    const after = pattern.slice(braceMatch.index + braceMatch[0].length);
+    const options = braceMatch[1].split(",");
+    const results = [];
+    for (const opt of options) {
+      const expanded = this.expandBraces(before + opt + after);
+      results.push(...expanded);
+    }
+    return results;
+  }
+  async matchPattern(pattern, cwd) {
+    const parts = pattern.split("/").filter((p) => p !== "");
+    const isAbsolute = pattern.startsWith("/");
+    const startDir = isAbsolute ? "/" : cwd;
+    return this.matchParts(parts, startDir);
+  }
+  async matchParts(parts, currentPath) {
+    if (parts.length === 0) {
+      return [currentPath];
+    }
+    const [part, ...rest] = parts;
+    if (part === "**") {
+      const results = [];
+      const withoutStar = await this.matchParts(rest, currentPath);
+      results.push(...withoutStar);
+      try {
+        const realPath = this.resolveSafePath(currentPath);
+        const entries = await this.underlyingFs.promises.readdir(realPath);
+        for (const entry of entries) {
+          const entryPath = path.posix.join(currentPath, String(entry));
+          try {
+            const entryRealPath = this.resolveSafePath(entryPath);
+            const stat = await this.underlyingFs.promises.stat(entryRealPath);
+            if (stat.isDirectory()) {
+              const subMatches = await this.matchParts(parts, entryPath);
+              results.push(...subMatches);
+            }
+          } catch {}
+        }
+      } catch {}
+      return results;
+    }
+    const regex = this.globToRegex(part);
+    try {
+      const realPath = this.resolveSafePath(currentPath);
+      const entries = await this.underlyingFs.promises.readdir(realPath);
+      const results = [];
+      for (const entry of entries) {
+        const entryName = String(entry);
+        if (regex.test(entryName)) {
+          const entryPath = path.posix.join(currentPath, entryName);
+          if (rest.length === 0) {
+            results.push(entryPath);
+          } else {
+            try {
+              const entryRealPath = this.resolveSafePath(entryPath);
+              const stat = await this.underlyingFs.promises.stat(entryRealPath);
+              if (stat.isDirectory()) {
+                const subMatches = await this.matchParts(rest, entryPath);
+                results.push(...subMatches);
+              }
+            } catch {}
+          }
+        }
+      }
+      return results;
+    } catch {
+      return [];
+    }
+  }
+  globToRegex(pattern) {
+    let regex = "^";
+    for (let i = 0;i < pattern.length; i++) {
+      const char = pattern[i];
+      if (char === "*") {
+        regex += "[^/]*";
+      } else if (char === "?") {
+        regex += "[^/]";
+      } else if (char === "[") {
+        let j = i + 1;
+        let classContent = "";
+        while (j < pattern.length && pattern[j] !== "]") {
+          classContent += pattern[j];
+          j++;
+        }
+        regex += `[${classContent}]`;
+        i = j;
+      } else if (".+^${}()|\\".includes(char)) {
+        regex += "\\" + char;
+      } else {
+        regex += char;
+      }
+    }
+    regex += "$";
+    return new RegExp(regex);
+  }
+}
+
+//# debugId=FE5125D36453662C64756E2164756E21

package/dist/cjs/src/fs/real-fs.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/fs/real-fs.ts"],
+  "sourcesContent": [
+    "import * as path from \"path\";\nimport * as nodeFs from \"node:fs/promises\";\nimport type { VirtualFS, FileStat } from \"../types.cjs\";\n\nexport type Permission = \"read-write\" | \"read-only\" | \"excluded\";\nexport type PermissionRules = Record<string, Permission>;\n\n// Minimal interface for the underlying fs (compatible with node:fs and memfs)\nexport interface UnderlyingFS {\n  promises: {\n    readFile(path: string): Promise<Buffer | Uint8Array | string>;\n    readdir(path: string): Promise<string[]>;\n    stat(path: string): Promise<{\n      isFile(): boolean;\n      isDirectory(): boolean;\n      size: number;\n      mtime: Date;\n    }>;\n    writeFile(path: string, data: Buffer | string): Promise<void>;\n    appendFile(path: string, data: Buffer | string): Promise<void>;\n    mkdir(path: string, opts?: { recursive?: boolean }): Promise<string | undefined | void>;\n    rm(path: string, opts?: { recursive?: boolean; force?: boolean }): Promise<void>;\n  };\n}\n\n// Default: use real node:fs\nconst defaultFS: UnderlyingFS = { promises: nodeFs };\n\ninterface CompiledRule {\n  pattern: string;\n  permission: Permission;\n  specificity: number;\n}\n\nexport class FileSystem implements VirtualFS {\n  private readonly mountBase: string | null;\n  private readonly rules: CompiledRule[];\n  protected readonly underlyingFs: UnderlyingFS;\n\n  constructor(mountPath?: string, permissions?: PermissionRules, fs?: UnderlyingFS) {\n    this.mountBase = mountPath ? path.resolve(mountPath) : null;\n    this.rules = this.compileRules(permissions ?? {});\n    this.underlyingFs = fs ?? defaultFS;\n  }\n\n  private compileRules(permissions: PermissionRules): CompiledRule[] {\n    return Object.entries(permissions)\n      .map(([pattern, permission]) => ({\n        pattern,\n        permission,\n        specificity: this.calculateSpecificity(pattern),\n      }))\n      .sort((a, b) => b.specificity - a.specificity); // highest first\n  }\n\n  private calculateSpecificity(pattern: string): number {\n    const segments = pattern.split(\"/\").filter(Boolean);\n    let score = segments.length * 1000; // segment count is primary\n\n    for (const seg of segments) {\n      if (seg === \"**\") score += 0;\n      else if (seg.includes(\"*\")) score += 1;\n      else score += 10; // literal segment\n    }\n    return score;\n  }\n\n  protected getPermission(virtualPath: string): Permission {\n    const normalized = virtualPath.replace(/^\\/+/, \"\"); // strip leading slashes\n\n    for (const rule of this.rules) {\n      if (this.matchGlob(rule.pattern, normalized)) {\n        return rule.permission;\n      }\n    }\n    return \"read-write\"; // default\n  }\n\n  private matchGlob(pattern: string, filePath: string): boolean {\n    // Convert glob to regex\n    // ** matches any path segments, * matches within segment\n    const regex = pattern\n      .split(\"/\")\n      .map((seg) => {\n        if (seg === \"**\") return \".*\";\n        return seg.replace(/\\*/g, \"[^/]*\").replace(/\\?/g, \"[^/]\");\n      })\n      .join(\"/\");\n    return new RegExp(`^${regex}$`).test(filePath);\n  }\n\n  protected checkPermission(virtualPath: string, operation: \"read\" | \"write\"): void {\n    const perm = this.getPermission(virtualPath);\n\n    if (perm === \"excluded\") {\n      throw new Error(`Access denied: \"${virtualPath}\" is excluded`);\n    }\n    if (operation === \"write\" && perm === \"read-only\") {\n      throw new Error(`Access denied: \"${virtualPath}\" is read-only`);\n    }\n  }\n\n  private resolveSafePath(virtualPath: string): string {\n    if (this.mountBase === null) {\n      return path.resolve(virtualPath);\n    }\n\n    // Check for path traversal by tracking depth\n    const segments = virtualPath.split(\"/\").filter(Boolean);\n    let depth = 0;\n    for (const seg of segments) {\n      if (seg === \"..\") {\n        depth--;\n        if (depth < 0) {\n          throw new Error(`Path traversal blocked: \"${virtualPath}\" escapes mount point`);\n        }\n      } else if (seg !== \".\") {\n        depth++;\n      }\n    }\n\n    const normalized = path.normalize(virtualPath);\n    const relativePath = normalized.startsWith(\"/\") ? normalized.slice(1) : normalized;\n    const realPath = path.join(this.mountBase, relativePath);\n    const resolved = path.resolve(realPath);\n\n    // Double-check containment (defense in depth)\n    if (!resolved.startsWith(this.mountBase + path.sep) && resolved !== this.mountBase) {\n      throw new Error(`Path traversal blocked: \"${virtualPath}\" escapes mount point`);\n    }\n\n    return resolved;\n  }\n\n  // Read operations\n  async readFile(filePath: string): Promise<Buffer> {\n    this.checkPermission(filePath, \"read\");\n    const realPath = this.resolveSafePath(filePath);\n    const content = await this.underlyingFs.promises.readFile(realPath);\n    return Buffer.from(content);\n  }\n\n  async readdir(dirPath: string): Promise<string[]> {\n    this.checkPermission(dirPath, \"read\");\n    const realPath = this.resolveSafePath(dirPath);\n    const entries = await this.underlyingFs.promises.readdir(realPath);\n    return entries.map(String);\n  }\n\n  async stat(filePath: string): Promise<FileStat> {\n    this.checkPermission(filePath, \"read\");\n    const realPath = this.resolveSafePath(filePath);\n    const stats = await this.underlyingFs.promises.stat(realPath);\n    return {\n      isFile: () => stats.isFile(),\n      isDirectory: () => stats.isDirectory(),\n      size: stats.size,\n      mtime: stats.mtime,\n    };\n  }\n\n  async exists(filePath: string): Promise<boolean> {\n    try {\n      this.checkPermission(filePath, \"read\");\n      const realPath = this.resolveSafePath(filePath);\n      await this.underlyingFs.promises.stat(realPath);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  // Write operations\n  async writeFile(filePath: string, data: Buffer | string): Promise<void> {\n    this.checkPermission(filePath, \"write\");\n    const realPath = this.resolveSafePath(filePath);\n    await this.underlyingFs.promises.writeFile(realPath, data);\n  }\n\n  async appendFile(filePath: string, data: Buffer | string): Promise<void> {\n    this.checkPermission(filePath, \"write\");\n    const realPath = this.resolveSafePath(filePath);\n    await this.underlyingFs.promises.appendFile(realPath, data);\n  }\n\n  async mkdir(dirPath: string, opts?: { recursive?: boolean }): Promise<void> {\n    this.checkPermission(dirPath, \"write\");\n    const realPath = this.resolveSafePath(dirPath);\n    await this.underlyingFs.promises.mkdir(realPath, opts);\n  }\n\n  async rm(filePath: string, opts?: { recursive?: boolean; force?: boolean }): Promise<void> {\n    this.checkPermission(filePath, \"write\");\n    const realPath = this.resolveSafePath(filePath);\n    await this.underlyingFs.promises.rm(realPath, opts);\n  }\n\n  // Path utilities (no permission check needed)\n  resolve(...paths: string[]): string {\n    return path.resolve(\"/\", ...paths);\n  }\n\n  dirname(filePath: string): string {\n    return path.dirname(filePath);\n  }\n\n  basename(filePath: string): string {\n    return path.basename(filePath);\n  }\n\n  // Glob with permission filtering\n  async glob(pattern: string, opts?: { cwd?: string }): Promise<string[]> {\n    const cwd = opts?.cwd ?? \"/\";\n    this.checkPermission(cwd, \"read\");\n\n    const matches = await this.expandGlob(pattern, cwd);\n\n    // Filter out excluded paths\n    return matches.filter((p) => this.getPermission(p) !== \"excluded\").sort();\n  }\n\n  // Glob expansion (similar to memfs-adapter implementation)\n  private async expandGlob(pattern: string, cwd: string): Promise<string[]> {\n    // Handle brace expansion first\n    const patterns = this.expandBraces(pattern);\n    const allMatches: string[] = [];\n\n    for (const pat of patterns) {\n      const matches = await this.matchPattern(pat, cwd);\n      allMatches.push(...matches);\n    }\n\n    // Remove duplicates and sort\n    return [...new Set(allMatches)].sort();\n  }\n\n  private expandBraces(pattern: string): string[] {\n    const braceMatch = pattern.match(/\\{([^{}]+)\\}/);\n    if (!braceMatch) return [pattern];\n\n    const before = pattern.slice(0, braceMatch.index);\n    const after = pattern.slice(braceMatch.index! + braceMatch[0].length);\n    const options = braceMatch[1]!.split(\",\");\n\n    const results: string[] = [];\n    for (const opt of options) {\n      const expanded = this.expandBraces(before + opt + after);\n      results.push(...expanded);\n    }\n    return results;\n  }\n\n  private async matchPattern(pattern: string, cwd: string): Promise<string[]> {\n    const parts = pattern.split(\"/\").filter((p) => p !== \"\");\n    const isAbsolute = pattern.startsWith(\"/\");\n    const startDir = isAbsolute ? \"/\" : cwd;\n\n    return this.matchParts(parts, startDir);\n  }\n\n  private async matchParts(parts: string[], currentPath: string): Promise<string[]> {\n    if (parts.length === 0) {\n      return [currentPath];\n    }\n\n    const [part, ...rest] = parts;\n\n    // Handle ** (recursive glob)\n    if (part === \"**\") {\n      const results: string[] = [];\n\n      // Match current directory\n      const withoutStar = await this.matchParts(rest, currentPath);\n      results.push(...withoutStar);\n\n      // Recurse into subdirectories\n      try {\n        const realPath = this.resolveSafePath(currentPath);\n        const entries = await this.underlyingFs.promises.readdir(realPath);\n        for (const entry of entries) {\n          const entryPath = path.posix.join(currentPath, String(entry));\n          try {\n            const entryRealPath = this.resolveSafePath(entryPath);\n            const stat = await this.underlyingFs.promises.stat(entryRealPath);\n            if (stat.isDirectory()) {\n              const subMatches = await this.matchParts(parts, entryPath);\n              results.push(...subMatches);\n            }\n          } catch {\n            // Skip inaccessible entries\n          }\n        }\n      } catch {\n        // Directory not readable\n      }\n\n      return results;\n    }\n\n    // Handle regular glob patterns\n    const regex = this.globToRegex(part!);\n\n    try {\n      const realPath = this.resolveSafePath(currentPath);\n      const entries = await this.underlyingFs.promises.readdir(realPath);\n      const results: string[] = [];\n\n      for (const entry of entries) {\n        const entryName = String(entry);\n        if (regex.test(entryName)) {\n          const entryPath = path.posix.join(currentPath, entryName);\n          if (rest.length === 0) {\n            results.push(entryPath);\n          } else {\n            try {\n              const entryRealPath = this.resolveSafePath(entryPath);\n              const stat = await this.underlyingFs.promises.stat(entryRealPath);\n              if (stat.isDirectory()) {\n                const subMatches = await this.matchParts(rest, entryPath);\n                results.push(...subMatches);\n              }\n            } catch {\n              // Skip inaccessible entries\n            }\n          }\n        }\n      }\n\n      return results;\n    } catch {\n      return [];\n    }\n  }\n\n  private globToRegex(pattern: string): RegExp {\n    let regex = \"^\";\n    for (let i = 0; i < pattern.length; i++) {\n      const char = pattern[i]!;\n      if (char === \"*\") {\n        regex += \"[^/]*\";\n      } else if (char === \"?\") {\n        regex += \"[^/]\";\n      } else if (char === \"[\") {\n        // Character class\n        let j = i + 1;\n        let classContent = \"\";\n        while (j < pattern.length && pattern[j] !== \"]\") {\n          classContent += pattern[j];\n          j++;\n        }\n        regex += `[${classContent}]`;\n        i = j;\n      } else if (\".+^${}()|\\\\\".includes(char)) {\n        regex += \"\\\\\" + char;\n      } else {\n        regex += char;\n      }\n    }\n    regex += \"$\";\n    return new RegExp(regex);\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "FE5125D36453662C64756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/index.cjs

@@ -55,13 +55,15 @@ __export(exports_src, {
   ShellPromise: () => import_shell_promise.ShellPromise,
   ShellError: () => import_errors.ShellError,
   ShellDSL: () => import_shell_dsl.ShellDSL,
+  ReadOnlyFileSystem: () => import_fs2.ReadOnlyFileSystem,
   PipeBuffer: () => import_io2.PipeBuffer,
   Parser: () => import_parser.Parser,
   ParseError: () => import_errors.ParseError,
   OutputCollectorImpl: () => import_io2.OutputCollectorImpl,
   Lexer: () => import_lexer.Lexer,
   LexError: () => import_errors.LexError,
-  Interpreter: () => import_interpreter.Interpreter
+  Interpreter: () => import_interpreter.Interpreter,
+  FileSystem: () => import_fs2.FileSystem
 });
 module.exports = __toCommonJS(exports_src);
 var import_shell_dsl = require("./shell-dsl.cjs");
@@ -73,8 +75,9 @@ var import_parser = require("./parser/index.cjs");
 var import_parser2 = require("./parser/index.cjs");
 var import_interpreter = require("./interpreter/index.cjs");
 var import_fs = require("./fs/index.cjs");
+var import_fs2 = require("./fs/index.cjs");
 var import_io = require("./io/index.cjs");
 var import_io2 = require("./io/index.cjs");
 var import_utils = require("./utils/index.cjs");
 
-//# debugId=CA28B33C8C95E9F064756E2164756E21
+//# debugId=308511120A1E796164756E2164756E21

package/dist/cjs/src/index.cjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../src/index.ts"],
   "sourcesContent": [
-    "// Main class exports\nexport { ShellDSL, createShellDSL, type Program } from \"./shell-dsl.cjs\";\nexport { ShellPromise, type ShellPromiseOptions } from \"./shell-promise.cjs\";\n\n// Types\nexport type {\n  VirtualFS,\n  FileStat,\n  Command,\n  CommandContext,\n  Stdin,\n  Stdout,\n  Stderr,\n  OutputCollector,\n  ExecResult,\n  ShellConfig,\n  RawValue,\n} from \"./types.cjs\";\nexport { isRawValue } from \"./types.cjs\";\n\n// Errors\nexport { ShellError, LexError, ParseError } from \"./errors.cjs\";\n\n// Lexer\nexport { Lexer, lex, tokenToString } from \"./lexer/index.cjs\";\nexport type { Token, RedirectMode } from \"./lexer/index.cjs\";\n\n// Parser\nexport { Parser, parse } from \"./parser/index.cjs\";\nexport type {\n  ASTNode,\n  Redirect,\n  CommandNode,\n  PipelineNode,\n  AndNode,\n  OrNode,\n  SequenceNode,\n  LiteralNode,\n  VariableNode,\n  SubstitutionNode,\n  GlobNode,\n  ConcatNode,\n} from \"./parser/index.cjs\";\nexport {\n  isCommandNode,\n  isPipelineNode,\n  isAndNode,\n  isOrNode,\n  isSequenceNode,\n  isLiteralNode,\n  isVariableNode,\n  isSubstitutionNode,\n  isGlobNode,\n  isConcatNode,\n} from \"./parser/index.cjs\";\n\n// Interpreter\nexport { Interpreter, type InterpreterOptions } from \"./interpreter/index.cjs\";\n\n// Filesystem\nexport { createVirtualFS } from \"./fs/index.cjs\";\n\n// I/O\nexport { createStdin, StdinImpl } from \"./io/index.cjs\";\nexport { createStdout, createStderr, createPipe, OutputCollectorImpl, PipeBuffer } from \"./io/index.cjs\";\n\n// Utilities\nexport { escape, escapeForInterpolation } from \"./utils/index.cjs\";\n"
+    "// Main class exports\nexport { ShellDSL, createShellDSL, type Program } from \"./shell-dsl.cjs\";\nexport { ShellPromise, type ShellPromiseOptions } from \"./shell-promise.cjs\";\n\n// Types\nexport type {\n  VirtualFS,\n  FileStat,\n  Command,\n  CommandContext,\n  Stdin,\n  Stdout,\n  Stderr,\n  OutputCollector,\n  ExecResult,\n  ShellConfig,\n  RawValue,\n} from \"./types.cjs\";\nexport { isRawValue } from \"./types.cjs\";\n\n// Errors\nexport { ShellError, LexError, ParseError } from \"./errors.cjs\";\n\n// Lexer\nexport { Lexer, lex, tokenToString } from \"./lexer/index.cjs\";\nexport type { Token, RedirectMode } from \"./lexer/index.cjs\";\n\n// Parser\nexport { Parser, parse } from \"./parser/index.cjs\";\nexport type {\n  ASTNode,\n  Redirect,\n  CommandNode,\n  PipelineNode,\n  AndNode,\n  OrNode,\n  SequenceNode,\n  LiteralNode,\n  VariableNode,\n  SubstitutionNode,\n  GlobNode,\n  ConcatNode,\n} from \"./parser/index.cjs\";\nexport {\n  isCommandNode,\n  isPipelineNode,\n  isAndNode,\n  isOrNode,\n  isSequenceNode,\n  isLiteralNode,\n  isVariableNode,\n  isSubstitutionNode,\n  isGlobNode,\n  isConcatNode,\n} from \"./parser/index.cjs\";\n\n// Interpreter\nexport { Interpreter, type InterpreterOptions } from \"./interpreter/index.cjs\";\n\n// Filesystem\nexport { createVirtualFS } from \"./fs/index.cjs\";\nexport {\n  FileSystem,\n  ReadOnlyFileSystem,\n  type Permission,\n  type PermissionRules,\n  type UnderlyingFS,\n} from \"./fs/index.cjs\";\n\n// I/O\nexport { createStdin, StdinImpl } from \"./io/index.cjs\";\nexport { createStdout, createStderr, createPipe, OutputCollectorImpl, PipeBuffer } from \"./io/index.cjs\";\n\n// Utilities\nexport { escape, escapeForInterpolation } from \"./utils/index.cjs\";\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACuD,IAAvD;AACuD,IAAvD;AAgB2B,IAA3B;AAGiD,IAAjD;AAG0C,IAA1C;AAI8B,IAA9B;AA0BO,IAXP;AAcqD,IAArD;AAGgC,IAAhC;AAGuC,IAAvC;AACwF,IAAxF;AAG+C,IAA/C;",
-  "debugId": "CA28B33C8C95E9F064756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACuD,IAAvD;AACuD,IAAvD;AAgB2B,IAA3B;AAGiD,IAAjD;AAG0C,IAA1C;AAI8B,IAA9B;AA0BO,IAXP;AAcqD,IAArD;AAGgC,IAAhC;AAOO,IANP;AASuC,IAAvC;AACwF,IAAxF;AAG+C,IAA/C;",
+  "debugId": "308511120A1E796164756E2164756E21",
   "names": []
 }

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "shell-dsl",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "type": "module"
 }

package/dist/mjs/src/fs/index.mjs

@@ -1,7 +1,11 @@
 // src/fs/index.ts
 import { createVirtualFS } from "./memfs-adapter.mjs";
+import { FileSystem } from "./real-fs.mjs";
+import { ReadOnlyFileSystem } from "./readonly-fs.mjs";
 export {
-  createVirtualFS
+  createVirtualFS,
+  ReadOnlyFileSystem,
+  FileSystem
 };
 
-//# debugId=6662852DAB957AC264756E2164756E21
+//# debugId=1175A4F96BC2DD3F64756E2164756E21

package/dist/mjs/src/fs/index.mjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../../src/fs/index.ts"],
   "sourcesContent": [
-    "export { createVirtualFS } from \"./memfs-adapter.mjs\";\n"
+    "export { createVirtualFS } from \"./memfs-adapter.mjs\";\nexport { FileSystem, type Permission, type PermissionRules, type UnderlyingFS } from \"./real-fs.mjs\";\nexport { ReadOnlyFileSystem } from \"./readonly-fs.mjs\";\n"
   ],
-  "mappings": ";AAAA;",
-  "debugId": "6662852DAB957AC264756E2164756E21",
+  "mappings": ";AAAA;AACA;AACA;",
+  "debugId": "1175A4F96BC2DD3F64756E2164756E21",
   "names": []
 }

package/dist/mjs/src/fs/readonly-fs.mjs

@@ -0,0 +1,17 @@
+// src/fs/readonly-fs.ts
+import { FileSystem } from "./real-fs.mjs";
+
+class ReadOnlyFileSystem extends FileSystem {
+  constructor(mountPath, permissions, fs) {
+    const mergedPermissions = {
+      "**": "read-only",
+      ...permissions
+    };
+    super(mountPath, mergedPermissions, fs);
+  }
+}
+export {
+  ReadOnlyFileSystem
+};
+
+//# debugId=1565D7691D56BD6B64756E2164756E21

package/dist/mjs/src/fs/readonly-fs.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/fs/readonly-fs.ts"],
+  "sourcesContent": [
+    "import { FileSystem, type PermissionRules, type UnderlyingFS } from \"./real-fs.mjs\";\n\nexport class ReadOnlyFileSystem extends FileSystem {\n  constructor(mountPath?: string, permissions?: PermissionRules, fs?: UnderlyingFS) {\n    // Merge user permissions with base read-only rule\n    const mergedPermissions: PermissionRules = {\n      \"**\": \"read-only\",\n      ...permissions,\n    };\n    super(mountPath, mergedPermissions, fs);\n  }\n}\n"
+  ],
+  "mappings": ";AAAA;AAAA;AAEO,MAAM,2BAA2B,WAAW;AAAA,EACjD,WAAW,CAAC,WAAoB,aAA+B,IAAmB;AAAA,IAEhF,MAAM,oBAAqC;AAAA,MACzC,MAAM;AAAA,SACH;AAAA,IACL;AAAA,IACA,MAAM,WAAW,mBAAmB,EAAE;AAAA;AAE1C;",
+  "debugId": "1565D7691D56BD6B64756E2164756E21",
+  "names": []
+}

package/dist/mjs/src/fs/real-fs.mjs

@@ -0,0 +1,268 @@
+// src/fs/real-fs.ts
+import * as path from "path";
+import * as nodeFs from "node:fs/promises";
+var defaultFS = { promises: nodeFs };
+
+class FileSystem {
+  mountBase;
+  rules;
+  underlyingFs;
+  constructor(mountPath, permissions, fs) {
+    this.mountBase = mountPath ? path.resolve(mountPath) : null;
+    this.rules = this.compileRules(permissions ?? {});
+    this.underlyingFs = fs ?? defaultFS;
+  }
+  compileRules(permissions) {
+    return Object.entries(permissions).map(([pattern, permission]) => ({
+      pattern,
+      permission,
+      specificity: this.calculateSpecificity(pattern)
+    })).sort((a, b) => b.specificity - a.specificity);
+  }
+  calculateSpecificity(pattern) {
+    const segments = pattern.split("/").filter(Boolean);
+    let score = segments.length * 1000;
+    for (const seg of segments) {
+      if (seg === "**")
+        score += 0;
+      else if (seg.includes("*"))
+        score += 1;
+      else
+        score += 10;
+    }
+    return score;
+  }
+  getPermission(virtualPath) {
+    const normalized = virtualPath.replace(/^\/+/, "");
+    for (const rule of this.rules) {
+      if (this.matchGlob(rule.pattern, normalized)) {
+        return rule.permission;
+      }
+    }
+    return "read-write";
+  }
+  matchGlob(pattern, filePath) {
+    const regex = pattern.split("/").map((seg) => {
+      if (seg === "**")
+        return ".*";
+      return seg.replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+    }).join("/");
+    return new RegExp(`^${regex}$`).test(filePath);
+  }
+  checkPermission(virtualPath, operation) {
+    const perm = this.getPermission(virtualPath);
+    if (perm === "excluded") {
+      throw new Error(`Access denied: "${virtualPath}" is excluded`);
+    }
+    if (operation === "write" && perm === "read-only") {
+      throw new Error(`Access denied: "${virtualPath}" is read-only`);
+    }
+  }
+  resolveSafePath(virtualPath) {
+    if (this.mountBase === null) {
+      return path.resolve(virtualPath);
+    }
+    const segments = virtualPath.split("/").filter(Boolean);
+    let depth = 0;
+    for (const seg of segments) {
+      if (seg === "..") {
+        depth--;
+        if (depth < 0) {
+          throw new Error(`Path traversal blocked: "${virtualPath}" escapes mount point`);
+        }
+      } else if (seg !== ".") {
+        depth++;
+      }
+    }
+    const normalized = path.normalize(virtualPath);
+    const relativePath = normalized.startsWith("/") ? normalized.slice(1) : normalized;
+    const realPath = path.join(this.mountBase, relativePath);
+    const resolved = path.resolve(realPath);
+    if (!resolved.startsWith(this.mountBase + path.sep) && resolved !== this.mountBase) {
+      throw new Error(`Path traversal blocked: "${virtualPath}" escapes mount point`);
+    }
+    return resolved;
+  }
+  async readFile(filePath) {
+    this.checkPermission(filePath, "read");
+    const realPath = this.resolveSafePath(filePath);
+    const content = await this.underlyingFs.promises.readFile(realPath);
+    return Buffer.from(content);
+  }
+  async readdir(dirPath) {
+    this.checkPermission(dirPath, "read");
+    const realPath = this.resolveSafePath(dirPath);
+    const entries = await this.underlyingFs.promises.readdir(realPath);
+    return entries.map(String);
+  }
+  async stat(filePath) {
+    this.checkPermission(filePath, "read");
+    const realPath = this.resolveSafePath(filePath);
+    const stats = await this.underlyingFs.promises.stat(realPath);
+    return {
+      isFile: () => stats.isFile(),
+      isDirectory: () => stats.isDirectory(),
+      size: stats.size,
+      mtime: stats.mtime
+    };
+  }
+  async exists(filePath) {
+    try {
+      this.checkPermission(filePath, "read");
+      const realPath = this.resolveSafePath(filePath);
+      await this.underlyingFs.promises.stat(realPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async writeFile(filePath, data) {
+    this.checkPermission(filePath, "write");
+    const realPath = this.resolveSafePath(filePath);
+    await this.underlyingFs.promises.writeFile(realPath, data);
+  }
+  async appendFile(filePath, data) {
+    this.checkPermission(filePath, "write");
+    const realPath = this.resolveSafePath(filePath);
+    await this.underlyingFs.promises.appendFile(realPath, data);
+  }
+  async mkdir(dirPath, opts) {
+    this.checkPermission(dirPath, "write");
+    const realPath = this.resolveSafePath(dirPath);
+    await this.underlyingFs.promises.mkdir(realPath, opts);
+  }
+  async rm(filePath, opts) {
+    this.checkPermission(filePath, "write");
+    const realPath = this.resolveSafePath(filePath);
+    await this.underlyingFs.promises.rm(realPath, opts);
+  }
+  resolve(...paths) {
+    return path.resolve("/", ...paths);
+  }
+  dirname(filePath) {
+    return path.dirname(filePath);
+  }
+  basename(filePath) {
+    return path.basename(filePath);
+  }
+  async glob(pattern, opts) {
+    const cwd = opts?.cwd ?? "/";
+    this.checkPermission(cwd, "read");
+    const matches = await this.expandGlob(pattern, cwd);
+    return matches.filter((p) => this.getPermission(p) !== "excluded").sort();
+  }
+  async expandGlob(pattern, cwd) {
+    const patterns = this.expandBraces(pattern);
+    const allMatches = [];
+    for (const pat of patterns) {
+      const matches = await this.matchPattern(pat, cwd);
+      allMatches.push(...matches);
+    }
+    return [...new Set(allMatches)].sort();
+  }
+  expandBraces(pattern) {
+    const braceMatch = pattern.match(/\{([^{}]+)\}/);
+    if (!braceMatch)
+      return [pattern];
+    const before = pattern.slice(0, braceMatch.index);
+    const after = pattern.slice(braceMatch.index + braceMatch[0].length);
+    const options = braceMatch[1].split(",");
+    const results = [];
+    for (const opt of options) {
+      const expanded = this.expandBraces(before + opt + after);
+      results.push(...expanded);
+    }
+    return results;
+  }
+  async matchPattern(pattern, cwd) {
+    const parts = pattern.split("/").filter((p) => p !== "");
+    const isAbsolute = pattern.startsWith("/");
+    const startDir = isAbsolute ? "/" : cwd;
+    return this.matchParts(parts, startDir);
+  }
+  async matchParts(parts, currentPath) {
+    if (parts.length === 0) {
+      return [currentPath];
+    }
+    const [part, ...rest] = parts;
+    if (part === "**") {
+      const results = [];
+      const withoutStar = await this.matchParts(rest, currentPath);
+      results.push(...withoutStar);
+      try {
+        const realPath = this.resolveSafePath(currentPath);
+        const entries = await this.underlyingFs.promises.readdir(realPath);
+        for (const entry of entries) {
+          const entryPath = path.posix.join(currentPath, String(entry));
+          try {
+            const entryRealPath = this.resolveSafePath(entryPath);
+            const stat = await this.underlyingFs.promises.stat(entryRealPath);
+            if (stat.isDirectory()) {
+              const subMatches = await this.matchParts(parts, entryPath);
+              results.push(...subMatches);
+            }
+          } catch {}
+        }
+      } catch {}
+      return results;
+    }
+    const regex = this.globToRegex(part);
+    try {
+      const realPath = this.resolveSafePath(currentPath);
+      const entries = await this.underlyingFs.promises.readdir(realPath);
+      const results = [];
+      for (const entry of entries) {
+        const entryName = String(entry);
+        if (regex.test(entryName)) {
+          const entryPath = path.posix.join(currentPath, entryName);
+          if (rest.length === 0) {
+            results.push(entryPath);
+          } else {
+            try {
+              const entryRealPath = this.resolveSafePath(entryPath);
+              const stat = await this.underlyingFs.promises.stat(entryRealPath);
+              if (stat.isDirectory()) {
+                const subMatches = await this.matchParts(rest, entryPath);
+                results.push(...subMatches);
+              }
+            } catch {}
+          }
+        }
+      }
+      return results;
+    } catch {
+      return [];
+    }
+  }
+  globToRegex(pattern) {
+    let regex = "^";
+    for (let i = 0;i < pattern.length; i++) {
+      const char = pattern[i];
+      if (char === "*") {
+        regex += "[^/]*";
+      } else if (char === "?") {
+        regex += "[^/]";
+      } else if (char === "[") {
+        let j = i + 1;
+        let classContent = "";
+        while (j < pattern.length && pattern[j] !== "]") {
+          classContent += pattern[j];
+          j++;
+        }
+        regex += `[${classContent}]`;
+        i = j;
+      } else if (".+^${}()|\\".includes(char)) {
+        regex += "\\" + char;
+      } else {
+        regex += char;
+      }
+    }
+    regex += "$";
+    return new RegExp(regex);
+  }
+}
+export {
+  FileSystem
+};
+
+//# debugId=78CB3041E0AD3DDE64756E2164756E21

package/dist/mjs/src/fs/real-fs.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/fs/real-fs.ts"],
+  "sourcesContent": [
+    "import * as path from \"path\";\nimport * as nodeFs from \"node:fs/promises\";\nimport type { VirtualFS, FileStat } from \"../types.mjs\";\n\nexport type Permission = \"read-write\" | \"read-only\" | \"excluded\";\nexport type PermissionRules = Record<string, Permission>;\n\n// Minimal interface for the underlying fs (compatible with node:fs and memfs)\nexport interface UnderlyingFS {\n  promises: {\n    readFile(path: string): Promise<Buffer | Uint8Array | string>;\n    readdir(path: string): Promise<string[]>;\n    stat(path: string): Promise<{\n      isFile(): boolean;\n      isDirectory(): boolean;\n      size: number;\n      mtime: Date;\n    }>;\n    writeFile(path: string, data: Buffer | string): Promise<void>;\n    appendFile(path: string, data: Buffer | string): Promise<void>;\n    mkdir(path: string, opts?: { recursive?: boolean }): Promise<string | undefined | void>;\n    rm(path: string, opts?: { recursive?: boolean; force?: boolean }): Promise<void>;\n  };\n}\n\n// Default: use real node:fs\nconst defaultFS: UnderlyingFS = { promises: nodeFs };\n\ninterface CompiledRule {\n  pattern: string;\n  permission: Permission;\n  specificity: number;\n}\n\nexport class FileSystem implements VirtualFS {\n  private readonly mountBase: string | null;\n  private readonly rules: CompiledRule[];\n  protected readonly underlyingFs: UnderlyingFS;\n\n  constructor(mountPath?: string, permissions?: PermissionRules, fs?: UnderlyingFS) {\n    this.mountBase = mountPath ? path.resolve(mountPath) : null;\n    this.rules = this.compileRules(permissions ?? {});\n    this.underlyingFs = fs ?? defaultFS;\n  }\n\n  private compileRules(permissions: PermissionRules): CompiledRule[] {\n    return Object.entries(permissions)\n      .map(([pattern, permission]) => ({\n        pattern,\n        permission,\n        specificity: this.calculateSpecificity(pattern),\n      }))\n      .sort((a, b) => b.specificity - a.specificity); // highest first\n  }\n\n  private calculateSpecificity(pattern: string): number {\n    const segments = pattern.split(\"/\").filter(Boolean);\n    let score = segments.length * 1000; // segment count is primary\n\n    for (const seg of segments) {\n      if (seg === \"**\") score += 0;\n      else if (seg.includes(\"*\")) score += 1;\n      else score += 10; // literal segment\n    }\n    return score;\n  }\n\n  protected getPermission(virtualPath: string): Permission {\n    const normalized = virtualPath.replace(/^\\/+/, \"\"); // strip leading slashes\n\n    for (const rule of this.rules) {\n      if (this.matchGlob(rule.pattern, normalized)) {\n        return rule.permission;\n      }\n    }\n    return \"read-write\"; // default\n  }\n\n  private matchGlob(pattern: string, filePath: string): boolean {\n    // Convert glob to regex\n    // ** matches any path segments, * matches within segment\n    const regex = pattern\n      .split(\"/\")\n      .map((seg) => {\n        if (seg === \"**\") return \".*\";\n        return seg.replace(/\\*/g, \"[^/]*\").replace(/\\?/g, \"[^/]\");\n      })\n      .join(\"/\");\n    return new RegExp(`^${regex}$`).test(filePath);\n  }\n\n  protected checkPermission(virtualPath: string, operation: \"read\" | \"write\"): void {\n    const perm = this.getPermission(virtualPath);\n\n    if (perm === \"excluded\") {\n      throw new Error(`Access denied: \"${virtualPath}\" is excluded`);\n    }\n    if (operation === \"write\" && perm === \"read-only\") {\n      throw new Error(`Access denied: \"${virtualPath}\" is read-only`);\n    }\n  }\n\n  private resolveSafePath(virtualPath: string): string {\n    if (this.mountBase === null) {\n      return path.resolve(virtualPath);\n    }\n\n    // Check for path traversal by tracking depth\n    const segments = virtualPath.split(\"/\").filter(Boolean);\n    let depth = 0;\n    for (const seg of segments) {\n      if (seg === \"..\") {\n        depth--;\n        if (depth < 0) {\n          throw new Error(`Path traversal blocked: \"${virtualPath}\" escapes mount point`);\n        }\n      } else if (seg !== \".\") {\n        depth++;\n      }\n    }\n\n    const normalized = path.normalize(virtualPath);\n    const relativePath = normalized.startsWith(\"/\") ? normalized.slice(1) : normalized;\n    const realPath = path.join(this.mountBase, relativePath);\n    const resolved = path.resolve(realPath);\n\n    // Double-check containment (defense in depth)\n    if (!resolved.startsWith(this.mountBase + path.sep) && resolved !== this.mountBase) {\n      throw new Error(`Path traversal blocked: \"${virtualPath}\" escapes mount point`);\n    }\n\n    return resolved;\n  }\n\n  // Read operations\n  async readFile(filePath: string): Promise<Buffer> {\n    this.checkPermission(filePath, \"read\");\n    const realPath = this.resolveSafePath(filePath);\n    const content = await this.underlyingFs.promises.readFile(realPath);\n    return Buffer.from(content);\n  }\n\n  async readdir(dirPath: string): Promise<string[]> {\n    this.checkPermission(dirPath, \"read\");\n    const realPath = this.resolveSafePath(dirPath);\n    const entries = await this.underlyingFs.promises.readdir(realPath);\n    return entries.map(String);\n  }\n\n  async stat(filePath: string): Promise<FileStat> {\n    this.checkPermission(filePath, \"read\");\n    const realPath = this.resolveSafePath(filePath);\n    const stats = await this.underlyingFs.promises.stat(realPath);\n    return {\n      isFile: () => stats.isFile(),\n      isDirectory: () => stats.isDirectory(),\n      size: stats.size,\n      mtime: stats.mtime,\n    };\n  }\n\n  async exists(filePath: string): Promise<boolean> {\n    try {\n      this.checkPermission(filePath, \"read\");\n      const realPath = this.resolveSafePath(filePath);\n      await this.underlyingFs.promises.stat(realPath);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  // Write operations\n  async writeFile(filePath: string, data: Buffer | string): Promise<void> {\n    this.checkPermission(filePath, \"write\");\n    const realPath = this.resolveSafePath(filePath);\n    await this.underlyingFs.promises.writeFile(realPath, data);\n  }\n\n  async appendFile(filePath: string, data: Buffer | string): Promise<void> {\n    this.checkPermission(filePath, \"write\");\n    const realPath = this.resolveSafePath(filePath);\n    await this.underlyingFs.promises.appendFile(realPath, data);\n  }\n\n  async mkdir(dirPath: string, opts?: { recursive?: boolean }): Promise<void> {\n    this.checkPermission(dirPath, \"write\");\n    const realPath = this.resolveSafePath(dirPath);\n    await this.underlyingFs.promises.mkdir(realPath, opts);\n  }\n\n  async rm(filePath: string, opts?: { recursive?: boolean; force?: boolean }): Promise<void> {\n    this.checkPermission(filePath, \"write\");\n    const realPath = this.resolveSafePath(filePath);\n    await this.underlyingFs.promises.rm(realPath, opts);\n  }\n\n  // Path utilities (no permission check needed)\n  resolve(...paths: string[]): string {\n    return path.resolve(\"/\", ...paths);\n  }\n\n  dirname(filePath: string): string {\n    return path.dirname(filePath);\n  }\n\n  basename(filePath: string): string {\n    return path.basename(filePath);\n  }\n\n  // Glob with permission filtering\n  async glob(pattern: string, opts?: { cwd?: string }): Promise<string[]> {\n    const cwd = opts?.cwd ?? \"/\";\n    this.checkPermission(cwd, \"read\");\n\n    const matches = await this.expandGlob(pattern, cwd);\n\n    // Filter out excluded paths\n    return matches.filter((p) => this.getPermission(p) !== \"excluded\").sort();\n  }\n\n  // Glob expansion (similar to memfs-adapter implementation)\n  private async expandGlob(pattern: string, cwd: string): Promise<string[]> {\n    // Handle brace expansion first\n    const patterns = this.expandBraces(pattern);\n    const allMatches: string[] = [];\n\n    for (const pat of patterns) {\n      const matches = await this.matchPattern(pat, cwd);\n      allMatches.push(...matches);\n    }\n\n    // Remove duplicates and sort\n    return [...new Set(allMatches)].sort();\n  }\n\n  private expandBraces(pattern: string): string[] {\n    const braceMatch = pattern.match(/\\{([^{}]+)\\}/);\n    if (!braceMatch) return [pattern];\n\n    const before = pattern.slice(0, braceMatch.index);\n    const after = pattern.slice(braceMatch.index! + braceMatch[0].length);\n    const options = braceMatch[1]!.split(\",\");\n\n    const results: string[] = [];\n    for (const opt of options) {\n      const expanded = this.expandBraces(before + opt + after);\n      results.push(...expanded);\n    }\n    return results;\n  }\n\n  private async matchPattern(pattern: string, cwd: string): Promise<string[]> {\n    const parts = pattern.split(\"/\").filter((p) => p !== \"\");\n    const isAbsolute = pattern.startsWith(\"/\");\n    const startDir = isAbsolute ? \"/\" : cwd;\n\n    return this.matchParts(parts, startDir);\n  }\n\n  private async matchParts(parts: string[], currentPath: string): Promise<string[]> {\n    if (parts.length === 0) {\n      return [currentPath];\n    }\n\n    const [part, ...rest] = parts;\n\n    // Handle ** (recursive glob)\n    if (part === \"**\") {\n      const results: string[] = [];\n\n      // Match current directory\n      const withoutStar = await this.matchParts(rest, currentPath);\n      results.push(...withoutStar);\n\n      // Recurse into subdirectories\n      try {\n        const realPath = this.resolveSafePath(currentPath);\n        const entries = await this.underlyingFs.promises.readdir(realPath);\n        for (const entry of entries) {\n          const entryPath = path.posix.join(currentPath, String(entry));\n          try {\n            const entryRealPath = this.resolveSafePath(entryPath);\n            const stat = await this.underlyingFs.promises.stat(entryRealPath);\n            if (stat.isDirectory()) {\n              const subMatches = await this.matchParts(parts, entryPath);\n              results.push(...subMatches);\n            }\n          } catch {\n            // Skip inaccessible entries\n          }\n        }\n      } catch {\n        // Directory not readable\n      }\n\n      return results;\n    }\n\n    // Handle regular glob patterns\n    const regex = this.globToRegex(part!);\n\n    try {\n      const realPath = this.resolveSafePath(currentPath);\n      const entries = await this.underlyingFs.promises.readdir(realPath);\n      const results: string[] = [];\n\n      for (const entry of entries) {\n        const entryName = String(entry);\n        if (regex.test(entryName)) {\n          const entryPath = path.posix.join(currentPath, entryName);\n          if (rest.length === 0) {\n            results.push(entryPath);\n          } else {\n            try {\n              const entryRealPath = this.resolveSafePath(entryPath);\n              const stat = await this.underlyingFs.promises.stat(entryRealPath);\n              if (stat.isDirectory()) {\n                const subMatches = await this.matchParts(rest, entryPath);\n                results.push(...subMatches);\n              }\n            } catch {\n              // Skip inaccessible entries\n            }\n          }\n        }\n      }\n\n      return results;\n    } catch {\n      return [];\n    }\n  }\n\n  private globToRegex(pattern: string): RegExp {\n    let regex = \"^\";\n    for (let i = 0; i < pattern.length; i++) {\n      const char = pattern[i]!;\n      if (char === \"*\") {\n        regex += \"[^/]*\";\n      } else if (char === \"?\") {\n        regex += \"[^/]\";\n      } else if (char === \"[\") {\n        // Character class\n        let j = i + 1;\n        let classContent = \"\";\n        while (j < pattern.length && pattern[j] !== \"]\") {\n          classContent += pattern[j];\n          j++;\n        }\n        regex += `[${classContent}]`;\n        i = j;\n      } else if (\".+^${}()|\\\\\".includes(char)) {\n        regex += \"\\\\\" + char;\n      } else {\n        regex += char;\n      }\n    }\n    regex += \"$\";\n    return new RegExp(regex);\n  }\n}\n"
+  ],
+  "mappings": ";AAAA;AACA;AAyBA,IAAM,YAA0B,EAAE,UAAU,OAAO;AAAA;AAQ5C,MAAM,WAAgC;AAAA,EAC1B;AAAA,EACA;AAAA,EACE;AAAA,EAEnB,WAAW,CAAC,WAAoB,aAA+B,IAAmB;AAAA,IAChF,KAAK,YAAY,YAAiB,aAAQ,SAAS,IAAI;AAAA,IACvD,KAAK,QAAQ,KAAK,aAAa,eAAe,CAAC,CAAC;AAAA,IAChD,KAAK,eAAe,MAAM;AAAA;AAAA,EAGpB,YAAY,CAAC,aAA8C;AAAA,IACjE,OAAO,OAAO,QAAQ,WAAW,EAC9B,IAAI,EAAE,SAAS,iBAAiB;AAAA,MAC/B;AAAA,MACA;AAAA,MACA,aAAa,KAAK,qBAAqB,OAAO;AAAA,IAChD,EAAE,EACD,KAAK,CAAC,GAAG,MAAM,EAAE,cAAc,EAAE,WAAW;AAAA;AAAA,EAGzC,oBAAoB,CAAC,SAAyB;AAAA,IACpD,MAAM,WAAW,QAAQ,MAAM,GAAG,EAAE,OAAO,OAAO;AAAA,IAClD,IAAI,QAAQ,SAAS,SAAS;AAAA,IAE9B,WAAW,OAAO,UAAU;AAAA,MAC1B,IAAI,QAAQ;AAAA,QAAM,SAAS;AAAA,MACtB,SAAI,IAAI,SAAS,GAAG;AAAA,QAAG,SAAS;AAAA,MAChC;AAAA,iBAAS;AAAA,IAChB;AAAA,IACA,OAAO;AAAA;AAAA,EAGC,aAAa,CAAC,aAAiC;AAAA,IACvD,MAAM,aAAa,YAAY,QAAQ,QAAQ,EAAE;AAAA,IAEjD,WAAW,QAAQ,KAAK,OAAO;AAAA,MAC7B,IAAI,KAAK,UAAU,KAAK,SAAS,UAAU,GAAG;AAAA,QAC5C,OAAO,KAAK;AAAA,MACd;AAAA,IACF;AAAA,IACA,OAAO;AAAA;AAAA,EAGD,SAAS,CAAC,SAAiB,UAA2B;AAAA,IAG5D,MAAM,QAAQ,QACX,MAAM,GAAG,EACT,IAAI,CAAC,QAAQ;AAAA,MACZ,IAAI,QAAQ;AAAA,QAAM,OAAO;AAAA,MACzB,OAAO,IAAI,QAAQ,OAAO,OAAO,EAAE,QAAQ,OAAO,MAAM;AAAA,KACzD,EACA,KAAK,GAAG;AAAA,IACX,OAAO,IAAI,OAAO,IAAI,QAAQ,EAAE,KAAK,QAAQ;AAAA;AAAA,EAGrC,eAAe,CAAC,aAAqB,WAAmC;AAAA,IAChF,MAAM,OAAO,KAAK,cAAc,WAAW;AAAA,IAE3C,IAAI,SAAS,YAAY;AAAA,MACvB,MAAM,IAAI,MAAM,mBAAmB,0BAA0B;AAAA,IAC/D;AAAA,IACA,IAAI,cAAc,WAAW,SAAS,aAAa;AAAA,MACjD,MAAM,IAAI,MAAM,mBAAmB,2BAA2B;AAAA,IAChE;AAAA;AAAA,EAGM,eAAe,CAAC,aAA6B;AAAA,IACnD,IAAI,KAAK,cAAc,MAAM;AAAA,MAC3B,OAAY,aAAQ,WAAW;AAAA,IACjC;AAAA,IAGA,MAAM,WAAW,YAAY,MAAM,GAAG,EAAE,OAAO,OAAO;AAAA,IACtD,IAAI,QAAQ;AAAA,IACZ,WAAW,OAAO,UAAU;AAAA,MAC1B,IAAI,QAAQ,MAAM;AAAA,QAChB;AAAA,QACA,IAAI,QAAQ,GAAG;AAAA,UACb,MAAM,IAAI,MAAM,4BAA4B,kCAAkC;AAAA,QAChF;AAAA,MACF,EAAO,SAAI,QAAQ,KAAK;AAAA,QACtB;AAAA,MACF;AAAA,IACF;AAAA,IAEA,MAAM,aAAkB,eAAU,WAAW;AAAA,IAC7C,MAAM,eAAe,WAAW,WAAW,GAAG,IAAI,WAAW,MAAM,CAAC,IAAI;AAAA,IACxE,MAAM,WAAgB,UAAK,KAAK,WAAW,YAAY;AAAA,IACvD,MAAM,WAAgB,aAAQ,QAAQ;AAAA,IAGtC,IAAI,CAAC,SAAS,WAAW,KAAK,YAAiB,QAAG,KAAK,aAAa,KAAK,WAAW;AAAA,MAClF,MAAM,IAAI,MAAM,4BAA4B,kCAAkC;AAAA,IAChF;AAAA,IAEA,OAAO;AAAA;AAAA,OAIH,SAAQ,CAAC,UAAmC;AAAA,IAChD,KAAK,gBAAgB,UAAU,MAAM;AAAA,IACrC,MAAM,WAAW,KAAK,gBAAgB,QAAQ;AAAA,IAC9C,MAAM,UAAU,MAAM,KAAK,aAAa,SAAS,SAAS,QAAQ;AAAA,IAClE,OAAO,OAAO,KAAK,OAAO;AAAA;AAAA,OAGtB,QAAO,CAAC,SAAoC;AAAA,IAChD,KAAK,gBAAgB,SAAS,MAAM;AAAA,IACpC,MAAM,WAAW,KAAK,gBAAgB,OAAO;AAAA,IAC7C,MAAM,UAAU,MAAM,KAAK,aAAa,SAAS,QAAQ,QAAQ;AAAA,IACjE,OAAO,QAAQ,IAAI,MAAM;AAAA;AAAA,OAGrB,KAAI,CAAC,UAAqC;AAAA,IAC9C,KAAK,gBAAgB,UAAU,MAAM;AAAA,IACrC,MAAM,WAAW,KAAK,gBAAgB,QAAQ;AAAA,IAC9C,MAAM,QAAQ,MAAM,KAAK,aAAa,SAAS,KAAK,QAAQ;AAAA,IAC5D,OAAO;AAAA,MACL,QAAQ,MAAM,MAAM,OAAO;AAAA,MAC3B,aAAa,MAAM,MAAM,YAAY;AAAA,MACrC,MAAM,MAAM;AAAA,MACZ,OAAO,MAAM;AAAA,IACf;AAAA;AAAA,OAGI,OAAM,CAAC,UAAoC;AAAA,IAC/C,IAAI;AAAA,MACF,KAAK,gBAAgB,UAAU,MAAM;AAAA,MACrC,MAAM,WAAW,KAAK,gBAAgB,QAAQ;AAAA,MAC9C,MAAM,KAAK,aAAa,SAAS,KAAK,QAAQ;AAAA,MAC9C,OAAO;AAAA,MACP,MAAM;AAAA,MACN,OAAO;AAAA;AAAA;AAAA,OAKL,UAAS,CAAC,UAAkB,MAAsC;AAAA,IACtE,KAAK,gBAAgB,UAAU,OAAO;AAAA,IACtC,MAAM,WAAW,KAAK,gBAAgB,QAAQ;AAAA,IAC9C,MAAM,KAAK,aAAa,SAAS,UAAU,UAAU,IAAI;AAAA;AAAA,OAGrD,WAAU,CAAC,UAAkB,MAAsC;AAAA,IACvE,KAAK,gBAAgB,UAAU,OAAO;AAAA,IACtC,MAAM,WAAW,KAAK,gBAAgB,QAAQ;AAAA,IAC9C,MAAM,KAAK,aAAa,SAAS,WAAW,UAAU,IAAI;AAAA;AAAA,OAGtD,MAAK,CAAC,SAAiB,MAA+C;AAAA,IAC1E,KAAK,gBAAgB,SAAS,OAAO;AAAA,IACrC,MAAM,WAAW,KAAK,gBAAgB,OAAO;AAAA,IAC7C,MAAM,KAAK,aAAa,SAAS,MAAM,UAAU,IAAI;AAAA;AAAA,OAGjD,GAAE,CAAC,UAAkB,MAAgE;AAAA,IACzF,KAAK,gBAAgB,UAAU,OAAO;AAAA,IACtC,MAAM,WAAW,KAAK,gBAAgB,QAAQ;AAAA,IAC9C,MAAM,KAAK,aAAa,SAAS,GAAG,UAAU,IAAI;AAAA;AAAA,EAIpD,OAAO,IAAI,OAAyB;AAAA,IAClC,OAAY,aAAQ,KAAK,GAAG,KAAK;AAAA;AAAA,EAGnC,OAAO,CAAC,UAA0B;AAAA,IAChC,OAAY,aAAQ,QAAQ;AAAA;AAAA,EAG9B,QAAQ,CAAC,UAA0B;AAAA,IACjC,OAAY,cAAS,QAAQ;AAAA;AAAA,OAIzB,KAAI,CAAC,SAAiB,MAA4C;AAAA,IACtE,MAAM,MAAM,MAAM,OAAO;AAAA,IACzB,KAAK,gBAAgB,KAAK,MAAM;AAAA,IAEhC,MAAM,UAAU,MAAM,KAAK,WAAW,SAAS,GAAG;AAAA,IAGlD,OAAO,QAAQ,OAAO,CAAC,MAAM,KAAK,cAAc,CAAC,MAAM,UAAU,EAAE,KAAK;AAAA;AAAA,OAI5D,WAAU,CAAC,SAAiB,KAAgC;AAAA,IAExE,MAAM,WAAW,KAAK,aAAa,OAAO;AAAA,IAC1C,MAAM,aAAuB,CAAC;AAAA,IAE9B,WAAW,OAAO,UAAU;AAAA,MAC1B,MAAM,UAAU,MAAM,KAAK,aAAa,KAAK,GAAG;AAAA,MAChD,WAAW,KAAK,GAAG,OAAO;AAAA,IAC5B;AAAA,IAGA,OAAO,CAAC,GAAG,IAAI,IAAI,UAAU,CAAC,EAAE,KAAK;AAAA;AAAA,EAG/B,YAAY,CAAC,SAA2B;AAAA,IAC9C,MAAM,aAAa,QAAQ,MAAM,cAAc;AAAA,IAC/C,IAAI,CAAC;AAAA,MAAY,OAAO,CAAC,OAAO;AAAA,IAEhC,MAAM,SAAS,QAAQ,MAAM,GAAG,WAAW,KAAK;AAAA,IAChD,MAAM,QAAQ,QAAQ,MAAM,WAAW,QAAS,WAAW,GAAG,MAAM;AAAA,IACpE,MAAM,UAAU,WAAW,GAAI,MAAM,GAAG;AAAA,IAExC,MAAM,UAAoB,CAAC;AAAA,IAC3B,WAAW,OAAO,SAAS;AAAA,MACzB,MAAM,WAAW,KAAK,aAAa,SAAS,MAAM,KAAK;AAAA,MACvD,QAAQ,KAAK,GAAG,QAAQ;AAAA,IAC1B;AAAA,IACA,OAAO;AAAA;AAAA,OAGK,aAAY,CAAC,SAAiB,KAAgC;AAAA,IAC1E,MAAM,QAAQ,QAAQ,MAAM,GAAG,EAAE,OAAO,CAAC,MAAM,MAAM,EAAE;AAAA,IACvD,MAAM,aAAa,QAAQ,WAAW,GAAG;AAAA,IACzC,MAAM,WAAW,aAAa,MAAM;AAAA,IAEpC,OAAO,KAAK,WAAW,OAAO,QAAQ;AAAA;AAAA,OAG1B,WAAU,CAAC,OAAiB,aAAwC;AAAA,IAChF,IAAI,MAAM,WAAW,GAAG;AAAA,MACtB,OAAO,CAAC,WAAW;AAAA,IACrB;AAAA,IAEA,OAAO,SAAS,QAAQ;AAAA,IAGxB,IAAI,SAAS,MAAM;AAAA,MACjB,MAAM,UAAoB,CAAC;AAAA,MAG3B,MAAM,cAAc,MAAM,KAAK,WAAW,MAAM,WAAW;AAAA,MAC3D,QAAQ,KAAK,GAAG,WAAW;AAAA,MAG3B,IAAI;AAAA,QACF,MAAM,WAAW,KAAK,gBAAgB,WAAW;AAAA,QACjD,MAAM,UAAU,MAAM,KAAK,aAAa,SAAS,QAAQ,QAAQ;AAAA,QACjE,WAAW,SAAS,SAAS;AAAA,UAC3B,MAAM,YAAiB,WAAM,KAAK,aAAa,OAAO,KAAK,CAAC;AAAA,UAC5D,IAAI;AAAA,YACF,MAAM,gBAAgB,KAAK,gBAAgB,SAAS;AAAA,YACpD,MAAM,OAAO,MAAM,KAAK,aAAa,SAAS,KAAK,aAAa;AAAA,YAChE,IAAI,KAAK,YAAY,GAAG;AAAA,cACtB,MAAM,aAAa,MAAM,KAAK,WAAW,OAAO,SAAS;AAAA,cACzD,QAAQ,KAAK,GAAG,UAAU;AAAA,YAC5B;AAAA,YACA,MAAM;AAAA,QAGV;AAAA,QACA,MAAM;AAAA,MAIR,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,QAAQ,KAAK,YAAY,IAAK;AAAA,IAEpC,IAAI;AAAA,MACF,MAAM,WAAW,KAAK,gBAAgB,WAAW;AAAA,MACjD,MAAM,UAAU,MAAM,KAAK,aAAa,SAAS,QAAQ,QAAQ;AAAA,MACjE,MAAM,UAAoB,CAAC;AAAA,MAE3B,WAAW,SAAS,SAAS;AAAA,QAC3B,MAAM,YAAY,OAAO,KAAK;AAAA,QAC9B,IAAI,MAAM,KAAK,SAAS,GAAG;AAAA,UACzB,MAAM,YAAiB,WAAM,KAAK,aAAa,SAAS;AAAA,UACxD,IAAI,KAAK,WAAW,GAAG;AAAA,YACrB,QAAQ,KAAK,SAAS;AAAA,UACxB,EAAO;AAAA,YACL,IAAI;AAAA,cACF,MAAM,gBAAgB,KAAK,gBAAgB,SAAS;AAAA,cACpD,MAAM,OAAO,MAAM,KAAK,aAAa,SAAS,KAAK,aAAa;AAAA,cAChE,IAAI,KAAK,YAAY,GAAG;AAAA,gBACtB,MAAM,aAAa,MAAM,KAAK,WAAW,MAAM,SAAS;AAAA,gBACxD,QAAQ,KAAK,GAAG,UAAU;AAAA,cAC5B;AAAA,cACA,MAAM;AAAA;AAAA,QAIZ;AAAA,MACF;AAAA,MAEA,OAAO;AAAA,MACP,MAAM;AAAA,MACN,OAAO,CAAC;AAAA;AAAA;AAAA,EAIJ,WAAW,CAAC,SAAyB;AAAA,IAC3C,IAAI,QAAQ;AAAA,IACZ,SAAS,IAAI,EAAG,IAAI,QAAQ,QAAQ,KAAK;AAAA,MACvC,MAAM,OAAO,QAAQ;AAAA,MACrB,IAAI,SAAS,KAAK;AAAA,QAChB,SAAS;AAAA,MACX,EAAO,SAAI,SAAS,KAAK;AAAA,QACvB,SAAS;AAAA,MACX,EAAO,SAAI,SAAS,KAAK;AAAA,QAEvB,IAAI,IAAI,IAAI;AAAA,QACZ,IAAI,eAAe;AAAA,QACnB,OAAO,IAAI,QAAQ,UAAU,QAAQ,OAAO,KAAK;AAAA,UAC/C,gBAAgB,QAAQ;AAAA,UACxB;AAAA,QACF;AAAA,QACA,SAAS,IAAI;AAAA,QACb,IAAI;AAAA,MACN,EAAO,SAAI,cAAc,SAAS,IAAI,GAAG;AAAA,QACvC,SAAS,OAAO;AAAA,MAClB,EAAO;AAAA,QACL,SAAS;AAAA;AAAA,IAEb;AAAA,IACA,SAAS;AAAA,IACT,OAAO,IAAI,OAAO,KAAK;AAAA;AAE3B;",
+  "debugId": "78CB3041E0AD3DDE64756E2164756E21",
+  "names": []
+}

package/dist/mjs/src/index.mjs

@@ -19,6 +19,10 @@ import {
 } from "./parser/index.mjs";
 import { Interpreter } from "./interpreter/index.mjs";
 import { createVirtualFS } from "./fs/index.mjs";
+import {
+  FileSystem,
+  ReadOnlyFileSystem
+} from "./fs/index.mjs";
 import { createStdin, StdinImpl } from "./io/index.mjs";
 import { createStdout, createStderr, createPipe, OutputCollectorImpl, PipeBuffer } from "./io/index.mjs";
 import { escape, escapeForInterpolation } from "./utils/index.mjs";
@@ -49,13 +53,15 @@ export {
   ShellPromise,
   ShellError,
   ShellDSL,
+  ReadOnlyFileSystem,
   PipeBuffer,
   Parser,
   ParseError,
   OutputCollectorImpl,
   Lexer,
   LexError,
-  Interpreter
+  Interpreter,
+  FileSystem
 };
 
-//# debugId=F0817E6C4D09F0A764756E2164756E21
+//# debugId=4DB7B709124A1C5464756E2164756E21

package/dist/mjs/src/index.mjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../src/index.ts"],
   "sourcesContent": [
-    "// Main class exports\nexport { ShellDSL, createShellDSL, type Program } from \"./shell-dsl.mjs\";\nexport { ShellPromise, type ShellPromiseOptions } from \"./shell-promise.mjs\";\n\n// Types\nexport type {\n  VirtualFS,\n  FileStat,\n  Command,\n  CommandContext,\n  Stdin,\n  Stdout,\n  Stderr,\n  OutputCollector,\n  ExecResult,\n  ShellConfig,\n  RawValue,\n} from \"./types.mjs\";\nexport { isRawValue } from \"./types.mjs\";\n\n// Errors\nexport { ShellError, LexError, ParseError } from \"./errors.mjs\";\n\n// Lexer\nexport { Lexer, lex, tokenToString } from \"./lexer/index.mjs\";\nexport type { Token, RedirectMode } from \"./lexer/index.mjs\";\n\n// Parser\nexport { Parser, parse } from \"./parser/index.mjs\";\nexport type {\n  ASTNode,\n  Redirect,\n  CommandNode,\n  PipelineNode,\n  AndNode,\n  OrNode,\n  SequenceNode,\n  LiteralNode,\n  VariableNode,\n  SubstitutionNode,\n  GlobNode,\n  ConcatNode,\n} from \"./parser/index.mjs\";\nexport {\n  isCommandNode,\n  isPipelineNode,\n  isAndNode,\n  isOrNode,\n  isSequenceNode,\n  isLiteralNode,\n  isVariableNode,\n  isSubstitutionNode,\n  isGlobNode,\n  isConcatNode,\n} from \"./parser/index.mjs\";\n\n// Interpreter\nexport { Interpreter, type InterpreterOptions } from \"./interpreter/index.mjs\";\n\n// Filesystem\nexport { createVirtualFS } from \"./fs/index.mjs\";\n\n// I/O\nexport { createStdin, StdinImpl } from \"./io/index.mjs\";\nexport { createStdout, createStderr, createPipe, OutputCollectorImpl, PipeBuffer } from \"./io/index.mjs\";\n\n// Utilities\nexport { escape, escapeForInterpolation } from \"./utils/index.mjs\";\n"
+    "// Main class exports\nexport { ShellDSL, createShellDSL, type Program } from \"./shell-dsl.mjs\";\nexport { ShellPromise, type ShellPromiseOptions } from \"./shell-promise.mjs\";\n\n// Types\nexport type {\n  VirtualFS,\n  FileStat,\n  Command,\n  CommandContext,\n  Stdin,\n  Stdout,\n  Stderr,\n  OutputCollector,\n  ExecResult,\n  ShellConfig,\n  RawValue,\n} from \"./types.mjs\";\nexport { isRawValue } from \"./types.mjs\";\n\n// Errors\nexport { ShellError, LexError, ParseError } from \"./errors.mjs\";\n\n// Lexer\nexport { Lexer, lex, tokenToString } from \"./lexer/index.mjs\";\nexport type { Token, RedirectMode } from \"./lexer/index.mjs\";\n\n// Parser\nexport { Parser, parse } from \"./parser/index.mjs\";\nexport type {\n  ASTNode,\n  Redirect,\n  CommandNode,\n  PipelineNode,\n  AndNode,\n  OrNode,\n  SequenceNode,\n  LiteralNode,\n  VariableNode,\n  SubstitutionNode,\n  GlobNode,\n  ConcatNode,\n} from \"./parser/index.mjs\";\nexport {\n  isCommandNode,\n  isPipelineNode,\n  isAndNode,\n  isOrNode,\n  isSequenceNode,\n  isLiteralNode,\n  isVariableNode,\n  isSubstitutionNode,\n  isGlobNode,\n  isConcatNode,\n} from \"./parser/index.mjs\";\n\n// Interpreter\nexport { Interpreter, type InterpreterOptions } from \"./interpreter/index.mjs\";\n\n// Filesystem\nexport { createVirtualFS } from \"./fs/index.mjs\";\nexport {\n  FileSystem,\n  ReadOnlyFileSystem,\n  type Permission,\n  type PermissionRules,\n  type UnderlyingFS,\n} from \"./fs/index.mjs\";\n\n// I/O\nexport { createStdin, StdinImpl } from \"./io/index.mjs\";\nexport { createStdout, createStderr, createPipe, OutputCollectorImpl, PipeBuffer } from \"./io/index.mjs\";\n\n// Utilities\nexport { escape, escapeForInterpolation } from \"./utils/index.mjs\";\n"
   ],
-  "mappings": ";AACA;AACA;AAgBA;AAGA;AAGA;AAIA;AAeA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAcA;AAGA;AAGA;AACA;AAGA;",
-  "debugId": "F0817E6C4D09F0A764756E2164756E21",
+  "mappings": ";AACA;AACA;AAgBA;AAGA;AAGA;AAIA;AAeA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAcA;AAGA;AACA;AAAA;AAAA;AAAA;AASA;AACA;AAGA;",
+  "debugId": "4DB7B709124A1C5464756E2164756E21",
   "names": []
 }

package/dist/types/src/fs/index.d.ts

@@ -1 +1,3 @@
 export { createVirtualFS } from "./memfs-adapter.ts";
+export { FileSystem, type Permission, type PermissionRules, type UnderlyingFS } from "./real-fs.ts";
+export { ReadOnlyFileSystem } from "./readonly-fs.ts";

package/dist/types/src/fs/readonly-fs.d.ts

@@ -0,0 +1,4 @@
+import { FileSystem, type PermissionRules, type UnderlyingFS } from "./real-fs.ts";
+export declare class ReadOnlyFileSystem extends FileSystem {
+    constructor(mountPath?: string, permissions?: PermissionRules, fs?: UnderlyingFS);
+}

package/dist/types/src/fs/real-fs.d.ts

@@ -0,0 +1,60 @@
+import type { VirtualFS, FileStat } from "../types.ts";
+export type Permission = "read-write" | "read-only" | "excluded";
+export type PermissionRules = Record<string, Permission>;
+export interface UnderlyingFS {
+    promises: {
+        readFile(path: string): Promise<Buffer | Uint8Array | string>;
+        readdir(path: string): Promise<string[]>;
+        stat(path: string): Promise<{
+            isFile(): boolean;
+            isDirectory(): boolean;
+            size: number;
+            mtime: Date;
+        }>;
+        writeFile(path: string, data: Buffer | string): Promise<void>;
+        appendFile(path: string, data: Buffer | string): Promise<void>;
+        mkdir(path: string, opts?: {
+            recursive?: boolean;
+        }): Promise<string | undefined | void>;
+        rm(path: string, opts?: {
+            recursive?: boolean;
+            force?: boolean;
+        }): Promise<void>;
+    };
+}
+export declare class FileSystem implements VirtualFS {
+    private readonly mountBase;
+    private readonly rules;
+    protected readonly underlyingFs: UnderlyingFS;
+    constructor(mountPath?: string, permissions?: PermissionRules, fs?: UnderlyingFS);
+    private compileRules;
+    private calculateSpecificity;
+    protected getPermission(virtualPath: string): Permission;
+    private matchGlob;
+    protected checkPermission(virtualPath: string, operation: "read" | "write"): void;
+    private resolveSafePath;
+    readFile(filePath: string): Promise<Buffer>;
+    readdir(dirPath: string): Promise<string[]>;
+    stat(filePath: string): Promise<FileStat>;
+    exists(filePath: string): Promise<boolean>;
+    writeFile(filePath: string, data: Buffer | string): Promise<void>;
+    appendFile(filePath: string, data: Buffer | string): Promise<void>;
+    mkdir(dirPath: string, opts?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rm(filePath: string, opts?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    resolve(...paths: string[]): string;
+    dirname(filePath: string): string;
+    basename(filePath: string): string;
+    glob(pattern: string, opts?: {
+        cwd?: string;
+    }): Promise<string[]>;
+    private expandGlob;
+    private expandBraces;
+    private matchPattern;
+    private matchParts;
+    private globToRegex;
+}

package/dist/types/src/index.d.ts

@@ -10,6 +10,7 @@ export type { ASTNode, Redirect, CommandNode, PipelineNode, AndNode, OrNode, Seq
 export { isCommandNode, isPipelineNode, isAndNode, isOrNode, isSequenceNode, isLiteralNode, isVariableNode, isSubstitutionNode, isGlobNode, isConcatNode, } from "./parser/index.ts";
 export { Interpreter, type InterpreterOptions } from "./interpreter/index.ts";
 export { createVirtualFS } from "./fs/index.ts";
+export { FileSystem, ReadOnlyFileSystem, type Permission, type PermissionRules, type UnderlyingFS, } from "./fs/index.ts";
 export { createStdin, StdinImpl } from "./io/index.ts";
 export { createStdout, createStderr, createPipe, OutputCollectorImpl, PipeBuffer } from "./io/index.ts";
 export { escape, escapeForInterpolation } from "./utils/index.ts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shell-dsl",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "A sandboxed shell-style DSL for running scriptable command pipelines in-process without host OS access",
   "author": "ricsam <oss@ricsam.dev>",
   "license": "MIT",