@rivet-dev/agentos-runtime-core 0.0.0-main.ab2ce7c

package/dist/response-payloads.js

@@ -0,0 +1,250 @@
+import { fromGeneratedRootFilesystemEntry, } from "./filesystem.js";
+import { fromGeneratedExtEnvelope } from "./ext.js";
+import { bigIntToSafeNumber } from "./numbers.js";
+import { fromGeneratedFilesystemOperation, fromGeneratedGuestFilesystemOperation, fromGeneratedRootFilesystemEntryEncoding, fromGeneratedSignalDispositionAction, } from "./protocol-maps.js";
+import { fromGeneratedGuestFilesystemStat, fromGeneratedProcessSnapshotEntry, fromGeneratedSocketStateEntry, } from "./state.js";
+export function fromGeneratedResponsePayload(payload) {
+    switch (payload.tag) {
+        case "AuthenticatedResponse":
+            return {
+                type: "authenticated",
+                sidecar_id: payload.val.sidecarId,
+                connection_id: payload.val.connectionId,
+                max_frame_bytes: payload.val.maxFrameBytes,
+            };
+        case "SessionOpenedResponse":
+            return {
+                type: "session_opened",
+                session_id: payload.val.sessionId,
+                owner_connection_id: payload.val.ownerConnectionId,
+            };
+        case "VmCreatedResponse":
+            return { type: "vm_created", vm_id: payload.val.vmId };
+        case "VmDisposedResponse":
+            return { type: "vm_disposed", vm_id: payload.val.vmId };
+        case "RootFilesystemBootstrappedResponse":
+            return {
+                type: "root_filesystem_bootstrapped",
+                entry_count: payload.val.entryCount,
+            };
+        case "VmConfiguredResponse":
+            return {
+                type: "vm_configured",
+                applied_mounts: payload.val.appliedMounts,
+                applied_software: payload.val.appliedSoftware,
+                projected_commands: payload.val.projectedCommands.map((command) => ({
+                    name: command.name,
+                    guest_path: command.guestPath,
+                })),
+                agents: payload.val.agents.map(fromGeneratedAgentosProjectedAgent),
+            };
+        case "PackageLinkedResponse":
+            return {
+                type: "package_linked",
+                projected_commands: payload.val.projectedCommands.map((command) => ({
+                    name: command.name,
+                    guest_path: command.guestPath,
+                })),
+                agents: payload.val.agents.map(fromGeneratedAgentosProjectedAgent),
+            };
+        case "ProvidedCommandsResponse":
+            return {
+                type: "provided_commands_response",
+                packages: payload.val.packages.map((pkg) => ({
+                    package_name: pkg.packageName,
+                    commands: [...pkg.commands],
+                })),
+            };
+        case "HostCallbacksRegisteredResponse":
+            return {
+                type: "host_callbacks_registered",
+                registration: payload.val.registration,
+                command_count: payload.val.commandCount,
+            };
+        case "LayerCreatedResponse":
+            return { type: "layer_created", layer_id: payload.val.layerId };
+        case "LayerSealedResponse":
+            return { type: "layer_sealed", layer_id: payload.val.layerId };
+        case "SnapshotImportedResponse":
+            return { type: "snapshot_imported", layer_id: payload.val.layerId };
+        case "SnapshotExportedResponse":
+            return {
+                type: "snapshot_exported",
+                layer_id: payload.val.layerId,
+                entries: payload.val.entries.map(fromGeneratedRootFilesystemEntry),
+            };
+        case "OverlayCreatedResponse":
+            return { type: "overlay_created", layer_id: payload.val.layerId };
+        case "GuestFilesystemResultResponse":
+            return {
+                type: "guest_filesystem_result",
+                operation: fromGeneratedGuestFilesystemOperation(payload.val.operation),
+                path: payload.val.path,
+                ...(payload.val.content !== null
+                    ? { content: payload.val.content }
+                    : {}),
+                ...(payload.val.encoding !== null
+                    ? {
+                        encoding: fromGeneratedRootFilesystemEntryEncoding(payload.val.encoding),
+                    }
+                    : {}),
+                ...(payload.val.entries !== null
+                    ? {
+                        entries: payload.val.entries.map((entry) => ({
+                            name: entry.name,
+                            path: entry.path,
+                            isDirectory: entry.isDirectory,
+                            isSymbolicLink: entry.isSymbolicLink,
+                            size: bigIntToSafeNumber(entry.size, "guest dir entry size"),
+                        })),
+                    }
+                    : {}),
+                ...(payload.val.stat !== null
+                    ? { stat: fromGeneratedGuestFilesystemStat(payload.val.stat) }
+                    : {}),
+                ...(payload.val.exists !== null ? { exists: payload.val.exists } : {}),
+                ...(payload.val.target !== null ? { target: payload.val.target } : {}),
+            };
+        case "GuestKernelResultResponse":
+            return {
+                type: "guest_kernel_result",
+                payload: payload.val.payload,
+            };
+        case "RootFilesystemSnapshotResponse":
+            return {
+                type: "root_filesystem_snapshot",
+                entries: payload.val.entries.map(fromGeneratedRootFilesystemEntry),
+            };
+        case "ProcessStartedResponse":
+            return {
+                type: "process_started",
+                process_id: payload.val.processId,
+                ...(payload.val.pid !== null ? { pid: payload.val.pid } : {}),
+            };
+        case "StdinWrittenResponse":
+            return {
+                type: "stdin_written",
+                process_id: payload.val.processId,
+                accepted_bytes: bigIntToSafeNumber(payload.val.acceptedBytes, "stdin_written.accepted_bytes"),
+            };
+        case "PtyResizedResponse":
+            return {
+                type: "pty_resized",
+                process_id: payload.val.processId,
+                cols: payload.val.cols,
+                rows: payload.val.rows,
+            };
+        case "StdinClosedResponse":
+            return { type: "stdin_closed", process_id: payload.val.processId };
+        case "ProcessKilledResponse":
+            return { type: "process_killed", process_id: payload.val.processId };
+        case "ProcessSnapshotResponse":
+            return {
+                type: "process_snapshot",
+                processes: payload.val.processes.map(fromGeneratedProcessSnapshotEntry),
+            };
+        case "ResourceSnapshotResponse":
+            return {
+                type: "resource_snapshot",
+                running_processes: bigIntToSafeNumber(payload.val.runningProcesses, "resource_snapshot.running_processes"),
+                exited_processes: bigIntToSafeNumber(payload.val.exitedProcesses, "resource_snapshot.exited_processes"),
+                fd_tables: bigIntToSafeNumber(payload.val.fdTables, "resource_snapshot.fd_tables"),
+                open_fds: bigIntToSafeNumber(payload.val.openFds, "resource_snapshot.open_fds"),
+                pipes: bigIntToSafeNumber(payload.val.pipes, "resource_snapshot.pipes"),
+                pipe_buffered_bytes: bigIntToSafeNumber(payload.val.pipeBufferedBytes, "resource_snapshot.pipe_buffered_bytes"),
+                ptys: bigIntToSafeNumber(payload.val.ptys, "resource_snapshot.ptys"),
+                pty_buffered_input_bytes: bigIntToSafeNumber(payload.val.ptyBufferedInputBytes, "resource_snapshot.pty_buffered_input_bytes"),
+                pty_buffered_output_bytes: bigIntToSafeNumber(payload.val.ptyBufferedOutputBytes, "resource_snapshot.pty_buffered_output_bytes"),
+                sockets: bigIntToSafeNumber(payload.val.sockets, "resource_snapshot.sockets"),
+                socket_listeners: bigIntToSafeNumber(payload.val.socketListeners, "resource_snapshot.socket_listeners"),
+                socket_connections: bigIntToSafeNumber(payload.val.socketConnections, "resource_snapshot.socket_connections"),
+                socket_buffered_bytes: bigIntToSafeNumber(payload.val.socketBufferedBytes, "resource_snapshot.socket_buffered_bytes"),
+                socket_datagram_queue_len: bigIntToSafeNumber(payload.val.socketDatagramQueueLen, "resource_snapshot.socket_datagram_queue_len"),
+                queue_snapshots: payload.val.queueSnapshots.map((queue) => ({
+                    name: queue.name,
+                    category: queue.category,
+                    depth: bigIntToSafeNumber(queue.depth, "resource_snapshot.queue.depth"),
+                    high_water: bigIntToSafeNumber(queue.highWater, "resource_snapshot.queue.high_water"),
+                    capacity: bigIntToSafeNumber(queue.capacity, "resource_snapshot.queue.capacity"),
+                    fill_percent: bigIntToSafeNumber(queue.fillPercent, "resource_snapshot.queue.fill_percent"),
+                })),
+            };
+        case "ListenerSnapshotResponse":
+            return {
+                type: "listener_snapshot",
+                ...(payload.val.listener !== null
+                    ? { listener: fromGeneratedSocketStateEntry(payload.val.listener) }
+                    : {}),
+            };
+        case "BoundUdpSnapshotResponse":
+            return {
+                type: "bound_udp_snapshot",
+                ...(payload.val.socket !== null
+                    ? { socket: fromGeneratedSocketStateEntry(payload.val.socket) }
+                    : {}),
+            };
+        case "SignalStateResponse":
+            return {
+                type: "signal_state",
+                process_id: payload.val.processId,
+                handlers: Object.fromEntries([...payload.val.handlers].map(([signal, registration]) => [
+                    String(signal),
+                    {
+                        action: fromGeneratedSignalDispositionAction(registration.action),
+                        mask: Array.from(registration.mask),
+                        flags: registration.flags,
+                    },
+                ])),
+            };
+        case "ZombieTimerCountResponse":
+            return {
+                type: "zombie_timer_count",
+                count: bigIntToSafeNumber(payload.val.count, "zombie_timer_count.count"),
+            };
+        case "FilesystemResultResponse":
+            return {
+                type: "filesystem_result",
+                operation: fromGeneratedFilesystemOperation(payload.val.operation),
+                status: payload.val.status,
+                payload_size_bytes: bigIntToSafeNumber(payload.val.payloadSizeBytes, "filesystem_result.payload_size_bytes"),
+            };
+        case "PermissionDecisionResponse":
+            throw new Error("unsupported bare response payload tag: permission_decision");
+        case "PersistenceStateResponse":
+            return {
+                type: "persistence_state",
+                key: payload.val.key,
+                found: payload.val.found,
+                payload_size_bytes: bigIntToSafeNumber(payload.val.payloadSizeBytes, "persistence_state.payload_size_bytes"),
+            };
+        case "PersistenceFlushedResponse":
+            return {
+                type: "persistence_flushed",
+                key: payload.val.key,
+                committed_bytes: bigIntToSafeNumber(payload.val.committedBytes, "persistence_flushed.committed_bytes"),
+            };
+        case "RejectedResponse":
+            return {
+                type: "rejected",
+                code: payload.val.code,
+                message: payload.val.message,
+            };
+        case "VmFetchResponse":
+            return {
+                type: "vm_fetch_result",
+                response_json: payload.val.responseJson,
+            };
+        case "ExtEnvelope":
+            return {
+                type: "ext_result",
+                envelope: fromGeneratedExtEnvelope(payload.val),
+            };
+    }
+}
+function fromGeneratedAgentosProjectedAgent(agent) {
+    return {
+        id: agent.id,
+        acp_entrypoint: agent.acpEntrypoint,
+        adapter_entrypoint: agent.adapterEntrypoint,
+    };
+}

