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

package/dist/numbers.d.ts

@@ -0,0 +1 @@
+export declare function bigIntToSafeNumber(value: bigint, context: string): number;

package/dist/numbers.js

@@ -0,0 +1,8 @@
+export function bigIntToSafeNumber(value, context) {
+    const max = BigInt(Number.MAX_SAFE_INTEGER);
+    const min = BigInt(Number.MIN_SAFE_INTEGER);
+    if (value > max || value < min) {
+        throw new Error(`${context} exceeds JavaScript safe integer range`);
+    }
+    return Number(value);
+}

package/dist/ownership.d.ts

@@ -0,0 +1,18 @@
+import * as protocol from "./generated-protocol.js";
+export type LiveOwnershipScope = {
+    scope: "connection";
+    connection_id: string;
+} | {
+    scope: "session";
+    connection_id: string;
+    session_id: string;
+} | {
+    scope: "vm";
+    connection_id: string;
+    session_id: string;
+    vm_id: string;
+};
+export declare function ownershipSelectorKey(ownership: LiveOwnershipScope): string;
+export declare function ownershipMatchesSelector(selector: LiveOwnershipScope | undefined, ownership: LiveOwnershipScope): boolean;
+export declare function toGeneratedOwnershipScope(ownership: LiveOwnershipScope): protocol.OwnershipScope;
+export declare function fromGeneratedOwnershipScope(ownership: protocol.OwnershipScope): LiveOwnershipScope;

package/dist/ownership.js

@@ -0,0 +1,77 @@
+export function ownershipSelectorKey(ownership) {
+    switch (ownership.scope) {
+        case "connection":
+            return `connection:${ownership.connection_id}`;
+        case "session":
+            return `session:${ownership.connection_id}:${ownership.session_id}`;
+        case "vm":
+            return `vm:${ownership.connection_id}:${ownership.session_id}:${ownership.vm_id}`;
+    }
+}
+export function ownershipMatchesSelector(selector, ownership) {
+    if (!selector) {
+        return true;
+    }
+    switch (selector.scope) {
+        case "connection":
+            return (ownership.scope === "connection" &&
+                selector.connection_id === ownership.connection_id);
+        case "session":
+            return (ownership.scope === "session" &&
+                selector.connection_id === ownership.connection_id &&
+                selector.session_id === ownership.session_id);
+        case "vm":
+            return (ownership.scope === "vm" &&
+                selector.connection_id === ownership.connection_id &&
+                selector.session_id === ownership.session_id &&
+                selector.vm_id === ownership.vm_id);
+    }
+}
+export function toGeneratedOwnershipScope(ownership) {
+    switch (ownership.scope) {
+        case "connection":
+            return {
+                tag: "ConnectionOwnership",
+                val: { connectionId: ownership.connection_id },
+            };
+        case "session":
+            return {
+                tag: "SessionOwnership",
+                val: {
+                    connectionId: ownership.connection_id,
+                    sessionId: ownership.session_id,
+                },
+            };
+        case "vm":
+            return {
+                tag: "VmOwnership",
+                val: {
+                    connectionId: ownership.connection_id,
+                    sessionId: ownership.session_id,
+                    vmId: ownership.vm_id,
+                },
+            };
+    }
+}
+export function fromGeneratedOwnershipScope(ownership) {
+    switch (ownership.tag) {
+        case "ConnectionOwnership":
+            return {
+                scope: "connection",
+                connection_id: ownership.val.connectionId,
+            };
+        case "SessionOwnership":
+            return {
+                scope: "session",
+                connection_id: ownership.val.connectionId,
+                session_id: ownership.val.sessionId,
+            };
+        case "VmOwnership":
+            return {
+                scope: "vm",
+                connection_id: ownership.val.connectionId,
+                session_id: ownership.val.sessionId,
+                vm_id: ownership.val.vmId,
+            };
+    }
+}

package/dist/permissions.d.ts

