@rivet-dev/agentos-core 0.2.5-rc.2 → 0.2.5-rc.4

package/dist/index.js

@@ -1,6 +1,5 @@
 // @rivet-dev/agentos
 export { AgentOs, AgentOsSidecar } from "./agent-os.js";
-export { AGENT_CONFIGS } from "./agents.js";
 export { CronManager, InvalidScheduleError, PastScheduleError, TimerScheduleDriver, } from "./cron/index.js";
 export { createHostDirBackend, nodeModulesMount } from "./host-dir-mount.js";
 export { hostTool, MAX_TOOL_DESCRIPTION_LENGTH, toolKit, validateToolkits, } from "./host-tools.js";

package/dist/options-schema.d.ts

@@ -151,6 +151,10 @@ export declare const agentOsLimitsSchema: z.ZodObject<{
     }, z.core.$strict>>;
     jsRuntime: z.ZodOptional<z.ZodObject<{
         v8HeapLimitMb: z.ZodOptional<z.ZodNumber>;
+        syncRpcWaitTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        cpuTimeLimitMs: z.ZodOptional<z.ZodNumber>;
+        wallClockLimitMs: z.ZodOptional<z.ZodNumber>;
+        importCacheMaterializeTimeoutMs: z.ZodOptional<z.ZodNumber>;
         capturedOutputLimitBytes: z.ZodOptional<z.ZodNumber>;
         stdinBufferLimitBytes: z.ZodOptional<z.ZodNumber>;
         eventPayloadLimitBytes: z.ZodOptional<z.ZodNumber>;
@@ -159,12 +163,15 @@ export declare const agentOsLimitsSchema: z.ZodObject<{
     python: z.ZodOptional<z.ZodObject<{
         outputBufferMaxBytes: z.ZodOptional<z.ZodNumber>;
         executionTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxOldSpaceMb: z.ZodOptional<z.ZodNumber>;
         vfsRpcTimeoutMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
     wasm: z.ZodOptional<z.ZodObject<{
         maxModuleFileBytes: z.ZodOptional<z.ZodNumber>;
         capturedOutputLimitBytes: z.ZodOptional<z.ZodNumber>;
         syncReadLimitBytes: z.ZodOptional<z.ZodNumber>;
+        prewarmTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        runnerHeapLimitMb: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const rootFilesystemConfigSchema: z.ZodObject<{
@@ -255,7 +262,6 @@ export declare const agentOsOptionFieldSchemas: {
             lowers: z.ZodArray<z.ZodUnknown>;
         }, z.core.$strict>;
     }, z.core.$strict>]>>>;
-    readonly moduleAccessCwd: z.ZodOptional<z.ZodString>;
     readonly additionalInstructions: z.ZodOptional<z.ZodString>;
     readonly scheduleDriver: z.ZodOptional<z.ZodCustom<unknown, unknown>>;
     readonly toolKits: z.ZodOptional<z.ZodArray<z.ZodType<ToolKit, unknown, z.core.$ZodTypeInternals<ToolKit, unknown>>>>;
@@ -416,6 +422,10 @@ export declare const agentOsOptionFieldSchemas: {
         }, z.core.$strict>>;
         jsRuntime: z.ZodOptional<z.ZodObject<{
             v8HeapLimitMb: z.ZodOptional<z.ZodNumber>;
+            syncRpcWaitTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            cpuTimeLimitMs: z.ZodOptional<z.ZodNumber>;
+            wallClockLimitMs: z.ZodOptional<z.ZodNumber>;
+            importCacheMaterializeTimeoutMs: z.ZodOptional<z.ZodNumber>;
             capturedOutputLimitBytes: z.ZodOptional<z.ZodNumber>;
             stdinBufferLimitBytes: z.ZodOptional<z.ZodNumber>;
             eventPayloadLimitBytes: z.ZodOptional<z.ZodNumber>;
@@ -424,12 +434,15 @@ export declare const agentOsOptionFieldSchemas: {
         python: z.ZodOptional<z.ZodObject<{
             outputBufferMaxBytes: z.ZodOptional<z.ZodNumber>;
             executionTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            maxOldSpaceMb: z.ZodOptional<z.ZodNumber>;
             vfsRpcTimeoutMs: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
         wasm: z.ZodOptional<z.ZodObject<{
             maxModuleFileBytes: z.ZodOptional<z.ZodNumber>;
             capturedOutputLimitBytes: z.ZodOptional<z.ZodNumber>;
             syncReadLimitBytes: z.ZodOptional<z.ZodNumber>;
+            prewarmTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            runnerHeapLimitMb: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
     readonly onAgentStderr: z.ZodOptional<z.ZodCustom<AgentStderrHandler, AgentStderrHandler>>;

package/dist/options-schema.js

@@ -73,59 +73,66 @@ export const agentOsLimitsSchema = z
         .strict()
         .optional(),
     http: z
-        .object({ maxFetchResponseBytes: nonNegativeInteger.optional() })
+        .object({ maxFetchResponseBytes: positiveInteger.optional() })
         .strict()
         .optional(),
     tools: z
         .object({
         defaultToolTimeoutMs: nonNegativeInteger.optional(),
         maxToolTimeoutMs: nonNegativeInteger.optional(),
-        maxRegisteredToolkits: nonNegativeInteger.optional(),
-        maxRegisteredToolsPerVm: nonNegativeInteger.optional(),
-        maxToolsPerToolkit: nonNegativeInteger.optional(),
-        maxToolSchemaBytes: nonNegativeInteger.optional(),
+        maxRegisteredToolkits: positiveInteger.optional(),
+        maxRegisteredToolsPerVm: positiveInteger.optional(),
+        maxToolsPerToolkit: positiveInteger.optional(),
+        maxToolSchemaBytes: positiveInteger.optional(),
         maxToolExamplesPerTool: nonNegativeInteger.optional(),
-        maxToolExampleInputBytes: nonNegativeInteger.optional(),
+        maxToolExampleInputBytes: positiveInteger.optional(),
     })
         .strict()
         .optional(),
     plugins: z
         .object({
-        maxPersistedManifestBytes: nonNegativeInteger.optional(),
+        maxPersistedManifestBytes: positiveInteger.optional(),
         maxPersistedManifestFileBytes: nonNegativeInteger.optional(),
     })
         .strict()
         .optional(),
     acp: z
         .object({
-        maxReadLineBytes: nonNegativeInteger.optional(),
-        stdoutBufferByteLimit: nonNegativeInteger.optional(),
+        maxReadLineBytes: positiveInteger.optional(),
+        stdoutBufferByteLimit: positiveInteger.optional(),
     })
         .strict()
         .optional(),
     jsRuntime: z
         .object({
-        v8HeapLimitMb: nonNegativeInteger.optional(),
-        capturedOutputLimitBytes: nonNegativeInteger.optional(),
-        stdinBufferLimitBytes: nonNegativeInteger.optional(),
-        eventPayloadLimitBytes: nonNegativeInteger.optional(),
-        v8IpcMaxFrameBytes: nonNegativeInteger.optional(),
+        v8HeapLimitMb: positiveInteger.optional(),
+        syncRpcWaitTimeoutMs: nonNegativeInteger.optional(),
+        cpuTimeLimitMs: nonNegativeInteger.optional(),
+        wallClockLimitMs: nonNegativeInteger.optional(),
+        importCacheMaterializeTimeoutMs: positiveInteger.optional(),
+        capturedOutputLimitBytes: positiveInteger.optional(),
+        stdinBufferLimitBytes: positiveInteger.optional(),
+        eventPayloadLimitBytes: positiveInteger.optional(),
+        v8IpcMaxFrameBytes: positiveInteger.optional(),
     })
         .strict()
         .optional(),
     python: z
         .object({
-        outputBufferMaxBytes: nonNegativeInteger.optional(),
-        executionTimeoutMs: nonNegativeInteger.optional(),
-        vfsRpcTimeoutMs: nonNegativeInteger.optional(),
+        outputBufferMaxBytes: positiveInteger.optional(),
+        executionTimeoutMs: positiveInteger.optional(),
+        maxOldSpaceMb: nonNegativeInteger.optional(),
+        vfsRpcTimeoutMs: positiveInteger.optional(),
     })
         .strict()
         .optional(),
     wasm: z
         .object({
-        maxModuleFileBytes: nonNegativeInteger.optional(),
-        capturedOutputLimitBytes: nonNegativeInteger.optional(),
-        syncReadLimitBytes: nonNegativeInteger.optional(),
+        maxModuleFileBytes: positiveInteger.optional(),
+        capturedOutputLimitBytes: positiveInteger.optional(),
+        syncReadLimitBytes: positiveInteger.optional(),
+        prewarmTimeoutMs: positiveInteger.optional(),
+        runnerHeapLimitMb: positiveInteger.optional(),
     })
         .strict()
         .optional(),
@@ -239,7 +246,6 @@ export const agentOsOptionFieldSchemas = {
     highResolutionTime: z.boolean().optional(),
     rootFilesystem: rootFilesystemConfigSchema.optional(),
     mounts: z.array(mountConfigSchema).optional(),
-    moduleAccessCwd: z.string().optional(),
     additionalInstructions: z.string().optional(),
     scheduleDriver: z
         .custom((value) => typeof value === "object" && value !== null, {

package/dist/packages.d.ts

@@ -1,4 +1,4 @@
-import { type SoftwarePackageRef } from "./agentos-package.js";
+import type { SoftwarePackageRef } from "./agentos-package.js";
 /**
  * Input type for the `software` option. Software is a self-contained package
  * directory that the secure-exec sidecar materializes into the `/opt/agentos`
@@ -23,6 +23,6 @@ export declare function defineSoftware<T extends SoftwareEntry>(desc: T): T;
  * the software set. Returns its source so it can be evaluated once into the
  * per-sidecar V8 startup snapshot (`jsRuntime.snapshotUserlandCode`) and reused
  * across sessions. Returns `undefined` when no agent opts in (`agent.snapshot`)
- * or the bundle is absent — the runtime then keeps the per-session import path.
+ * or the bundle is absent -- the runtime then keeps the per-session import path.
  */
 export declare function resolveAgentSnapshotBundle(software: SoftwareInput[]): string | undefined;

package/dist/packages.js

@@ -1,6 +1,6 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { tryReadAgentosPackageManifest, } from "./agentos-package.js";
+import { tryReadAgentosPackageManifest } from "./agentos-package.js";
 // ── defineSoftware ───────────────────────────────────────────────────
 /**
  * Define a software descriptor. A type-safe identity function that validates the
@@ -16,19 +16,33 @@ export function defineSoftware(desc) {
  * the software set. Returns its source so it can be evaluated once into the
  * per-sidecar V8 startup snapshot (`jsRuntime.snapshotUserlandCode`) and reused
  * across sessions. Returns `undefined` when no agent opts in (`agent.snapshot`)
- * or the bundle is absent — the runtime then keeps the per-session import path.
+ * or the bundle is absent -- the runtime then keeps the per-session import path.
  */
 export function resolveAgentSnapshotBundle(software) {
     const descriptors = software.flat();
     for (const entry of descriptors) {
-        const dir = entry.packageDir;
-        const manifest = tryReadAgentosPackageManifest(dir);
+        // Only transition package DIRS are readable host-side (their
+        // agentos-package.json is the toolchain-input manifest). Packed
+        // `.aospkg` refs carry the bundle inside the mount tar; the sidecar
+        // reads it from the packed vbare manifest's snapshotBundlePath.
+        const path = entry.packagePath;
+        if (path === undefined || !statIsDirectory(path))
+            continue;
+        const manifest = tryReadAgentosPackageManifest(path);
         if (!manifest?.agent?.snapshot)
             continue;
-        const bundlePath = join(dir, "dist", "sdk-snapshot.js");
+        const bundlePath = join(path, "dist", "sdk-snapshot.js");
         if (existsSync(bundlePath)) {
             return readFileSync(bundlePath, "utf-8");
         }
     }
     return undefined;
 }
+function statIsDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/runtime-compat.d.ts

@@ -1,3 +1,4 @@
+import type { NodeModulesMountConfig } from "./host-dir-mount.js";
 export declare const AF_INET = 2;
 export declare const AF_UNIX = 1;
 export declare const SOCK_STREAM = 1;
@@ -229,6 +230,7 @@ export interface SystemDriver {
     network?: NetworkAdapter;
     commandExecutor?: CommandExecutor;
     permissions?: Permissions;
+    mounts: readonly NodeModulesMountConfig[];
     runtime: {
         process: ProcessConfig;
         os: OSConfig;
@@ -263,6 +265,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>;
@@ -278,11 +287,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>;
@@ -304,17 +320,14 @@ export interface BindingTree {
     [key: string]: BindingFunction | BindingTree;
 }
 export type BindingFunction = (...args: unknown[]) => unknown;
-export interface ModuleAccessOptions {
-    cwd?: string;
-}
 export interface NodeDriverOptions {
     filesystem?: VirtualFileSystem;
     networkAdapter?: NetworkAdapter;
     commandExecutor?: CommandExecutor;
     permissions?: Permissions;
+    mounts?: readonly NodeModulesMountConfig[];
     processConfig?: ProcessConfig;
     osConfig?: OSConfig;
-    moduleAccess?: ModuleAccessOptions;
 }
 export interface DefaultNetworkAdapterOptions {
     loopbackExemptPorts?: number[];

package/dist/runtime-compat.js

@@ -17,7 +17,6 @@ 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",
@@ -738,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 ?? {},
@@ -1022,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
@@ -1030,7 +1030,7 @@ function discoverWasmCommandEntries(commandDirs) {
                 .sort((left, right) => left.localeCompare(right));
         }
         catch {
-            return;
+            continue;
         }
         for (const entry of entries) {
             if (entry.startsWith("."))
@@ -1043,7 +1043,6 @@ function discoverWasmCommandEntries(commandDirs) {
                 discovered.push({
                     name: entry,
                     hostPath: fullPath,
-                    dirOffset,
                 });
                 continue;
             }
@@ -1054,13 +1053,12 @@ function discoverWasmCommandEntries(commandDirs) {
                     discovered.push({
                         name: entry,
                         hostPath: fullPath,
-                        dirOffset,
                     });
                 }
             }
             catch { }
         }
-    });
+    }
     return discovered;
 }
 class WasmVmRuntimeDescriptor {
@@ -1070,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
@@ -1101,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) ||
@@ -1127,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);
         }
     }
 }
@@ -1197,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",
@@ -1226,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();
@@ -1379,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) {
@@ -1663,7 +1617,6 @@ class NativeKernel {
     pendingLocalMounts = [];
     mountedCommandDirs = [];
     mountedRuntimeDrivers = [];
-    runtimeDriverCommandDirStarts = new Map();
     loopbackExemptPorts;
     constructor(options) {
         this.options = options;
@@ -1693,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) {
@@ -1704,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 ?? [];
@@ -1713,37 +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) => serializeLocalCompatMountForSidecar(mount));
-        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(() => { });
@@ -1876,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);
@@ -1892,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) {
@@ -1903,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;
@@ -1946,7 +1908,7 @@ class NativeKernel {
             lowers: [
                 {
                     kind: "snapshot",
-                    entries: rootFilesystemEntriesForConfig(mergeRootFilesystemEntries(createBootstrapEntries([...NODE_RUNTIME_BOOTSTRAP_COMMANDS]), snapshotEntries)),
+                    entries: rootFilesystemEntriesForConfig(mergeRootFilesystemEntries(createBootstrapEntries(), snapshotEntries)),
                 },
             ],
             bootstrapEntries: [],
@@ -1965,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",

package/dist/runtime.d.ts

@@ -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;
 }