@rivet-dev/agentos-runtime-core 0.0.0-glibc.4af31c1

package/dist/request-payloads.js

@@ -0,0 +1,269 @@
+import { toExactArrayBuffer } from "./bytes.js";
+import { toGeneratedMountDescriptor, toGeneratedPackageDescriptor, toGeneratedProjectedModuleDescriptor, toGeneratedSidecarPlacement, toGeneratedSoftwareDescriptor, } from "./descriptors.js";
+import { toGeneratedExtEnvelope } from "./ext.js";
+import { toGeneratedRootFilesystemEntry, } from "./filesystem.js";
+import { stringifyJsonUtf8 } from "./json.js";
+import { toGeneratedPermissionsPolicy, } from "./permissions.js";
+import { toGeneratedDisposeReason, toGeneratedFilesystemOperation, toGeneratedGuestFilesystemOperation, toGeneratedGuestRuntimeKind, toGeneratedRootFilesystemEntryEncoding, toGeneratedRootFilesystemMode, toGeneratedWasmPermissionTier, } from "./protocol-maps.js";
+export function toGeneratedRequestPayload(payload) {
+    switch (payload.type) {
+        case "authenticate":
+            return {
+                tag: "AuthenticateRequest",
+                val: {
+                    clientName: payload.client_name,
+                    authToken: payload.auth_token,
+                    protocolVersion: payload.protocol_version,
+                    bridgeVersion: payload.bridge_version,
+                },
+            };
+        case "open_session":
+            return {
+                tag: "OpenSessionRequest",
+                val: {
+                    placement: toGeneratedSidecarPlacement(payload.placement),
+                    metadata: new Map(Object.entries(payload.metadata ?? {})),
+                },
+            };
+        case "create_vm":
+            return {
+                tag: "CreateVmRequest",
+                val: {
+                    runtime: toGeneratedGuestRuntimeKind(payload.runtime),
+                    config: stringifyJsonUtf8(payload.config, "create VM config"),
+                },
+            };
+        case "dispose_vm":
+            return {
+                tag: "DisposeVmRequest",
+                val: { reason: toGeneratedDisposeReason(payload.reason) },
+            };
+        case "bootstrap_root_filesystem":
+            return {
+                tag: "BootstrapRootFilesystemRequest",
+                val: { entries: payload.entries.map(toGeneratedRootFilesystemEntry) },
+            };
+        case "configure_vm":
+            return {
+                tag: "ConfigureVmRequest",
+                val: {
+                    mounts: (payload.mounts ?? []).map(toGeneratedMountDescriptor),
+                    software: (payload.software ?? []).map(toGeneratedSoftwareDescriptor),
+                    permissions: toGeneratedPermissionsPolicy(payload.permissions),
+                    moduleAccessCwd: payload.module_access_cwd ?? null,
+                    instructions: payload.instructions ?? [],
+                    projectedModules: (payload.projected_modules ?? []).map(toGeneratedProjectedModuleDescriptor),
+                    commandPermissions: new Map(Object.entries(payload.command_permissions ?? {}).map(([name, tier]) => [name, toGeneratedWasmPermissionTier(tier)])),
+                    loopbackExemptPorts: new Uint16Array(payload.loopback_exempt_ports ?? []),
+                    packages: (payload.packages ?? []).map(toGeneratedPackageDescriptor),
+                    packagesMountAt: payload.packages_mount_at ?? "",
+                    bootstrapCommands: payload.bootstrap_commands ?? [],
+                    toolShimCommands: payload.tool_shim_commands ?? [],
+                },
+            };
+        case "link_package":
+            return {
+                tag: "LinkPackageRequest",
+                val: {
+                    package: toGeneratedPackageDescriptor(payload.package),
+                },
+            };
+        case "provided_commands":
+            return {
+                tag: "ProvidedCommandsRequest",
+                val: null,
+            };
+        case "register_host_callbacks":
+            return {
+                tag: "RegisterHostCallbacksRequest",
+                val: {
+                    name: payload.name,
+                    description: payload.description,
+                    commandAliases: payload.command_aliases ?? [],
+                    registryCommandAliases: payload.registry_command_aliases ?? [],
+                    callbacks: new Map(Object.entries(payload.callbacks).map(([name, callback]) => [
+                        name,
+                        {
+                            description: callback.description,
+                            inputSchema: stringifyJsonUtf8(callback.input_schema, "register_host_callbacks.callback.input_schema"),
+                            timeoutMs: callback.timeout_ms === undefined
+                                ? null
+                                : BigInt(callback.timeout_ms),
+                            examples: (callback.examples ?? []).map((example) => ({
+                                description: example.description,
+                                input: stringifyJsonUtf8(example.input, "register_host_callbacks.callback.example.input"),
+                            })),
+                        },
+                    ])),
+                },
+            };
+        case "create_layer":
+            return { tag: "CreateLayerRequest", val: null };
+        case "seal_layer":
+            return { tag: "SealLayerRequest", val: { layerId: payload.layer_id } };
+        case "import_snapshot":
+            return {
+                tag: "ImportSnapshotRequest",
+                val: { entries: payload.entries.map(toGeneratedRootFilesystemEntry) },
+            };
+        case "export_snapshot":
+            return {
+                tag: "ExportSnapshotRequest",
+                val: { layerId: payload.layer_id },
+            };
+        case "create_overlay":
+            return {
+                tag: "CreateOverlayRequest",
+                val: {
+                    mode: toGeneratedRootFilesystemMode(payload.mode ?? "ephemeral"),
+                    upperLayerId: payload.upper_layer_id ?? null,
+                    lowerLayerIds: payload.lower_layer_ids ?? [],
+                },
+            };
+        case "guest_filesystem_call":
+            return {
+                tag: "GuestFilesystemCallRequest",
+                val: {
+                    operation: toGeneratedGuestFilesystemOperation(payload.operation),
+                    path: payload.path,
+                    destinationPath: payload.destination_path ?? null,
+                    target: payload.target ?? null,
+                    content: payload.content ?? null,
+                    encoding: payload.encoding === undefined
+                        ? null
+                        : toGeneratedRootFilesystemEntryEncoding(payload.encoding),
+                    recursive: payload.recursive ?? false,
+                    maxDepth: payload.max_depth ?? null,
+                    mode: payload.mode ?? null,
+                    uid: payload.uid ?? null,
+                    gid: payload.gid ?? null,
+                    atimeMs: toGeneratedOptionalU64(payload.atime_ms),
+                    mtimeMs: toGeneratedOptionalU64(payload.mtime_ms),
+                    len: toGeneratedOptionalU64(payload.len),
+                    offset: toGeneratedOptionalU64(payload.offset),
+                },
+            };
+        case "guest_kernel_call":
+            return {
+                tag: "GuestKernelCallRequest",
+                val: {
+                    executionId: payload.execution_id,
+                    operation: payload.operation,
+                    payload: payload.payload,
+                },
+            };
+        case "snapshot_root_filesystem":
+            return { tag: "SnapshotRootFilesystemRequest", val: null };
+        case "execute":
+            return {
+                tag: "ExecuteRequest",
+                val: {
+                    processId: payload.process_id,
+                    command: payload.command ?? null,
+                    runtime: payload.runtime === undefined
+                        ? null
+                        : toGeneratedGuestRuntimeKind(payload.runtime),
+                    entrypoint: payload.entrypoint ?? null,
+                    args: payload.args ?? [],
+                    env: new Map(Object.entries(payload.env ?? {})),
+                    cwd: payload.cwd ?? null,
+                    wasmPermissionTier: payload.wasm_permission_tier === undefined
+                        ? null
+                        : toGeneratedWasmPermissionTier(payload.wasm_permission_tier),
+                },
+            };
+        case "write_stdin":
+            return {
+                tag: "WriteStdinRequest",
+                val: {
+                    processId: payload.process_id,
+                    chunk: toExactArrayBuffer(payload.chunk),
+                },
+            };
+        case "resize_pty":
+            return {
+                tag: "ResizePtyRequest",
+                val: {
+                    processId: payload.process_id,
+                    cols: payload.cols,
+                    rows: payload.rows,
+                },
+            };
+        case "close_stdin":
+            return {
+                tag: "CloseStdinRequest",
+                val: { processId: payload.process_id },
+            };
+        case "kill_process":
+            return {
+                tag: "KillProcessRequest",
+                val: { processId: payload.process_id, signal: payload.signal },
+            };
+        case "get_process_snapshot":
+            return { tag: "GetProcessSnapshotRequest", val: null };
+        case "get_resource_snapshot":
+            return { tag: "GetResourceSnapshotRequest", val: null };
+        case "find_listener":
+            return {
+                tag: "FindListenerRequest",
+                val: {
+                    host: payload.host ?? null,
+                    port: payload.port ?? null,
+                    path: payload.path ?? null,
+                },
+            };
+        case "find_bound_udp":
+            return {
+                tag: "FindBoundUdpRequest",
+                val: { host: payload.host ?? null, port: payload.port ?? null },
+            };
+        case "vm_fetch":
+            return {
+                tag: "VmFetchRequest",
+                val: {
+                    port: payload.port,
+                    method: payload.method,
+                    path: payload.path,
+                    headersJson: payload.headers_json,
+                    body: payload.body ?? null,
+                },
+            };
+        case "get_signal_state":
+            return {
+                tag: "GetSignalStateRequest",
+                val: { processId: payload.process_id },
+            };
+        case "get_zombie_timer_count":
+            return { tag: "GetZombieTimerCountRequest", val: null };
+        case "host_filesystem_call":
+            return {
+                tag: "HostFilesystemCallRequest",
+                val: {
+                    operation: toGeneratedFilesystemOperation(payload.operation),
+                    path: payload.path,
+                    payloadSizeBytes: BigInt(payload.payload_size_bytes),
+                },
+            };
+        case "persistence_load":
+            return {
+                tag: "PersistenceLoadRequest",
+                val: { key: payload.key },
+            };
+        case "persistence_flush":
+            return {
+                tag: "PersistenceFlushRequest",
+                val: {
+                    key: payload.key,
+                    payloadSizeBytes: BigInt(payload.payload_size_bytes),
+                },
+            };
+        case "ext":
+            return {
+                tag: "ExtEnvelope",
+                val: toGeneratedExtEnvelope(payload.envelope),
+            };
+    }
+}
+function toGeneratedOptionalU64(value) {
+    return value === undefined ? null : BigInt(value);
+}