@@ -0,0 +1,29 @@
+import * as protocol from "./generated-protocol.js";
+import { type LivePermissionMode } from "./protocol-maps.js";
+export type { LivePermissionMode } from "./protocol-maps.js";
+export interface LiveFsPermissionRule {
+    mode: LivePermissionMode;
+    operations?: string[];
+    paths?: string[];
+}
+export interface LivePatternPermissionRule {
+    mode: LivePermissionMode;
+    operations?: string[];
+    patterns?: string[];
+}
+export interface LiveRulePermissions<TRule> {
+    default?: LivePermissionMode;
+    rules: TRule[];
+}
+export type LivePermissionScope<TRule> = LivePermissionMode | LiveRulePermissions<TRule>;
+export interface LivePermissionsPolicy {
+    fs?: LivePermissionScope<LiveFsPermissionRule>;
+    network?: LivePermissionScope<LivePatternPermissionRule>;
+    child_process?: LivePermissionScope<LivePatternPermissionRule>;
+    process?: LivePermissionScope<LivePatternPermissionRule>;
+    env?: LivePermissionScope<LivePatternPermissionRule>;
+    binding?: LivePermissionScope<LivePatternPermissionRule>;
+}
+export declare function toGeneratedPermissionsPolicy(policy: LivePermissionsPolicy | undefined): protocol.PermissionsPolicy | null;
+export declare function toGeneratedFilesystemPermissionScope(scope: LivePermissionScope<LiveFsPermissionRule>): protocol.FsPermissionScope;
+export declare function toGeneratedPatternPermissionScope(scope: LivePermissionScope<LivePatternPermissionRule>): protocol.PatternPermissionScope;

package/dist/permissions.js

@@ -0,0 +1,68 @@
+import { toGeneratedPermissionMode, } from "./protocol-maps.js";
+export function toGeneratedPermissionsPolicy(policy) {
+    if (policy === undefined) {
+        return null;
+    }
+    return {
+        fs: policy.fs === undefined
+            ? null
+            : toGeneratedFilesystemPermissionScope(policy.fs),
+        network: policy.network === undefined
+            ? null
+            : toGeneratedPatternPermissionScope(policy.network),
+        childProcess: policy.child_process === undefined
+            ? null
+            : toGeneratedPatternPermissionScope(policy.child_process),
+        process: policy.process === undefined
+            ? null
+            : toGeneratedPatternPermissionScope(policy.process),
+        env: policy.env === undefined
+            ? null
+            : toGeneratedPatternPermissionScope(policy.env),
+        binding: policy.binding === undefined
+            ? null
+            : toGeneratedPatternPermissionScope(policy.binding),
+    };
+}
+export function toGeneratedFilesystemPermissionScope(scope) {
+    if (typeof scope === "string") {
+        return {
+            tag: "PermissionMode",
+            val: toGeneratedPermissionMode(scope),
+        };
+    }
+    return {
+        tag: "FsPermissionRuleSet",
+        val: {
+            default: scope.default === undefined
+                ? null
+                : toGeneratedPermissionMode(scope.default),
+            rules: scope.rules.map((rule) => ({
+                mode: toGeneratedPermissionMode(rule.mode),
+                operations: rule.operations ?? [],
+                paths: rule.paths ?? [],
+            })),
+        },
+    };
+}
+export function toGeneratedPatternPermissionScope(scope) {
+    if (typeof scope === "string") {
+        return {
+            tag: "PermissionMode",
+            val: toGeneratedPermissionMode(scope),
+        };
+    }
+    return {
+        tag: "PatternPermissionRuleSet",
+        val: {
+            default: scope.default === undefined
+                ? null
+                : toGeneratedPermissionMode(scope.default),
+            rules: scope.rules.map((rule) => ({
+                mode: toGeneratedPermissionMode(rule.mode),
+                operations: rule.operations ?? [],
+                patterns: rule.patterns ?? [],
+            })),
+        },
+    };
+}

package/dist/process.d.ts

