zeitlich 0.2.15 → 0.2.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeitlich",
-  "version": "0.2.15",
+  "version": "0.2.16",
   "description": "[EXPERIMENTAL] An opinionated AI agent implementation for Temporal",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/src/adapters/sandbox/daytona/filesystem.ts

@@ -15,46 +15,62 @@ import { posix } from "node:path";
  * (e.g. `appendFile`, `cp`) are composed from primitives.
  */
 export class DaytonaSandboxFileSystem implements SandboxFileSystem {
-  constructor(private sandbox: DaytonaSdkSandbox) {}
+  readonly workspaceBase: string;
+
+  constructor(
+    private sandbox: DaytonaSdkSandbox,
+    workspaceBase = "/home/daytona",
+  ) {
+    this.workspaceBase = posix.resolve("/", workspaceBase);
+  }
+
+  private normalisePath(path: string): string {
+    return posix.resolve(this.workspaceBase, path);
+  }
 
   async readFile(path: string): Promise<string> {
-    const buf = await this.sandbox.fs.downloadFile(path);
+    const norm = this.normalisePath(path);
+    const buf = await this.sandbox.fs.downloadFile(norm);
     return buf.toString("utf-8");
   }
 
   async readFileBuffer(path: string): Promise<Uint8Array> {
-    const buf = await this.sandbox.fs.downloadFile(path);
+    const norm = this.normalisePath(path);
+    const buf = await this.sandbox.fs.downloadFile(norm);
     return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
   }
 
   async writeFile(path: string, content: string | Uint8Array): Promise<void> {
+    const norm = this.normalisePath(path);
     const buf =
       typeof content === "string"
         ? Buffer.from(content, "utf-8")
         : Buffer.from(content);
-    await this.sandbox.fs.uploadFile(buf, path);
+    await this.sandbox.fs.uploadFile(buf, norm);
   }
 
   async appendFile(
     path: string,
     content: string | Uint8Array,
   ): Promise<void> {
+    const norm = this.normalisePath(path);
     let existing: Buffer;
     try {
-      existing = await this.sandbox.fs.downloadFile(path);
+      existing = await this.sandbox.fs.downloadFile(norm);
     } catch {
-      return this.writeFile(path, content);
+      return this.writeFile(norm, content);
     }
 
     const addition =
       typeof content === "string" ? Buffer.from(content, "utf-8") : content;
     const merged = Buffer.concat([existing, Buffer.from(addition)]);
-    await this.sandbox.fs.uploadFile(merged, path);
+    await this.sandbox.fs.uploadFile(merged, norm);
   }
 
   async exists(path: string): Promise<boolean> {
+    const norm = this.normalisePath(path);
     try {
-      await this.sandbox.fs.getFileDetails(path);
+      await this.sandbox.fs.getFileDetails(norm);
       return true;
     } catch {
       return false;
@@ -62,7 +78,8 @@ export class DaytonaSandboxFileSystem implements SandboxFileSystem {
   }
 
   async stat(path: string): Promise<FileStat> {
-    const info = await this.sandbox.fs.getFileDetails(path);
+    const norm = this.normalisePath(path);
+    const info = await this.sandbox.fs.getFileDetails(norm);
     return {
       isFile: !info.isDir,
       isDirectory: info.isDir,
@@ -76,16 +93,19 @@ export class DaytonaSandboxFileSystem implements SandboxFileSystem {
     path: string,
     _options?: { recursive?: boolean },
   ): Promise<void> {
-    await this.sandbox.fs.createFolder(path, "755");
+    const norm = this.normalisePath(path);
+    await this.sandbox.fs.createFolder(norm, "755");
   }
 
   async readdir(path: string): Promise<string[]> {
-    const entries = await this.sandbox.fs.listFiles(path);
+    const norm = this.normalisePath(path);
+    const entries = await this.sandbox.fs.listFiles(norm);
     return entries.map((e) => e.name);
   }
 
   async readdirWithFileTypes(path: string): Promise<DirentEntry[]> {
-    const entries = await this.sandbox.fs.listFiles(path);
+    const norm = this.normalisePath(path);
+    const entries = await this.sandbox.fs.listFiles(norm);
     return entries.map((e) => ({
       name: e.name,
       isFile: !e.isDir,
@@ -98,8 +118,9 @@ export class DaytonaSandboxFileSystem implements SandboxFileSystem {
     path: string,
     options?: { recursive?: boolean; force?: boolean },
   ): Promise<void> {
+    const norm = this.normalisePath(path);
     try {
-      await this.sandbox.fs.deleteFile(path, options?.recursive);
+      await this.sandbox.fs.deleteFile(norm, options?.recursive);
     } catch (err) {
       if (!options?.force) throw err;
     }
@@ -110,19 +131,23 @@ export class DaytonaSandboxFileSystem implements SandboxFileSystem {
     dest: string,
     options?: { recursive?: boolean },
   ): Promise<void> {
-    const info = await this.sandbox.fs.getFileDetails(src);
+    const normSrc = this.normalisePath(src);
+    const normDest = this.normalisePath(dest);
+    const info = await this.sandbox.fs.getFileDetails(normSrc);
     if (info.isDir) {
       if (!options?.recursive) {
         throw new Error(`EISDIR: is a directory (use recursive): ${src}`);
       }
-      await this.sandbox.process.executeCommand(`cp -r "${src}" "${dest}"`);
+      await this.sandbox.process.executeCommand(`cp -r "${normSrc}" "${normDest}"`);
     } else {
-      await this.sandbox.process.executeCommand(`cp "${src}" "${dest}"`);
+      await this.sandbox.process.executeCommand(`cp "${normSrc}" "${normDest}"`);
     }
   }
 
   async mv(src: string, dest: string): Promise<void> {
-    await this.sandbox.fs.moveFiles(src, dest);
+    const normSrc = this.normalisePath(src);
+    const normDest = this.normalisePath(dest);
+    await this.sandbox.fs.moveFiles(normSrc, normDest);
   }
 
   async readlink(_path: string): Promise<string> {
@@ -130,7 +155,6 @@ export class DaytonaSandboxFileSystem implements SandboxFileSystem {
   }
 
   resolvePath(base: string, path: string): string {
-    if (posix.isAbsolute(path)) return posix.normalize(path);
-    return posix.resolve(base, path);
+    return posix.resolve(this.normalisePath(base), path);
   }
 }

package/src/adapters/sandbox/daytona/index.ts

@@ -38,8 +38,9 @@ class DaytonaSandboxImpl implements Sandbox {
   constructor(
     readonly id: string,
     private sdkSandbox: DaytonaSdkSandbox,
+    workspaceBase = "/home/daytona",
   ) {
-    this.fs = new DaytonaSandboxFileSystem(sdkSandbox);
+    this.fs = new DaytonaSandboxFileSystem(sdkSandbox, workspaceBase);
   }
 
   async exec(command: string, options?: ExecOptions): Promise<ExecResult> {
@@ -77,9 +78,12 @@ export class DaytonaSandboxProvider
   };
 
   private client: Daytona;
+  private readonly defaultWorkspaceBase: string;
+  private workspaceBaseById = new Map<string, string>();
 
   constructor(config?: DaytonaSandboxConfig) {
     this.client = new Daytona(config);
+    this.defaultWorkspaceBase = config?.workspaceBase ?? "/home/daytona";
   }
 
   async create(
@@ -98,7 +102,13 @@ export class DaytonaSandboxProvider
       { timeout: options?.timeout ?? 60 },
     );
 
-    const sandbox = new DaytonaSandboxImpl(sdkSandbox.id, sdkSandbox);
+    const workspaceBase = options?.workspaceBase ?? this.defaultWorkspaceBase;
+    this.workspaceBaseById.set(sdkSandbox.id, workspaceBase);
+    const sandbox = new DaytonaSandboxImpl(
+      sdkSandbox.id,
+      sdkSandbox,
+      workspaceBase,
+    );
 
     if (options?.initialFiles) {
       for (const [path, content] of Object.entries(options.initialFiles)) {
@@ -112,7 +122,9 @@ export class DaytonaSandboxProvider
   async get(sandboxId: string): Promise<DaytonaSandbox> {
     try {
       const sdkSandbox = await this.client.get(sandboxId);
-      return new DaytonaSandboxImpl(sdkSandbox.id, sdkSandbox);
+      const workspaceBase =
+        this.workspaceBaseById.get(sandboxId) ?? this.defaultWorkspaceBase;
+      return new DaytonaSandboxImpl(sdkSandbox.id, sdkSandbox, workspaceBase);
     } catch {
       throw new SandboxNotFoundError(sandboxId);
     }
@@ -122,6 +134,7 @@ export class DaytonaSandboxProvider
     try {
       const sdkSandbox = await this.client.get(sandboxId);
       await this.client.delete(sdkSandbox);
+      this.workspaceBaseById.delete(sandboxId);
     } catch {
       // Already gone
     }

package/src/adapters/sandbox/daytona/types.ts

@@ -10,6 +10,8 @@ export interface DaytonaSandboxConfig {
   apiKey?: string;
   apiUrl?: string;
   target?: string;
+  /** Default base path for resolving relative filesystem paths. */
+  workspaceBase?: string;
 }
 
 export interface DaytonaSandboxCreateOptions extends SandboxCreateOptions {
@@ -31,4 +33,6 @@ export interface DaytonaSandboxCreateOptions extends SandboxCreateOptions {
   labels?: Record<string, string>;
   /** Timeout in seconds for sandbox creation. Default 60. */
   timeout?: number;
+  /** Base path for resolving relative filesystem paths in this sandbox. */
+  workspaceBase?: string;
 }

package/src/adapters/sandbox/inmemory/index.ts

@@ -26,14 +26,18 @@ import { getShortId } from "../../../lib/thread/id";
 // ============================================================================
 
 function toSandboxFs(fs: IFileSystem): SandboxFileSystem {
+  const workspaceBase = "/";
+  const normalisePath = (path: string): string => fs.resolvePath(workspaceBase, path);
+
   return {
-    readFile: (path) => fs.readFile(path),
-    readFileBuffer: (path) => fs.readFileBuffer(path),
-    writeFile: (path, content) => fs.writeFile(path, content),
-    appendFile: (path, content) => fs.appendFile(path, content),
-    exists: (path) => fs.exists(path),
+    workspaceBase,
+    readFile: (path) => fs.readFile(normalisePath(path)),
+    readFileBuffer: (path) => fs.readFileBuffer(normalisePath(path)),
+    writeFile: (path, content) => fs.writeFile(normalisePath(path), content),
+    appendFile: (path, content) => fs.appendFile(normalisePath(path), content),
+    exists: (path) => fs.exists(normalisePath(path)),
     stat: async (path): Promise<FileStat> => {
-      const s = await fs.stat(path);
+      const s = await fs.stat(normalisePath(path));
       return {
         isFile: s.isFile,
         isDirectory: s.isDirectory,
@@ -42,14 +46,16 @@ function toSandboxFs(fs: IFileSystem): SandboxFileSystem {
         mtime: s.mtime,
       };
     },
-    mkdir: (path, opts) => fs.mkdir(path, opts),
-    readdir: (path) => fs.readdir(path),
+    mkdir: (path, opts) => fs.mkdir(normalisePath(path), opts),
+    readdir: (path) => fs.readdir(normalisePath(path)),
     readdirWithFileTypes: async (path): Promise<DirentEntry[]> => {
+      const dirPath = normalisePath(path);
       if (!fs.readdirWithFileTypes) {
-        const names = await fs.readdir(path);
+        const names = await fs.readdir(dirPath);
         return Promise.all(
           names.map(async (name) => {
-            const s = await fs.stat(`${path}/${name}`);
+            const childPath = fs.resolvePath(dirPath, name);
+            const s = await fs.stat(childPath);
             return {
               name,
               isFile: s.isFile,
@@ -59,13 +65,13 @@ function toSandboxFs(fs: IFileSystem): SandboxFileSystem {
           })
         );
       }
-      return fs.readdirWithFileTypes(path);
+      return fs.readdirWithFileTypes(dirPath);
     },
-    rm: (path, opts) => fs.rm(path, opts),
-    cp: (src, dest, opts) => fs.cp(src, dest, opts),
-    mv: (src, dest) => fs.mv(src, dest),
-    readlink: (path) => fs.readlink(path),
-    resolvePath: (base, p) => fs.resolvePath(base, p),
+    rm: (path, opts) => fs.rm(normalisePath(path), opts),
+    cp: (src, dest, opts) => fs.cp(normalisePath(src), normalisePath(dest), opts),
+    mv: (src, dest) => fs.mv(normalisePath(src), normalisePath(dest)),
+    readlink: (path) => fs.readlink(normalisePath(path)),
+    resolvePath: (base, p) => fs.resolvePath(normalisePath(base), p),
   };
 }
 

package/src/adapters/sandbox/virtual/filesystem.ts

@@ -4,6 +4,7 @@ import type {
   FileStat,
 } from "../../../lib/sandbox/types";
 import { SandboxNotSupportedError } from "../../../lib/sandbox/types";
+import { posix } from "node:path";
 import type {
   FileEntry,
   FileEntryMetadata,
@@ -11,15 +12,9 @@ import type {
   TreeMutation,
 } from "./types";
 
-/**
- * Normalise a virtual path to a canonical form: absolute, no trailing slash
- * (except root), no double slashes.
- */
-function normalisePath(p: string): string {
-  if (!p.startsWith("/")) p = "/" + p;
-  p = p.replace(/\/+/g, "/");
-  if (p.length > 1 && p.endsWith("/")) p = p.slice(0, -1);
-  return p;
+/** Normalize a path against the provided workspace base. */
+function normalisePath(p: string, workspaceBase = "/"): string {
+  return posix.resolve(workspaceBase, p);
 }
 
 /** Return the parent directory of a normalised path ("/a/b" → "/a"). */
@@ -32,11 +27,14 @@ function parentDir(p: string): string {
  * Collect the set of implicit directory paths from a flat file list.
  * E.g. "/a/b/c.ts" contributes "/a/b", "/a", "/".
  */
-function inferDirectories(entries: { path: string }[]): Set<string> {
+function inferDirectories(
+  entries: { path: string }[],
+  workspaceBase: string,
+): Set<string> {
   const dirs = new Set<string>();
   dirs.add("/");
   for (const entry of entries) {
-    let dir = parentDir(normalisePath(entry.path));
+    let dir = parentDir(normalisePath(entry.path, workspaceBase));
     while (dir !== "/" && !dirs.has(dir)) {
       dirs.add(dir);
       dir = parentDir(dir);
@@ -58,6 +56,7 @@ export class VirtualSandboxFileSystem<
   TMeta = FileEntryMetadata,
 > implements SandboxFileSystem
 {
+  readonly workspaceBase: string;
   private entries: Map<string, FileEntry<TMeta>>;
   private directories: Set<string>;
   private mutations: TreeMutation<TMeta>[] = [];
@@ -66,11 +65,13 @@ export class VirtualSandboxFileSystem<
     tree: FileEntry<TMeta>[],
     private resolver: FileResolver<TCtx, TMeta>,
     private ctx: TCtx,
+    workspaceBase = "/",
   ) {
+    this.workspaceBase = normalisePath(workspaceBase);
     this.entries = new Map(
-      tree.map((e) => [normalisePath(e.path), e]),
+      tree.map((e) => [normalisePath(e.path, this.workspaceBase), e]),
     );
-    this.directories = inferDirectories(tree);
+    this.directories = inferDirectories(tree, this.workspaceBase);
   }
 
   /** Return all mutations accumulated during this invocation. */
@@ -80,7 +81,7 @@ export class VirtualSandboxFileSystem<
 
   /** Look up a file entry by virtual path. */
   getEntry(path: string): FileEntry<TMeta> | undefined {
-    return this.entries.get(normalisePath(path));
+    return this.entries.get(normalisePath(path, this.workspaceBase));
   }
 
   // --------------------------------------------------------------------------
@@ -88,13 +89,13 @@ export class VirtualSandboxFileSystem<
   // --------------------------------------------------------------------------
 
   async readFile(path: string): Promise<string> {
-    const entry = this.entries.get(normalisePath(path));
+    const entry = this.entries.get(normalisePath(path, this.workspaceBase));
     if (!entry) throw new Error(`ENOENT: no such file: ${path}`);
     return this.resolver.readFile(entry.id, this.ctx);
   }
 
   async readFileBuffer(path: string): Promise<Uint8Array> {
-    const entry = this.entries.get(normalisePath(path));
+    const entry = this.entries.get(normalisePath(path, this.workspaceBase));
     if (!entry) throw new Error(`ENOENT: no such file: ${path}`);
     return this.resolver.readFileBuffer(entry.id, this.ctx);
   }
@@ -104,12 +105,12 @@ export class VirtualSandboxFileSystem<
   // --------------------------------------------------------------------------
 
   async exists(path: string): Promise<boolean> {
-    const norm = normalisePath(path);
+    const norm = normalisePath(path, this.workspaceBase);
     return this.entries.has(norm) || this.directories.has(norm);
   }
 
   async stat(path: string): Promise<FileStat> {
-    const norm = normalisePath(path);
+    const norm = normalisePath(path, this.workspaceBase);
     const entry = this.entries.get(norm);
     if (entry) {
       return {
@@ -133,7 +134,7 @@ export class VirtualSandboxFileSystem<
   }
 
   async readdir(path: string): Promise<string[]> {
-    const norm = normalisePath(path);
+    const norm = normalisePath(path, this.workspaceBase);
     if (!this.directories.has(norm)) {
       throw new Error(`ENOENT: no such directory: ${path}`);
     }
@@ -159,7 +160,7 @@ export class VirtualSandboxFileSystem<
 
   async readdirWithFileTypes(path: string): Promise<DirentEntry[]> {
     const names = await this.readdir(path);
-    const norm = normalisePath(path);
+    const norm = normalisePath(path, this.workspaceBase);
     const prefix = norm === "/" ? "/" : norm + "/";
 
     return names.map((name) => {
@@ -175,7 +176,7 @@ export class VirtualSandboxFileSystem<
   // --------------------------------------------------------------------------
 
   async writeFile(path: string, content: string | Uint8Array): Promise<void> {
-    const norm = normalisePath(path);
+    const norm = normalisePath(path, this.workspaceBase);
     const existing = this.entries.get(norm);
 
     if (existing) {
@@ -201,7 +202,7 @@ export class VirtualSandboxFileSystem<
   }
 
   async appendFile(path: string, content: string | Uint8Array): Promise<void> {
-    const norm = normalisePath(path);
+    const norm = normalisePath(path, this.workspaceBase);
     const existing = this.entries.get(norm);
 
     if (!existing) {
@@ -226,7 +227,7 @@ export class VirtualSandboxFileSystem<
   }
 
   async mkdir(_path: string, _options?: { recursive?: boolean }): Promise<void> {
-    const norm = normalisePath(_path);
+    const norm = normalisePath(_path, this.workspaceBase);
     if (this.directories.has(norm)) return;
 
     if (_options?.recursive) {
@@ -245,7 +246,7 @@ export class VirtualSandboxFileSystem<
     path: string,
     options?: { recursive?: boolean; force?: boolean },
   ): Promise<void> {
-    const norm = normalisePath(path);
+    const norm = normalisePath(path, this.workspaceBase);
     const entry = this.entries.get(norm);
 
     if (entry) {
@@ -284,8 +285,8 @@ export class VirtualSandboxFileSystem<
     dest: string,
     _options?: { recursive?: boolean },
   ): Promise<void> {
-    const normSrc = normalisePath(src);
-    const normDest = normalisePath(dest);
+    const normSrc = normalisePath(src, this.workspaceBase);
+    const normDest = normalisePath(dest, this.workspaceBase);
 
     const entry = this.entries.get(normSrc);
     if (entry) {
@@ -325,10 +326,7 @@ export class VirtualSandboxFileSystem<
   }
 
   resolvePath(base: string, path: string): string {
-    if (path.startsWith("/")) return normalisePath(path);
-    const combined =
-      base.endsWith("/") ? base + path : base + "/" + path;
-    return normalisePath(combined);
+    return posix.resolve(normalisePath(base, this.workspaceBase), path);
   }
 
   // --------------------------------------------------------------------------
@@ -336,7 +334,7 @@ export class VirtualSandboxFileSystem<
   // --------------------------------------------------------------------------
 
   private addParentDirectories(filePath: string): void {
-    let dir = parentDir(normalisePath(filePath));
+    let dir = parentDir(normalisePath(filePath, this.workspaceBase));
     while (!this.directories.has(dir)) {
       this.directories.add(dir);
       dir = parentDir(dir);

package/src/adapters/sandbox/virtual/index.ts

@@ -34,9 +34,10 @@ class VirtualSandboxImpl<
     readonly id: string,
     tree: FileEntry<TMeta>[],
     resolver: FileResolver<TCtx, TMeta>,
-    ctx: TCtx
+    ctx: TCtx,
+    workspaceBase = "/",
   ) {
-    this.fs = new VirtualSandboxFileSystem(tree, resolver, ctx);
+    this.fs = new VirtualSandboxFileSystem(tree, resolver, ctx, workspaceBase);
   }
 
   async exec(_command: string, _options?: ExecOptions): Promise<ExecResult> {
@@ -67,8 +68,9 @@ export function createVirtualSandbox<
   tree: FileEntry<TMeta>[],
   resolver: FileResolver<TCtx, TMeta>,
   ctx: TCtx,
+  workspaceBase = "/",
 ): VirtualSandbox<TCtx, TMeta> {
-  return new VirtualSandboxImpl(id, tree, resolver, ctx);
+  return new VirtualSandboxImpl(id, tree, resolver, ctx, workspaceBase);
 }
 
 // Re-exports for convenience

package/src/adapters/sandbox/virtual/provider.ts

@@ -16,7 +16,7 @@ import type {
  * Stateless {@link SandboxProvider} backed by a {@link FileResolver}.
  *
  * The provider holds **no internal state**. All sandbox state (sandboxId,
- * fileTree, resolverContext) is returned as a `stateUpdate` from
+ * fileTree, resolverContext, workspaceBase) is returned as a `stateUpdate` from
  * {@link create} and merged into the workflow's `AgentState` by the session.
  * {@link withVirtualSandbox} reads this state back on every tool invocation.
  *
@@ -59,12 +59,14 @@ export class VirtualSandboxProvider<
     const fileTree = await this.resolver.resolveEntries(
       options.resolverContext
     );
+    const workspaceBase = options.workspaceBase ?? "/";
 
     const sandbox = createVirtualSandbox(
       sandboxId,
       fileTree,
       this.resolver,
-      options.resolverContext
+      options.resolverContext,
+      workspaceBase,
     );
 
     return {
@@ -73,6 +75,7 @@ export class VirtualSandboxProvider<
         sandboxId,
         fileTree,
         resolverContext: options.resolverContext,
+        workspaceBase,
       },
     };
   }

package/src/adapters/sandbox/virtual/types.ts

@@ -79,6 +79,8 @@ export interface VirtualSandboxCreateOptions<
   TCtx,
 > extends SandboxCreateOptions {
   resolverContext: TCtx;
+  /** Base path for resolving relative filesystem paths (default "/"). */
+  workspaceBase?: string;
 }
 
 // ============================================================================
@@ -97,6 +99,7 @@ export interface VirtualSandboxState<
   sandboxId: string;
   fileTree: FileEntry<TMeta>[];
   resolverContext: TCtx;
+  workspaceBase?: string;
 }
 
 // ============================================================================

package/src/adapters/sandbox/virtual/with-virtual-sandbox.ts

@@ -15,7 +15,7 @@ import { createVirtualSandbox } from "./index";
  * the parent workflow for the current file tree and resolver context.
  *
  * On each invocation the wrapper:
- * 1. Queries the workflow's `AgentState` for `fileTree` and `resolverContext`
+ * 1. Queries the workflow's `AgentState` for `fileTree`, `resolverContext`, and `workspaceBase`
  * 2. Creates an ephemeral {@link VirtualSandbox} from tree + provider's resolver
  * 3. Runs the inner handler
  * 4. Returns the handler's result together with any {@link TreeMutation}s
@@ -63,7 +63,7 @@ export function withVirtualSandbox<
     const state =
       await queryParentWorkflowState<VirtualSandboxState<TCtx, TMeta>>(client);
 
-    const { sandboxId, fileTree, resolverContext } = state;
+    const { sandboxId, fileTree, resolverContext, workspaceBase } = state;
     if (!fileTree || !sandboxId) {
       return {
         toolResponse: `Error: No fileTree/sandboxId in agent state. The ${context.toolName} tool requires a virtual sandbox.`,
@@ -75,7 +75,8 @@ export function withVirtualSandbox<
       sandboxId,
       fileTree,
       provider.resolver,
-      resolverContext
+      resolverContext,
+      workspaceBase ?? "/",
     );
     const response = await handler(args, { ...context, sandbox });
     const mutations = sandbox.fs.getMutations();