package/dist/sidecar-client.d.ts

@@ -0,0 +1,17 @@
+import type { LiveSidecarEventSelector } from "./event-buffer.js";
+import type { LiveOwnershipScope } from "./ownership.js";
+import type { LiveEventFrame, LiveResponseFrame, LiveSidecarRequestHandler } from "./protocol-frames.js";
+import type { LiveRequestPayload } from "./request-payloads.js";
+export interface SidecarProcessTransport {
+    setSidecarRequestHandler(handler: LiveSidecarRequestHandler | null): void;
+    onEvent(handler: (event: LiveEventFrame) => void): () => void;
+    sendRequest(input: {
+        ownership: LiveOwnershipScope;
+        payload: LiveRequestPayload;
+    }): Promise<LiveResponseFrame>;
+    waitForEvent(matcher: LiveSidecarEventSelector | ((event: LiveEventFrame) => boolean), timeoutMs?: number, options?: {
+        signal?: AbortSignal;
+    }): Promise<LiveEventFrame>;
+    failPermanently(error: Error): void;
+    dispose(): Promise<void>;
+}

package/dist/sidecar-client.js

@@ -0,0 +1 @@
+export {};

package/dist/sidecar-errors.d.ts

@@ -0,0 +1,15 @@
+export declare class SidecarProcessExited extends Error {
+    readonly exitCode: number | null;
+    readonly signal: string | null;
+    readonly stderr: string;
+    constructor(options: {
+        exitCode: number | null;
+        signal: string | null;
+        stderr: string;
+    });
+}
+export declare class SidecarProcessError extends Error {
+    readonly childError: Error;
+    readonly stderr: string;
+    constructor(error: Error, stderr: string);
+}