@@ -0,0 +1,22 @@
+import { type ChildProcessWithoutNullStreams } from "node:child_process";
+export { SidecarProcessError, SidecarProcessExited, } from "./sidecar-errors.js";
+import { SidecarProcessError, SidecarProcessExited } from "./sidecar-errors.js";
+export interface StdioSidecarProcessSpawnOptions {
+    command: string;
+    args?: string[];
+    cwd?: string;
+}
+export declare class StdioSidecarProcess {
+    readonly child: ChildProcessWithoutNullStreams;
+    private readonly stderrChunks;
+    private readonly exitListeners;
+    private readonly errorListeners;
+    private constructor();
+    static spawn(options: StdioSidecarProcessSpawnOptions): StdioSidecarProcess;
+    static fromChild(child: ChildProcessWithoutNullStreams): StdioSidecarProcess;
+    onExit(handler: (error: SidecarProcessExited) => void): () => void;
+    onError(handler: (error: SidecarProcessError) => void): () => void;
+    stderrText(): string;
+    currentExitError(): SidecarProcessExited | null;
+    waitForExit(timeoutMs: number): Promise<number | null>;
+}

package/dist/process.js

@@ -0,0 +1,97 @@
+import { spawn, } from "node:child_process";
+export { SidecarProcessError, SidecarProcessExited, } from "./sidecar-errors.js";
+import { SidecarProcessError, SidecarProcessExited, } from "./sidecar-errors.js";
+export class StdioSidecarProcess {
+    child;
+    stderrChunks = [];
+    exitListeners = new Set();
+    errorListeners = new Set();
+    constructor(child) {
+        this.child = child;
+        this.child.stderr.on("data", (chunk) => {
+            this.stderrChunks.push(typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk));
+        });
+        this.child.on("exit", (code, signal) => {
+            const error = new SidecarProcessExited({
+                exitCode: code,
+                signal,
+                stderr: this.stderrText(),
+            });
+            for (const listener of this.exitListeners) {
+                listener(error);
+            }
+        });
+        this.child.on("error", (error) => {
+            const normalized = error instanceof Error ? error : new Error(String(error));
+            const sidecarError = new SidecarProcessError(normalized, this.stderrText());
+            for (const listener of this.errorListeners) {
+                listener(sidecarError);
+            }
+        });
+    }
+    static spawn(options) {
+        return new StdioSidecarProcess(spawn(options.command, options.args ?? [], {
+            cwd: options.cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+        }));
+    }
+    static fromChild(child) {
+        return new StdioSidecarProcess(child);
+    }
+    onExit(handler) {
+        this.exitListeners.add(handler);
+        return () => {
+            this.exitListeners.delete(handler);
+        };
+    }
+    onError(handler) {
+        this.errorListeners.add(handler);
+        return () => {
+            this.errorListeners.delete(handler);
+        };
+    }
+    stderrText() {
+        return Buffer.concat(this.stderrChunks).toString("utf8").trim();
+    }
+    currentExitError() {
+        if (this.child.exitCode === null && this.child.signalCode === null) {
+            return null;
+        }
+        return new SidecarProcessExited({
+            exitCode: this.child.exitCode,
+            signal: this.child.signalCode,
+            stderr: this.stderrText(),
+        });
+    }
+    waitForExit(timeoutMs) {
+        return new Promise((resolve) => {
+            let timer = null;
+            const cleanup = () => {
+                this.child.off("exit", onExit);
+                this.child.off("close", onClose);
+                if (timer !== null) {
+                    clearTimeout(timer);
+                    timer = null;
+                }
+            };
+            const onExit = (code) => {
+                cleanup();
+                resolve(code);
+            };
+            const onClose = (code) => {
+                cleanup();
+                resolve(code);
+            };
+            if (this.child.exitCode !== null || this.child.signalCode !== null) {
+                resolve(this.child.exitCode);
+                return;
+            }
+            this.child.on("exit", onExit);
+            this.child.on("close", onClose);
+            timer = setTimeout(() => {
+                cleanup();
+                resolve(null);
+            }, timeoutMs);
+        });
+    }
+}

package/dist/protocol-client.d.ts

