@rivet-dev/agentos-core 0.2.4 → 0.2.5-rc.1

package/dist/packages.d.ts

@@ -1,149 +1,28 @@
-import type { PermissionTier } from "./runtime.js";
+import { type SoftwarePackageRef } from "./agentos-package.js";
 /**
- * Resolve a package directory by walking up the directory tree.
- * Supports both nested (pnpm) and flat (npm) node_modules layouts.
+ * Input type for the `software` option. Software is a self-contained package
+ * directory that the secure-exec sidecar materializes into the `/opt/agentos`
+ * projection. Accepts a package-dir ref or an array of refs for meta-packages.
  */
-export declare function resolvePackageDir(startDir: string, packageName: string): string;
-import type { AgentConfig } from "./agents.js";
-export interface SoftwareDescriptor {
-    name: string;
-    type: "agent" | "tool" | "wasm-commands";
-}
-export interface AgentSoftwareDescriptor extends SoftwareDescriptor {
-    type: "agent";
-    /**
-     * Root directory of this npm package on the host. Used to resolve
-     * dependencies listed in `requires` from this package's node_modules/.
-     */
-    packageDir: string;
-    /** npm packages that must be available inside the VM. */
-    requires: string[];
-    agent: {
-        /** Unique agent ID used in createSession(id). */
-        id: string;
-        /** npm package name of the ACP adapter. Must be in requires. */
-        acpAdapter: string;
-        /** npm package name of the agent CLI. Must be in requires. */
-        agentPackage: string;
-        /**
-         * Whether to evaluate this agent's SDK into the per-sidecar V8 heap
-         * snapshot so it is loaded once per sidecar and reused across sessions
-         * (instead of re-evaluated on every `createSession`). Opt-in: the agent's
-         * SDK must be **snapshot-safe** — its module-init must not create native
-         * (`.node` addon / WASM / External) handles, open fds/sockets, start
-         * timers, read per-session config, or leave pending promises. SDKs that
-         * are not snapshot-safe (or where snapshot creation fails) automatically
-         * fall back to the per-session dynamic-import path, so this flag is a
-         * safety/performance switch, not a correctness requirement. Defaults to
-         * `false`. See the Custom Agents / dependencies docs for the full rules.
-         */
-        snapshot?: boolean;
-        /** Static env vars passed when spawning the adapter. */
-        staticEnv?: Record<string, string>;
-        /** Dynamic env vars computed at boot time. */
-        env?: (ctx: SoftwareContext) => Record<string, string>;
-        /** Additional CLI args prepended when launching the ACP adapter. */
-        launchArgs?: string[];
-    };
-}
-export interface ToolSoftwareDescriptor extends SoftwareDescriptor {
-    type: "tool";
-    /**
-     * Root directory of this npm package on the host. Used to resolve
-     * dependencies listed in `requires` from this package's node_modules/.
-     */
-    packageDir: string;
-    /** npm packages that must be available inside the VM. */
-    requires: string[];
-    /** Map of bin command name -> npm package name. */
-    bins: Record<string, string>;
-}
-export interface WasmCommandSoftwareDescriptor extends SoftwareDescriptor {
-    type: "wasm-commands";
-    /** Absolute path to directory containing WASM command binaries on the host. */
-    commandDir: string;
-    /** Symlink aliases: aliasName -> targetCommandName. */
-    aliases?: Record<string, string>;
-    /** Permission tier assignments. */
-    permissions?: {
-        full?: string[];
-        readWrite?: string[];
-        readOnly?: string[] | "*";
-        isolated?: string[];
-    };
-}
-/**
- * Any object with a commandDir property is treated as a WASM command package.
- * This allows registry packages (e.g., @agentos-software/coreutils) to be
- * passed directly to the `software` option without wrapping.
- */
-export interface WasmCommandDirDescriptor {
-    readonly commandDir: string;
-    [key: string]: unknown;
-}
-export type AnySoftwareDescriptor = AgentSoftwareDescriptor | ToolSoftwareDescriptor | WasmCommandSoftwareDescriptor | WasmCommandDirDescriptor;
-/** Input type for the `software` option. Accepts descriptors or arrays of descriptors (for meta-packages). */
-export type SoftwareInput = AnySoftwareDescriptor | AnySoftwareDescriptor[];
-export interface SoftwareContext {
-    /**
-     * Resolve the bin entry for an npm package to a VM-side path.
-     * Uses require.resolve on the HOST, then maps to /root/node_modules/...
-     *
-     * Example: ctx.resolveBin("@mariozechner/pi-coding-agent", "pi")
-     *   -> "/root/node_modules/@mariozechner/pi-coding-agent/dist/cli.js"
-     */
-    resolveBin(packageName: string, binName?: string): string;
-    /**
-     * Resolve a package's root directory to a VM-side path.
-     *
-     * Example: ctx.resolvePackage("pi-acp")
-     *   -> "/root/node_modules/pi-acp"
-     */
-    resolvePackage(packageName: string): string;
-}
+export type SoftwareEntry = SoftwarePackageRef;
+export type SoftwareInput = SoftwareEntry | SoftwareEntry[];
 /** Host-to-VM path mapping for a software package's `/root/node_modules/<pkg>` mount. */
 export interface SoftwareRoot {
     hostPath: string;
     vmPath: string;
 }