package/dist/sidecar-errors.js

@@ -0,0 +1,30 @@
+function formatSidecarStderrSuffix(stderr) {
+    return stderr ? `\nstderr:\n${stderr}` : "";
+}
+export class SidecarProcessExited extends Error {
+    exitCode;
+    signal;
+    stderr;
+    constructor(options) {
+        const reason = options.signal !== null
+            ? `signal ${options.signal}`
+            : options.exitCode !== null
+                ? `code ${options.exitCode}`
+                : "disconnect";
+        super(`sidecar process exited with ${reason}${formatSidecarStderrSuffix(options.stderr)}`);
+        this.name = "SidecarProcessExited";
+        this.exitCode = options.exitCode;
+        this.signal = options.signal;
+        this.stderr = options.stderr;
+    }
+}
+export class SidecarProcessError extends Error {
+    childError;
+    stderr;
+    constructor(error, stderr) {
+        super(`sidecar process error: ${error.message}${formatSidecarStderrSuffix(stderr)}`);
+        this.name = "SidecarProcessError";
+        this.childError = error;
+        this.stderr = stderr;
+    }
+}

package/dist/sidecar-process.d.ts

@@ -0,0 +1,356 @@
+import { type LiveSidecarRequestPayload, type LiveSidecarResponsePayload } from "./callbacks.js";
+import type { MountConfigJsonObject } from "./descriptors.js";
+import { type LiveSidecarEventSelector } from "./event-buffer.js";
+import { type LiveRootFilesystemEntry } from "./filesystem.js";
+import type { CreateVmConfig } from "./generated/CreateVmConfig.js";
+import type { SidecarProcessTransport } from "./sidecar-client.js";
+import { type LiveFsPermissionRule, type LivePatternPermissionRule, type LivePermissionMode, type LivePermissionScope, type LiveRulePermissions } from "./permissions.js";
+import type { LiveFilesystemOperation, LiveGuestRuntimeKind, LiveWasmPermissionTier } from "./protocol-maps.js";
+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 { 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 {
+}
+export interface RootFilesystemLowerDescriptor {
+    kind: "snapshot" | "bundled_base_filesystem";
+    entries?: RootFilesystemEntry[];
+}
+export interface GuestFilesystemStat extends LiveGuestFilesystemStat {
+}
+export interface SidecarSocketStateEntry {
+    processId: string;
+    host?: string;
+    port?: number;
+    path?: string;
+}
+export interface SidecarSignalHandlerRegistration {
+    action: "default" | "ignore" | "user";
+    mask: number[];
+    flags: number;
+}
+export interface SidecarSignalState {
+    processId: string;
+    handlers: Map<number, SidecarSignalHandlerRegistration>;
+}
+export interface SidecarProcessSnapshotEntry {
+    processId: string;
+    pid: number;
+    ppid: number;
+    pgid: number;
+    sid: number;
+    driver: string;
+    command: string;
+    args: string[];
+    cwd: string;
+    status: "running" | "exited" | "stopped";
+    exitCode: number | null;
+}
+export interface SidecarQueueSnapshotEntry {
+    name: string;
+    category: string;
+    depth: number;
+    highWater: number;
+    capacity: number;
+    fillPercent: number;
+}
+export interface SidecarResourceSnapshot {
+    runningProcesses: number;
+    exitedProcesses: number;
+    fdTables: number;
+    openFds: number;
+    pipes: number;
+    pipeBufferedBytes: number;
+    ptys: number;
+    ptyBufferedInputBytes: number;
+    ptyBufferedOutputBytes: number;
+    sockets: number;
+    socketListeners: number;
+    socketConnections: number;
+    socketBufferedBytes: number;
+    socketDatagramQueueLen: number;
+    queueSnapshots: SidecarQueueSnapshotEntry[];
+}
+export interface SidecarZombieTimerCount {
+    count: number;
+}
+export interface SidecarRegisteredHostCallbackExample {
+    description: string;
+    input: unknown;
+}
+export interface SidecarRegisteredHostCallbackDefinition {
+    description: string;
+    inputSchema: unknown;
+    timeoutMs?: number;
+    examples?: SidecarRegisteredHostCallbackExample[];
+}
+export interface ExtEnvelope {
+    namespace: string;
+    payload: Uint8Array;
+}
+export type SidecarRequestPayload = LiveSidecarRequestPayload;
+export type SidecarResponsePayload = LiveSidecarResponsePayload;
+type EventFrame = LiveEventFrame;
+export type SidecarEventSelector = LiveSidecarEventSelector;
+export type SidecarRequestFrame = LiveSidecarRequestFrame;
+export type SidecarResponseFrame = LiveSidecarResponseFrame;
+type NativeTransportPayloadCodec = ProtocolFramePayloadCodec;
+export type SidecarRequestHandler = LiveSidecarRequestHandler;
+export interface SidecarSpawnOptions {
+    cwd?: string;
+    command?: string;
+    args?: string[];
+    frameTimeoutMs?: number;
+    eventBufferCapacity?: number;
+    payloadCodec?: NativeTransportPayloadCodec;
+}
+export interface ResolvedSidecarSpawnOptions {
+    cwd?: string;
+    command?: string;
+    args: string[];
+    frameTimeoutMs: number;
+    eventBufferCapacity: number;
+    gracefulExitMs: number;
+    forceExitMs: number;
+    disposedErrorMessage: string;
+    payloadCodec: NativeTransportPayloadCodec;
+}
+type SidecarProcessSpawnFactory = (options: ResolvedSidecarSpawnOptions) => SidecarProcessTransport;
+export declare function registerSidecarProcessSpawnFactory(factory: SidecarProcessSpawnFactory): void;
+export interface AuthenticatedSession {
+    connectionId: string;
+    sessionId: string;
+}
+export interface CreatedVm {
+    vmId: string;
+}
+export interface SidecarSessionState {
+    sessionId: string;
+    agentType: string;
+    processId: string;
+    pid?: number;
+    closed: boolean;
+    modes?: unknown;
+    configOptions: unknown[];
+    agentCapabilities?: unknown;
+    agentInfo?: unknown;
+}
+export interface SidecarMountPluginDescriptor {
+    id: string;
+    config?: MountConfigJsonObject;
+}
+export interface SidecarMountDescriptor {
+    guestPath: string;
+    readOnly: boolean;
+    plugin: SidecarMountPluginDescriptor;
+}
+export interface SidecarSoftwareDescriptor {
+    packageName: string;
+    root: string;
+}
+export type SidecarPermissionMode = LivePermissionMode;
+export interface SidecarFsPermissionRule extends LiveFsPermissionRule {
+}
+export interface SidecarPatternPermissionRule extends LivePatternPermissionRule {
+}
+export interface SidecarRulePermissions<TRule> extends LiveRulePermissions<TRule> {
+}
+export type SidecarPermissionScope<TRule> = LivePermissionScope<TRule>;
+export interface SidecarPermissionsPolicy {
+    fs?: SidecarPermissionScope<SidecarFsPermissionRule>;
+    network?: SidecarPermissionScope<SidecarPatternPermissionRule>;
+    childProcess?: SidecarPermissionScope<SidecarPatternPermissionRule>;
+    process?: SidecarPermissionScope<SidecarPatternPermissionRule>;
+    env?: SidecarPermissionScope<SidecarPatternPermissionRule>;
+    binding?: SidecarPermissionScope<SidecarPatternPermissionRule>;
+}
+export interface SidecarProjectedModuleDescriptor {
+    packageName: string;
+    entrypoint: string;
+}
+export interface SidecarPackageDescriptor {
+    path: string;
+}
+export interface SidecarProjectedAgent {
+    id: string;
+    acpEntrypoint: string;
+    adapterEntrypoint: string;
+}
+export interface SidecarLinkPackageResult {
+    projectedCommands: SidecarProjectedCommand[];
+    agents: SidecarProjectedAgent[];
+}
+export interface SidecarProjectedCommand {
+    name: string;
+    guestPath: string;
+}
+export interface SidecarPackageCommands {
+    packageName: string;
+    commands: string[];
+}
+export interface SidecarVmConfiguredResponse {
+    appliedMounts: number;
+    appliedSoftware: number;
+    projectedCommands: SidecarProjectedCommand[];
+    agents: SidecarProjectedAgent[];
+}
+export interface SidecarFilesystemResult {
+    operation: LiveFilesystemOperation;
+    status: string;
+    payloadSizeBytes: number;
+}
+export interface SidecarPersistenceState {
+    key: string;
+    found: boolean;
+    payloadSizeBytes: number;
+}
+export interface SidecarPersistenceFlushed {
+    key: string;
+    committedBytes: number;
+}
+export declare class SidecarProcess {
+    private readonly protocolClient;
+    private constructor();
+    static fromClient(protocolClient: SidecarProcessTransport): SidecarProcess;
+    static spawn(options?: SidecarSpawnOptions): SidecarProcess;
+    setSidecarRequestHandler(handler: SidecarRequestHandler | null): void;
+    onEvent(handler: (event: EventFrame) => void): () => void;
+    authenticateAndOpenSession(sessionMetadata?: Record<string, string>): Promise<AuthenticatedSession>;
+    createVm(session: AuthenticatedSession, options: {
+        runtime: GuestRuntimeKind;
+        config: CreateVmConfig;
+    }): Promise<CreatedVm>;
+    extensionRequest(session: AuthenticatedSession, vm: CreatedVm, envelope: ExtEnvelope): Promise<ExtEnvelope>;
+    configureVm(session: AuthenticatedSession, vm: CreatedVm, options: {
+        mounts?: SidecarMountDescriptor[];
+        software?: SidecarSoftwareDescriptor[];
+        permissions?: SidecarPermissionsPolicy;
+        moduleAccessCwd?: string;
+        instructions?: string[];
+        projectedModules?: SidecarProjectedModuleDescriptor[];
+        commandPermissions?: Record<string, WasmPermissionTier>;
+        loopbackExemptPorts?: number[];
+        packages?: SidecarPackageDescriptor[];
+        packagesMountAt?: string;
+        bootstrapCommands?: string[];
+        toolShimCommands?: string[];
+    }): Promise<SidecarVmConfiguredResponse>;
+    /**
+     * Runtime dynamic `linkSoftware`: project one package into the live
+     * `/opt/agentos` tree. Returns projected command entrypoints and agents.
+     */
+    linkPackage(session: AuthenticatedSession, vm: CreatedVm, descriptor: SidecarPackageDescriptor): Promise<SidecarLinkPackageResult>;
+    providedCommands(session: AuthenticatedSession, vm: CreatedVm): Promise<SidecarPackageCommands[]>;
+    registerHostCallbacks(session: AuthenticatedSession, vm: CreatedVm, registration: {
+        name: string;
+        description: string;
+        commandAliases?: string[];
+        registryCommandAliases?: string[];
+        callbacks: Record<string, SidecarRegisteredHostCallbackDefinition>;
+    }): Promise<{
+        registration: string;
+        commandCount: number;
+    }>;
+    createLayer(session: AuthenticatedSession, vm: CreatedVm): Promise<string>;
+    sealLayer(session: AuthenticatedSession, vm: CreatedVm, layerId: string): Promise<string>;
+    importSnapshot(session: AuthenticatedSession, vm: CreatedVm, entries: RootFilesystemEntry[]): Promise<string>;
+    exportSnapshot(session: AuthenticatedSession, vm: CreatedVm, layerId: string): Promise<RootFilesystemEntry[]>;
+    createOverlay(session: AuthenticatedSession, vm: CreatedVm, options: {
+        mode?: "ephemeral" | "read_only";
+        upperLayerId?: string;
+        lowerLayerIds: string[];
+    }): Promise<string>;
+    bootstrapRootFilesystem(session: AuthenticatedSession, vm: CreatedVm, entries: RootFilesystemEntry[]): Promise<void>;
+    snapshotRootFilesystem(session: AuthenticatedSession, vm: CreatedVm): Promise<RootFilesystemEntry[]>;
+    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>;
+    mkdir(session: AuthenticatedSession, vm: CreatedVm, path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    readdir(session: AuthenticatedSession, vm: CreatedVm, path: string): Promise<string[]>;
+    readdirRecursive(session: AuthenticatedSession, vm: CreatedVm, path: string, options?: {
+        maxDepth?: number;
+    }): Promise<LiveGuestDirEntry[]>;
+    exists(session: AuthenticatedSession, vm: CreatedVm, path: string): Promise<boolean>;
+    stat(session: AuthenticatedSession, vm: CreatedVm, path: string, options?: {
+        dereference?: boolean;
+    }): Promise<GuestFilesystemStat>;
+    lstat(session: AuthenticatedSession, vm: CreatedVm, path: string): Promise<GuestFilesystemStat>;
+    rename(session: AuthenticatedSession, vm: CreatedVm, fromPath: string, toPath: string): Promise<void>;
+    realpath(session: AuthenticatedSession, vm: CreatedVm, path: string): Promise<string>;
+    removeFile(session: AuthenticatedSession, vm: CreatedVm, path: string): Promise<void>;
+    removeDir(session: AuthenticatedSession, vm: CreatedVm, path: string): Promise<void>;
+    removePath(session: AuthenticatedSession, vm: CreatedVm, path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    copyPath(session: AuthenticatedSession, vm: CreatedVm, fromPath: string, toPath: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    movePath(session: AuthenticatedSession, vm: CreatedVm, fromPath: string, toPath: string): Promise<void>;
+    symlink(session: AuthenticatedSession, vm: CreatedVm, target: string, linkPath: string): Promise<void>;
+    readLink(session: AuthenticatedSession, vm: CreatedVm, path: string): Promise<string>;
+    link(session: AuthenticatedSession, vm: CreatedVm, fromPath: string, toPath: string): Promise<void>;
+    chmod(session: AuthenticatedSession, vm: CreatedVm, path: string, mode: number): Promise<void>;
+    chown(session: AuthenticatedSession, vm: CreatedVm, path: string, uid: number, gid: number): Promise<void>;
+    utimes(session: AuthenticatedSession, vm: CreatedVm, path: string, atimeMs: number, mtimeMs: number): Promise<void>;
+    truncate(session: AuthenticatedSession, vm: CreatedVm, path: string, length: number): Promise<void>;
+    disposeVm(session: AuthenticatedSession, vm: CreatedVm): Promise<void>;
+    execute(session: AuthenticatedSession, vm: CreatedVm, options: {
+        processId: string;
+        command?: string;
+        runtime?: GuestRuntimeKind;
+        entrypoint?: string;
+        args?: string[];
+        env?: Record<string, string>;
+        cwd?: string;
+        wasmPermissionTier?: WasmPermissionTier;
+    }): Promise<{
+        pid: number | null;
+    }>;
+    writeStdin(session: AuthenticatedSession, vm: CreatedVm, processId: string, chunk: string | Uint8Array): Promise<void>;
+    resizePty(session: AuthenticatedSession, vm: CreatedVm, processId: string, cols: number, rows: number): Promise<void>;
+    closeStdin(session: AuthenticatedSession, vm: CreatedVm, processId: string): Promise<void>;
+    killProcess(session: AuthenticatedSession, vm: CreatedVm, processId: string, signal?: string): Promise<void>;
+    findListener(session: AuthenticatedSession, vm: CreatedVm, request: {
+        host?: string;
+        port?: number;
+        path?: string;
+    }): Promise<SidecarSocketStateEntry | null>;
+    getProcessSnapshot(session: AuthenticatedSession, vm: CreatedVm): Promise<SidecarProcessSnapshotEntry[]>;
+    getResourceSnapshot(session: AuthenticatedSession, vm: CreatedVm): Promise<SidecarResourceSnapshot>;
+    findBoundUdp(session: AuthenticatedSession, vm: CreatedVm, request: {
+        host?: string;
+        port?: number;
+    }): Promise<SidecarSocketStateEntry | null>;
+    vmFetch(session: AuthenticatedSession, vm: CreatedVm, request: {
+        port: number;
+        method: string;
+        path: string;
+        headersJson: string;
+        body?: string;
+    }): Promise<string>;
+    getSignalState(session: AuthenticatedSession, vm: CreatedVm, processId: string): Promise<SidecarSignalState>;
+    getZombieTimerCount(session: AuthenticatedSession, vm: CreatedVm): Promise<SidecarZombieTimerCount>;
+    hostFilesystemCall(session: AuthenticatedSession, vm: CreatedVm, request: {
+        operation: LiveFilesystemOperation;
+        path: string;
+        payloadSizeBytes: number;
+    }): Promise<SidecarFilesystemResult>;
+    persistenceLoad(session: AuthenticatedSession, key: string): Promise<SidecarPersistenceState>;
+    persistenceFlush(session: AuthenticatedSession, request: {
+        key: string;
+        payloadSizeBytes: number;
+    }): Promise<SidecarPersistenceFlushed>;
+    waitForEvent(matcher: SidecarEventSelector | ((event: EventFrame) => boolean), timeoutMs?: number, options?: {
+        signal?: AbortSignal;
+    }): Promise<EventFrame>;
+    dispose(): Promise<void>;
+    private sendRequest;
+    private guestFilesystemCall;
+}