@@ -0,0 +1,65 @@
+import type { Readable, Writable } from "node:stream";
+import { type LiveSidecarEventSelector } from "./event-buffer.js";
+import type { FrameTransport } from "./frame-stream.js";
+import { type LiveEventFrame, type LiveProtocolFrame, type LiveResponseFrame, type LiveSidecarRequestFrame, type LiveSidecarRequestHandler, type ProtocolFramePayloadCodec } from "./protocol-frames.js";
+import type { LiveOwnershipScope } from "./ownership.js";
+import type { LiveRequestPayload } from "./request-payloads.js";
+export interface SidecarProtocolClientOptions {
+    frameTransport?: FrameTransport<LiveResponseFrame | LiveEventFrame | LiveSidecarRequestFrame, LiveProtocolFrame>;
+    stdin?: Writable;
+    stdout?: Readable;
+    eventBufferCapacity: number;
+    payloadCodec?: ProtocolFramePayloadCodec;
+    stderrText?: () => string;
+    frameError?: (error: Error) => Error;
+    streamEndedError?: () => Error;
+    /** Override the silence watchdog window. Tests only; production uses the default. */
+    silenceTimeoutMs?: number;
+    /**
+     * Runs when the silence watchdog fires, before pending work is rejected.
+     * The stdio layer uses it to SIGKILL the sidecar child.
+     */
+    onSilenceExpired?: () => void;
+}
+export declare class SidecarProtocolClient {
+    private readonly eventBuffer;
+    private readonly eventListeners;
+    private readonly silenceTimeoutMs;
+    private silenceTimer;
+    private lastInboundAtMs;
+    private readonly payloadCodec;
+    private readonly stderrText;
+    private readonly hostFrameFactory;
+    private readonly frameTransport;
+    private closedError;
+    private readonly eventWaiters;
+    private sidecarRequestHandler;
+    constructor(options: SidecarProtocolClientOptions);
+    /**
+     * Arm the silence watchdog: ANY inbound frame resets the clock (see the
+     * `onFrameActivity` tap above), and the sidecar heartbeats every 10s even
+     * while busy, so sustained silence for the full window means the process
+     * is dead or wedged — not slow. The check interval is unref'd so an idle
+     * host process can still exit naturally.
+     */
+    private startSilenceWatchdog;
+    private stopSilenceWatchdog;
+    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, options?: {
+        replaceExisting?: (current: Error, next: Error) => boolean;
+    }): void;
+    dispose(): void;
+    private writeFrame;
+    private dispatchSidecarRequest;
+    private dispatchEvent;
+    private bufferEvent;
+    private rejectPending;
+}

package/dist/protocol-client.js