-export interface CommandPackageMetadata {
-    commandDir: string;
-    declaredCommands: string[];
-    aliases: Record<string, string>;
-}
 /**
- * Define a software descriptor. This is a type-safe identity function that
- * validates the descriptor shape at compile time.
+ * Define a software descriptor. A type-safe identity function that validates the
+ * package-dir reference at compile time. The sidecar materializes the package into
+ * the `/opt/agentos` projection.
  */
-export declare function defineSoftware<T extends AnySoftwareDescriptor>(desc: T): T;
+export declare function defineSoftware<T extends SoftwareEntry>(desc: T): T;
 /**
  * Resolve the agent-SDK snapshot bundle (an esbuild IIFE at
- * `<packageDir>/dist/sdk-snapshot.js`) for the first snapshot-enabled agent in
+ * `<dir>/dist/sdk-snapshot.js`) for the first snapshot-enabled agent package in
  * 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.
  */
 export declare function resolveAgentSnapshotBundle(software: SoftwareInput[]): string | undefined;
-/** Result of processing all software descriptors at boot time. */
-export interface ProcessedSoftware {
-    /** WASM command directories to pass to the WasmVM driver. */
-    commandDirs: string[];
-    /** Per-package command metadata used to preserve command availability on the sidecar path. */
-    commandPackages: CommandPackageMetadata[];
-    /** Per-command permission tiers propagated into the WasmVM runtime. */
-    commandPermissions: Record<string, PermissionTier>;
-    /** Host-to-VM path mappings for software-package `/root/node_modules/<pkg>` mounts. */
-    softwareRoots: SoftwareRoot[];
-    /** Agent configs registered by agent software. */
-    agentConfigs: Map<string, AgentConfig>;
-}
-/**
- * Process an array of software descriptors at boot time.
- * Collects WASM command dirs, module access roots, and agent configurations.
- *
- * Any object with a `commandDir` property (e.g., registry packages) is treated
- * as a WASM command source. Typed descriptors with `type: "agent"` or `type: "tool"`
- * are processed for module mounting and agent registration.
- */
-export declare function processSoftware(software: SoftwareInput[]): ProcessedSoftware;

package/dist/packages.js

