@rivet-dev/agentos-runtime-core 0.0.0-codex-actor-plugin-contract-coverage.115ca8a → 0.0.0-fix-main-wasm-ownership.150c49a

package/dist/sidecar-process.d.ts

@@ -9,10 +9,9 @@ import type { LiveFilesystemOperation, LiveGuestRuntimeKind, LiveWasmPermissionT
 import { type LiveEventFrame, type LiveSidecarRequestHandler, type LiveSidecarRequestFrame, type LiveSidecarResponseFrame, type ProtocolFramePayloadCodec } from "./protocol-frames.js";
 import type { LiveGuestDirEntry } from "./response-payloads.js";
 import { type LiveGuestFilesystemStat } from "./state.js";
-export { SidecarProcessError, SidecarProcessExited, } from "./sidecar-errors.js";
+export { SidecarProcessError, SidecarProcessExited, SidecarSilenceTimeout, } from "./sidecar-errors.js";
 export { SidecarEventBufferOverflow } from "./event-buffer.js";
 export { SidecarProcess as Sidecar };
-export declare const NATIVE_SIDECAR_FRAME_TIMEOUT_MS = 120000;
 type GuestRuntimeKind = Extract<LiveGuestRuntimeKind, "java_script" | "python" | "web_assembly">;
 type WasmPermissionTier = LiveWasmPermissionTier;
 export interface RootFilesystemEntry extends LiveRootFilesystemEntry {
@@ -105,20 +104,27 @@ export interface SidecarSpawnOptions {
     cwd?: string;
     command?: string;
     args?: string[];
-    frameTimeoutMs?: number;
     eventBufferCapacity?: number;
+    gracefulExitMs?: number;
+    forceExitMs?: number;
     payloadCodec?: NativeTransportPayloadCodec;
+    /**
+     * Override the sidecar silence watchdog window (default 30s). Tests only —
+     * it is a fixed protocol constant paired with the sidecar's 10s heartbeat
+     * cadence, not an operator tunable.
+     */
+    silenceTimeoutMs?: number;
 }
 export interface ResolvedSidecarSpawnOptions {
     cwd?: string;
     command?: string;
     args: string[];
-    frameTimeoutMs: number;
     eventBufferCapacity: number;
     gracefulExitMs: number;
     forceExitMs: number;
     disposedErrorMessage: string;
     payloadCodec: NativeTransportPayloadCodec;
+    silenceTimeoutMs?: number;
 }
 type SidecarProcessSpawnFactory = (options: ResolvedSidecarSpawnOptions) => SidecarProcessTransport;
 export declare function registerSidecarProcessSpawnFactory(factory: SidecarProcessSpawnFactory): void;
@@ -146,6 +152,8 @@ export interface SidecarMountPluginDescriptor {
 }
 export interface SidecarMountDescriptor {
     guestPath: string;
+    guestSource?: string;
+    guestFstype?: string;
     readOnly: boolean;
     plugin: SidecarMountPluginDescriptor;
 }
@@ -238,7 +246,7 @@ export declare class SidecarProcess {
         packages?: SidecarPackageDescriptor[];
         packagesMountAt?: string;
         bootstrapCommands?: string[];
-        toolShimCommands?: string[];
+        bindingShimCommands?: string[];
     }): Promise<SidecarVmConfiguredResponse>;
     /**
      * Runtime dynamic `linkSoftware`: project one package into the live
@@ -266,10 +274,16 @@ export declare class SidecarProcess {
         lowerLayerIds: string[];
     }): Promise<string>;
     bootstrapRootFilesystem(session: AuthenticatedSession, vm: CreatedVm, entries: RootFilesystemEntry[]): Promise<void>;
-    snapshotRootFilesystem(session: AuthenticatedSession, vm: CreatedVm): Promise<RootFilesystemEntry[]>;
+    snapshotRootFilesystem(session: AuthenticatedSession, vm: CreatedVm, maxBytes: number): Promise<RootFilesystemEntry[]>;
+    listMounts(session: AuthenticatedSession, vm: CreatedVm): Promise<Array<{
+        path: string;
+        kind: string;
+        readOnly: boolean;
+    }>>;
     readFile(session: AuthenticatedSession, vm: CreatedVm, path: string): Promise<Uint8Array>;
     pread(session: AuthenticatedSession, vm: CreatedVm, path: string, offset: number, length: number): Promise<Uint8Array>;
     writeFile(session: AuthenticatedSession, vm: CreatedVm, path: string, content: string | Uint8Array): Promise<void>;
+    pwrite(session: AuthenticatedSession, vm: CreatedVm, path: string, offset: number, content: Uint8Array): Promise<void>;
     mkdir(session: AuthenticatedSession, vm: CreatedVm, path: string, options?: {
         recursive?: boolean;
     }): Promise<void>;

package/dist/sidecar-process.js

@@ -1,13 +1,12 @@
 import { decodeGuestFilesystemContent, encodeGuestFilesystemContent, } from "./filesystem.js";
 import { SIDECAR_PROTOCOL_SCHEMA } from "./protocol-schema.js";
-export { SidecarProcessError, SidecarProcessExited, } from "./sidecar-errors.js";
+export { SidecarProcessError, SidecarProcessExited, SidecarSilenceTimeout, } from "./sidecar-errors.js";
 export { SidecarEventBufferOverflow } from "./event-buffer.js";
 // `Sidecar` is the public name for the native sidecar process client. The class
 // is `SidecarProcess` internally; consumers import it as `Sidecar` via the
 // `@rivet-dev/agentos-runtime-core/sidecar-client` subpath and the package root.
 export { SidecarProcess as Sidecar };
 const BRIDGE_CONTRACT_VERSION = 1;
-export const NATIVE_SIDECAR_FRAME_TIMEOUT_MS = 120_000;
 const DEFAULT_SIDECAR_EVENT_BUFFER_CAPACITY = 4_096;
 const DEFAULT_SIDECAR_GRACEFUL_EXIT_MS = 5_000;
 const DEFAULT_SIDECAR_FORCE_EXIT_MS = 2_000;
@@ -31,10 +30,10 @@ export class SidecarProcess {
             command: options.command,
             args: options.args ?? [],
             cwd: options.cwd,
-            frameTimeoutMs: options.frameTimeoutMs ?? NATIVE_SIDECAR_FRAME_TIMEOUT_MS,
+            silenceTimeoutMs: options.silenceTimeoutMs,
             eventBufferCapacity: options.eventBufferCapacity ?? DEFAULT_SIDECAR_EVENT_BUFFER_CAPACITY,
-            gracefulExitMs: DEFAULT_SIDECAR_GRACEFUL_EXIT_MS,
-            forceExitMs: DEFAULT_SIDECAR_FORCE_EXIT_MS,
+            gracefulExitMs: options.gracefulExitMs ?? DEFAULT_SIDECAR_GRACEFUL_EXIT_MS,
+            forceExitMs: options.forceExitMs ?? DEFAULT_SIDECAR_FORCE_EXIT_MS,
             disposedErrorMessage: "native sidecar disposed",
             payloadCodec: options.payloadCodec ?? "bare",
         });
@@ -148,7 +147,7 @@ export class SidecarProcess {
                     ? { packages_mount_at: options.packagesMountAt }
                     : {}),
                 bootstrap_commands: options.bootstrapCommands ?? [],
-                tool_shim_commands: options.toolShimCommands ?? [],
+                binding_shim_commands: options.bindingShimCommands ?? [],
             },
         });
         if (response.payload.type !== "vm_configured") {
@@ -362,7 +361,7 @@ export class SidecarProcess {
             throw new Error(`unexpected bootstrap_root_filesystem response: ${response.payload.type}`);
         }
     }
-    async snapshotRootFilesystem(session, vm) {
+    async snapshotRootFilesystem(session, vm, maxBytes) {
         const response = await this.sendRequest({
             ownership: {
                 scope: "vm",
@@ -372,6 +371,7 @@ export class SidecarProcess {
             },
             payload: {
                 type: "snapshot_root_filesystem",
+                max_bytes: maxBytes,
             },
         });
         if (response.payload.type !== "root_filesystem_snapshot") {
@@ -379,6 +379,25 @@ export class SidecarProcess {
         }
         return response.payload.entries;
     }
+    async listMounts(session, vm) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: { type: "list_mounts" },
+        });
+        if (response.payload.type !== "mounts_listed") {
+            throw new Error(`unexpected list_mounts response: ${response.payload.type}`);
+        }
+        return response.payload.mounts.map((mount) => ({
+            path: mount.path,
+            kind: mount.kind,
+            readOnly: mount.read_only,
+        }));
+    }
     async readFile(session, vm, path) {
         const response = await this.guestFilesystemCall(session, vm, {
             operation: "read_file",
@@ -404,6 +423,16 @@ export class SidecarProcess {
             encoding: encoded.encoding,
         });
     }
+    async pwrite(session, vm, path, offset, content) {
+        const encoded = encodeGuestFilesystemContent(content);
+        await this.guestFilesystemCall(session, vm, {
+            operation: "pwrite",
+            path,
+            offset,
+            content: encoded.content,
+            encoding: encoded.encoding,
+        });
+    }
     async mkdir(session, vm, path, options) {
         await this.guestFilesystemCall(session, vm, {
             operation: options?.recursive ? "mkdir" : "create_dir",
@@ -841,33 +870,66 @@ export class SidecarProcess {
     }
     async hostFilesystemCall(session, vm, request) {
         const response = await this.sendRequest({
-            ownership: { scope: "vm", connection_id: session.connectionId, session_id: session.sessionId, vm_id: vm.vmId },
-            payload: { type: "host_filesystem_call", operation: request.operation, path: request.path, payload_size_bytes: request.payloadSizeBytes },
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "host_filesystem_call",
+                operation: request.operation,
+                path: request.path,
+                payload_size_bytes: request.payloadSizeBytes,
+            },
         });
         if (response.payload.type !== "filesystem_result") {
             throw new Error(`unexpected host_filesystem_call response: ${response.payload.type}`);
         }
-        return { operation: response.payload.operation, status: response.payload.status, payloadSizeBytes: response.payload.payload_size_bytes };
+        return {
+            operation: response.payload.operation,
+            status: response.payload.status,
+            payloadSizeBytes: response.payload.payload_size_bytes,
+        };
     }
     async persistenceLoad(session, key) {
         const response = await this.sendRequest({
-            ownership: { scope: "session", connection_id: session.connectionId, session_id: session.sessionId },
+            ownership: {
+                scope: "session",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+            },
             payload: { type: "persistence_load", key },
         });
         if (response.payload.type !== "persistence_state") {
             throw new Error(`unexpected persistence_load response: ${response.payload.type}`);
         }
-        return { key: response.payload.key, found: response.payload.found, payloadSizeBytes: response.payload.payload_size_bytes };
+        return {
+            key: response.payload.key,
+            found: response.payload.found,
+            payloadSizeBytes: response.payload.payload_size_bytes,
+        };
     }
     async persistenceFlush(session, request) {
         const response = await this.sendRequest({
-            ownership: { scope: "session", connection_id: session.connectionId, session_id: session.sessionId },
-            payload: { type: "persistence_flush", key: request.key, payload_size_bytes: request.payloadSizeBytes },
+            ownership: {
+                scope: "session",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+            },
+            payload: {
+                type: "persistence_flush",
+                key: request.key,
+                payload_size_bytes: request.payloadSizeBytes,
+            },
         });
         if (response.payload.type !== "persistence_flushed") {
             throw new Error(`unexpected persistence_flush response: ${response.payload.type}`);
         }
-        return { key: response.payload.key, committedBytes: response.payload.committed_bytes };
+        return {
+            key: response.payload.key,
+            committedBytes: response.payload.committed_bytes,
+        };
     }
     async waitForEvent(matcher, timeoutMs, options) {
         return await this.protocolClient.waitForEvent(matcher, timeoutMs, options);
@@ -962,6 +1024,8 @@ function toWireRootFilesystemEntry(entry) {
 function toWireMountDescriptor(descriptor) {
     return {
         guest_path: descriptor.guestPath,
+        guest_source: descriptor.guestSource ?? descriptor.plugin.id,
+        guest_fstype: descriptor.guestFstype ?? descriptor.plugin.id,
         read_only: descriptor.readOnly,
         plugin: {
             id: descriptor.plugin.id,

package/dist/state.d.ts

@@ -1,18 +1,18 @@
 import * as protocol from "./generated-protocol.js";
 export interface LiveGuestFilesystemStat {
     mode: number;
-    size: number;
-    blocks: number;
-    dev: number;
-    rdev: number;
+    size: bigint;
+    blocks: bigint;
+    dev: bigint;
+    rdev: bigint;
     is_directory: boolean;
     is_symbolic_link: boolean;
     atime_ms: number;
     mtime_ms: number;
     ctime_ms: number;
     birthtime_ms: number;
-    ino: number;
-    nlink: number;
+    ino: bigint;
+    nlink: bigint;
     uid: number;
     gid: number;
 }

package/dist/state.js

@@ -1,20 +1,19 @@
-import { bigIntToSafeNumber } from "./numbers.js";
 import { fromGeneratedProcessSnapshotStatus } from "./protocol-maps.js";
 export function fromGeneratedGuestFilesystemStat(stat) {
     return {
         mode: stat.mode,
-        size: bigIntToSafeNumber(stat.size, "guest filesystem stat size"),
-        blocks: bigIntToSafeNumber(stat.blocks, "guest filesystem stat blocks"),
-        dev: bigIntToSafeNumber(stat.dev, "guest filesystem stat dev"),
-        rdev: bigIntToSafeNumber(stat.rdev, "guest filesystem stat rdev"),
+        size: stat.size,
+        blocks: stat.blocks,
+        dev: stat.dev,
+        rdev: stat.rdev,
         is_directory: stat.isDirectory,
         is_symbolic_link: stat.isSymbolicLink,
-        atime_ms: bigIntToSafeNumber(stat.atimeMs, "guest filesystem stat atime"),
-        mtime_ms: bigIntToSafeNumber(stat.mtimeMs, "guest filesystem stat mtime"),
-        ctime_ms: bigIntToSafeNumber(stat.ctimeMs, "guest filesystem stat ctime"),
-        birthtime_ms: bigIntToSafeNumber(stat.birthtimeMs, "guest filesystem stat birthtime"),
-        ino: bigIntToSafeNumber(stat.ino, "guest filesystem stat ino"),
-        nlink: bigIntToSafeNumber(stat.nlink, "guest filesystem stat nlink"),
+        atime_ms: Number(stat.atimeMs),
+        mtime_ms: Number(stat.mtimeMs),
+        ctime_ms: Number(stat.ctimeMs),
+        birthtime_ms: Number(stat.birthtimeMs),
+        ino: stat.ino,
+        nlink: stat.nlink,
         uid: stat.uid,
         gid: stat.gid,
     };

package/dist/test-runtime.d.ts

@@ -1,6 +1,7 @@
 import "./native-client.js";
 import { SidecarProcess } from "./kernel-proxy.js";
 import type { JsRuntimeConfig } from "./generated/JsRuntimeConfig.js";
+import type { VmUserConfig } from "./generated/VmUserConfig.js";
 export declare const AF_INET = 2;
 export declare const AF_UNIX = 1;
 export declare const SOCK_STREAM = 1;
@@ -23,6 +24,7 @@ export interface VirtualDirEntry {
 export interface VirtualStat {
     mode: number;
     size: number;
+    sizeExact?: bigint;
     blocks: number;
     dev: number;
     rdev: number;
@@ -33,7 +35,9 @@ export interface VirtualStat {
     ctimeMs: number;
     birthtimeMs: number;
     ino: number;
+    inoExact?: bigint;
     nlink: number;
+    nlinkExact?: bigint;
     uid: number;
     gid: number;
 }
@@ -58,7 +62,9 @@ export interface VirtualFileSystem {
     lstat(path: string): Promise<VirtualStat>;
     link(oldPath: string, newPath: string): Promise<void>;
     chmod(path: string, mode: number): Promise<void>;
-    chown(path: string, uid: number, gid: number): Promise<void>;
+    chown(path: string, uid: number, gid: number, options?: {
+        followSymlinks?: boolean;
+    }): Promise<void>;
     utimes(path: string, atime: number, mtime: number): Promise<void>;
     truncate(path: string, length: number): Promise<void>;
     pread(path: string, offset: number, length: number): Promise<Uint8Array>;
@@ -115,6 +121,7 @@ export interface ManagedProcess {
 export interface ShellHandle {
     pid: number;
     write(data: Uint8Array | string): void;
+    /** Ordered PTY output containing stdout and stderr exactly once. */
     onData: ((data: Uint8Array) => void) | null;
     resize(cols: number, rows: number): void;
     kill(signal?: number): void;
@@ -127,6 +134,7 @@ export interface OpenShellOptions {
     cwd?: string;
     cols?: number;
     rows?: number;
+    /** Optional stderr-only diagnostic tap; do not render it alongside `onData`. */
     onStderr?: (data: Uint8Array) => void;
 }
 export interface ConnectTerminalOptions extends OpenShellOptions {
@@ -179,7 +187,7 @@ export interface Permissions {
     binding?: BindingPermissions;
 }
 /** A worked example shown alongside a registered binding. */
-export interface HostToolExample {
+export interface BindingExample {
     /** What this example demonstrates. */
     description: string;
     /** Example input matching the binding's input schema. */
@@ -201,7 +209,7 @@ export interface BindingDefinition {
     /** Abort the invocation after this many milliseconds. */
     timeoutMs?: number;
     /** Worked examples shown alongside the binding. */
-    examples?: HostToolExample[];
+    examples?: BindingExample[];
     /**
      * Extra command names the guest can use to invoke this binding, in addition
      * to the key it is registered under.
@@ -326,6 +334,7 @@ export interface Kernel extends KernelInterface {
     removeFile(path: string): Promise<void>;
     removeDir(path: string): Promise<void>;
     rename(oldPath: string, newPath: string): Promise<void>;
+    pwrite(path: string, offset: number, data: Uint8Array): Promise<void>;
     vmFetch(request: {
         port: number;
         method: string;
@@ -333,7 +342,7 @@ export interface Kernel extends KernelInterface {
         headersJson: string;
         body?: string;
     }): Promise<string>;
-    registerHostTools(tools: Record<string, BindingDefinition>): Promise<void>;
+    registerBindings(bindings: Record<string, BindingDefinition>): Promise<void>;
     getResourceSnapshot(): Promise<{
         runningProcesses: number;
         exitedProcesses: number;
@@ -450,7 +459,9 @@ export declare class InMemoryFileSystem implements VirtualFileSystem {
     lstat(targetPath: string): Promise<VirtualStat>;
     link(oldPath: string, newPath: string): Promise<void>;
     chmod(targetPath: string, mode: number): Promise<void>;
-    chown(targetPath: string, uid: number, gid: number): Promise<void>;
+    chown(targetPath: string, uid: number, gid: number, options?: {
+        followSymlinks?: boolean;
+    }): Promise<void>;
     utimes(targetPath: string, atime: number, mtime: number): Promise<void>;
     truncate(targetPath: string, length: number): Promise<void>;
     pread(targetPath: string, offset: number, length: number): Promise<Uint8Array>;
@@ -488,7 +499,9 @@ export declare class NodeFileSystem implements VirtualFileSystem {
     lstat(targetPath: string): Promise<VirtualStat>;
     link(oldPath: string, newPath: string): Promise<void>;
     chmod(targetPath: string, mode: number): Promise<void>;
-    chown(targetPath: string, uid: number, gid: number): Promise<void>;
+    chown(targetPath: string, uid: number, gid: number, options?: {
+        followSymlinks?: boolean;
+    }): Promise<void>;
     utimes(targetPath: string, atime: number, mtime: number): Promise<void>;
     truncate(targetPath: string, length: number): Promise<void>;
     pread(targetPath: string, offset: number, length: number): Promise<Uint8Array>;
@@ -547,6 +560,7 @@ export declare function createKernel(options: {
     permissions?: Permissions;
     env?: Record<string, string>;
     cwd?: string;
+    user?: VmUserConfig;
     sidecar?: SidecarProcess;
     onBootTiming?: (timing: KernelBootTiming) => void;
     maxProcesses?: number;
@@ -560,4 +574,5 @@ export declare function createKernel(options: {
         readOnly?: boolean;
     }>;
     syncFilesystemOnDispose?: boolean;
+    maxFilesystemBytes?: number;
 }): Kernel;