@@ -0,0 +1,242 @@
+import { SidecarEventBuffer, SidecarEventBufferOverflow, normalizeSidecarEventMatcher, sidecarEventWaitAbortError, } from "./event-buffer.js";
+import { FrameRpcTransport } from "./frame-rpc.js";
+import { HostProtocolFrameFactory, classifySidecarWrittenProtocolFrame, decodeProtocolFramePayload, encodeProtocolFramePayload, resolveSidecarRequestFramePayload, } from "./protocol-frames.js";
+import { SidecarSilenceTimeout } from "./sidecar-errors.js";
+/**
+ * How long the host tolerates TOTAL inbound silence (no responses, events,
+ * sidecar requests, or heartbeats) before declaring the sidecar dead. The
+ * sidecar heartbeats every 10s from a dedicated thread, so this allows two
+ * missed beats plus margin; it bounds "sidecar is dead or wedged", never "this
+ * request is slow" — individual requests have no deadline of their own.
+ */
+const DEFAULT_SIDECAR_SILENCE_TIMEOUT_MS = 30_000;
+export class SidecarProtocolClient {
+    eventBuffer;
+    eventListeners = new Set();
+    silenceTimeoutMs;
+    silenceTimer = null;
+    lastInboundAtMs = 0;
+    payloadCodec;
+    stderrText;
+    hostFrameFactory = new HostProtocolFrameFactory();
+    frameTransport;
+    closedError = null;
+    eventWaiters = new Set();
+    sidecarRequestHandler = null;
+    constructor(options) {
+        this.silenceTimeoutMs =
+            options.silenceTimeoutMs ?? DEFAULT_SIDECAR_SILENCE_TIMEOUT_MS;
+        this.eventBuffer = new SidecarEventBuffer(options.eventBufferCapacity);
+        this.payloadCodec = options.payloadCodec ?? "bare";
+        this.stderrText = options.stderrText ?? (() => "");
+        this.frameTransport = new FrameRpcTransport({
+            frameTransport: options.frameTransport,
+            stdin: options.stdin,
+            stdout: options.stdout,
+            encodeFrame: (frame) => encodeProtocolFramePayload(frame, this.payloadCodec),
+            decodeFrame: (payload) => decodeProtocolFramePayload(payload, this.payloadCodec),
+            classifyFrame: classifySidecarWrittenProtocolFrame,
+        });
+        this.frameTransport.onEvent((event) => {
+            this.dispatchEvent(event);
+        });
+        this.frameTransport.onSidecarRequest((request) => {
+            void this.dispatchSidecarRequest(request);
+        });
+        this.frameTransport.onError((error) => {
+            this.failPermanently(options.frameError?.(error) ?? error);
+        });
+        this.frameTransport.onEnd(() => {
+            this.failPermanently(options.streamEndedError?.() ??
+                new Error("sidecar protocol stream ended"));
+        });
+        this.frameTransport.onFrameActivity(() => {
+            this.lastInboundAtMs = performance.now();
+        });
+        this.startSilenceWatchdog(options.onSilenceExpired);
+    }
+    /**
+     * Arm the silence watchdog: ANY inbound frame resets the clock (see the
+     * `onFrameActivity` tap above), and the sidecar heartbeats every 10s even
+     * while busy, so sustained silence for the full window means the process
+     * is dead or wedged — not slow. The check interval is unref'd so an idle
+     * host process can still exit naturally.
+     */
+    startSilenceWatchdog(onExpired) {
+        this.lastInboundAtMs = performance.now();
+        const checkIntervalMs = Math.max(Math.min(this.silenceTimeoutMs / 4, 1_000), 10);
+        this.silenceTimer = setInterval(() => {
+            const silenceMs = performance.now() - this.lastInboundAtMs;
+            if (silenceMs < this.silenceTimeoutMs) {
+                return;
+            }
+            this.stopSilenceWatchdog();
+            const error = new SidecarSilenceTimeout({
+                silenceMs,
+                stderr: this.stderrText(),
+            });
+            try {
+                onExpired?.();
+            }
+            finally {
+                this.failPermanently(error);
+            }
+        }, checkIntervalMs);
+        this.silenceTimer.unref?.();
+    }
+    stopSilenceWatchdog() {
+        if (this.silenceTimer !== null) {
+            clearInterval(this.silenceTimer);
+            this.silenceTimer = null;
+        }
+    }
+    setSidecarRequestHandler(handler) {
+        this.sidecarRequestHandler = handler;
+    }
+    onEvent(handler) {
+        this.eventListeners.add(handler);
+        return () => {
+            this.eventListeners.delete(handler);
+        };
+    }
+    async sendRequest(input) {
+        if (this.closedError) {
+            throw this.closedError;
+        }
+        const request = this.hostFrameFactory.createRequestFrame(input);
+        // No per-request deadline: only the caller knows whether an operation is
+        // legitimately long (a whole agent turn is one request). A dead or
+        // wedged sidecar rejects this via the silence watchdog instead.
+        const response = await this.frameTransport.sendFrame(request.request_id, request);
+        if (response.payload.type === "rejected") {
+            throw new Error(`sidecar rejected request ${request.request_id}: ${response.payload.code}: ${response.payload.message}`);
+        }
+        return response;
+    }
+    async waitForEvent(matcher, timeoutMs, options) {
+        if (this.closedError instanceof SidecarEventBufferOverflow) {
+            throw this.closedError;
+        }
+        const normalizedMatcher = normalizeSidecarEventMatcher(matcher);
+        const bufferedEvent = this.eventBuffer.take(normalizedMatcher);
+        if (bufferedEvent) {
+            return bufferedEvent;
+        }
+        if (this.closedError) {
+            throw this.closedError;
+        }
+        if (options?.signal?.aborted) {
+            throw sidecarEventWaitAbortError(options.signal.reason);
+        }
+        return await new Promise((resolve, reject) => {
+            let abortListener = null;
+            const waiter = {
+                matches: normalizedMatcher.matches,
+                resolve: (event) => {
+                    if (waiter.timer !== null) {
+                        clearTimeout(waiter.timer);
+                    }
+                    if (abortListener) {
+                        options?.signal?.removeEventListener("abort", abortListener);
+                        abortListener = null;
+                    }
+                    this.eventWaiters.delete(waiter);
+                    resolve(event);
+                },
+                reject: (error) => {
+                    if (waiter.timer !== null) {
+                        clearTimeout(waiter.timer);
+                    }
+                    if (abortListener) {
+                        options?.signal?.removeEventListener("abort", abortListener);
+                        abortListener = null;
+                    }
+                    this.eventWaiters.delete(waiter);
+                    reject(error);
+                },
+                timer: timeoutMs === undefined
+                    ? null
+                    : setTimeout(() => {
+                        this.eventWaiters.delete(waiter);
+                        reject(new Error(`timed out waiting for sidecar event\nstderr:\n${this.stderrText()}`));
+                    }, timeoutMs),
+            };
+            if (options?.signal) {
+                abortListener = () => {
+                    waiter.reject(sidecarEventWaitAbortError(options.signal?.reason));
+                };
+                options.signal.addEventListener("abort", abortListener, { once: true });
+            }
+            this.eventWaiters.add(waiter);
+        });
+    }
+    failPermanently(error, options) {
+        if (this.closedError) {
+            if (!options?.replaceExisting?.(this.closedError, error)) {
+                return;
+            }
+        }
+        this.closedError = error;
+        this.stopSilenceWatchdog();
+        this.rejectPending(error);
+    }
+    dispose() {
+        this.stopSilenceWatchdog();
+        this.frameTransport.dispose();
+    }
+    async writeFrame(frame) {
+        await this.frameTransport.writeFrame(frame);
+    }
+    async dispatchSidecarRequest(request) {
+        const payload = await resolveSidecarRequestFramePayload(request, this.sidecarRequestHandler);
+        try {
+            await this.writeFrame(this.hostFrameFactory.createSidecarResponseFrame({
+                request,
+                payload,
+            }));
+        }
+        catch (error) {
+            const normalized = error instanceof Error ? error : new Error(String(error));
+            this.failPermanently(normalized);
+        }
+    }
+    dispatchEvent(event) {
+        // Transport-level liveness beats from the sidecar. Their arrival already
+        // reset the silence watchdog at the frame layer; they carry no meaning
+        // for consumers and must never reach the bounded event buffer, where a
+        // long-idle VM would accumulate one every 10s until overflow.
+        if (event.payload.type === "structured" &&
+            event.payload.name === "heartbeat") {
+            return;
+        }
+        for (const listener of this.eventListeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // Event listeners are best-effort observers and must not break framing.
+            }
+        }
+        for (const waiter of this.eventWaiters) {
+            if (!waiter.matches(event)) {
+                continue;
+            }
+            waiter.resolve(event);
+            return;
+        }
+        this.bufferEvent(event);
+    }
+    bufferEvent(event) {
+        const overflow = this.eventBuffer.buffer(event);
+        if (overflow) {
+            this.failPermanently(overflow);
+        }
+    }
+    rejectPending(error) {
+        this.frameTransport.rejectAll(error);
+        for (const waiter of this.eventWaiters) {
+            waiter.reject(error);
+        }
+        this.eventWaiters.clear();
+    }
+}