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

package/dist/native-client.d.ts

@@ -0,0 +1,42 @@
+import { StdioSidecarProcess } from "./process.js";
+import type { SidecarProcessTransport } from "./sidecar-client.js";
+import type { LiveEventFrame, LiveResponseFrame, LiveSidecarRequestHandler, ProtocolFramePayloadCodec } from "./protocol-frames.js";
+import type { LiveOwnershipScope } from "./ownership.js";
+import type { LiveRequestPayload } from "./request-payloads.js";
+import type { LiveSidecarEventSelector } from "./event-buffer.js";
+export declare const DEFAULT_SIDECAR_FRAME_TIMEOUT_MS = 120000;
+export declare const DEFAULT_SIDECAR_EVENT_BUFFER_CAPACITY = 4096;
+export declare const DEFAULT_SIDECAR_GRACEFUL_EXIT_MS = 5000;
+export declare const DEFAULT_SIDECAR_FORCE_EXIT_MS = 2000;
+export interface StdioSidecarProtocolClientSpawnOptions {
+    cwd?: string;
+    command?: string;
+    args?: string[];
+    frameTimeoutMs?: number;
+    eventBufferCapacity?: number;
+    gracefulExitMs?: number;
+    forceExitMs?: number;
+    disposedErrorMessage?: string;
+    payloadCodec?: ProtocolFramePayloadCodec;
+}
+export declare class StdioSidecarProtocolClient implements SidecarProcessTransport {
+    readonly child: StdioSidecarProcess["child"];
+    private readonly sidecarProcess;
+    private readonly protocolClient;
+    private readonly gracefulExitMs;
+    private readonly forceExitMs;
+    private readonly disposedErrorMessage;
+    private constructor();
+    static spawn(options?: StdioSidecarProtocolClientSpawnOptions): StdioSidecarProtocolClient;
+    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>;
+    dispose(): Promise<void>;
+    failPermanently(error: Error): void;
+}

package/dist/native-client.js

@@ -0,0 +1,126 @@
+import { resolvePublishedSidecarBinary } from "./binary.js";
+import { SidecarProcessExited, StdioSidecarProcess, } from "./process.js";
+import { SidecarProtocolClient } from "./protocol-client.js";
+import { registerSidecarProcessSpawnFactory } from "./sidecar-process.js";
+export const DEFAULT_SIDECAR_FRAME_TIMEOUT_MS = 120_000;
+export const DEFAULT_SIDECAR_EVENT_BUFFER_CAPACITY = 4_096;
+export const DEFAULT_SIDECAR_GRACEFUL_EXIT_MS = 5_000;
+export const DEFAULT_SIDECAR_FORCE_EXIT_MS = 2_000;
+export class StdioSidecarProtocolClient {
+    child;
+    sidecarProcess;
+    protocolClient;
+    gracefulExitMs;
+    forceExitMs;
+    disposedErrorMessage;
+    constructor(sidecarProcess, options) {
+        this.sidecarProcess = sidecarProcess;
+        this.child = sidecarProcess.child;
+        this.gracefulExitMs = options.gracefulExitMs;
+        this.forceExitMs = options.forceExitMs;
+        this.disposedErrorMessage = options.disposedErrorMessage;
+        this.protocolClient = new SidecarProtocolClient({
+            stdin: this.child.stdin,
+            stdout: this.child.stdout,
+            frameTimeoutMs: options.frameTimeoutMs,
+            eventBufferCapacity: options.eventBufferCapacity,
+            payloadCodec: options.payloadCodec,
+            stderrText: () => this.sidecarProcess.stderrText(),
+            streamEndedError: () => this.sidecarProcess.currentExitError() ??
+                new SidecarProcessExited({
+                    exitCode: this.child.exitCode,
+                    signal: this.child.signalCode,
+                    stderr: this.sidecarProcess.stderrText(),
+                }),
+            frameError: (error) => this.sidecarProcess.currentExitError() ?? error,
+        });
+        this.sidecarProcess.onExit((error) => {
+            this.failPermanently(error);
+        });
+        this.sidecarProcess.onError((error) => {
+            this.failPermanently(error);
+        });
+    }
+    static spawn(options = {}) {
+        return new StdioSidecarProtocolClient(StdioSidecarProcess.spawn({
+            command: options.command ?? resolvePublishedSidecarBinary(),
+            args: options.args ?? [],
+            cwd: options.cwd,
+        }), {
+            frameTimeoutMs: options.frameTimeoutMs ?? DEFAULT_SIDECAR_FRAME_TIMEOUT_MS,
+            eventBufferCapacity: options.eventBufferCapacity ??
+                DEFAULT_SIDECAR_EVENT_BUFFER_CAPACITY,
+            gracefulExitMs: options.gracefulExitMs ?? DEFAULT_SIDECAR_GRACEFUL_EXIT_MS,
+            forceExitMs: options.forceExitMs ?? DEFAULT_SIDECAR_FORCE_EXIT_MS,
+            disposedErrorMessage: options.disposedErrorMessage ?? "sidecar client disposed",
+            payloadCodec: options.payloadCodec ?? "bare",
+        });
+    }
+    setSidecarRequestHandler(handler) {
+        this.protocolClient.setSidecarRequestHandler(handler);
+    }
+    onEvent(handler) {
+        return this.protocolClient.onEvent(handler);
+    }
+    async sendRequest(input) {
+        return await this.protocolClient.sendRequest(input);
+    }
+    async waitForEvent(matcher, timeoutMs, options) {
+        return await this.protocolClient.waitForEvent(matcher, timeoutMs, options);
+    }
+    async dispose() {
+        this.protocolClient.failPermanently(new Error(this.disposedErrorMessage));
+        if (!this.child.stdin.destroyed) {
+            try {
+                this.child.stdin.end();
+            }
+            catch {
+                // Stdin may already be closing. The child exit watcher will catch up.
+            }
+        }
+        const exitCode = await this.sidecarProcess.waitForExit(this.gracefulExitMs);
+        if (exitCode === null) {
+            try {
+                this.child.kill("SIGKILL");
+            }
+            catch {
+                // The child may have exited between the timeout and the kill attempt.
+            }
+            await this.sidecarProcess.waitForExit(this.forceExitMs);
+        }
+        this.protocolClient.dispose();
+        try {
+            this.child.stdin.destroy();
+        }
+        catch {
+            // Best effort. The child is gone so the descriptor will close on its own.
+        }
+        try {
+            this.child.stdout.destroy();
+        }
+        catch {
+            // Best effort. The child is gone so the descriptor will close on its own.
+        }
+        try {
+            this.child.stderr.destroy();
+        }
+        catch {
+            // Best effort. The child is gone so the descriptor will close on its own.
+        }
+        if (exitCode !== null &&
+            exitCode !== 0 &&
+            this.child.signalCode === null) {
+            throw new Error(`sidecar exited with code ${exitCode}\nstderr:\n${this.sidecarProcess.stderrText()}`);
+        }
+    }
+    failPermanently(error) {
+        this.protocolClient.failPermanently(error, {
+            replaceExisting: (current, next) => current instanceof SidecarProcessExited &&
+                current.exitCode === null &&
+                current.signal === null &&
+                next instanceof SidecarProcessExited &&
+                (next.exitCode !== null || next.signal !== null),
+        });
+    }
+}
+registerSidecarProcessSpawnFactory((options) => StdioSidecarProtocolClient.spawn(options));

