@rivet-dev/agentos-runtime-core 0.0.0-chdir-fix.3d9feab

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: 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,30 @@
+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;
+    });
+}
+/**
+ * The silence watchdog fired: the sidecar produced no protocol frames at all —
+ * not even its 10s liveness heartbeats — for the full silence window, so the
+ * process is dead or wedged (not merely busy: a busy sidecar still heartbeats
+ * from a dedicated thread). The host kills the sidecar and rejects every
+ * in-flight request with this error.
+ */
+export declare class SidecarSilenceTimeout extends Error {
+    readonly silenceMs: number;
+    readonly stderr: string;
+    constructor(options: {
+        silenceMs: number;
+        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,47 @@
+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;
+    }
+}
+/**
+ * The silence watchdog fired: the sidecar produced no protocol frames at all —
+ * not even its 10s liveness heartbeats — for the full silence window, so the
+ * process is dead or wedged (not merely busy: a busy sidecar still heartbeats
+ * from a dedicated thread). The host kills the sidecar and rejects every
+ * in-flight request with this error.
+ */
+export class SidecarSilenceTimeout extends Error {
+    silenceMs;
+    stderr;
+    constructor(options) {
+        super(`sidecar unresponsive: no protocol frames or heartbeats for ${Math.round(options.silenceMs)}ms; killing sidecar${formatSidecarStderrSuffix(options.stderr)}`);
+        this.name = "SidecarSilenceTimeout";
+        this.silenceMs = options.silenceMs;
+        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;
+    }
+}