package/dist/response-payloads.d.ts

@@ -0,0 +1,186 @@
+import { type LiveRootFilesystemEntry, type LiveRootFilesystemEntryEncoding } from "./filesystem.js";
+import { type LiveExtEnvelope } from "./ext.js";
+import type * as protocol from "./generated-protocol.js";
+import { type LiveFilesystemOperation, type LiveGuestFilesystemOperation, type LiveSignalDispositionAction } from "./protocol-maps.js";
+import { type LiveGuestFilesystemStat, type LiveProcessSnapshotEntry, type LiveSocketStateEntry } from "./state.js";
+/** A directory child with its file type, from `read_dir` (no extra lstat). */
+export interface LiveGuestDirEntry {
+    name: string;
+    path: string;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+    size: number;
+}
+export interface LiveSignalHandlerRegistration {
+    action: LiveSignalDispositionAction;
+    mask: number[];
+    flags: number;
+}
+export interface LiveQueueSnapshotEntry {
+    name: string;
+    category: string;
+    depth: number;
+    high_water: number;
+    capacity: number;
+    fill_percent: number;
+}
+export interface LiveResourceSnapshot {
+    running_processes: number;
+    exited_processes: number;
+    fd_tables: number;
+    open_fds: number;
+    pipes: number;
+    pipe_buffered_bytes: number;
+    ptys: number;
+    pty_buffered_input_bytes: number;
+    pty_buffered_output_bytes: number;
+    sockets: number;
+    socket_listeners: number;
+    socket_connections: number;
+    socket_buffered_bytes: number;
+    socket_datagram_queue_len: number;
+    queue_snapshots: LiveQueueSnapshotEntry[];
+}
+export interface LiveProjectedCommand {
+    name: string;
+    guest_path: string;
+}
+export interface LivePackageCommands {
+    package_name: string;
+    commands: string[];
+}
+export interface LiveAgentosProjectedAgent {
+    id: string;
+    acp_entrypoint: string;
+    adapter_entrypoint: string;
+}
+export type LiveResponsePayload = {
+    type: "authenticated";
+    sidecar_id: string;
+    connection_id: string;
+    max_frame_bytes: number;
+} | {
+    type: "session_opened";
+    session_id: string;
+    owner_connection_id: string;
+} | {
+    type: "vm_created";
+    vm_id: string;
+} | {
+    type: "vm_configured";
+    applied_mounts: number;
+    applied_software: number;
+    projected_commands: LiveProjectedCommand[];
+    agents: LiveAgentosProjectedAgent[];
+} | {
+    type: "package_linked";
+    projected_commands: LiveProjectedCommand[];
+    agents: LiveAgentosProjectedAgent[];
+} | {
+    type: "provided_commands_response";
+    packages: LivePackageCommands[];
+} | {
+    type: "host_callbacks_registered";
+    registration: string;
+    command_count: number;
+} | {
+    type: "layer_created";
+    layer_id: string;
+} | {
+    type: "layer_sealed";
+    layer_id: string;
+} | {
+    type: "snapshot_imported";
+    layer_id: string;
+} | {
+    type: "snapshot_exported";
+    layer_id: string;
+    entries: LiveRootFilesystemEntry[];
+} | {
+    type: "overlay_created";
+    layer_id: string;
+} | {
+    type: "root_filesystem_bootstrapped";
+    entry_count: number;
+} | {
+    type: "guest_filesystem_result";
+    operation: LiveGuestFilesystemOperation;
+    path: string;
+    content?: string;
+    encoding?: LiveRootFilesystemEntryEncoding;
+    entries?: LiveGuestDirEntry[];
+    stat?: LiveGuestFilesystemStat;
+    exists?: boolean;
+    target?: string;
+} | {
+    type: "guest_kernel_result";
+    payload: ArrayBuffer;
+} | {
+    type: "root_filesystem_snapshot";
+    entries: LiveRootFilesystemEntry[];
+} | {
+    type: "vm_disposed";
+    vm_id: string;
+} | {
+    type: "process_started";
+    process_id: string;
+    pid?: number;
+} | {
+    type: "stdin_written";
+    process_id: string;
+    accepted_bytes: number;
+} | {
+    type: "pty_resized";
+    process_id: string;
+    cols: number;
+    rows: number;
+} | {
+    type: "stdin_closed";
+    process_id: string;
+} | {
+    type: "process_killed";
+    process_id: string;
+} | {
+    type: "process_snapshot";
+    processes: LiveProcessSnapshotEntry[];
+} | ({
+    type: "resource_snapshot";
+} & LiveResourceSnapshot) | {
+    type: "listener_snapshot";
+    listener?: LiveSocketStateEntry;
+} | {
+    type: "bound_udp_snapshot";
+    socket?: LiveSocketStateEntry;
+} | {
+    type: "vm_fetch_result";
+    response_json: string;
+} | {
+    type: "signal_state";
+    process_id: string;
+    handlers: Record<string, LiveSignalHandlerRegistration>;
+} | {
+    type: "zombie_timer_count";
+    count: number;
+} | {
+    type: "filesystem_result";
+    operation: LiveFilesystemOperation;
+    status: string;
+    payload_size_bytes: number;
+} | {
+    type: "persistence_state";
+    key: string;
+    found: boolean;
+    payload_size_bytes: number;
+} | {
+    type: "persistence_flushed";
+    key: string;
+    committed_bytes: number;
+} | {
+    type: "rejected";
+    code: string;
+    message: string;
+} | {
+    type: "ext_result";
+    envelope: LiveExtEnvelope;
+};
+export declare function fromGeneratedResponsePayload(payload: protocol.ResponsePayload): LiveResponsePayload;