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

package/dist/agentos-package.d.ts

@@ -0,0 +1,27 @@
+/**
+ * agentOS package model (Linux-exact, Homebrew-modeled) — client-facing surface.
+ *
+ * A package is a self-contained directory produced by `@rivet-dev/agentos-toolchain
+ * pack`. The HOST no longer projects it: the client forwards only the package
+ * directory over the wire and the secure-exec sidecar owns the `/opt/agentos`
+ * projection. Package metadata lives in `<dir>/agentos-package.json`.
+ *
+ * This module is therefore only the client-facing package-dir surface plus the
+ * `/opt/agentos` path constants used for agent-config wiring.
+ *
+ * See `website/src/content/docs/docs/architecture/packages-and-command-resolution.mdx`.
+ */
+import type { PackageAgentDescriptor, PackageRef as ManifestPackageRef } from "@agentos-software/manifest";
+/** Root of the agentOS package tree inside the VM. */
+export declare const OPT_AGENTOS_ROOT = "/opt/agentos";
+/** The symlink farm on `$PATH` (commands link here). */
+export declare const OPT_AGENTOS_BIN = "/opt/agentos/bin";
+export type AgentBlock = PackageAgentDescriptor;
+export type PackageRef = ManifestPackageRef;
+export type SoftwarePackageRef = {
+    packagePath: string;
+};
+/** @deprecated Package software is now represented by its package directory. */
+export type PackageDescriptor = PackageRef;
+/** Discriminate the dir-only package reference. */
+export declare function isPackageDescriptor(value: unknown): value is PackageDescriptor;

package/dist/agentos-package.js

@@ -0,0 +1,21 @@
+/**
+ * agentOS package model (Linux-exact, Homebrew-modeled) — client-facing surface.
+ *
+ * A package is a self-contained directory produced by `@rivet-dev/agentos-toolchain
+ * pack`. The HOST no longer projects it: the client forwards only the package
+ * directory over the wire and the secure-exec sidecar owns the `/opt/agentos`
+ * projection. Package metadata lives in `<dir>/agentos-package.json`.
+ *
+ * This module is therefore only the client-facing package-dir surface plus the
+ * `/opt/agentos` path constants used for agent-config wiring.
+ *
+ * See `website/src/content/docs/docs/architecture/packages-and-command-resolution.mdx`.
+ */
+/** Root of the agentOS package tree inside the VM. */
+export const OPT_AGENTOS_ROOT = "/opt/agentos";
+/** The symlink farm on `$PATH` (commands link here). */
+export const OPT_AGENTOS_BIN = "/opt/agentos/bin";
+/** Discriminate the dir-only package reference. */
+export function isPackageDescriptor(value) {
+    return typeof value === "string";
+}

package/dist/base-filesystem.d.ts

@@ -1,5 +1,4 @@
-import { type FilesystemEntry } from "./filesystem-snapshot.js";
-import { type VirtualFileSystem } from "./runtime-compat.js";
+import type { FilesystemEntry } from "./filesystem-snapshot.js";
 export interface BaseFilesystemEnvironment {
     env: Record<string, string>;
     prompt: string;
@@ -18,17 +17,3 @@ export interface BaseFilesystemSnapshot {
         entries: BaseFilesystemEntry[];
     };
 }
-export declare function createBaseLowerFilesystem(): Promise<VirtualFileSystem>;
-export declare function createBootstrapAwareFilesystem(filesystem: VirtualFileSystem, existingRoot: VirtualFileSystem, options?: {
-    readOnlyAfterBootstrap?: boolean;
-}): {
-    filesystem: VirtualFileSystem;
-    finishKernelBootstrap: () => void;
-};
-export declare function getBaseFilesystemSnapshot(): BaseFilesystemSnapshot;
-export declare function getBaseEnvironment(): Record<string, string>;
-export declare function getBaseFilesystemEntries(): BaseFilesystemEntry[];
-export declare function createBaseRootFilesystem(): Promise<{
-    filesystem: VirtualFileSystem;
-    finishKernelBootstrap: () => void;
-}>;

package/dist/base-filesystem.js

