@rivet-dev/agentos-core 0.0.0-integrate-dylib-into-main.815fcda → 0.0.0-main.ab2ce7c

package/dist/runtime-compat.js

@@ -17,8 +17,13 @@ const S_IFREG = 0o100000;
 const S_IFDIR = 0o040000;
 const S_IFLNK = 0o120000;
 const MAX_SYMLINK_DEPTH = 40;
-const KERNEL_COMMAND_STUB = "#!/bin/sh\n# kernel command stub\n";
-const NODE_RUNTIME_BOOTSTRAP_COMMANDS = ["node", "npm", "npx"];
+const NODE_RUNTIME_BOOTSTRAP_COMMANDS = [
+    "node",
+    "npm",
+    "npx",
+    "python",
+    "python3",
+];
 const KERNEL_POSIX_BOOTSTRAP_DIRS = [
     "/dev",
     "/proc",
@@ -36,7 +41,8 @@ const KERNEL_POSIX_BOOTSTRAP_DIRS = [
     "/mnt",
     "/media",
     "/home",
-    "/home/user",
+    "/home/agentos",
+    "/workspace",
     "/usr",
     "/usr/bin",
     "/usr/games",
@@ -118,7 +124,7 @@ export class InMemoryFileSystem {
             throw errnoError("ENOENT", `open '${targetPath}'`);
         }
         entry.atimeMs = Date.now();
-        return entry.data;
+        return new Uint8Array(entry.data);
     }
     async readTextFile(targetPath) {
         return new TextDecoder().decode(await this.readFile(targetPath));
@@ -151,7 +157,9 @@ export class InMemoryFileSystem {
     async writeFile(targetPath, content) {
         const normalized = normalizePath(targetPath);
         await this.mkdir(dirnameVirtual(normalized), { recursive: true });
-        const data = typeof content === "string" ? new TextEncoder().encode(content) : content;
+        const data = typeof content === "string"
+            ? new TextEncoder().encode(content)
+            : new Uint8Array(content);
         const existing = this.entries.get(normalized);
         if (existing?.type === "file") {
             existing.data = data;
@@ -211,7 +219,7 @@ export class InMemoryFileSystem {
         return this.toStat(entry);
     }
     async removeFile(targetPath) {
-        const resolved = this.resolvePath(targetPath);
+        const resolved = normalizePath(targetPath);
         const entry = this.entries.get(resolved);
         if (!entry || entry.type === "dir") {
             throw errnoError("ENOENT", `unlink '${targetPath}'`);
@@ -373,7 +381,7 @@ export class InMemoryFileSystem {
         const nextSize = Math.max(entry.data.length, offset + data.length);
         const updated = new Uint8Array(nextSize);
         updated.set(entry.data);
-        updated.set(data, offset);
+        updated.set(new Uint8Array(data), offset);
         entry.data = updated;
         entry.mtimeMs = Date.now();
         entry.ctimeMs = Date.now();
@@ -729,6 +737,7 @@ export function createNodeDriver(options = {}) {
         network: options.networkAdapter,
         commandExecutor: options.commandExecutor,
         permissions: options.permissions,
+        mounts: options.mounts ?? [],
         runtime: {
             process: options.processConfig ?? {},
             os: options.osConfig ?? {},
@@ -816,7 +825,6 @@ export const WASMVM_COMMANDS = Object.freeze([
     "sqlite3",
     "curl",
     "wget",
-    "make",
     "git",
     "git-remote-http",
     "git-remote-https",
@@ -915,7 +923,6 @@ export const DEFAULT_FIRST_PARTY_TIERS = Object.freeze({
     nice: "full",
     nohup: "full",
     stdbuf: "full",
-    make: "full",
     codex: "full",
     "codex-exec": "full",
     git: "full",
@@ -1015,7 +1022,7 @@ function isWasmBinaryFile(filePath) {
 function discoverWasmCommandEntries(commandDirs) {
     const discovered = [];
     const seen = new Set();
-    commandDirs.forEach((commandDir, dirOffset) => {
+    for (const commandDir of commandDirs) {
         let entries;
         try {
             entries = fsSync
@@ -1023,7 +1030,7 @@ function discoverWasmCommandEntries(commandDirs) {
                 .sort((left, right) => left.localeCompare(right));
         }
         catch {
-            return;
+            continue;
         }
         for (const entry of entries) {
             if (entry.startsWith("."))
@@ -1036,7 +1043,6 @@ function discoverWasmCommandEntries(commandDirs) {
                 discovered.push({
                     name: entry,
                     hostPath: fullPath,
-                    dirOffset,
                 });
                 continue;
             }
@@ -1047,13 +1053,12 @@ function discoverWasmCommandEntries(commandDirs) {
                     discovered.push({
                         name: entry,
                         hostPath: fullPath,
-                        dirOffset,
                     });
                 }
             }
             catch { }
         }
-    });
+    }
     return discovered;
 }
 class WasmVmRuntimeDescriptor {
@@ -1063,7 +1068,6 @@ class WasmVmRuntimeDescriptor {
     commandDirs;
     _commandPaths = new Map();
     _moduleCache = new Map();
-    commandDirOffsets = new Map();
     constructor(options) {
         this.commandDirs =
             options.commandDirs && options.commandDirs.length > 0
@@ -1094,17 +1098,6 @@ class WasmVmRuntimeDescriptor {
         this.refreshDiscovery();
         return this._commandPaths.has(normalized);
     }
-    getGuestCommandPaths(startIndex) {
-        const guestPaths = new Map();
-        for (const [name] of this._commandPaths) {
-            const dirOffset = this.commandDirOffsets.get(name);
-            if (dirOffset === undefined) {
-                continue;
-            }
-            guestPaths.set(name, `/__secure_exec/commands/${startIndex + dirOffset}/${name}`);
-        }
-        return guestPaths;
-    }
     recordModuleExecution(command) {
         const normalized = normalizeCommandLookup(command);
         if (this._commandPaths.has(normalized) ||
@@ -1120,11 +1113,9 @@ class WasmVmRuntimeDescriptor {
         const discovered = discoverWasmCommandEntries(this.commandDirs);
         this.commands.length = 0;
         this._commandPaths.clear();
-        this.commandDirOffsets.clear();
         for (const entry of discovered) {
             this.commands.push(entry.name);
             this._commandPaths.set(entry.name, entry.hostPath);
-            this.commandDirOffsets.set(entry.name, entry.dirOffset);
         }
     }
 }
@@ -1190,8 +1181,8 @@ function ensureNativeSidecarBinary() {
 function rootEntryExecutable(kind, mode) {
     return kind === "file" && (mode & 0o111) !== 0;
 }
-function createBootstrapEntries(commandNames) {
-    const entries = [
+function createBootstrapEntries() {
+    return [
         {
             path: "/",
             kind: "directory",
@@ -1219,19 +1210,6 @@ function createBootstrapEntries(commandNames) {
             executable: false,
         },
     ];
-    for (const command of [...new Set(commandNames)].sort((left, right) => left.localeCompare(right))) {
-        entries.push({
-            path: `/bin/${command}`,
-            kind: "file",
-            mode: 0o755,
-            uid: 0,
-            gid: 0,
-            content: KERNEL_COMMAND_STUB,
-            encoding: "utf8",
-            executable: true,
-        });
-    }
-    return entries;
 }
 function mergeRootFilesystemEntries(baseEntries, overrideEntries) {
     const merged = new Map();
@@ -1372,23 +1350,6 @@ function planNodeFilesystemPassthroughMounts(filesystem, existingMounts) {
         passthroughDirectories,
     };
 }
-function collectGuestCommandPaths(commandDirs, startIndex = 0) {
-    const guestPaths = new Map();
-    for (const entry of discoverWasmCommandEntries(commandDirs)) {
-        if (!guestPaths.has(entry.name)) {
-            guestPaths.set(entry.name, `/__secure_exec/commands/${startIndex + entry.dirOffset}/${entry.name}`);
-        }
-    }
-    return guestPaths;
-}
-async function ensureCommandStubs(proxy, commands) {
-    const rootView = proxy.createRootView();
-    for (const command of commands) {
-        const stubPath = `/bin/${command}`;
-        await rootView.writeFile(stubPath, KERNEL_COMMAND_STUB);
-        await rootView.chmod(stubPath, 0o755);
-    }
-}
 class DeferredFileSystem {
     getFilesystem;
     constructor(getFilesystem) {
@@ -1606,6 +1567,35 @@ function bindLiveFilesystem(target, getFilesystem) {
         },
     };
 }
+function serializeLocalCompatMountForSidecar(mount) {
+    return (mount.sidecarMount ??
+        (mount.fs instanceof NodeFileSystem
+            ? serializeMountConfigForSidecar({
+                path: mount.path,
+                readOnly: mount.readOnly,
+                plugin: {
+                    id: "host_dir",
+                    config: {
+                        hostPath: mount.fs.rootPath,
+                        readOnly: mount.readOnly,
+                    },
+                },
+            })
+            : serializeMountConfigForSidecar({
+                path: mount.path,
+                driver: mount.fs,
+                readOnly: mount.readOnly,
+            })));
+}
+function makeLocalCompatMount(options) {
+    const localMount = {
+        path: normalizePath(options.path),
+        fs: options.fs,
+        readOnly: options.readOnly ?? false,
+    };
+    localMount.sidecarMount = serializeLocalCompatMountForSidecar(localMount);
+    return localMount;
+}
 class NativeKernel {
     options;
     env;
@@ -1627,12 +1617,11 @@ class NativeKernel {
     pendingLocalMounts = [];
     mountedCommandDirs = [];
     mountedRuntimeDrivers = [];
-    runtimeDriverCommandDirStarts = new Map();
     loopbackExemptPorts;
     constructor(options) {
         this.options = options;
         this.env = { ...(options.env ?? {}) };
-        this.cwd = options.cwd ?? "/home/user";
+        this.cwd = options.cwd ?? "/workspace";
         this.socketTable = {
             hasHostNetworkAdapter: () => Boolean(options.hostNetworkAdapter),
             findListener: (request) => this.proxy?.findListener(request) ?? null,
@@ -1645,11 +1634,11 @@ class NativeKernel {
         };
         this.loopbackExemptPorts = [...(options.loopbackExemptPorts ?? [])];
         for (const mount of options.mounts ?? []) {
-            this.pendingLocalMounts.push({
-                path: normalizePath(mount.path),
+            this.pendingLocalMounts.push(makeLocalCompatMount({
+                path: mount.path,
                 fs: mount.fs,
-                readOnly: mount.readOnly ?? false,
-            });
+                readOnly: mount.readOnly,
+            }));
         }
         this.vfs = new DeferredFileSystem(() => this.rootFilesystem);
         this.liveFilesystemBinding = bindLiveFilesystem(this.options.filesystem, () => this.rootFilesystem);
@@ -1657,6 +1646,32 @@ class NativeKernel {
     get zombieTimerCount() {
         return this.proxy?.zombieTimerCount ?? 0;
     }
+    async configureRuntimeCommandStubs(commands, commandDirs = this.mountedCommandDirs) {
+        if (!this.client || !this.session || !this.vm) {
+            throw new Error("kernel is not ready");
+        }
+        const sidecarMounts = commandDirs.map((commandDir, index) => serializeMountConfigForSidecar({
+            path: `/__secure_exec/commands/${index}`,
+            readOnly: true,
+            plugin: {
+                id: "host_dir",
+                config: {
+                    hostPath: commandDir,
+                    readOnly: true,
+                },
+            },
+        }));
+        const localMounts = this.pendingLocalMounts.map((mount) => serializeLocalCompatMountForSidecar(mount));
+        const configuredVm = await this.client.configureVm(this.session, this.vm, {
+            mounts: [...localMounts, ...sidecarMounts],
+            loopbackExemptPorts: this.loopbackExemptPorts,
+            bootstrapCommands: [...new Set(commands)].sort((left, right) => left.localeCompare(right)),
+        });
+        return new Map(configuredVm.projectedCommands.map((command) => [
+            command.name,
+            command.guestPath,
+        ]));
+    }
     async mount(driver) {
         await this.ensureReady();
         if (!this.proxy || !this.client || !this.session || !this.vm) {
@@ -1668,7 +1683,7 @@ class NativeKernel {
                 this.commands.set(command, "node");
             }
             this.mountedRuntimeDrivers.push(driver);
-            await ensureCommandStubs(this.proxy, driver.commands);
+            await this.configureRuntimeCommandStubs(driver.commands);
             return;
         }
         const commandDirs = driver.commandDirs ?? [];
@@ -1677,53 +1692,17 @@ class NativeKernel {
                 this.commands.set(command, "wasmvm");
             }
             this.mountedRuntimeDrivers.push(driver);
-            await ensureCommandStubs(this.proxy, driver.commands);
+            await this.configureRuntimeCommandStubs(driver.commands);
             return;
         }
-        const startIndex = this.mountedCommandDirs.length;
-        const newGuestPaths = driver.getGuestCommandPaths?.(startIndex) ??
-            collectGuestCommandPaths(commandDirs, startIndex);
         const allCommandDirs = [...this.mountedCommandDirs, ...commandDirs];
-        const sidecarMounts = allCommandDirs.map((commandDir, index) => serializeMountConfigForSidecar({
-            path: `/__secure_exec/commands/${index}`,
-            readOnly: true,
-            plugin: {
-                id: "host_dir",
-                config: {
-                    hostPath: commandDir,
-                    readOnly: true,
-                },
-            },
-        }));
-        const localMounts = this.pendingLocalMounts.map((mount) => mount.fs instanceof NodeFileSystem
-            ? serializeMountConfigForSidecar({
-                path: mount.path,
-                readOnly: mount.readOnly,
-                plugin: {
-                    id: "host_dir",
-                    config: {
-                        hostPath: mount.fs.rootPath,
-                        readOnly: mount.readOnly,
-                    },
-                },
-            })
-            : serializeMountConfigForSidecar({
-                path: mount.path,
-                driver: mount.fs,
-                readOnly: mount.readOnly,
-            }));
-        await this.client.configureVm(this.session, this.vm, {
-            mounts: [...localMounts, ...sidecarMounts],
-            loopbackExemptPorts: this.loopbackExemptPorts,
-        });
-        this.proxy.registerCommandGuestPaths(newGuestPaths);
+        const projectedCommands = await this.configureRuntimeCommandStubs(driver.commands, allCommandDirs);
+        this.proxy.registerCommandGuestPaths(projectedCommands);
         this.mountedCommandDirs.push(...commandDirs);
         this.mountedRuntimeDrivers.push(driver);
-        this.runtimeDriverCommandDirStarts.set(driver, startIndex);
-        for (const command of newGuestPaths.keys()) {
+        for (const command of projectedCommands.keys()) {
             this.commands.set(command, "wasmvm");
         }
-        await ensureCommandStubs(this.proxy, newGuestPaths.keys());
     }
     async dispose() {
         await this.readyPromise?.catch(() => { });
@@ -1784,10 +1763,10 @@ class NativeKernel {
         return {
             pid: proc.pid,
             writeStdin(data) {
-                proc.writeStdin(data);
+                return proc.writeStdin(data);
             },
             closeStdin() {
-                proc.closeStdin();
+                return proc.closeStdin();
             },
             kill(signal) {
                 proc.kill(signal);
@@ -1817,17 +1796,27 @@ class NativeKernel {
         return this.proxy.connectTerminal(options);
     }
     mountFs(mountPath, filesystem, options) {
+        const localMount = makeLocalCompatMount({
+            path: mountPath,
+            fs: filesystem,
+            readOnly: options?.readOnly,
+        });
+        this.pendingLocalMounts.unshift(localMount);
+        this.pendingLocalMounts.sort((left, right) => right.path.length - left.path.length);
         if (!this.proxy) {
-            this.pendingLocalMounts.push({
-                path: normalizePath(mountPath),
-                fs: filesystem,
-                readOnly: options?.readOnly ?? false,
-            });
             return;
         }
-        this.proxy.mountFs(mountPath, filesystem, options);
+        this.proxy.mountFs(mountPath, filesystem, {
+            readOnly: localMount.readOnly,
+            sidecarMount: localMount.sidecarMount,
+        });
     }
     unmountFs(mountPath) {
+        const normalized = normalizePath(mountPath);
+        const pendingIndex = this.pendingLocalMounts.findIndex((mount) => mount.path === normalized);
+        if (pendingIndex >= 0) {
+            this.pendingLocalMounts.splice(pendingIndex, 1);
+        }
         this.proxy?.unmountFs(mountPath);
     }
     async readFile(targetPath) {
@@ -1846,6 +1835,10 @@ class NativeKernel {
         await this.ensureReady();
         return this.proxy.readdir(targetPath);
     }
+    async readdirRecursive(targetPath, options) {
+        await this.ensureReady();
+        return this.proxy.readdirRecursive(targetPath, options);
+    }
     async stat(targetPath) {
         await this.ensureReady();
         return this.proxy.stat(targetPath);
@@ -1862,10 +1855,18 @@ class NativeKernel {
         await this.ensureReady();
         return this.proxy.removeDir(targetPath);
     }
+    async removePath(targetPath, options) {
+        await this.ensureReady();
+        return this.proxy.removePath(targetPath, options);
+    }
     async rename(oldPath, newPath) {
         await this.ensureReady();
         return this.proxy.rename(oldPath, newPath);
     }
+    async movePath(oldPath, newPath) {
+        await this.ensureReady();
+        return this.proxy.movePath(oldPath, newPath);
+    }
     tryResolveMountedCommand(command) {
         const normalized = normalizeCommandLookup(command);
         for (const driver of this.mountedRuntimeDrivers) {
@@ -1873,15 +1874,6 @@ class NativeKernel {
                 continue;
             }
             this.commands.set(normalized, driver.kind);
-            if (driver.kind === "wasmvm" && this.proxy) {
-                const startIndex = this.runtimeDriverCommandDirStarts.get(driver);
-                if (startIndex !== undefined) {
-                    const guestPaths = driver.getGuestCommandPaths?.(startIndex);
-                    if (guestPaths?.has(normalized)) {
-                        this.proxy.registerCommandGuestPaths(new Map([[normalized, guestPaths.get(normalized)]]));
-                    }
-                }
-            }
             return true;
         }
         return false;
@@ -1916,7 +1908,7 @@ class NativeKernel {
             lowers: [
                 {
                     kind: "snapshot",
-                    entries: rootFilesystemEntriesForConfig(mergeRootFilesystemEntries(createBootstrapEntries([...NODE_RUNTIME_BOOTSTRAP_COMMANDS]), snapshotEntries)),
+                    entries: rootFilesystemEntriesForConfig(mergeRootFilesystemEntries(createBootstrapEntries(), snapshotEntries)),
                 },
             ],
             bootstrapEntries: [],
@@ -1935,6 +1927,7 @@ class NativeKernel {
                 ? serializePermissionsForSidecar(bootstrapPermissions)
                 : undefined,
             loopbackExemptPorts: this.loopbackExemptPorts,
+            bootstrapCommands: [...NODE_RUNTIME_BOOTSTRAP_COMMANDS],
         };
         const vm = await client.createVm(session, {
             runtime: "java_script",
@@ -1954,41 +1947,34 @@ class NativeKernel {
             await materializeSnapshotEntriesIntoVm(client, session, vm, snapshotEntries);
         }
         if (rootPassthroughPlan.mounts.length > 0) {
-            this.pendingLocalMounts.push(...rootPassthroughPlan.mounts);
+            this.pendingLocalMounts.push(...rootPassthroughPlan.mounts.map((mount) => makeLocalCompatMount({
+                path: mount.path,
+                fs: mount.fs,
+                readOnly: mount.readOnly,
+            })));
         }
         if (this.pendingLocalMounts.length > 0 ||
             this.loopbackExemptPorts.length > 0 ||
             requestedPermissions) {
+            const sidecarMounts = this.pendingLocalMounts.map((mount) => serializeLocalCompatMountForSidecar(mount));
             await client.configureVm(session, vm, {
-                mounts: this.pendingLocalMounts.map((mount) => mount.fs instanceof NodeFileSystem
-                    ? serializeMountConfigForSidecar({
-                        path: mount.path,
-                        readOnly: mount.readOnly,
-                        plugin: {
-                            id: "host_dir",
-                            config: {
-                                hostPath: mount.fs.rootPath,
-                                readOnly: mount.readOnly,
-                            },
-                        },
-                    })
-                    : serializeMountConfigForSidecar({
-                        path: mount.path,
-                        driver: mount.fs,
-                        readOnly: mount.readOnly,
-                    })),
+                mounts: sidecarMounts,
                 permissions: requestedPermissions,
                 loopbackExemptPorts: this.loopbackExemptPorts,
             });
         }
+        const configuredSidecarMounts = this.pendingLocalMounts.map((mount) => serializeLocalCompatMountForSidecar(mount));
         const proxy = new NativeSidecarKernelProxy({
             client,
             session,
             vm,
             env: this.env,
             cwd: this.cwd,
-            defaultExecCwd: this.options.cwd === undefined ? "/home/user" : this.cwd,
+            defaultExecCwd: this.options.cwd === undefined ? "/workspace" : this.cwd,
             localMounts: this.pendingLocalMounts,
+            sidecarMounts: configuredSidecarMounts,
+            permissions: requestedPermissions,
+            loopbackExemptPorts: this.loopbackExemptPorts,
             commandGuestPaths: new Map(),
             onWasmCommandResolved: (command) => {
                 this.recordModuleExecution(command);

package/dist/runtime.d.ts

@@ -76,7 +76,7 @@ export type NetworkPermissions = PermissionMode | RulePermissions<PatternPermiss
 export type ChildProcessPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export type ProcessPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export type EnvPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
-export type ToolPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
+export type BindingPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export interface ProcessInfo {
     pid: number;
     ppid: number;
@@ -93,15 +93,15 @@ export interface ProcessInfo {
 }
 export interface ManagedProcess {
     pid: number;
-    writeStdin(data: Uint8Array | string): void;
-    closeStdin(): void;
+    writeStdin(data: Uint8Array | string): Promise<void>;
+    closeStdin(): Promise<void>;
     kill(signal?: number): void;
     wait(): Promise<number>;
     readonly exitCode: number | null;
 }
 export interface ShellHandle {
     pid: number;
-    write(data: Uint8Array | string): void;
+    write(data: Uint8Array | string): Promise<void>;
     onData: ((data: Uint8Array) => void) | null;
     resize(cols: number, rows: number): void;
     kill(signal?: number): void;
@@ -163,7 +163,7 @@ export interface Permissions {
     childProcess?: ChildProcessPermissions;
     process?: ProcessPermissions;
     env?: EnvPermissions;
-    tool?: ToolPermissions;
+    binding?: BindingPermissions;
 }
 export interface ResourceBudgets {
     maxOutputBytes?: number;
@@ -224,6 +224,7 @@ export interface SystemDriver {
     network?: NetworkAdapter;
     commandExecutor?: CommandExecutor;
     permissions?: Permissions;
+    mounts: readonly NodeModulesMountConfig[];
     runtime: {
         process: ProcessConfig;
         os: OSConfig;
@@ -258,6 +259,13 @@ export interface NodeRuntimeDriverFactory {
 export interface KernelInterface {
     vfs: VirtualFileSystem;
 }
+export interface KernelRecursiveDirEntry {
+    name: string;
+    path: string;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+    size: number;
+}
 export interface Kernel extends KernelInterface {
     mount(driver: KernelRuntimeDriver): Promise<void>;
     dispose(): Promise<void>;
@@ -273,11 +281,18 @@ export interface Kernel extends KernelInterface {
     writeFile(path: string, content: string | Uint8Array): Promise<void>;
     mkdir(path: string): Promise<void>;
     readdir(path: string): Promise<string[]>;
+    readdirRecursive(path: string, options?: {
+        maxDepth?: number;
+    }): Promise<KernelRecursiveDirEntry[]>;
     stat(path: string): Promise<VirtualStat>;
     exists(path: string): Promise<boolean>;
     removeFile(path: string): Promise<void>;
     removeDir(path: string): Promise<void>;
+    removePath(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
     rename(oldPath: string, newPath: string): Promise<void>;
+    movePath(oldPath: string, newPath: string): Promise<void>;
     readonly commands: ReadonlyMap<string, string>;
     readonly processes: ReadonlyMap<number, ProcessInfo>;
     readonly env: Record<string, string>;
@@ -299,11 +314,23 @@ export interface BindingTree {
     [key: string]: BindingFunction | BindingTree;
 }
 export type BindingFunction = (...args: unknown[]) => unknown;
+export interface NodeModulesMountConfig {
+    path: string;
+    plugin: {
+        id: "host_dir";
+        config: {
+            hostPath: string;
+            readOnly: boolean;
+        };
+    };
+    readOnly: boolean;
+}
 export interface NodeDriverOptions {
     filesystem?: VirtualFileSystem;
     networkAdapter?: NetworkAdapter;
     commandExecutor?: CommandExecutor;
     permissions?: Permissions;
+    mounts?: readonly NodeModulesMountConfig[];
     processConfig?: ProcessConfig;
     osConfig?: OSConfig;
 }