package/dist/node-runtime-options-schema.d.ts

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import type { NodeRuntimeCreateOptions } from "./node-runtime.js";
+export declare const nodeRuntimePermissionsSchema: z.ZodObject<{
+    fs: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+    }>, z.ZodObject<{
+        default: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+        }>>;
+        rules: z.ZodArray<z.ZodObject<{
+            mode: z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+            }>;
+            operations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>]>>;
+    network: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+    }>, z.ZodObject<{
+        default: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+        }>>;
+        rules: z.ZodArray<z.ZodObject<{
+            mode: z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+            }>;
+            operations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>]>>;
+    childProcess: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+    }>, z.ZodObject<{
+        default: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+        }>>;
+        rules: z.ZodArray<z.ZodObject<{
+            mode: z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+            }>;
+            operations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>]>>;
+    process: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+    }>, z.ZodObject<{
+        default: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+        }>>;
+        rules: z.ZodArray<z.ZodObject<{
+            mode: z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+            }>;
+            operations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>]>>;
+    env: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+    }>, z.ZodObject<{
+        default: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+        }>>;
+        rules: z.ZodArray<z.ZodObject<{
+            mode: z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+            }>;
+            operations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>]>>;
+    binding: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+    }>, z.ZodObject<{
+        default: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+        }>>;
+        rules: z.ZodArray<z.ZodObject<{
+            mode: z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+            }>;
+            operations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+/**
+ * Runtime validation for the public `NodeRuntime.create(...)` API.
+ *
+ * This is the TS-side guard for the ergonomic options shape. The sidecar VM
+ * JSON it eventually produces is still validated by
+ * `crates/vm-config/src/lib.rs::CreateVmConfig` with `deny_unknown_fields`.
+ * Keep these in sync when adding high-level create options that translate into
+ * the Rust VM config.
+ */
+export declare const nodeRuntimeCreateOptionsSchema: z.ZodType<NodeRuntimeCreateOptions>;
+export declare function parseNodeRuntimeCreateOptions(options?: NodeRuntimeCreateOptions): NodeRuntimeCreateOptions;

