@rivet-dev/agentos-core 0.0.0-agentos-dylib-plugin.473700e

package/dist/js-bridge.d.ts

@@ -0,0 +1,3 @@
+import { type LocalCompatMount, serializeMountConfigForSidecar as serializeMountConfig } from "./sidecar/rpc-client.js";
+export type { LocalCompatMount };
+export declare const serializeMountConfigForSidecar: typeof serializeMountConfig;

package/dist/js-bridge.js

@@ -0,0 +1,2 @@
+import { serializeMountConfigForSidecar as serializeMountConfig, } from "./sidecar/rpc-client.js";
+export const serializeMountConfigForSidecar = serializeMountConfig;

package/dist/json-rpc.d.ts

@@ -0,0 +1,50 @@
+export interface AcpTimeoutErrorData {
+    kind: "acp_timeout";
+    method: string;
+    id: number | string | null;
+    timeoutMs: number;
+    exitCode?: number;
+    killed?: boolean;
+    transportState?: string;
+    recentActivity: string[];
+}
+/**
+ * Structured error payload meaning "the session id is not known to the agent" —
+ * e.g. a `session/load` / `session/resume` against a session whose on-disk store did
+ * not survive a VM teardown. The sidecar normalizes the adapter's native error into
+ * this shape so the resume orchestration can distinguish "fall through to a fresh
+ * session" from a transport/timeout error (which must propagate). Mirrors the
+ * `acp_timeout` convention.
+ */
+export interface UnknownSessionErrorData {
+    kind: "unknown_session";
+    /** Optional metadata. The discriminator is `kind` alone — the sidecar's
+     * normalized error carries only `kind`, so this stays optional to keep the
+     * sidecar and client contracts aligned. */
+    sessionId?: string;
+}
+export type JsonRpcErrorData = AcpTimeoutErrorData | UnknownSessionErrorData | Record<string, unknown>;
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: number | string | null;
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: number | string | null;
+    result?: unknown;
+    error?: JsonRpcError;
+}
+export interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: JsonRpcErrorData;
+}
+export interface JsonRpcNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: unknown;
+}
+export declare function isAcpTimeoutErrorData(value: unknown): value is AcpTimeoutErrorData;
+export declare function isUnknownSessionErrorData(value: unknown): value is UnknownSessionErrorData;

package/dist/json-rpc.js

@@ -0,0 +1,22 @@
+export function isAcpTimeoutErrorData(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    return (record.kind === "acp_timeout" &&
+        typeof record.method === "string" &&
+        (typeof record.id === "number" ||
+            typeof record.id === "string" ||
+            record.id === null) &&
+        typeof record.timeoutMs === "number" &&
+        Array.isArray(record.recentActivity) &&
+        record.recentActivity.every((entry) => typeof entry === "string"));
+}
+export function isUnknownSessionErrorData(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    return (record.kind === "unknown_session" &&
+        (record.sessionId === undefined || typeof record.sessionId === "string"));
+}

package/dist/layers.d.ts

@@ -0,0 +1,51 @@
+import { type BaseFilesystemSnapshot } from "./base-filesystem.js";
+import { type FilesystemEntry } from "./filesystem-snapshot.js";
+import type { VirtualFileSystem } from "./runtime-compat.js";
+export type OverlayFilesystemMode = "ephemeral" | "read-only";
+export interface FilesystemSnapshotExport {
+    format: "agent-os-filesystem-snapshot-v1";
+    filesystem: {
+        entries: FilesystemEntry[];
+    };
+}
+export type RootSnapshotExport = {
+    kind: "snapshot-export";
+    source: FilesystemSnapshotExport;
+};
+export interface LayerHandle {
+    kind: "writable" | "snapshot";
+    storeId: string;
+    layerId: string;
+}
+export interface WritableLayerHandle extends LayerHandle {
+    kind: "writable";
+    leaseId: string;
+}
+export interface SnapshotLayerHandle extends LayerHandle {
+    kind: "snapshot";
+}
+export type SnapshotImportSource = {
+    kind: "base-filesystem-artifact";
+    source: BaseFilesystemSnapshot | unknown;
+} | {
+    kind: "snapshot-export";
+    source: FilesystemSnapshotExport | unknown;
+};
+export interface LayerStore {
+    readonly storeId: string;
+    createWritableLayer(): Promise<WritableLayerHandle>;
+    importSnapshot(source: SnapshotImportSource): Promise<SnapshotLayerHandle>;
+    openSnapshotLayer(layerId: string): Promise<SnapshotLayerHandle>;
+    sealLayer(layer: WritableLayerHandle): Promise<SnapshotLayerHandle>;
+    createOverlayFilesystem(options: {
+        mode?: "ephemeral";
+        upper: WritableLayerHandle;
+        lowers: SnapshotLayerHandle[];
+    } | {
+        mode: "read-only";
+        lowers: SnapshotLayerHandle[];
+    }): VirtualFileSystem;
+}
+export declare function createSnapshotExport(entries: FilesystemEntry[]): RootSnapshotExport;
+export declare function createInMemoryLayerStore(): LayerStore;
+export declare function createDefaultRootLowerInput(): SnapshotImportSource;

