@rivet-dev/agentos-runtime-core 0.2.8-rc.2 → 0.2.8-rc.3

package/dist/generated-protocol.js

@@ -784,15 +784,31 @@ export function writeMountPluginDescriptor(bc, x) {
 export function readMountDescriptor(bc) {
     return {
         guestPath: bare.readString(bc),
+        guestSource: bare.readString(bc),
+        guestFstype: bare.readString(bc),
         readOnly: bare.readBool(bc),
         plugin: readMountPluginDescriptor(bc),
     };
 }
 export function writeMountDescriptor(bc, x) {
     bare.writeString(bc, x.guestPath);
+    bare.writeString(bc, x.guestSource);
+    bare.writeString(bc, x.guestFstype);
     bare.writeBool(bc, x.readOnly);
     writeMountPluginDescriptor(bc, x.plugin);
 }
+export function readMountInfo(bc) {
+    return {
+        path: bare.readString(bc),
+        kind: bare.readString(bc),
+        readOnly: bare.readBool(bc),
+    };
+}
+export function writeMountInfo(bc, x) {
+    bare.writeString(bc, x.path);
+    bare.writeString(bc, x.kind);
+    bare.writeBool(bc, x.readOnly);
+}
 export function readSoftwareDescriptor(bc) {
     return {
         packageName: bare.readString(bc),
@@ -1086,7 +1102,7 @@ export function readConfigureVmRequest(bc) {
         packages: read20(bc),
         packagesMountAt: bare.readString(bc),
         bootstrapCommands: read6(bc),
-        toolShimCommands: read6(bc),
+        bindingShimCommands: read6(bc),
     };
 }
 export function writeConfigureVmRequest(bc, x) {
@@ -1101,7 +1117,7 @@ export function writeConfigureVmRequest(bc, x) {
     write20(bc, x.packages);
     bare.writeString(bc, x.packagesMountAt);
     write6(bc, x.bootstrapCommands);
-    write6(bc, x.toolShimCommands);
+    write6(bc, x.bindingShimCommands);
 }
 export function readRegisteredHostCallbackExample(bc) {
     return {
@@ -1466,6 +1482,14 @@ export function writeGuestKernelCallRequest(bc, x) {
     bare.writeString(bc, x.operation);
     bare.writeData(bc, x.payload);
 }
+export function readSnapshotRootFilesystemRequest(bc) {
+    return {
+        maxBytes: bare.readU64(bc),
+    };
+}
+export function writeSnapshotRootFilesystemRequest(bc, x) {
+    bare.writeU64(bc, x.maxBytes);
+}
 function read24(bc) {
     return bare.readBool(bc) ? readGuestRuntimeKind(bc) : null;
 }
@@ -1728,7 +1752,7 @@ export function readRequestPayload(bc) {
         case 12:
             return { tag: "GuestFilesystemCallRequest", val: readGuestFilesystemCallRequest(bc) };
         case 13:
-            return { tag: "SnapshotRootFilesystemRequest", val: null };
+            return { tag: "SnapshotRootFilesystemRequest", val: readSnapshotRootFilesystemRequest(bc) };
         case 14:
             return { tag: "ExecuteRequest", val: readExecuteRequest(bc) };
         case 15:
@@ -1767,6 +1791,8 @@ export function readRequestPayload(bc) {
             return { tag: "LinkPackageRequest", val: readLinkPackageRequest(bc) };
         case 32:
             return { tag: "ProvidedCommandsRequest", val: null };
+        case 33:
+            return { tag: "ListMountsRequest", val: null };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -1841,6 +1867,7 @@ export function writeRequestPayload(bc, x) {
         }
         case "SnapshotRootFilesystemRequest": {
             bare.writeU8(bc, 13);
+            writeSnapshotRootFilesystemRequest(bc, x.val);
             break;
         }
         case "ExecuteRequest": {
@@ -1934,6 +1961,10 @@ export function writeRequestPayload(bc, x) {
             bare.writeU8(bc, 32);
             break;
         }
+        case "ListMountsRequest": {
+            bare.writeU8(bc, 33);
+            break;
+        }
     }
 }
 export function readRequestFrame(bc) {
@@ -2196,6 +2227,31 @@ export function readRootFilesystemSnapshotResponse(bc) {
 export function writeRootFilesystemSnapshotResponse(bc, x) {
     write4(bc, x.entries);
 }
+function read31(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readMountInfo(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readMountInfo(bc);
+    }
+    return result;
+}
+function write31(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeMountInfo(bc, x[i]);
+    }
+}
+export function readListMountsResponse(bc) {
+    return {
+        mounts: read31(bc),
+    };
+}
+export function writeListMountsResponse(bc, x) {
+    write31(bc, x.mounts);
+}
 export function readProcessStartedResponse(bc) {
     return {
         processId: bare.readString(bc),
@@ -2282,10 +2338,10 @@ export function writeProcessSnapshotStatus(bc, x) {
         }
     }
 }
-function read31(bc) {
+function read32(bc) {
     return bare.readBool(bc) ? bare.readI32(bc) : null;
 }
-function write31(bc, x) {
+function write32(bc, x) {
     bare.writeBool(bc, x != null);
     if (x != null) {
         bare.writeI32(bc, x);
@@ -2303,7 +2359,7 @@ export function readProcessSnapshotEntry(bc) {
         args: read6(bc),
         cwd: bare.readString(bc),
         status: readProcessSnapshotStatus(bc),
-        exitCode: read31(bc),
+        exitCode: read32(bc),
     };
 }
 export function writeProcessSnapshotEntry(bc, x) {
@@ -2317,9 +2373,9 @@ export function writeProcessSnapshotEntry(bc, x) {
     write6(bc, x.args);
     bare.writeString(bc, x.cwd);
     writeProcessSnapshotStatus(bc, x.status);
-    write31(bc, x.exitCode);
+    write32(bc, x.exitCode);
 }
-function read32(bc) {
+function read33(bc) {
     const len = bare.readUintSafe(bc);
     if (len === 0) {
         return [];
@@ -2330,7 +2386,7 @@ function read32(bc) {
     }
     return result;
 }
-function write32(bc, x) {
+function write33(bc, x) {
     bare.writeUintSafe(bc, x.length);
     for (let i = 0; i < x.length; i++) {
         writeProcessSnapshotEntry(bc, x[i]);
@@ -2338,11 +2394,11 @@ function write32(bc, x) {
 }
 export function readProcessSnapshotResponse(bc) {
     return {
-        processes: read32(bc),
+        processes: read33(bc),
     };
 }
 export function writeProcessSnapshotResponse(bc, x) {
-    write32(bc, x.processes);
+    write33(bc, x.processes);
 }
 export function readQueueSnapshotEntry(bc) {
     return {
@@ -2362,7 +2418,7 @@ export function writeQueueSnapshotEntry(bc, x) {
     bare.writeU64(bc, x.capacity);
     bare.writeU64(bc, x.fillPercent);
 }
-function read33(bc) {
+function read34(bc) {
     const len = bare.readUintSafe(bc);
     if (len === 0) {
         return [];
@@ -2373,7 +2429,7 @@ function read33(bc) {
     }
     return result;
 }
-function write33(bc, x) {
+function write34(bc, x) {
     bare.writeUintSafe(bc, x.length);
     for (let i = 0; i < x.length; i++) {
         writeQueueSnapshotEntry(bc, x[i]);
@@ -2395,7 +2451,7 @@ export function readResourceSnapshotResponse(bc) {
         socketConnections: bare.readU64(bc),
         socketBufferedBytes: bare.readU64(bc),
         socketDatagramQueueLen: bare.readU64(bc),
-        queueSnapshots: read33(bc),
+        queueSnapshots: read34(bc),
     };
 }
 export function writeResourceSnapshotResponse(bc, x) {
@@ -2413,7 +2469,7 @@ export function writeResourceSnapshotResponse(bc, x) {
     bare.writeU64(bc, x.socketConnections);
     bare.writeU64(bc, x.socketBufferedBytes);
     bare.writeU64(bc, x.socketDatagramQueueLen);
-    write33(bc, x.queueSnapshots);
+    write34(bc, x.queueSnapshots);
 }
 export function readSocketStateEntry(bc) {
     return {
@@ -2429,10 +2485,10 @@ export function writeSocketStateEntry(bc, x) {
     write26(bc, x.port);
     write0(bc, x.path);
 }
-function read34(bc) {
+function read35(bc) {
     return bare.readBool(bc) ? readSocketStateEntry(bc) : null;
 }
-function write34(bc, x) {
+function write35(bc, x) {
     bare.writeBool(bc, x != null);
     if (x != null) {
         writeSocketStateEntry(bc, x);
@@ -2440,19 +2496,19 @@ function write34(bc, x) {
 }
 export function readListenerSnapshotResponse(bc) {
     return {
-        listener: read34(bc),
+        listener: read35(bc),
     };
 }
 export function writeListenerSnapshotResponse(bc, x) {
-    write34(bc, x.listener);
+    write35(bc, x.listener);
 }
 export function readBoundUdpSnapshotResponse(bc) {
     return {
-        socket: read34(bc),
+        socket: read35(bc),
     };
 }
 export function writeBoundUdpSnapshotResponse(bc, x) {
-    write34(bc, x.socket);
+    write35(bc, x.socket);
 }
 export var SignalDispositionAction;
 (function (SignalDispositionAction) {
@@ -2504,7 +2560,7 @@ export function writeSignalHandlerRegistration(bc, x) {
     bare.writeU32Array(bc, x.mask);
     bare.writeU32(bc, x.flags);
 }
-function read35(bc) {
+function read36(bc) {
     const len = bare.readUintSafe(bc);
     const result = new Map();
     for (let i = 0; i < len; i++) {
@@ -2518,7 +2574,7 @@ function read35(bc) {
     }
     return result;
 }
-function write35(bc, x) {
+function write36(bc, x) {
     bare.writeUintSafe(bc, x.size);
     for (const kv of x) {
         bare.writeU32(bc, kv[0]);
@@ -2528,12 +2584,12 @@ function write35(bc, x) {
 export function readSignalStateResponse(bc) {
     return {
         processId: bare.readString(bc),
-        handlers: read35(bc),
+        handlers: read36(bc),
     };
 }
 export function writeSignalStateResponse(bc, x) {
     bare.writeString(bc, x.processId);
-    write35(bc, x.handlers);
+    write36(bc, x.handlers);
 }
 export function readZombieTimerCountResponse(bc) {
     return {
@@ -2591,11 +2647,37 @@ export function readRejectedResponse(bc) {
     return {
         code: bare.readString(bc),
         message: bare.readString(bc),
+        limitName: read0(bc),
+        configuredLimit: read21(bc),
+        currentUsage: read21(bc),
+        requested: read21(bc),
+        unit: read0(bc),
+        scope: read0(bc),
+        vmId: read0(bc),
+        sessionGeneration: read21(bc),
+        capabilityId: read21(bc),
+        operation: read0(bc),
+        configurationPath: read0(bc),
+        retryable: read30(bc),
+        errno: read0(bc),
     };
 }
 export function writeRejectedResponse(bc, x) {
     bare.writeString(bc, x.code);
     bare.writeString(bc, x.message);
+    write0(bc, x.limitName);
+    write21(bc, x.configuredLimit);
+    write21(bc, x.currentUsage);
+    write21(bc, x.requested);
+    write0(bc, x.unit);
+    write0(bc, x.scope);
+    write0(bc, x.vmId);
+    write21(bc, x.sessionGeneration);
+    write21(bc, x.capabilityId);
+    write0(bc, x.operation);
+    write0(bc, x.configurationPath);
+    write30(bc, x.retryable);
+    write0(bc, x.errno);
 }
 export function readVmFetchResponse(bc) {
     return {
@@ -2679,6 +2761,8 @@ export function readResponsePayload(bc) {
             return { tag: "PackageLinkedResponse", val: readPackageLinkedResponse(bc) };
         case 34:
             return { tag: "ProvidedCommandsResponse", val: readProvidedCommandsResponse(bc) };
+        case 35:
+            return { tag: "ListMountsResponse", val: readListMountsResponse(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -2862,6 +2946,11 @@ export function writeResponsePayload(bc, x) {
             writeProvidedCommandsResponse(bc, x.val);
             break;
         }
+        case "ListMountsResponse": {
+            bare.writeU8(bc, 35);
+            writeListMountsResponse(bc, x.val);
+            break;
+        }
     }
 }
 export function readResponseFrame(bc) {
@@ -3139,10 +3228,10 @@ export function writeSidecarRequestFrame(bc, x) {
     writeOwnershipScope(bc, x.ownership);
     writeSidecarRequestPayload(bc, x.payload);
 }
-function read36(bc) {
+function read37(bc) {
     return bare.readBool(bc) ? readJsonUtf8(bc) : null;
 }
-function write36(bc, x) {
+function write37(bc, x) {
     bare.writeBool(bc, x != null);
     if (x != null) {
         writeJsonUtf8(bc, x);
@@ -3151,25 +3240,25 @@ function write36(bc, x) {
 export function readHostCallbackResultResponse(bc) {
     return {
         invocationId: bare.readString(bc),
-        result: read36(bc),
+        result: read37(bc),
         error: read0(bc),
     };
 }
 export function writeHostCallbackResultResponse(bc, x) {
     bare.writeString(bc, x.invocationId);
-    write36(bc, x.result);
+    write37(bc, x.result);
     write0(bc, x.error);
 }
 export function readJsBridgeResultResponse(bc) {
     return {
         callId: bare.readString(bc),
-        result: read36(bc),
+        result: read37(bc),
         error: read0(bc),
     };
 }
 export function writeJsBridgeResultResponse(bc, x) {
     bare.writeString(bc, x.callId);
-    write36(bc, x.result);
+    write37(bc, x.result);
     write0(bc, x.error);
 }
 export function readSidecarResponsePayload(bc) {
@@ -3221,6 +3310,45 @@ export function writeSidecarResponseFrame(bc, x) {
     writeOwnershipScope(bc, x.ownership);
     writeSidecarResponsePayload(bc, x.payload);
 }
+export function readShutdownControl(bc) {
+    return {
+        reason: bare.readString(bc),
+    };
+}
+export function writeShutdownControl(bc, x) {
+    bare.writeString(bc, x.reason);
+}
+export function readControlPayload(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "ShutdownControl", val: readShutdownControl(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeControlPayload(bc, x) {
+    switch (x.tag) {
+        case "ShutdownControl": {
+            bare.writeU8(bc, 0);
+            writeShutdownControl(bc, x.val);
+            break;
+        }
+    }
+}
+export function readControlFrame(bc) {
+    return {
+        schema: readProtocolSchema(bc),
+        payload: readControlPayload(bc),
+    };
+}
+export function writeControlFrame(bc, x) {
+    writeProtocolSchema(bc, x.schema);
+    writeControlPayload(bc, x.payload);
+}
 export function readProtocolFrame(bc) {
     const offset = bc.offset;
     const tag = bare.readU8(bc);
@@ -3235,6 +3363,8 @@ export function readProtocolFrame(bc) {
             return { tag: "SidecarRequestFrame", val: readSidecarRequestFrame(bc) };
         case 4:
             return { tag: "SidecarResponseFrame", val: readSidecarResponseFrame(bc) };
+        case 5:
+            return { tag: "ControlFrame", val: readControlFrame(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -3268,6 +3398,11 @@ export function writeProtocolFrame(bc, x) {
             writeSidecarResponseFrame(bc, x.val);
             break;
         }
+        case "ControlFrame": {
+            bare.writeU8(bc, 5);
+            writeControlFrame(bc, x.val);
+            break;
+        }
     }
 }
 export function encodeProtocolFrame(x, config) {

package/dist/kernel-proxy.d.ts

@@ -4,11 +4,15 @@ import type { AuthenticatedSession, CreatedVm, SidecarProcess, SidecarMountDescr
 export interface PlainMountConfig {
     path: string;
     driver: VirtualFileSystem;
+    guestSource?: string;
+    guestFstype?: string;
     readOnly?: boolean;
 }
 export interface NativeMountConfig {
     path: string;
     plugin: NativeMountPluginDescriptor;
+    guestSource?: string;
+    guestFstype?: string;
     readOnly?: boolean;
 }
 export declare function serializeMountConfigForSidecar(mount: PlainMountConfig | NativeMountConfig): SidecarMountDescriptor;

package/dist/kernel-proxy.js

@@ -4,6 +4,8 @@ export function serializeMountConfigForSidecar(mount) {
     if ("driver" in mount) {
         return {
             guestPath: mount.path,
+            guestSource: mount.guestSource ?? "js_bridge",
+            guestFstype: mount.guestFstype ?? "js_bridge",
             readOnly: mount.readOnly ?? false,
             plugin: {
                 id: "js_bridge",
@@ -13,6 +15,8 @@ export function serializeMountConfigForSidecar(mount) {
     }
     return {
         guestPath: mount.path,
+        guestSource: mount.guestSource ?? mount.plugin.id,
+        guestFstype: mount.guestFstype ?? mount.plugin.id,
         readOnly: mount.readOnly ?? false,
         plugin: {
             id: mount.plugin.id,
@@ -70,6 +74,15 @@ const PREFERRED_SIGNAL_NAMES = [
     "SIGEMT",
     "SIGINFO",
 ];
+const NON_TERMINATING_SIGNALS = new Set([
+    "0",
+    "SIGCHLD",
+    "SIGCONT",
+    "SIGSTOP",
+    "SIGURG",
+    "SIGWINCH",
+]);
+const LOCALLY_TERMINATING_SIGNALS = new Set(["SIGKILL", "SIGTERM"]);
 const NON_CANONICAL_SIGNAL_NAMES = new Set([
     "SIGCLD",
     "SIGIOT",
@@ -262,7 +275,10 @@ export class NativeSidecarKernelProxy {
         this.eventPumpAbortController.abort();
         const liveProcesses = [...this.trackedProcesses.values()].filter((entry) => entry.exitCode === null);
         await Promise.allSettled(liveProcesses.map((entry) => this.signalProcess(entry, 15)));
-        await this.client.disposeVm(this.session, this.vm).catch(() => { });
+        await Promise.race([
+            this.client.disposeVm(this.session, this.vm),
+            new Promise((resolve) => setTimeout(resolve, 1000)),
+        ]).catch(() => { });
         for (const entry of liveProcesses) {
             if (entry.exitCode === null) {
                 // The sidecar dispose path already performs TERM/KILL escalation for any
@@ -477,14 +493,22 @@ export class NativeSidecarKernelProxy {
                     return;
                 }
                 entry.pendingKillSignal = signal;
-                void entry.startPromise.then(async () => {
-                    if (entry.exitCode !== null || entry.pendingKillSignal === null) {
+                void entry.startPromise
+                    .then(async () => {
+                    if (entry.pendingKillSignal === null) {
                         return;
                     }
                     const pendingSignal = entry.pendingKillSignal;
                     entry.pendingKillSignal = null;
                     await this.signalProcess(entry, pendingSignal);
+                })
+                    .catch((error) => {
+                    this.handleBackgroundProcessError(entry, error);
                 });
+                if ((signal === 9 || signal === 15) &&
+                    entry.exitCode === null) {
+                    this.finishProcess(entry, 128 + signal);
+                }
             },
             wait: async () => {
                 const exitCode = await this.waitForTrackedProcess(entry);
@@ -1127,15 +1151,6 @@ export class NativeSidecarKernelProxy {
         if (entry.onStdout.size === 0 && entry.onStderr.size === 0) {
             return;
         }
-        if (entry.exitViaEvent) {
-            // The sidecar drains process output before it emits `process_exited`,
-            // the stdio frame stream is FIFO, and this pump dispatches events in
-            // order. Once the exit event reaches this entry, no trailing output can
-            // follow it; one zero-delay turn is cheap insurance for same-tick
-            // listener scheduling.
-            await drainTrailingProcessOutputTurn(0);
-            return;
-        }
         let observedGeneration = entry.outputGeneration;
         let quietTurns = 0;
         let delayMs = 0;
@@ -1306,9 +1321,27 @@ export class NativeSidecarKernelProxy {
         return entry.waitWithFallbackPromise;
     }
     async signalProcess(entry, signal) {
-        await this.signalRefreshes.get(entry.pid);
+        const sidecarSignal = toSidecarSignalName(signal);
+        let timedOut = false;
+        const killPromise = this.client.killProcess(this.session, this.vm, entry.processId, sidecarSignal);
         try {
-            await this.client.killProcess(this.session, this.vm, entry.processId, toSidecarSignalName(signal));
+            await Promise.race([
+                killPromise,
+                new Promise((resolve) => setTimeout(() => {
+                    timedOut = true;
+                    resolve();
+                }, 1000)),
+            ]);
+            if (timedOut) {
+                void killPromise.catch(() => { });
+            }
+            const hasGuestHandler = this.signalStates.get(entry.pid)?.handlers.has(signal) ?? false;
+            if (entry.exitCode === null &&
+                !hasGuestHandler &&
+                LOCALLY_TERMINATING_SIGNALS.has(sidecarSignal) &&
+                (entry.driver === "wasmvm" || timedOut)) {
+                this.finishProcess(entry, 128 + signal);
+            }
         }
         catch (error) {
             if (isNoSuchProcessError(error) || isUnknownVmError(error)) {
@@ -1523,12 +1556,12 @@ export class NativeSidecarKernelProxy {
                 return this.client.pread(this.session, this.vm, path, offset, length);
             },
             pwrite: async (path, offset, data) => {
-                const bytes = await this.createFilesystemView(includeLocalMounts).readFile(path);
-                const nextSize = Math.max(bytes.length, offset + data.length);
-                const updated = new Uint8Array(nextSize);
-                updated.set(bytes);
-                updated.set(data, offset);
-                await this.createFilesystemView(includeLocalMounts).writeFile(path, updated);
+                const local = includeLocalMounts ? this.resolveLocalMount(path) : null;
+                if (local) {
+                    this.assertLocalWritable(local.mount);
+                    return local.mount.fs.pwrite(local.relativePath, offset, data);
+                }
+                return this.client.pwrite(this.session, this.vm, path, offset, data);
             },
         };
     }

package/dist/native-client.d.ts

@@ -1,9 +1,9 @@
+import type { LiveSidecarEventSelector } from "./event-buffer.js";
+import type { LiveOwnershipScope } from "./ownership.js";
 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";
+import type { SidecarProcessTransport } from "./sidecar-client.js";
 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;