@@ -1,126 +1,18 @@
-import { existsSync, readFileSync, realpathSync } from "node:fs";
-import { dirname, join, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-/**
- * Resolve a package directory by walking up the directory tree.
- * Supports both nested (pnpm) and flat (npm) node_modules layouts.
- */
-export function resolvePackageDir(startDir, packageName) {
-    const localPkgJson = join(startDir, "package.json");
-    if (existsSync(localPkgJson)) {
-        try {
-            const localPkg = JSON.parse(readFileSync(localPkgJson, "utf-8"));
-            if (localPkg.name === packageName) {
-                return realpathSync(startDir);
-            }
-        }
-        catch {
-            // Ignore malformed local package metadata and continue walking.
-        }
-    }
-    let searchDir = startDir;
-    while (true) {
-        const candidate = join(searchDir, "node_modules", packageName);
-        if (existsSync(join(candidate, "package.json"))) {
-            return realpathSync(candidate);
-        }
-        const parent = dirname(searchDir);
-        if (parent === searchDir)
-            break;
-        searchDir = parent;
-    }
-    throw new Error(`Package "${packageName}" not found starting from ${startDir}. ` +
-        `Ensure it is installed.`);
-}
-const LOCAL_REGISTRY_COMMAND_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "../../../../secure-exec", "registry/native/target/wasm32-wasip1/release/commands");
-function readPackageName(packageDir) {
-    const pkg = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf-8"));
-    if (typeof pkg.name !== "string" || pkg.name.length === 0) {
-        throw new Error(`Package at ${packageDir} is missing a valid name`);
-    }
-    return pkg.name;
-}
-function pushSoftwareRoot(softwareRoots, seenVmPaths, hostPath, vmPath) {
-    if (seenVmPaths.has(vmPath)) {
-        return;
-    }
-    seenVmPaths.add(vmPath);
-    softwareRoots.push({ hostPath, vmPath });
-}
-function findPnpmStoreRoot(hostPath) {
-    const marker = `${sep}node_modules${sep}.pnpm${sep}`;
-    const markerIndex = hostPath.indexOf(marker);
-    if (markerIndex === -1) {
-        return null;
-    }
-    const nodeModulesRoot = `${hostPath.slice(0, markerIndex)}${sep}node_modules`;
-    const pnpmStoreRoot = join(nodeModulesRoot, ".pnpm");
-    return existsSync(pnpmStoreRoot) ? pnpmStoreRoot : null;
-}
-function pushPackageSoftwareRoot(softwareRoots, seenVmPaths, hostPath, vmPath) {
-    pushSoftwareRoot(softwareRoots, seenVmPaths, hostPath, vmPath);
-    const pnpmStoreRoot = findPnpmStoreRoot(hostPath);
-    if (!pnpmStoreRoot) {
-        return;
-    }
-    pushSoftwareRoot(softwareRoots, seenVmPaths, pnpmStoreRoot, "/root/node_modules/.pnpm");
-}
-/**
- * Create a SoftwareContext for a software descriptor.
- * Resolves npm package paths relative to the descriptor's packageDir.
- */
-function createSoftwareContext(packageDir, requires) {
-    // Pre-resolve all required packages to host paths
-    const resolvedPackages = new Map();
-    for (const reqPkg of requires) {
-        const hostDir = resolvePackageDir(packageDir, reqPkg);
-        const pkg = JSON.parse(readFileSync(join(hostDir, "package.json"), "utf-8"));
-        const vmDir = `/root/node_modules/${reqPkg}`;
-        resolvedPackages.set(reqPkg, { hostDir, vmDir, pkg });
-    }
-    return {
-        resolveBin(packageName, binName) {
-            const resolved = resolvedPackages.get(packageName);
-            if (!resolved) {
-                throw new Error(`Package "${packageName}" is not in the requires list. ` +
-                    `Available: ${[...resolvedPackages.keys()].join(", ")}`);
-            }
-            const { pkg, vmDir } = resolved;
-            let binEntry;
-            const effectiveBinName = binName ?? packageName;
-            if (typeof pkg.bin === "string") {
-                binEntry = pkg.bin;
-            }
-            else if (typeof pkg.bin === "object" && pkg.bin !== null) {
-                const binMap = pkg.bin;
-                binEntry = binMap[effectiveBinName] ?? Object.values(binMap)[0];
-            }
-            if (!binEntry) {
-                throw new Error(`No bin entry "${effectiveBinName}" found in ${packageName}/package.json`);
-            }
-            return `${vmDir}/${binEntry}`;
-        },
-        resolvePackage(packageName) {
-            const resolved = resolvedPackages.get(packageName);
-            if (!resolved) {
-                throw new Error(`Package "${packageName}" is not in the requires list. ` +
-                    `Available: ${[...resolvedPackages.keys()].join(", ")}`);
-            }
-            return resolved.vmDir;
-        },
-    };
-}
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tryReadAgentosPackageManifest, } from "./agentos-package.js";
 // ── defineSoftware ───────────────────────────────────────────────────
 /**
- * Define a software descriptor. This is a type-safe identity function that
- * validates the descriptor shape at compile time.
+ * Define a software descriptor. A type-safe identity function that validates the
+ * package-dir reference at compile time. The sidecar materializes the package into
+ * the `/opt/agentos` projection.
  */
 export function defineSoftware(desc) {
     return desc;
 }
 /**
  * Resolve the agent-SDK snapshot bundle (an esbuild IIFE at
- * `<packageDir>/dist/sdk-snapshot.js`) for the first snapshot-enabled agent in
+ * `<dir>/dist/sdk-snapshot.js`) for the first snapshot-enabled agent package in
  * 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`)
@@ -128,239 +20,15 @@ export function defineSoftware(desc) {
  */
 export function resolveAgentSnapshotBundle(software) {
     const descriptors = software.flat();
-    for (const desc of descriptors) {
-        if (desc.type !== "agent")
-            continue;
-        const agent = desc;
-        if (!agent.agent.snapshot)
+    for (const entry of descriptors) {
+        const dir = entry.packageDir;
+        const manifest = tryReadAgentosPackageManifest(dir);
+        if (!manifest?.agent?.snapshot)
             continue;
-        const bundlePath = join(agent.packageDir, "dist", "sdk-snapshot.js");
+        const bundlePath = join(dir, "dist", "sdk-snapshot.js");
         if (existsSync(bundlePath)) {
             return readFileSync(bundlePath, "utf-8");
         }
     }
     return undefined;
 }
-/** Check if a descriptor is a typed software descriptor (has a `type` field). */
-function isTypedDescriptor(desc) {
-    return ("type" in desc && typeof desc.type === "string");
-}
-const VALID_PERMISSION_TIERS = new Set([
-    "full",
-    "read-write",
-    "read-only",
-    "isolated",
-]);
-function isPermissionTier(value) {
-    return (typeof value === "string" &&
-        VALID_PERMISSION_TIERS.has(value));
-}
-function registerPermission(commandPermissions, commandName, tier) {
-    if (commandName in commandPermissions)
-        return;
-    commandPermissions[commandName] = tier;
-}
-function appendDeclaredCommand(declaredCommands, seen, commandName) {
-    if (typeof commandName !== "string" || seen.has(commandName)) {
-        return;
-    }
-    seen.add(commandName);
-    declaredCommands.push(commandName);
-}
-function collectCommandMetadata(pkg) {
-    const declaredCommands = [];
-    const seen = new Set();
-    const aliases = {};
-    if ("aliases" in pkg && pkg.aliases) {
-        for (const [aliasName, targetName] of Object.entries(pkg.aliases)) {
-            if (typeof targetName !== "string") {
-                continue;
-            }
-            aliases[aliasName] = targetName;
-            appendDeclaredCommand(declaredCommands, seen, aliasName);
-            appendDeclaredCommand(declaredCommands, seen, targetName);
-        }
-    }
-    const rawCommands = pkg.commands;
-    if (Array.isArray(rawCommands)) {
-        for (const rawCommand of rawCommands) {
-            if (typeof rawCommand !== "object" || rawCommand === null) {
-                continue;
-            }
-            const name = rawCommand.name;
-            const aliasOf = rawCommand.aliasOf;
-            appendDeclaredCommand(declaredCommands, seen, name);
-            appendDeclaredCommand(declaredCommands, seen, aliasOf);
-            if (typeof name === "string" && typeof aliasOf === "string") {
-                aliases[name] = aliasOf;
-            }
-        }
-    }
-    const permissions = pkg.permissions;
-    if (permissions) {
-        for (const commandName of permissions.full ?? []) {
-            appendDeclaredCommand(declaredCommands, seen, commandName);
-        }
-        for (const commandName of permissions.readWrite ?? []) {
-            appendDeclaredCommand(declaredCommands, seen, commandName);
-        }
-        if (Array.isArray(permissions.readOnly)) {
-            for (const commandName of permissions.readOnly) {
-                appendDeclaredCommand(declaredCommands, seen, commandName);
-            }
-        }
-        for (const commandName of permissions.isolated ?? []) {
-            appendDeclaredCommand(declaredCommands, seen, commandName);
-        }
-    }
-    const commandDir = resolveLocalCommandDirFallback(pkg.commandDir, declaredCommands);
-    return {
-        commandDir,
-        declaredCommands,
-        aliases,
-    };
-}
-function hasUsableCommandDir(commandDir, declaredCommands) {
-    if (!existsSync(commandDir)) {
-        return false;
-    }
-    return declaredCommands.every((commandName) => existsSync(join(commandDir, commandName)));
-}
-function resolveLocalCommandDirFallback(commandDir, declaredCommands) {
-    if (declaredCommands.length === 0 ||
-        hasUsableCommandDir(commandDir, declaredCommands) ||
-        !hasUsableCommandDir(LOCAL_REGISTRY_COMMAND_DIR, declaredCommands)) {
-        return commandDir;
-    }
-    return LOCAL_REGISTRY_COMMAND_DIR;
-}
-function collectRegistryPackagePermissions(commandPermissions, pkg) {
-    const rawCommands = pkg.commands;
-    if (!Array.isArray(rawCommands))
-        return;
-    for (const rawCommand of rawCommands) {
-        if (typeof rawCommand !== "object" ||
-            rawCommand === null ||
-            !Object.hasOwn(rawCommand, "name") ||
-            !Object.hasOwn(rawCommand, "permissionTier")) {
-            continue;
-        }
-        const name = rawCommand.name;
-        const permissionTier = rawCommand
-            .permissionTier;
-        if (typeof name !== "string" || !isPermissionTier(permissionTier))
-            continue;
-        registerPermission(commandPermissions, name, permissionTier);
-    }
-}
-function collectTypedDescriptorPermissions(commandPermissions, pkg) {
-    const permissions = pkg.permissions;
-    if (!permissions)
-        return;
-    for (const commandName of permissions.full ?? []) {
-        registerPermission(commandPermissions, commandName, "full");
-    }
-    for (const commandName of permissions.readWrite ?? []) {
-        registerPermission(commandPermissions, commandName, "read-write");
-    }
-    if (Array.isArray(permissions.readOnly)) {
-        for (const commandName of permissions.readOnly) {
-            registerPermission(commandPermissions, commandName, "read-only");
-        }
-    }
-    for (const commandName of permissions.isolated ?? []) {
-        registerPermission(commandPermissions, commandName, "isolated");
-    }
-}
-/**
- * Process an array of software descriptors at boot time.
- * Collects WASM command dirs, module access roots, and agent configurations.
- *
- * Any object with a `commandDir` property (e.g., registry packages) is treated
- * as a WASM command source. Typed descriptors with `type: "agent"` or `type: "tool"`
- * are processed for module mounting and agent registration.
- */
-export function processSoftware(software) {
-    const commandDirs = [];
-    const commandPackages = [];
-    const commandPermissions = {};
-    const softwareRoots = [];
-    const seenSoftwareVmPaths = new Set();
-    const agentConfigs = new Map();
-    // Flatten nested arrays (meta-packages export arrays of sub-packages).
-    const flat = software.flat();
-    for (const pkg of flat) {
-        if (!isTypedDescriptor(pkg)) {
-            // Duck-typed: any object with commandDir is a WASM command source.
-            const commandMetadata = collectCommandMetadata(pkg);
-            if (!existsSync(commandMetadata.commandDir)) {
-                console.warn(`[agentos] skipping WASM command source with missing commandDir: ${commandMetadata.commandDir} (build its wasm artifacts to enable these commands)`);
-                continue;
-            }
-            commandDirs.push(commandMetadata.commandDir);
-            commandPackages.push(commandMetadata);
-            collectRegistryPackagePermissions(commandPermissions, pkg);
-            continue;
-        }
-        switch (pkg.type) {
-            case "wasm-commands": {
-                const commandMetadata = collectCommandMetadata(pkg);
-                if (!existsSync(commandMetadata.commandDir)) {
-                    console.warn(`[agentos] skipping WASM command source with missing commandDir: ${commandMetadata.commandDir} (build its wasm artifacts to enable these commands)`);
-                    break;
-                }
-                commandDirs.push(commandMetadata.commandDir);
-                commandPackages.push(commandMetadata);
-                collectTypedDescriptorPermissions(commandPermissions, pkg);
-                break;
-            }
-            case "agent": {
-                // Collect module roots for all required npm packages.
-                // Walks up directory tree to support flat (npm) and nested (pnpm) layouts.
-                const ctx = createSoftwareContext(pkg.packageDir, pkg.requires);
-                const declaringPackageName = readPackageName(pkg.packageDir);
-                pushPackageSoftwareRoot(softwareRoots, seenSoftwareVmPaths, pkg.packageDir, `/root/node_modules/${declaringPackageName}`);
-                for (const reqPkg of pkg.requires) {
-                    const hostDir = resolvePackageDir(pkg.packageDir, reqPkg);
-                    const vmDir = `/root/node_modules/${reqPkg}`;
-                    pushPackageSoftwareRoot(softwareRoots, seenSoftwareVmPaths, hostDir, vmDir);
-                }
-                // Compute static + dynamic env vars.
-                const staticEnv = pkg.agent.staticEnv ?? {};
-                const dynamicEnv = pkg.agent.env ? pkg.agent.env(ctx) : {};
-                const combinedEnv = { ...staticEnv, ...dynamicEnv };
-                // Register agent config.
-                const agentConfig = {
-                    acpAdapter: pkg.agent.acpAdapter,
-                    agentPackage: pkg.agent.agentPackage,
-                    declaringPackageDir: pkg.packageDir,
-                    launchArgs: pkg.agent.launchArgs,
-                    defaultEnv: Object.keys(combinedEnv).length > 0 ? combinedEnv : undefined,
-                };
-                agentConfigs.set(pkg.agent.id, agentConfig);
-                break;
-            }
-            case "tool": {
-                // Collect module roots for all required npm packages.
-                // Walks up directory tree to support flat (npm) and nested (pnpm) layouts.
-                const declaringPackageName = readPackageName(pkg.packageDir);
-                pushPackageSoftwareRoot(softwareRoots, seenSoftwareVmPaths, pkg.packageDir, `/root/node_modules/${declaringPackageName}`);
-                for (const reqPkg of pkg.requires) {
-                    const hostDir = resolvePackageDir(pkg.packageDir, reqPkg);
-                    const vmDir = `/root/node_modules/${reqPkg}`;
-                    pushPackageSoftwareRoot(softwareRoots, seenSoftwareVmPaths, hostDir, vmDir);
-                }
-                // Tool bin registration is handled by the caller (AgentOs.create)
-                // since it requires kernel access.
-                break;
-            }
-        }
-    }
-    return {
-        commandDirs,
-        commandPackages,
-        commandPermissions,
-        softwareRoots,
-        agentConfigs,
-    };
-}

package/dist/runtime-compat.d.ts

@@ -98,15 +98,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;

package/dist/runtime-compat.js

@@ -18,7 +18,13 @@ 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",
@@ -819,7 +825,6 @@ export const WASMVM_COMMANDS = Object.freeze([
     "sqlite3",
     "curl",
     "wget",
-    "make",
     "git",
     "git-remote-http",
     "git-remote-https",
@@ -918,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",
@@ -1800,10 +1804,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);

package/dist/runtime.d.ts

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