package/dist/layers.js

@@ -0,0 +1,185 @@
+import { randomUUID } from "node:crypto";
+import { getBaseFilesystemSnapshot, } from "./base-filesystem.js";
+import { createFilesystemFromEntries, snapshotVirtualFilesystem, } from "./filesystem-snapshot.js";
+import { createOverlayBackend } from "./overlay-filesystem.js";
+function cloneSnapshotHandle(storeId, layerId) {
+    return { kind: "snapshot", storeId, layerId };
+}
+function cloneWritableHandle(storeId, layerId, leaseId) {
+    return { kind: "writable", storeId, layerId, leaseId };
+}
+function isBaseFilesystemSnapshot(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const filesystem = value.filesystem;
+    if (!filesystem || typeof filesystem !== "object") {
+        return false;
+    }
+    return Array.isArray(filesystem.entries);
+}
+function isFilesystemSnapshotExport(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    if (value.format !== "agent-os-filesystem-snapshot-v1") {
+        return false;
+    }
+    const filesystem = value.filesystem;
+    if (!filesystem || typeof filesystem !== "object") {
+        return false;
+    }
+    return Array.isArray(filesystem.entries);
+}
+function normalizeSnapshotExport(source) {
+    if (source.kind === "base-filesystem-artifact") {
+        if (!isBaseFilesystemSnapshot(source.source)) {
+            throw new Error("Invalid base filesystem artifact");
+        }
+        return {
+            format: "agent-os-filesystem-snapshot-v1",
+            filesystem: {
+                entries: source.source.filesystem.entries,
+            },
+        };
+    }
+    if (!isFilesystemSnapshotExport(source.source)) {
+        throw new Error("Invalid snapshot export");
+    }
+    return source.source;
+}
+export function createSnapshotExport(entries) {
+    return {
+        kind: "snapshot-export",
+        source: {
+            format: "agent-os-filesystem-snapshot-v1",
+            filesystem: { entries },
+        },
+    };
+}
+export function createInMemoryLayerStore() {
+    const storeId = `memory-layer-store:${randomUUID()}`;
+    const layers = new Map();
+    function getLayerState(handle) {
+        if (handle.storeId !== storeId) {
+            throw new Error(`Layer ${handle.layerId} belongs to store ${handle.storeId}, not ${storeId}`);
+        }
+        const state = layers.get(handle.layerId);
+        if (!state) {
+            throw new Error(`Unknown layer: ${handle.layerId}`);
+        }
+        if (state.kind !== handle.kind) {
+            throw new Error(`Layer kind mismatch for ${handle.layerId}`);
+        }
+        return state;
+    }
+    return {
+        storeId,
+        async createWritableLayer() {
+            const layerId = randomUUID();
+            const leaseId = randomUUID();
+            layers.set(layerId, {
+                kind: "writable",
+                fs: await createFilesystemFromEntries([
+                    {
+                        path: "/",
+                        type: "directory",
+                        mode: "0755",
+                        uid: 0,
+                        gid: 0,
+                    },
+                ]),
+                leaseId,
+                valid: true,
+                activeOverlay: null,
+            });
+            return cloneWritableHandle(storeId, layerId, leaseId);
+        },
+        async importSnapshot(source) {
+            const snapshot = normalizeSnapshotExport(source);
+            const layerId = randomUUID();
+            layers.set(layerId, {
+                kind: "snapshot",
+                snapshot,
+                fs: await createFilesystemFromEntries(snapshot.filesystem.entries),
+            });
+            return cloneSnapshotHandle(storeId, layerId);
+        },
+        async openSnapshotLayer(layerId) {
+            const state = layers.get(layerId);
+            if (!state || state.kind !== "snapshot") {
+                throw new Error(`Unknown snapshot layer: ${layerId}`);
+            }
+            return cloneSnapshotHandle(storeId, layerId);
+        },
+        async sealLayer(layer) {
+            const state = getLayerState(layer);
+            if (state.kind !== "writable") {
+                throw new Error(`Layer ${layer.layerId} is not writable`);
+            }
+            if (!state.valid || state.leaseId !== layer.leaseId) {
+                throw new Error(`Writable layer ${layer.layerId} is no longer valid`);
+            }
+            const entries = await snapshotVirtualFilesystem(state.activeOverlay ?? state.fs);
+            const snapshot = createSnapshotExport(entries).source;
+            const layerId = randomUUID();
+            layers.set(layerId, {
+                kind: "snapshot",
+                snapshot,
+                fs: await createFilesystemFromEntries(snapshot.filesystem.entries),
+            });
+            state.valid = false;
+            state.activeOverlay = null;
+            return cloneSnapshotHandle(storeId, layerId);
+        },
+        createOverlayFilesystem(options) {
+            const lowers = options.lowers.map((lower) => {
+                const state = getLayerState(lower);
+                if (state.kind !== "snapshot") {
+                    throw new Error(`Layer ${lower.layerId} is not a snapshot`);
+                }
+                return lower;
+            });
+            if (options.mode === "read-only") {
+                return createOverlayBackend({
+                    mode: "read-only",
+                    lowers: lowers.map((lower) => {
+                        const state = getLayerState(lower);
+                        if (state.kind !== "snapshot") {
+                            throw new Error(`Layer ${lower.layerId} is not a snapshot`);
+                        }
+                        return state.fs;
+                    }),
+                });
+            }
+            const upperState = getLayerState(options.upper);
+            if (upperState.kind !== "writable") {
+                throw new Error(`Layer ${options.upper.layerId} is not writable`);
+            }
+            if (!upperState.valid || upperState.leaseId !== options.upper.leaseId) {
+                throw new Error(`Writable layer ${options.upper.layerId} is no longer valid`);
+            }
+            if (upperState.activeOverlay) {
+                throw new Error(`Writable layer ${options.upper.layerId} is already attached to an overlay`);
+            }
+            const overlay = createOverlayBackend({
+                upper: upperState.fs,
+                lowers: lowers.map((lower) => {
+                    const state = getLayerState(lower);
+                    if (state.kind !== "snapshot") {
+                        throw new Error(`Layer ${lower.layerId} is not a snapshot`);
+                    }
+                    return state.fs;
+                }),
+            });
+            upperState.activeOverlay = overlay;
+            return overlay;
+        },
+    };
+}
+export function createDefaultRootLowerInput() {
+    return {
+        kind: "base-filesystem-artifact",
+        source: getBaseFilesystemSnapshot(),
+    };
+}

package/dist/overlay-filesystem.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Overlay (copy-on-write) filesystem backend.
+ *
+ * Layers an optional writable upper filesystem over zero or more lower
+ * filesystems. Reads resolve from highest precedence to lowest. Writes
+ * go to the writable upper only, with copy-up and whiteout behavior.
+ */
+import { type VirtualFileSystem } from "./runtime-compat.js";
+export interface OverlayBackendOptions {
+    /** Legacy single lower layer. */
+    lower?: VirtualFileSystem;
+    /** Lower layers ordered highest-precedence first. */
+    lowers?: VirtualFileSystem[];
+    /** Writable upper layer. Defaults to a fresh in-memory filesystem in ephemeral mode. */
+    upper?: VirtualFileSystem;
+    /** Overlay mode. Defaults to ephemeral. */
+    mode?: "ephemeral" | "read-only";
+}
+export declare function createOverlayBackend(options: OverlayBackendOptions): VirtualFileSystem;