@rivet-dev/agentos-core 0.0.0-abc-fixes-1.d8c4d95 → 0.0.0-agent-acp-codex-session-benchmark.62b1f46

package/dist/cron/cron-manager.js

@@ -1,157 +1,318 @@
-import { randomUUID } from "node:crypto";
-import { resolveSchedule, validateScheduleForRegistration, } from "./parse-schedule.js";
-/**
- * Compute the next fire time for a schedule string. Returns undefined if
- * the schedule is a one-shot ISO timestamp in the past or if croner
- * cannot determine a next run.
- */
-function computeNextTime(schedule) {
-    return resolveSchedule(schedule).nextRun;
+import { InvalidScheduleError, PastScheduleError } from "./errors.js";
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+class TimerCronAlarmDriver {
+    timer = null;
+    set(alarm, wake) {
+        this.clear();
+        if (alarm.nextAlarmMs === undefined)
+            return;
+        const delay = Math.min(MAX_TIMER_DELAY_MS, Math.max(0, alarm.nextAlarmMs - Date.now()));
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            if (delay === MAX_TIMER_DELAY_MS) {
+                this.set(alarm, wake);
+                return;
+            }
+            void wake(alarm.generation).catch((error) => {
+                console.error("[agent-os] cron wake failed", error);
+            });
+        }, delay);
+        this.timer.unref?.();
+    }
+    dispose() {
+        this.clear();
+    }
+    clear() {
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
 }
 /**
- * Internal class that bridges ScheduleDriver and AgentOs. Owns the job
- * registry, executes actions, and emits lifecycle events.
+ * Thin cron host adapter. The sidecar owns grammar, defaults, job/run state,
+ * overlap policy, counts, missed-fire coalescing, and alarm generations. This
+ * class only arms the host clock and routes actions containing host resources.
  */
 export class CronManager {
-    jobs = new Map();
-    driver;
-    vm;
-    listeners = [];
-    constructor(vm, driver) {
-        this.vm = vm;
-        this.driver = driver;
-    }
-    schedule(options) {
-        const id = options.id ?? randomUUID();
-        const overlap = options.overlap ?? "allow";
-        const resolved = validateScheduleForRegistration(options.schedule);
-        const handle = this.driver.schedule({
-            id,
-            schedule: options.schedule,
-            callback: () => this.executeJob(id),
-        });
-        const state = {
-            id,
-            schedule: options.schedule,
-            action: options.action,
-            overlap,
-            handle,
-            lastRun: undefined,
-            nextRun: resolved.nextRun,
-            runCount: 0,
-            running: false,
-            queued: false,
-        };
-        this.jobs.set(id, state);
-        return { id, cancel: () => this.cancel(id) };
+    transport;
+    session;
+    sidecarVm;
+    alarmDriver;
+    listeners = new Set();
+    callbacks = new Map();
+    callbackByJob = new Map();
+    callbackSequence = 0;
+    alarmGeneration = 0;
+    disposed = false;
+    constructor(transport, session, sidecarVm, alarmDriver = new TimerCronAlarmDriver()) {
+        this.transport = transport;
+        this.session = session;
+        this.sidecarVm = sidecarVm;
+        this.alarmDriver = alarmDriver;
     }
-    cancel(id) {
-        const state = this.jobs.get(id);
-        if (!state)
-            return;
-        this.driver.cancel(state.handle);
-        this.jobs.delete(id);
-    }
-    list() {
-        const result = [];
-        for (const state of this.jobs.values()) {
-            result.push({
-                id: state.id,
-                schedule: state.schedule,
-                action: state.action,
-                overlap: state.overlap,
-                lastRun: state.lastRun,
-                nextRun: state.nextRun,
-                runCount: state.runCount,
-                running: state.running,
+    async schedule(options) {
+        this.ensureActive();
+        let callbackId;
+        const action = (() => {
+            if (options.action.type !== "callback")
+                return options.action;
+            callbackId = this.allocateCallbackId();
+            this.callbacks.set(callbackId, {
+                fn: options.action.fn,
+                scheduled: false,
+                activeRuns: 0,
+            });
+            return { type: "callback", callbackId };
+        })();
+        try {
+            const response = await this.transport.scheduleCron(this.session, this.sidecarVm, {
+                ...(options.id === undefined ? {} : { id: options.id }),
+                schedule: options.schedule,
+                action,
+                ...(options.overlap === undefined
+                    ? {}
+                    : { overlap: options.overlap }),
             });
+            this.replaceJobCallback(response.id, callbackId);
+            this.applyAlarm(response.alarm);
+            return {
+                id: response.id,
+                cancel: () => this.cancel(response.id),
+            };
+        }
+        catch (error) {
+            if (callbackId !== undefined)
+                this.releaseCallback(callbackId);
+            throw normalizeScheduleError(options.schedule, error);
         }
-        return result;
     }
-    onEvent(handler) {
-        this.listeners.push(handler);
+    async cancel(id) {
+        this.ensureActive();
+        const response = await this.transport.cancelCronJob(this.session, this.sidecarVm, id);
+        if (response.cancelled)
+            this.replaceJobCallback(id, undefined);
+        this.applyAlarm(response.alarm);
     }
-    dispose() {
-        for (const state of this.jobs.values()) {
-            this.driver.cancel(state.handle);
-        }
-        this.jobs.clear();
-        this.driver.dispose();
+    async list() {
+        this.ensureActive();
+        const response = await this.transport.listCronJobs(this.session, this.sidecarVm);
+        this.applyAlarm(response.alarm);
+        return response.jobs.map((job) => this.toJobInfo(job));
     }
-    emit(event) {
-        for (const handler of this.listeners) {
-            try {
-                handler(event);
-            }
-            catch {
-                // Event handler errors must not crash the manager.
-            }
-        }
+    onEvent(handler) {
+        this.ensureActive();
+        this.listeners.add(handler);
     }
-    async executeJob(id) {
-        const state = this.jobs.get(id);
-        if (!state)
+    dispose() {
+        if (this.disposed)
             return;
-        // Overlap policy.
-        if (state.running && state.overlap === "skip") {
+        this.disposed = true;
+        this.alarmDriver.dispose();
+        this.listeners.clear();
+        this.callbacks.clear();
+        this.callbackByJob.clear();
+    }
+    async wake(generation) {
+        if (this.disposed)
             return;
-        }
-        if (state.running && state.overlap === "queue") {
-            state.queued = true;
+        const dispatch = await this.transport.wakeCron(this.session, this.sidecarVm, generation);
+        this.consumeDispatch(dispatch);
+    }
+    consumeDispatch(dispatch) {
+        if (this.disposed)
             return;
+        this.applyAlarm(dispatch.alarm);
+        for (const event of dispatch.events)
+            this.emit(event);
+        for (const run of dispatch.runs) {
+            void this.executeRun(run).catch((error) => {
+                console.error("[agent-os] cron completion failed", error);
+            });
         }
-        state.running = true;
-        state.lastRun = new Date();
-        state.runCount++;
-        this.emit({ type: "cron:fire", jobId: state.id, time: new Date() });
-        const startTime = Date.now();
+    }
+    async executeRun(run) {
+        let errorMessage;
+        let callbackId;
         try {
-            await this.runAction(state.action);
-            this.emit({
-                type: "cron:complete",
-                jobId: state.id,
-                time: new Date(),
-                durationMs: Date.now() - startTime,
-            });
+            const action = decodeWireAction(run.action);
+            if (action.type !== "callback") {
+                throw new Error(`sidecar returned non-host cron action to client: ${action.type}`);
+            }
+            callbackId = action.callbackId;
+            const route = this.callbacks.get(callbackId);
+            if (!route) {
+                throw new Error(`cron callback route not found: ${callbackId}`);
+            }
+            route.activeRuns++;
+            await route.fn();
         }
         catch (error) {
-            this.emit({
-                type: "cron:error",
-                jobId: state.id,
-                time: new Date(),
-                error: error,
-            });
+            errorMessage = error instanceof Error ? error.message : String(error);
         }
         finally {
-            state.running = false;
-            state.nextRun = computeNextTime(state.schedule);
-            // Process queued execution.
-            if (state.queued) {
-                state.queued = false;
-                void this.executeJob(id);
+            if (callbackId !== undefined) {
+                const route = this.callbacks.get(callbackId);
+                if (route) {
+                    route.activeRuns = Math.max(0, route.activeRuns - 1);
+                    this.releaseCallback(callbackId);
+                }
             }
         }
+        // VM disposal removes the sidecar scheduler and its active runs. Do not
+        // issue a completion request against a transport that is being torn down.
+        if (this.disposed)
+            return;
+        const dispatch = await this.transport.completeCronRun(this.session, this.sidecarVm, run.runId, errorMessage);
+        this.consumeDispatch(dispatch);
     }
-    async runAction(action) {
-        switch (action.type) {
-            case "session": {
-                const { sessionId } = await this.vm.createSession(action.agentType, action.options);
-                try {
-                    await this.vm.prompt(sessionId, action.prompt);
-                }
-                finally {
-                    this.vm.closeSession(sessionId);
-                }
-                break;
+    toJobInfo(job) {
+        const wireAction = decodeWireAction(job.action);
+        const action = wireAction.type === "callback"
+            ? {
+                type: "callback",
+                fn: this.callbacks.get(wireAction.callbackId)?.fn ?? missingCallback,
+            }
+            : wireAction;
+        return {
+            id: job.id,
+            schedule: job.schedule,
+            action,
+            overlap: job.overlap,
+            ...(job.lastRunMs === undefined
+                ? {}
+                : { lastRun: new Date(job.lastRunMs) }),
+            ...(job.nextRunMs === undefined
+                ? {}
+                : { nextRun: new Date(job.nextRunMs) }),
+            runCount: job.runCount,
+            running: job.running,
+        };
+    }
+    emit(event) {
+        let publicEvent;
+        if (event.kind === "fire") {
+            publicEvent = {
+                type: "cron:fire",
+                jobId: event.jobId,
+                time: new Date(event.timeMs),
+            };
+        }
+        else if (event.kind === "complete") {
+            if (event.durationMs === undefined) {
+                throw new Error("sidecar complete cron event is missing durationMs");
             }
-            case "exec": {
-                await this.vm.execArgv(action.command, action.args ?? []);
-                break;
+            publicEvent = {
+                type: "cron:complete",
+                jobId: event.jobId,
+                time: new Date(event.timeMs),
+                durationMs: event.durationMs,
+            };
+        }
+        else {
+            if (event.error === undefined) {
+                throw new Error("sidecar error cron event is missing error");
             }
-            case "callback": {
-                await action.fn();
-                break;
+            publicEvent = {
+                type: "cron:error",
+                jobId: event.jobId,
+                time: new Date(event.timeMs),
+                error: new Error(event.error),
+            };
+        }
+        for (const listener of this.listeners) {
+            try {
+                listener(publicEvent);
+            }
+            catch (error) {
+                console.warn("[agent-os] cron event listener failed", error);
             }
         }
     }
+    applyAlarm(alarm) {
+        if (alarm.generation < this.alarmGeneration)
+            return;
+        this.alarmGeneration = alarm.generation;
+        this.alarmDriver.set(alarm, (generation) => this.wake(generation));
+    }
+    replaceJobCallback(jobId, callbackId) {
+        const previous = this.callbackByJob.get(jobId);
+        if (previous !== undefined && previous !== callbackId) {
+            this.callbackByJob.delete(jobId);
+            const route = this.callbacks.get(previous);
+            if (route)
+                route.scheduled = false;
+            this.releaseCallback(previous);
+        }
+        if (callbackId !== undefined) {
+            const route = this.callbacks.get(callbackId);
+            if (!route)
+                throw new Error(`cron callback route not found: ${callbackId}`);
+            route.scheduled = true;
+            this.callbackByJob.set(jobId, callbackId);
+        }
+    }
+    releaseCallback(callbackId) {
+        const route = this.callbacks.get(callbackId);
+        if (route && !route.scheduled && route.activeRuns === 0) {
+            this.callbacks.delete(callbackId);
+        }
+    }
+    allocateCallbackId() {
+        this.callbackSequence++;
+        if (!Number.isSafeInteger(this.callbackSequence)) {
+            throw new Error("cron callback id counter exhausted; recreate the VM");
+        }
+        return `host-cron-callback-${this.callbackSequence}`;
+    }
+    ensureActive() {
+        if (this.disposed)
+            throw new Error("cron manager is disposed");
+    }
+}
+function decodeWireAction(value) {
+    if (!value || typeof value !== "object") {
+        throw new TypeError("sidecar returned an invalid cron action");
+    }
+    const action = value;
+    if (action.type === "callback" && typeof action.callbackId === "string") {
+        return { type: "callback", callbackId: action.callbackId };
+    }
+    if (action.type === "exec" &&
+        typeof action.command === "string" &&
+        (action.args === undefined ||
+            (Array.isArray(action.args) &&
+                action.args.every((arg) => typeof arg === "string")))) {
+        return {
+            type: "exec",
+            command: action.command,
+            ...(action.args === undefined ? {} : { args: action.args }),
+        };
+    }
+    if (action.type === "session" &&
+        typeof action.agentType === "string" &&
+        typeof action.prompt === "string") {
+        return {
+            type: "session",
+            agentType: action.agentType,
+            prompt: action.prompt,
+            ...(action.options === undefined
+                ? {}
+                : {
+                    options: action.options,
+                }),
+        };
+    }
+    throw new TypeError("sidecar returned an invalid cron action");
+}
+function normalizeScheduleError(schedule, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("[invalid_schedule]"))
+        return new InvalidScheduleError(schedule);
+    if (message.includes("[past_schedule]"))
+        return new PastScheduleError(schedule);
+    return error;
+}
+async function missingCallback() {
+    throw new Error("cron callback route is unavailable");
 }

package/dist/cron/errors.d.ts

@@ -0,0 +1,8 @@
+export declare class InvalidScheduleError extends Error {
+    readonly schedule: string;
+    constructor(schedule: string);
+}
+export declare class PastScheduleError extends Error {
+    readonly schedule: string;
+    constructor(schedule: string);
+}

package/dist/cron/errors.js

@@ -0,0 +1,16 @@
+export class InvalidScheduleError extends Error {
+    schedule;
+    constructor(schedule) {
+        super(`Invalid schedule "${schedule}". Expected a cron expression or an ISO-like one-shot timestamp.`);
+        this.name = "InvalidScheduleError";
+        this.schedule = schedule;
+    }
+}
+export class PastScheduleError extends Error {
+    schedule;
+    constructor(schedule) {
+        super(`One-shot schedule "${schedule}" is already in the past.`);
+        this.name = "PastScheduleError";
+        this.schedule = schedule;
+    }
+}

package/dist/cron/index.d.ts

@@ -1,5 +1,3 @@
 export { CronManager } from "./cron-manager.js";
-export { InvalidScheduleError, PastScheduleError, } from "./parse-schedule.js";
-export type { ScheduleDriver, ScheduleEntry, ScheduleHandle, } from "./schedule-driver.js";
-export { TimerScheduleDriver } from "./timer-driver.js";
+export { InvalidScheduleError, PastScheduleError, } from "./errors.js";
 export type { CronAction, CronEvent, CronEventHandler, CronJob, CronJobInfo, CronJobOptions, } from "./types.js";

package/dist/cron/index.js

@@ -1,3 +1,2 @@
 export { CronManager } from "./cron-manager.js";
-export { InvalidScheduleError, PastScheduleError, } from "./parse-schedule.js";
-export { TimerScheduleDriver } from "./timer-driver.js";
+export { InvalidScheduleError, PastScheduleError, } from "./errors.js";

package/dist/cron/types.d.ts

@@ -1,5 +1,5 @@
 import type { CreateSessionOptions } from "../agent-os.js";
-import type { AgentType } from "../agents.js";
+import type { AgentType } from "../types.js";
 export type CronAction = {
     type: "session";
     agentType: AgentType;
@@ -25,7 +25,7 @@ export interface CronJobOptions {
 }
 export interface CronJob {
     id: string;
-    cancel(): void;
+    cancel(): Promise<void>;
 }
 export interface CronJobInfo {
     id: string;

package/dist/default-software.d.ts

@@ -0,0 +1,8 @@
+import type { SoftwarePackageRef } from "@agentos-software/manifest";
+/**
+ * Default software for a bare `AgentOs.create()`: the `@agentos-software/common`
+ * coreutils bundle, imported like any other package. The client makes NO
+ * npm/node_modules assumptions (see root CLAUDE.md) — no dep scan, no
+ * require.resolve. Opt out with `defaultSoftware: false`; add more via `software`.
+ */
+export declare function resolveDefaultSoftware(): SoftwarePackageRef[];

package/dist/default-software.js

@@ -0,0 +1,10 @@
+import common from "@agentos-software/common";
+/**
+ * Default software for a bare `AgentOs.create()`: the `@agentos-software/common`
+ * coreutils bundle, imported like any other package. The client makes NO
+ * npm/node_modules assumptions (see root CLAUDE.md) — no dep scan, no
+ * require.resolve. Opt out with `defaultSoftware: false`; add more via `software`.
+ */
+export function resolveDefaultSoftware() {
+    return [common].flat();
+}

package/dist/filesystem-snapshot.d.ts

@@ -1,4 +1,4 @@
-import { type VirtualFileSystem } from "./runtime-compat.js";
+import type { VirtualFileSystem } from "./runtime.js";
 export interface FilesystemEntry {
     path: string;
     type: "directory" | "file" | "symlink";

package/dist/filesystem-snapshot.js

@@ -1,5 +1,5 @@
 import * as posixPath from "node:path/posix";
-import { createInMemoryFileSystem, } from "./runtime-compat.js";
+import { createInMemoryFileSystem } from "./memory-filesystem.js";
 function parseMode(mode) {
     return Number.parseInt(mode, 8);
 }

package/dist/generated/AcpLimitsConfig.d.ts

@@ -0,0 +1,4 @@
+export type AcpLimitsConfig = {
+    maxReadLineBytes?: number;
+    stdoutBufferByteLimit?: number;
+};

package/dist/generated/AcpLimitsConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/CreateVmConfig.d.ts

@@ -0,0 +1,29 @@
+import type { JsRuntimeConfig } from "./JsRuntimeConfig.js";
+import type { NativeRootFilesystemConfig } from "./NativeRootFilesystemConfig.js";
+import type { PermissionsPolicy } from "./PermissionsPolicy.js";
+import type { RootFilesystemConfig } from "./RootFilesystemConfig.js";
+import type { VmDnsConfig } from "./VmDnsConfig.js";
+import type { VmLimitsConfig } from "./VmLimitsConfig.js";
+import type { VmListenPolicyConfig } from "./VmListenPolicyConfig.js";
+/**
+ * Canonical Rust-side VM config. Unknown fields must stay rejected here and by
+ * TypeScript thin-client option validation. Update both when an explicit wire
+ * option changes the generated VM config.
+ */
+export type CreateVmConfig = {
+    cwd?: string;
+    env?: Record<string, string>;
+    rootFilesystem?: RootFilesystemConfig;
+    permissions?: PermissionsPolicy;
+    limits?: VmLimitsConfig;
+    dns?: VmDnsConfig;
+    nativeRoot?: NativeRootFilesystemConfig;
+    listen?: VmListenPolicyConfig;
+    loopbackExemptPorts?: Array<number>;
+    jsRuntime?: JsRuntimeConfig;
+    /**
+     * VM-scoped instructions applied to every ACP session. Session-specific
+     * instructions are combined with these by the ACP sidecar adapter.
+     */
+    agentAdditionalInstructions?: string;
+};

package/dist/generated/FsPermissionRule.d.ts

@@ -0,0 +1,6 @@
+import type { PermissionMode } from "./PermissionMode.js";
+export type FsPermissionRule = {
+    mode: PermissionMode;
+    operations?: Array<string>;
+    paths?: Array<string>;
+};

package/dist/generated/FsPermissionRule.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/FsPermissionRuleSet.d.ts

@@ -0,0 +1,6 @@
+import type { FsPermissionRule } from "./FsPermissionRule.js";
+import type { PermissionMode } from "./PermissionMode.js";
+export type FsPermissionRuleSet = {
+    default?: PermissionMode;
+    rules: Array<FsPermissionRule>;
+};

package/dist/generated/FsPermissionRuleSet.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/FsPermissionScope.d.ts

@@ -0,0 +1,3 @@
+import type { FsPermissionRuleSet } from "./FsPermissionRuleSet.js";
+import type { PermissionMode } from "./PermissionMode.js";
+export type FsPermissionScope = PermissionMode | FsPermissionRuleSet;

package/dist/generated/FsPermissionScope.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/HttpLimitsConfig.d.ts

@@ -0,0 +1,3 @@
+export type HttpLimitsConfig = {
+    maxFetchResponseBytes?: number;
+};

package/dist/generated/HttpLimitsConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/JsModuleResolution.d.ts

@@ -0,0 +1 @@
+export type JsModuleResolution = "node" | "relative" | "none";

package/dist/generated/JsModuleResolution.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};