@@ -1,173 +1 @@
-import { readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import * as posixPath from "node:path/posix";
-import { createFilesystemFromEntries, } from "./filesystem-snapshot.js";
-import { createOverlayBackend } from "./overlay-filesystem.js";
-import { KernelError } from "./runtime-compat.js";
-const require = createRequire(import.meta.url);
-const SNAPSHOT_PATH = require.resolve("@secure-exec/core/fixtures/base-filesystem.json");
-const SUPPRESSED_KERNEL_BOOTSTRAP_DIRS = new Set([
-    "/boot",
-    "/usr/games",
-    "/usr/include",
-    "/usr/libexec",
-    "/usr/man",
-]);
-const SUPPRESSED_KERNEL_BOOTSTRAP_FILES = new Set(["/usr/bin/env"]);
-let snapshotCache = null;
-function loadSnapshot() {
-    if (snapshotCache) {
-        return snapshotCache;
-    }
-    snapshotCache = JSON.parse(readFileSync(SNAPSHOT_PATH, "utf-8"));
-    return snapshotCache;
-}
-function normalizePath(path) {
-    const normalized = posixPath.normalize(path);
-    return normalized === "." ? "/" : normalized;
-}
-export async function createBaseLowerFilesystem() {
-    return createFilesystemFromEntries(getBaseFilesystemEntries());
-}
-export function createBootstrapAwareFilesystem(filesystem, existingRoot, options) {
-    let bootstrapActive = true;
-    let writesLocked = false;
-    function throwReadOnly() {
-        throw new KernelError("EROFS", "read-only file system");
-    }
-    async function rootHasPath(path) {
-        try {
-            return await existingRoot.exists(path);
-        }
-        catch {
-            return false;
-        }
-    }
-    const wrapped = {
-        ...filesystem,
-        async createDir(path) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            const normalized = normalizePath(path);
-            if (bootstrapActive &&
-                SUPPRESSED_KERNEL_BOOTSTRAP_DIRS.has(normalized) &&
-                !(await rootHasPath(normalized))) {
-                return;
-            }
-            return filesystem.createDir(path);
-        },
-        async mkdir(path, options) {
-            if (writesLocked) {
-                if (options?.recursive && (await rootHasPath(path))) {
-                    return;
-                }
-                throwReadOnly();
-            }
-            const normalized = normalizePath(path);
-            if (bootstrapActive &&
-                options?.recursive &&
-                SUPPRESSED_KERNEL_BOOTSTRAP_DIRS.has(normalized) &&
-                !(await rootHasPath(normalized))) {
-                return;
-            }
-            return filesystem.mkdir(path, options);
-        },
-        async writeFile(path, content) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            const normalized = normalizePath(path);
-            if (bootstrapActive &&
-                SUPPRESSED_KERNEL_BOOTSTRAP_FILES.has(normalized)) {
-                return;
-            }
-            return filesystem.writeFile(path, content);
-        },
-        async removeFile(path) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.removeFile(path);
-        },
-        async removeDir(path) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.removeDir(path);
-        },
-        async rename(oldPath, newPath) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.rename(oldPath, newPath);
-        },
-        async symlink(target, linkPath) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.symlink(target, linkPath);
-        },
-        async link(oldPath, newPath) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.link(oldPath, newPath);
-        },
-        async chmod(path, mode) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.chmod(path, mode);
-        },
-        async chown(path, uid, gid) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.chown(path, uid, gid);
-        },
-        async utimes(path, atime, mtime) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.utimes(path, atime, mtime);
-        },
-        async truncate(path, length) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.truncate(path, length);
-        },
-        async pwrite(path, offset, data) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.pwrite(path, offset, data);
-        },
-    };
-    return {
-        filesystem: wrapped,
-        finishKernelBootstrap() {
-            bootstrapActive = false;
-            writesLocked = options?.readOnlyAfterBootstrap ?? false;
-        },
-    };
-}
-export function getBaseFilesystemSnapshot() {
-    return loadSnapshot();
-}
-export function getBaseEnvironment() {
-    const snapshot = loadSnapshot();
-    return {
-        ...snapshot.environment.env,
-        PS1: snapshot.environment.prompt,
-    };
-}
-export function getBaseFilesystemEntries() {
-    return loadSnapshot().filesystem.entries;
-}
-export async function createBaseRootFilesystem() {
-    const lower = await createBaseLowerFilesystem();
-    const overlay = createOverlayBackend({ lower });
-    return createBootstrapAwareFilesystem(overlay, lower);
-}
+export {};

package/dist/cron/cron-manager.d.ts

@@ -1,22 +1,47 @@
-import type { AgentOs } from "../agent-os.js";
-import type { ScheduleDriver } from "./schedule-driver.js";
+import type { AuthenticatedSession, CreatedVm, SidecarCronAlarm, SidecarCronDispatch, SidecarProcess } from "../sidecar/native-process-client.js";
 import type { CronEventHandler, CronJob, CronJobInfo, CronJobOptions } from "./types.js";
+interface CronAlarmDriver {
+    set(alarm: SidecarCronAlarm, wake: (generation: number) => Promise<void>): void;
+    dispose(): void;
+}
+interface CronTransport {
+    scheduleCron: SidecarProcess["scheduleCron"];
+    listCronJobs: SidecarProcess["listCronJobs"];
+    cancelCronJob: SidecarProcess["cancelCronJob"];
+    wakeCron: SidecarProcess["wakeCron"];
+    completeCronRun: SidecarProcess["completeCronRun"];
+}
 /**
- * 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 declare class CronManager {
-    private jobs;
-    private driver;
-    private vm;
-    private listeners;
-    constructor(vm: AgentOs, driver: ScheduleDriver);
-    schedule(options: CronJobOptions): CronJob;
-    cancel(id: string): void;
-    list(): CronJobInfo[];
+    private readonly transport;
+    private readonly session;
+    private readonly sidecarVm;
+    private readonly alarmDriver;
+    private readonly listeners;
+    private readonly callbacks;
+    private readonly callbackByJob;
+    private callbackSequence;
+    private alarmGeneration;
+    private disposed;
+    constructor(transport: CronTransport, session: AuthenticatedSession, sidecarVm: CreatedVm, alarmDriver?: CronAlarmDriver);
+    schedule(options: CronJobOptions): Promise<CronJob>;
+    cancel(id: string): Promise<void>;
+    list(): Promise<CronJobInfo[]>;
     onEvent(handler: CronEventHandler): void;
     dispose(): void;
+    private wake;
+    consumeDispatch(dispatch: SidecarCronDispatch): void;
+    private executeRun;
+    private toJobInfo;
     private emit;
-    private executeJob;
-    private runAction;
+    private applyAlarm;
+    private replaceJobCallback;
+    private releaseCallback;
+    private allocateCallbackId;
+    private ensureActive;
 }
+export {};