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

package/dist/runtime-compat.js

@@ -7,18 +7,19 @@ import { fileURLToPath } from "node:url";
 import { resolvePublishedSidecarBinary } from "./sidecar/binary.js";
 import { findCargoBinary, resolveCargoBinary } from "./sidecar/cargo.js";
 import { serializePermissionsForSidecar } from "./sidecar/permissions.js";
-import { NATIVE_SIDECAR_FRAME_TIMEOUT_MS, NativeSidecarKernelProxy, SidecarProcess, serializeMountConfigForSidecar, } from "./sidecar/rpc-client.js";
+import { NativeSidecarKernelProxy, SidecarProcess, serializeMountConfigForSidecar, } from "./sidecar/rpc-client.js";
 export const AF_INET = 2;
 export const AF_UNIX = 1;
 export const SOCK_STREAM = 1;
 export const SOCK_DGRAM = 2;
 export const SIGTERM = 15;
-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 +37,8 @@ const KERNEL_POSIX_BOOTSTRAP_DIRS = [
     "/mnt",
     "/media",
     "/home",
-    "/home/user",
+    "/home/agentos",
+    "/workspace",
     "/usr",
     "/usr/bin",
     "/usr/games",
@@ -65,9 +67,23 @@ const SIDECAR_BUILD_INPUTS = [
     path.join(REPO_ROOT, "Cargo.toml"),
     path.join(REPO_ROOT, "Cargo.lock"),
     path.join(REPO_ROOT, "crates/bridge"),
+    path.join(REPO_ROOT, "crates/build-support"),
     path.join(REPO_ROOT, "crates/execution"),
     path.join(REPO_ROOT, "crates/kernel"),
-    path.join(REPO_ROOT, "crates/sidecar"),
+    path.join(REPO_ROOT, "crates/agentos-protocol"),
+    path.join(REPO_ROOT, "crates/agentos-sidecar"),
+    path.join(REPO_ROOT, "crates/native-sidecar"),
+    path.join(REPO_ROOT, "crates/native-sidecar-core"),
+    path.join(REPO_ROOT, "crates/sidecar-protocol"),
+    path.join(REPO_ROOT, "crates/v8-runtime"),
+    path.join(REPO_ROOT, "crates/vfs"),
+    path.join(REPO_ROOT, "crates/vm-config"),
+    path.join(REPO_ROOT, "packages/build-tools/bridge-src"),
+    path.join(REPO_ROOT, "packages/build-tools/package.json"),
+    path.join(REPO_ROOT, "packages/build-tools/scripts/build-v8-bridge.mjs"),
+    path.join(REPO_ROOT, "packages/core/fixtures/base-filesystem.json"),
+    path.join(REPO_ROOT, "packages/runtime-core/fixtures/base-filesystem.json"),
+    path.join(REPO_ROOT, "pnpm-lock.yaml"),
 ];
 let ensuredSidecarBinary = null;
 export class KernelError extends Error {
@@ -106,336 +122,6 @@ function dirnameVirtual(inputPath) {
     const parts = normalized.split("/").filter(Boolean);
     return parts.length <= 1 ? "/" : `/${parts.slice(0, -1).join("/")}`;
 }
-let nextInode = 1;
-export class InMemoryFileSystem {
-    entries = new Map();
-    constructor() {
-        this.entries.set("/", this.newDirectory());
-    }
-    async readFile(targetPath) {
-        const entry = this.resolveEntry(targetPath);
-        if (!entry || entry.type !== "file") {
-            throw errnoError("ENOENT", `open '${targetPath}'`);
-        }
-        entry.atimeMs = Date.now();
-        return entry.data;
-    }
-    async readTextFile(targetPath) {
-        return new TextDecoder().decode(await this.readFile(targetPath));
-    }
-    async readDir(targetPath) {
-        return (await this.readDirWithTypes(targetPath)).map((entry) => entry.name);
-    }
-    async readDirWithTypes(targetPath) {
-        const resolved = this.resolvePath(targetPath);
-        const entry = this.entries.get(resolved);
-        if (!entry || entry.type !== "dir") {
-            throw errnoError("ENOENT", `scandir '${targetPath}'`);
-        }
-        const prefix = resolved === "/" ? "/" : `${resolved}/`;
-        const output = new Map();
-        for (const [entryPath, candidate] of this.entries) {
-            if (!entryPath.startsWith(prefix))
-                continue;
-            const rest = entryPath.slice(prefix.length);
-            if (!rest || rest.includes("/"))
-                continue;
-            output.set(rest, {
-                name: rest,
-                isDirectory: candidate.type === "dir",
-                isSymbolicLink: candidate.type === "symlink",
-            });
-        }
-        return [...output.values()];
-    }
-    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 existing = this.entries.get(normalized);
-        if (existing?.type === "file") {
-            existing.data = data;
-            existing.mtimeMs = Date.now();
-            existing.ctimeMs = Date.now();
-            return;
-        }
-        const now = Date.now();
-        this.entries.set(normalized, {
-            type: "file",
-            data,
-            mode: S_IFREG | 0o644,
-            uid: 0,
-            gid: 0,
-            nlink: 1,
-            ino: nextInode++,
-            atimeMs: now,
-            mtimeMs: now,
-            ctimeMs: now,
-            birthtimeMs: now,
-        });
-    }
-    async createDir(targetPath) {
-        const normalized = normalizePath(targetPath);
-        if (!this.entries.has(dirnameVirtual(normalized))) {
-            throw errnoError("ENOENT", `mkdir '${targetPath}'`);
-        }
-        if (!this.entries.has(normalized)) {
-            this.entries.set(normalized, this.newDirectory());
-        }
-    }
-    async mkdir(targetPath, options) {
-        const normalized = normalizePath(targetPath);
-        if (options?.recursive === false) {
-            return this.createDir(normalized);
-        }
-        let current = "";
-        for (const part of normalized.split("/").filter(Boolean)) {
-            current += `/${part}`;
-            if (!this.entries.has(current)) {
-                this.entries.set(current, this.newDirectory());
-            }
-        }
-    }
-    async exists(targetPath) {
-        try {
-            return this.entries.has(this.resolvePath(targetPath));
-        }
-        catch {
-            return false;
-        }
-    }
-    async stat(targetPath) {
-        const entry = this.resolveEntry(targetPath);
-        if (!entry)
-            throw errnoError("ENOENT", `stat '${targetPath}'`);
-        return this.toStat(entry);
-    }
-    async removeFile(targetPath) {
-        const resolved = this.resolvePath(targetPath);
-        const entry = this.entries.get(resolved);
-        if (!entry || entry.type === "dir") {
-            throw errnoError("ENOENT", `unlink '${targetPath}'`);
-        }
-        this.entries.delete(resolved);
-    }
-    async removeDir(targetPath) {
-        const resolved = this.resolvePath(targetPath);
-        if (resolved === "/") {
-            throw errnoError("EPERM", "operation not permitted");
-        }
-        const entry = this.entries.get(resolved);
-        if (!entry || entry.type !== "dir") {
-            throw errnoError("ENOENT", `rmdir '${targetPath}'`);
-        }
-        const prefix = `${resolved}/`;
-        for (const key of this.entries.keys()) {
-            if (key.startsWith(prefix)) {
-                throw errnoError("ENOTEMPTY", `directory not empty '${targetPath}'`);
-            }
-        }
-        this.entries.delete(resolved);
-    }
-    async rename(oldPath, newPath) {
-        const oldResolved = this.resolvePath(oldPath);
-        const newResolved = normalizePath(newPath);
-        const entry = this.entries.get(oldResolved);
-        if (!entry)
-            throw errnoError("ENOENT", `rename '${oldPath}'`);
-        if (!this.entries.has(dirnameVirtual(newResolved))) {
-            throw errnoError("ENOENT", `rename '${newPath}'`);
-        }
-        if (entry.type !== "dir") {
-            this.entries.set(newResolved, entry);
-            this.entries.delete(oldResolved);
-            return;
-        }
-        const prefix = `${oldResolved}/`;
-        const moved = [];
-        for (const candidate of this.entries) {
-            if (candidate[0] === oldResolved || candidate[0].startsWith(prefix)) {
-                moved.push(candidate);
-            }
-        }
-        for (const [candidatePath] of moved) {
-            this.entries.delete(candidatePath);
-        }
-        for (const [candidatePath, candidate] of moved) {
-            const nextPath = candidatePath === oldResolved
-                ? newResolved
-                : `${newResolved}${candidatePath.slice(oldResolved.length)}`;
-            this.entries.set(nextPath, candidate);
-        }
-    }
-    async realpath(targetPath) {
-        return this.resolvePath(targetPath);
-    }
-    async symlink(target, linkPath) {
-        const normalized = normalizePath(linkPath);
-        if (this.entries.has(normalized)) {
-            throw errnoError("EEXIST", `symlink '${linkPath}'`);
-        }
-        const now = Date.now();
-        this.entries.set(normalized, {
-            type: "symlink",
-            target,
-            mode: S_IFLNK | 0o777,
-            uid: 0,
-            gid: 0,
-            nlink: 1,
-            ino: nextInode++,
-            atimeMs: now,
-            mtimeMs: now,
-            ctimeMs: now,
-            birthtimeMs: now,
-        });
-    }
-    async readlink(targetPath) {
-        const normalized = normalizePath(targetPath);
-        const entry = this.entries.get(normalized);
-        if (!entry || entry.type !== "symlink") {
-            throw errnoError("ENOENT", `readlink '${targetPath}'`);
-        }
-        return entry.target;
-    }
-    async lstat(targetPath) {
-        const entry = this.entries.get(normalizePath(targetPath));
-        if (!entry)
-            throw errnoError("ENOENT", `lstat '${targetPath}'`);
-        return this.toStat(entry);
-    }
-    async link(oldPath, newPath) {
-        const entry = this.resolveEntry(oldPath);
-        if (!entry || entry.type !== "file") {
-            throw errnoError("ENOENT", `link '${oldPath}'`);
-        }
-        const normalized = normalizePath(newPath);
-        if (this.entries.has(normalized)) {
-            throw errnoError("EEXIST", `link '${newPath}'`);
-        }
-        entry.nlink += 1;
-        this.entries.set(normalized, entry);
-    }
-    async chmod(targetPath, mode) {
-        const entry = this.resolveEntry(targetPath);
-        if (!entry)
-            throw errnoError("ENOENT", `chmod '${targetPath}'`);
-        const typeBits = mode & 0o170000;
-        entry.mode =
-            typeBits === 0 ? (entry.mode & 0o170000) | (mode & 0o7777) : mode;
-        entry.ctimeMs = Date.now();
-    }
-    async chown(targetPath, uid, gid) {
-        const entry = this.resolveEntry(targetPath);
-        if (!entry)
-            throw errnoError("ENOENT", `chown '${targetPath}'`);
-        entry.uid = uid;
-        entry.gid = gid;
-        entry.ctimeMs = Date.now();
-    }
-    async utimes(targetPath, atime, mtime) {
-        const entry = this.resolveEntry(targetPath);
-        if (!entry)
-            throw errnoError("ENOENT", `utimes '${targetPath}'`);
-        entry.atimeMs = atime;
-        entry.mtimeMs = mtime;
-        entry.ctimeMs = Date.now();
-    }
-    async truncate(targetPath, length) {
-        const entry = this.resolveEntry(targetPath);
-        if (!entry || entry.type !== "file") {
-            throw errnoError("ENOENT", `truncate '${targetPath}'`);
-        }
-        if (length < entry.data.length) {
-            entry.data = entry.data.slice(0, length);
-        }
-        else if (length > entry.data.length) {
-            const expanded = new Uint8Array(length);
-            expanded.set(entry.data);
-            entry.data = expanded;
-        }
-        entry.mtimeMs = Date.now();
-        entry.ctimeMs = Date.now();
-    }
-    async pread(targetPath, offset, length) {
-        const entry = this.resolveEntry(targetPath);
-        if (!entry || entry.type !== "file") {
-            throw errnoError("ENOENT", `open '${targetPath}'`);
-        }
-        if (offset >= entry.data.length)
-            return new Uint8Array(0);
-        return entry.data.slice(offset, Math.min(offset + length, entry.data.length));
-    }
-    async pwrite(targetPath, offset, data) {
-        const entry = this.resolveEntry(targetPath);
-        if (!entry || entry.type !== "file") {
-            throw errnoError("ENOENT", `open '${targetPath}'`);
-        }
-        const nextSize = Math.max(entry.data.length, offset + data.length);
-        const updated = new Uint8Array(nextSize);
-        updated.set(entry.data);
-        updated.set(data, offset);
-        entry.data = updated;
-        entry.mtimeMs = Date.now();
-        entry.ctimeMs = Date.now();
-    }
-    resolvePath(targetPath, depth = 0) {
-        if (depth > MAX_SYMLINK_DEPTH) {
-            throw errnoError("ELOOP", `too many symbolic links '${targetPath}'`);
-        }
-        const normalized = normalizePath(targetPath);
-        const entry = this.entries.get(normalized);
-        if (!entry)
-            return normalized;
-        if (entry.type === "symlink") {
-            const target = entry.target.startsWith("/")
-                ? entry.target
-                : `${dirnameVirtual(normalized)}/${entry.target}`;
-            return this.resolvePath(target, depth + 1);
-        }
-        return normalized;
-    }
-    resolveEntry(targetPath) {
-        return this.entries.get(this.resolvePath(targetPath));
-    }
-    newDirectory() {
-        const now = Date.now();
-        return {
-            type: "dir",
-            mode: S_IFDIR | 0o755,
-            uid: 0,
-            gid: 0,
-            nlink: 2,
-            ino: nextInode++,
-            atimeMs: now,
-            mtimeMs: now,
-            ctimeMs: now,
-            birthtimeMs: now,
-        };
-    }
-    toStat(entry) {
-        const size = entry.type === "file" ? entry.data.length : 4096;
-        return {
-            mode: entry.mode,
-            size,
-            blocks: size === 0 ? 0 : Math.ceil(size / 512),
-            dev: 1,
-            rdev: 0,
-            isDirectory: entry.type === "dir",
-            isSymbolicLink: entry.type === "symlink",
-            atimeMs: entry.atimeMs,
-            mtimeMs: entry.mtimeMs,
-            ctimeMs: entry.ctimeMs,
-            birthtimeMs: entry.birthtimeMs,
-            ino: entry.ino,
-            nlink: entry.nlink,
-            uid: entry.uid,
-            gid: entry.gid,
-        };
-    }
-}
-export function createInMemoryFileSystem() {
-    return new InMemoryFileSystem();
-}
 export class NodeFileSystem {
     rootPath;
     constructor(options) {
@@ -729,6 +415,7 @@ export function createNodeDriver(options = {}) {
         network: options.networkAdapter,
         commandExecutor: options.commandExecutor,
         permissions: options.permissions,
+        mounts: options.mounts ?? [],
         runtime: {
             process: options.processConfig ?? {},
             os: options.osConfig ?? {},
@@ -815,8 +502,6 @@ export const WASMVM_COMMANDS = Object.freeze([
     "unzip",
     "sqlite3",
     "curl",
-    "wget",
-    "make",
     "git",
     "git-remote-http",
     "git-remote-https",
@@ -915,7 +600,6 @@ export const DEFAULT_FIRST_PARTY_TIERS = Object.freeze({
     nice: "full",
     nohup: "full",
     stdbuf: "full",
-    make: "full",
     codex: "full",
     "codex-exec": "full",
     git: "full",
@@ -981,7 +665,6 @@ export const DEFAULT_FIRST_PARTY_TIERS = Object.freeze({
     tac: "read-only",
     tsort: "read-only",
     curl: "full",
-    wget: "full",
     sqlite3: "read-write",
 });
 class NativeRuntimeDescriptor {
@@ -1015,7 +698,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 +706,7 @@ function discoverWasmCommandEntries(commandDirs) {
                 .sort((left, right) => left.localeCompare(right));
         }
         catch {
-            return;
+            continue;
         }
         for (const entry of entries) {
             if (entry.startsWith("."))
@@ -1036,7 +719,6 @@ function discoverWasmCommandEntries(commandDirs) {
                 discovered.push({
                     name: entry,
                     hostPath: fullPath,
-                    dirOffset,
                 });
                 continue;
             }
@@ -1047,13 +729,12 @@ function discoverWasmCommandEntries(commandDirs) {
                     discovered.push({
                         name: entry,
                         hostPath: fullPath,
-                        dirOffset,
                     });
                 }
             }
             catch { }
         }
-    });
+    }
     return discovered;
 }
 class WasmVmRuntimeDescriptor {
@@ -1063,7 +744,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 +774,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 +789,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 +857,8 @@ function ensureNativeSidecarBinary() {
 function rootEntryExecutable(kind, mode) {
     return kind === "file" && (mode & 0o111) !== 0;
 }
-function createBootstrapEntries(commandNames) {
-    const entries = [
+function createBootstrapEntries() {
+    return [
         {
             path: "/",
             kind: "directory",
@@ -1203,7 +870,7 @@ function createBootstrapEntries(commandNames) {
         ...KERNEL_POSIX_BOOTSTRAP_DIRS.map((entryPath) => ({
             path: entryPath,
             kind: "directory",
-            mode: 0o755,
+            mode: entryPath === "/tmp" || entryPath === "/var/tmp" ? 0o1777 : 0o755,
             uid: 0,
             gid: 0,
             executable: false,
@@ -1219,19 +886,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 +1026,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) {
@@ -1496,7 +1133,10 @@ const VIRTUAL_FILESYSTEM_METHOD_NAMES = [
     "pread",
     "pwrite",
 ];
-const LIVE_FILESYSTEM_SYNC_CHUNK_SIZE = 512 * 1024;
+const DEFAULT_LIVE_FILESYSTEM_SYNC_MAX_BYTES = 64 * 1024 * 1024;
+class LiveFilesystemSyncLimitError extends Error {
+    code = "ERR_AGENTOS_LIVE_FILESYSTEM_SYNC_LIMIT";
+}
 function topLevelSyncRoot(targetPath) {
     const normalized = normalizePath(targetPath);
     const [first] = normalized.split("/").filter(Boolean);
@@ -1528,50 +1168,71 @@ async function ensureBoundParentDirectory(methods, targetPath) {
         recursive: true,
     });
 }
-async function syncLiveFilesystemToBoundMethods(live, methods, paths) {
+async function syncLiveFilesystemToBoundMethods(live, methods, paths, maxBytes) {
+    const snapshot = [];
+    const usage = { bytes: 0 };
     for (const targetPath of [...new Set(paths.map(normalizePath))].sort((left, right) => left.localeCompare(right))) {
         if (!(await live.exists(targetPath).catch(() => false))) {
             continue;
         }
-        await syncLiveFilesystemPathToBoundMethods(live, methods, targetPath);
+        await snapshotLiveFilesystemPath(live, targetPath, snapshot, usage, maxBytes);
+    }
+    if (usage.bytes >= maxBytes * 0.8) {
+        process.emitWarning(`live filesystem sync retained ${usage.bytes} of ${maxBytes} bytes; ` +
+            "raise createKernel({ maxFilesystemBytes }) before increasing VM filesystem limits", { code: "AGENTOS_LIVE_FILESYSTEM_SYNC_NEAR_LIMIT" });
+    }
+    for (const entry of snapshot) {
+        await applyLiveFilesystemSnapshotEntry(methods, entry);
     }
 }
-async function syncLiveFilesystemPathToBoundMethods(live, methods, targetPath) {
-    const stat = targetPath === "/"
-        ? await live.stat(targetPath)
-        : await live.lstat(targetPath);
+async function snapshotLiveFilesystemPath(live, targetPath, snapshot, usage, maxBytes, knownEntry) {
+    const stat = knownEntry ??
+        (targetPath === "/" ? await live.stat(targetPath) : await live.lstat(targetPath));
     if (stat.isSymbolicLink) {
-        await ensureBoundParentDirectory(methods, targetPath);
-        await callBoundFilesystemMethod(methods, "removeFile", targetPath).catch(() => { });
-        await callBoundFilesystemMethod(methods, "symlink", await live.readlink(targetPath), targetPath);
+        snapshot.push({ kind: "symlink", path: targetPath, target: await live.readlink(targetPath) });
         return;
     }
     if (stat.isDirectory) {
-        await callBoundFilesystemMethod(methods, "mkdir", targetPath, {
-            recursive: true,
-        });
+        snapshot.push({ kind: "directory", path: targetPath });
         const children = (await live.readDirWithTypes(targetPath))
-            .map((entry) => entry.name)
-            .filter((name) => name !== "." && name !== "..")
-            .sort((left, right) => left.localeCompare(right));
+            .filter((entry) => entry.name !== "." && entry.name !== "..")
+            .sort((left, right) => left.name.localeCompare(right.name));
         for (const child of children) {
-            await syncLiveFilesystemPathToBoundMethods(live, methods, targetPath === "/"
-                ? posixPath.join("/", child)
-                : posixPath.join(targetPath, child));
+            await snapshotLiveFilesystemPath(live, targetPath === "/"
+                ? posixPath.join("/", child.name)
+                : posixPath.join(targetPath, child.name), snapshot, usage, maxBytes, child);
         }
         return;
     }
-    await ensureBoundParentDirectory(methods, targetPath);
-    await callBoundFilesystemMethod(methods, "writeFile", targetPath, new Uint8Array(0));
-    for (let offset = 0; offset < stat.size; offset += LIVE_FILESYSTEM_SYNC_CHUNK_SIZE) {
-        const chunk = await live.pread(targetPath, offset, Math.min(LIVE_FILESYSTEM_SYNC_CHUNK_SIZE, stat.size - offset));
-        if (chunk.length === 0) {
-            break;
-        }
-        await callBoundFilesystemMethod(methods, "pwrite", targetPath, offset, chunk);
+    const fileSize = "size" in stat && typeof stat.size === "number"
+        ? stat.size
+        : (await live.lstat(targetPath)).size;
+    if (fileSize > maxBytes - usage.bytes) {
+        throw new LiveFilesystemSyncLimitError(`live filesystem sync for ${targetPath} exceeds ${maxBytes} bytes ` +
+            "(createKernel maxFilesystemBytes); raise createKernel({ maxFilesystemBytes })");
+    }
+    const content = await live.readFile(targetPath);
+    if (content.byteLength > maxBytes - usage.bytes) {
+        throw new LiveFilesystemSyncLimitError(`live filesystem sync for ${targetPath} exceeds ${maxBytes} bytes ` +
+            "(createKernel maxFilesystemBytes); raise createKernel({ maxFilesystemBytes })");
     }
+    usage.bytes += content.byteLength;
+    snapshot.push({ kind: "file", path: targetPath, content });
 }
-function bindLiveFilesystem(target, getFilesystem) {
+async function applyLiveFilesystemSnapshotEntry(methods, entry) {
+    if (entry.kind === "directory") {
+        await callBoundFilesystemMethod(methods, "mkdir", entry.path, { recursive: true });
+        return;
+    }
+    await ensureBoundParentDirectory(methods, entry.path);
+    if (entry.kind === "symlink") {
+        await callBoundFilesystemMethod(methods, "removeFile", entry.path).catch(() => { });
+        await callBoundFilesystemMethod(methods, "symlink", entry.target, entry.path);
+        return;
+    }
+    await callBoundFilesystemMethod(methods, "writeFile", entry.path, entry.content);
+}
+function bindLiveFilesystem(target, getFilesystem, maxBytes) {
     const fallback = {};
     for (const method of VIRTUAL_FILESYSTEM_METHOD_NAMES) {
         const candidate = target[method];
@@ -1597,7 +1258,7 @@ function bindLiveFilesystem(target, getFilesystem) {
             if (!filesystem) {
                 return;
             }
-            await syncLiveFilesystemToBoundMethods(filesystem, fallback, paths);
+            await syncLiveFilesystemToBoundMethods(filesystem, fallback, paths, maxBytes);
         },
         restore() {
             for (const [method, delegate] of Object.entries(fallback)) {
@@ -1606,6 +1267,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 +1317,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,18 +1334,44 @@ 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);
+        this.liveFilesystemBinding = bindLiveFilesystem(this.options.filesystem, () => this.rootFilesystem, options.maxFilesystemBytes ?? DEFAULT_LIVE_FILESYSTEM_SYNC_MAX_BYTES);
     }
     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 +1383,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 +1392,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 +1463,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,18 +1496,29 @@ 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,
-            });
+            // Pre-boot mounts apply during kernel initialization.
             return;
         }
-        this.proxy.mountFs(mountPath, filesystem, options);
+        return this.proxy.mountFs(mountPath, filesystem, {
+            readOnly: localMount.readOnly,
+            sidecarMount: localMount.sidecarMount,
+        });
     }
     unmountFs(mountPath) {
-        this.proxy?.unmountFs(mountPath);
+        const normalized = normalizePath(mountPath);
+        const pendingIndex = this.pendingLocalMounts.findIndex((mount) => mount.path === normalized);
+        if (pendingIndex >= 0) {
+            this.pendingLocalMounts.splice(pendingIndex, 1);
+        }
+        return this.proxy?.unmountFs(mountPath);
     }
     async readFile(targetPath) {
         await this.ensureReady();
@@ -1846,6 +1536,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 +1556,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 +1575,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 +1609,7 @@ class NativeKernel {
             lowers: [
                 {
                     kind: "snapshot",
-                    entries: rootFilesystemEntriesForConfig(mergeRootFilesystemEntries(createBootstrapEntries([...NODE_RUNTIME_BOOTSTRAP_COMMANDS]), snapshotEntries)),
+                    entries: rootFilesystemEntriesForConfig(mergeRootFilesystemEntries(createBootstrapEntries(), snapshotEntries)),
                 },
             ],
             bootstrapEntries: [],
@@ -1925,7 +1618,6 @@ class NativeKernel {
             cwd: REPO_ROOT,
             command: ensureNativeSidecarBinary(),
             args: [],
-            frameTimeoutMs: NATIVE_SIDECAR_FRAME_TIMEOUT_MS,
         });
         const session = await client.authenticateAndOpenSession();
         const createVmConfig = {
@@ -1935,6 +1627,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 +1647,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);