package/dist/node-runtime-options-schema.js

@@ -0,0 +1,121 @@
+import { z } from "zod";
+const permissionModeSchema = z.enum(["allow", "deny"]);
+const stringArray = z.array(z.string());
+const fsPermissionRuleSchema = z
+    .object({
+    mode: permissionModeSchema,
+    operations: stringArray.optional(),
+    paths: stringArray.optional(),
+})
+    .strict();
+const patternPermissionRuleSchema = z
+    .object({
+    mode: permissionModeSchema,
+    operations: stringArray.optional(),
+    patterns: stringArray.optional(),
+})
+    .strict();
+const fsRulePermissionsSchema = z
+    .object({
+    default: permissionModeSchema.optional(),
+    rules: z.array(fsPermissionRuleSchema),
+})
+    .strict();
+const patternRulePermissionsSchema = z
+    .object({
+    default: permissionModeSchema.optional(),
+    rules: z.array(patternPermissionRuleSchema),
+})
+    .strict();
+const fsPermissionsSchema = z.union([permissionModeSchema, fsRulePermissionsSchema]);
+const patternPermissionsSchema = z.union([
+    permissionModeSchema,
+    patternRulePermissionsSchema,
+]);
+export const nodeRuntimePermissionsSchema = z
+    .object({
+    fs: fsPermissionsSchema.optional(),
+    network: patternPermissionsSchema.optional(),
+    childProcess: patternPermissionsSchema.optional(),
+    process: patternPermissionsSchema.optional(),
+    env: patternPermissionsSchema.optional(),
+    binding: patternPermissionsSchema.optional(),
+})
+    .strict();
+const uint8ArraySchema = z.custom((value) => value instanceof Uint8Array, { message: "Expected Uint8Array" });
+const hostDirectoryMountSchema = z
+    .object({
+    guestPath: z.string(),
+    hostPath: z.string(),
+    readOnly: z.boolean().optional(),
+})
+    .strict();
+const nodeModulesMountSchema = z
+    .object({
+    hostPath: z.string(),
+    guestPath: z.string().optional(),
+})
+    .strict();
+const jsRuntimeSchema = z
+    .object({
+    platform: z.enum(["node", "browser", "neutral", "bare"]).optional(),
+    moduleResolution: z.enum(["node", "relative", "none"]).optional(),
+    allowedBuiltins: stringArray.optional(),
+    highResolutionTime: z.boolean().optional(),
+})
+    .strict();
+const bindingExampleSchema = z
+    .object({
+    description: z.string(),
+    input: z.unknown(),
+})
+    .strict();
+const bindingDefinitionSchema = z
+    .object({
+    description: z.string(),
+    inputSchema: z.custom((value) => typeof value === "object" && value !== null, { message: "Expected JSON Schema object" }),
+    timeoutMs: z.number().int().nonnegative().optional(),
+    examples: z.array(bindingExampleSchema).optional(),
+    commandAliases: stringArray.optional(),
+    handler: z.custom((value) => typeof value === "function", { message: "Expected function" }),
+})
+    .strict();
+/**
+ * Runtime validation for the public `NodeRuntime.create(...)` API.
+ *
+ * This is the TS-side guard for the ergonomic options shape. The sidecar VM
+ * JSON it eventually produces is still validated by
+ * `crates/vm-config/src/lib.rs::CreateVmConfig` with `deny_unknown_fields`.
+ * Keep these in sync when adding high-level create options that translate into
+ * the Rust VM config.
+ */
+export const nodeRuntimeCreateOptionsSchema = z
+    .object({
+    env: z.record(z.string(), z.string()).optional(),
+    cwd: z.string().optional(),
+    permissions: nodeRuntimePermissionsSchema.optional(),
+    commandsDir: z.string().optional(),
+    wasmCommandDirs: stringArray.optional(),
+    sidecar: z
+        .custom((value) => typeof value === "object" && value !== null, {
+        message: "Expected SidecarProcess object",
+    })
+        .optional(),
+    onBootTiming: z
+        .custom((value) => typeof value === "function", { message: "Expected function" })
+        .optional(),
+    files: z
+        .record(z.string(), z.union([z.string(), uint8ArraySchema]))
+        .optional(),
+    mounts: z.array(hostDirectoryMountSchema).optional(),
+    nodeModules: z.union([z.string(), nodeModulesMountSchema]).optional(),
+    bindings: z.record(z.string(), bindingDefinitionSchema).optional(),
+    loopbackExemptPorts: z
+        .array(z.number().int().min(0).max(65535))
+        .optional(),
+    jsRuntime: jsRuntimeSchema.optional(),
+})
+    .strict();
+export function parseNodeRuntimeCreateOptions(options = {}) {
+    return nodeRuntimeCreateOptionsSchema.parse(options);
+}