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

package/dist/agent-session-types.d.ts

@@ -0,0 +1,67 @@
+import type { JsonRpcNotification } from "./json-rpc.js";
+export type SessionEventHandler = (event: JsonRpcNotification) => void;
+export interface PermissionRequest {
+    permissionId: string;
+    description?: string;
+    params: Record<string, unknown>;
+}
+export type PermissionReply = "once" | "always" | "reject";
+export type PermissionRequestHandler = (request: PermissionRequest) => void;
+export interface SessionMode {
+    id: string;
+    name?: string;
+    label?: string;
+    description?: string;
+    [key: string]: unknown;
+}
+export interface SessionModeState {
+    currentModeId: string;
+    availableModes: SessionMode[];
+}
+export interface SessionConfigOption {
+    id: string;
+    category?: string;
+    label?: string;
+    description?: string;
+    currentValue?: string;
+    allowedValues?: Array<{
+        id: string;
+        label?: string;
+    }>;
+    readOnly?: boolean;
+}
+export interface PromptCapabilities {
+    audio?: boolean;
+    embeddedContext?: boolean;
+    image?: boolean;
+    [key: string]: unknown;
+}
+export interface AgentCapabilities {
+    permissions?: boolean;
+    plan_mode?: boolean;
+    questions?: boolean;
+    tool_calls?: boolean;
+    text_messages?: boolean;
+    images?: boolean;
+    file_attachments?: boolean;
+    session_lifecycle?: boolean;
+    error_events?: boolean;
+    reasoning?: boolean;
+    status?: boolean;
+    streaming_deltas?: boolean;
+    mcp_tools?: boolean;
+    promptCapabilities?: PromptCapabilities;
+    [key: string]: unknown;
+}
+export interface AgentInfo {
+    name: string;
+    title?: string;
+    version?: string;
+    [key: string]: unknown;
+}
+export interface SessionInitData {
+    modes?: SessionModeState;
+    configOptions?: SessionConfigOption[];
+    capabilities?: AgentCapabilities;
+    agentInfo?: AgentInfo;
+}

package/dist/agent-session-types.js

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

package/dist/agents.d.ts

@@ -0,0 +1,63 @@
+export interface AgentConfig {
+    /** npm package name for the ACP adapter (spawned inside the VM) */
+    acpAdapter: string;
+    /** npm package name for the underlying agent */
+    agentPackage: string;
+    /**
+     * Absolute host path to the software package directory that registered this
+     * agent config. Package-provided agent adapters should resolve their nested
+     * dependencies relative to this directory before falling back to the host dir
+     * behind the caller-supplied `/root/node_modules` mount.
+     */
+    declaringPackageDir?: string;
+    /** Additional CLI args prepended when launching the ACP adapter. */
+    launchArgs?: string[];
+    /**
+     * Default env vars to pass when spawning the adapter. These are merged
+     * UNDER user env (lowest priority).
+     * Typically set by package descriptors for computed paths (e.g. PI_ACP_PI_COMMAND).
+     */
+    defaultEnv?: Record<string, string>;
+}
+export declare const AGENT_CONFIGS: {
+    pi: {
+        acpAdapter: string;
+        agentPackage: string;
+    };
+    "pi-cli": {
+        acpAdapter: string;
+        agentPackage: string;
+    };
+    opencode: {
+        acpAdapter: string;
+        agentPackage: string;
+        defaultEnv: {
+            OPENCODE_DISABLE_CONFIG_DEP_INSTALL: string;
+            OPENCODE_DISABLE_EMBEDDED_WEB_UI: string;
+        };
+    };
+    claude: {
+        acpAdapter: string;
+        agentPackage: string;
+        defaultEnv: {
+            CLAUDE_AGENT_SDK_CLIENT_APP: string;
+            CLAUDE_CODE_SIMPLE: string;
+            CLAUDE_CODE_FORCE_AGENT_OS_RIPGREP: string;
+            CLAUDE_CODE_DEFER_GROWTHBOOK_INIT: string;
+            CLAUDE_CODE_DISABLE_CWD_PERSIST: string;
+            CLAUDE_CODE_DISABLE_DEV_NULL_REDIRECT: string;
+            CLAUDE_CODE_NODE_SHELL_WRAPPER: string;
+            CLAUDE_CODE_DISABLE_STREAM_JSON_HOOK_EVENTS: string;
+            CLAUDE_CODE_SHELL: string;
+            CLAUDE_CODE_SKIP_INITIAL_MESSAGES: string;
+            CLAUDE_CODE_SKIP_SANDBOX_INIT: string;
+            CLAUDE_CODE_SIMPLE_SHELL_EXEC: string;
+            CLAUDE_CODE_SWAP_STDIO: string;
+            CLAUDE_CODE_USE_PIPE_OUTPUT: string;
+            DISABLE_TELEMETRY: string;
+            SHELL: string;
+            USE_BUILTIN_RIPGREP: string;
+        };
+    };
+};
+export type AgentType = keyof typeof AGENT_CONFIGS;

package/dist/agents.js

@@ -0,0 +1,42 @@
+// Agent configurations for ACP-compatible coding agents
+export const AGENT_CONFIGS = {
+    pi: {
+        acpAdapter: "@rivet-dev/agentos-pi",
+        agentPackage: "@mariozechner/pi-coding-agent",
+    },
+    "pi-cli": {
+        acpAdapter: "pi-acp",
+        agentPackage: "@mariozechner/pi-coding-agent",
+    },
+    opencode: {
+        acpAdapter: "@rivet-dev/agentos-opencode",
+        agentPackage: "@rivet-dev/agentos-opencode",
+        defaultEnv: {
+            OPENCODE_DISABLE_CONFIG_DEP_INSTALL: "1",
+            OPENCODE_DISABLE_EMBEDDED_WEB_UI: "1",
+        },
+    },
+    claude: {
+        acpAdapter: "@rivet-dev/agentos-claude",
+        agentPackage: "@anthropic-ai/claude-agent-sdk",
+        defaultEnv: {
+            CLAUDE_AGENT_SDK_CLIENT_APP: "@rivet-dev/agent-os",
+            CLAUDE_CODE_SIMPLE: "1",
+            CLAUDE_CODE_FORCE_AGENT_OS_RIPGREP: "1",
+            CLAUDE_CODE_DEFER_GROWTHBOOK_INIT: "1",
+            CLAUDE_CODE_DISABLE_CWD_PERSIST: "1",
+            CLAUDE_CODE_DISABLE_DEV_NULL_REDIRECT: "1",
+            CLAUDE_CODE_NODE_SHELL_WRAPPER: "1",
+            CLAUDE_CODE_DISABLE_STREAM_JSON_HOOK_EVENTS: "1",
+            CLAUDE_CODE_SHELL: "/bin/sh",
+            CLAUDE_CODE_SKIP_INITIAL_MESSAGES: "1",
+            CLAUDE_CODE_SKIP_SANDBOX_INIT: "1",
+            CLAUDE_CODE_SIMPLE_SHELL_EXEC: "1",
+            CLAUDE_CODE_SWAP_STDIO: "0",
+            CLAUDE_CODE_USE_PIPE_OUTPUT: "1",
+            DISABLE_TELEMETRY: "1",
+            SHELL: "/bin/sh",
+            USE_BUILTIN_RIPGREP: "0",
+        },
+    },
+};

package/dist/base-filesystem.d.ts

@@ -0,0 +1,34 @@
+import { type FilesystemEntry } from "./filesystem-snapshot.js";
+import { type VirtualFileSystem } from "./runtime-compat.js";
+export interface BaseFilesystemEnvironment {
+    env: Record<string, string>;
+    prompt: string;
+}
+export type BaseFilesystemEntry = FilesystemEntry;
+export interface BaseFilesystemSnapshot {
+    source?: {
+        snapshotPath?: string;
+        image?: string;
+        snapshotCreatedAt?: string;
+        builtAt?: string;
+        transforms?: string[];
+    };
+    environment: BaseFilesystemEnvironment;
+    filesystem: {
+        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

@@ -0,0 +1,173 @@
+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);
+}

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

@@ -0,0 +1,22 @@
+import type { AgentOs } from "../agent-os.js";
+import type { ScheduleDriver } from "./schedule-driver.js";
+import type { CronEventHandler, CronJob, CronJobInfo, CronJobOptions } from "./types.js";
+/**
+ * Internal class that bridges ScheduleDriver and AgentOs. Owns the job
+ * registry, executes actions, and emits lifecycle events.
+ */
+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[];
+    onEvent(handler: CronEventHandler): void;
+    dispose(): void;
+    private emit;
+    private executeJob;
+    private runAction;
+}

package/dist/cron/cron-manager.js

@@ -0,0 +1,160 @@
+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;
+}
+/**
+ * Internal class that bridges ScheduleDriver and AgentOs. Owns the job
+ * registry, executes actions, and emits lifecycle events.
+ */
+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) };
+    }
+    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,
+            });
+        }
+        return result;
+    }
+    onEvent(handler) {
+        this.listeners.push(handler);
+    }
+    dispose() {
+        for (const state of this.jobs.values()) {
+            this.driver.cancel(state.handle);
+        }
+        this.jobs.clear();
+        this.driver.dispose();
+    }
+    emit(event) {
+        for (const handler of this.listeners) {
+            try {
+                handler(event);
+            }
+            catch {
+                // Event handler errors must not crash the manager.
+            }
+        }
+    }
+    async executeJob(id) {
+        const state = this.jobs.get(id);
+        if (!state)
+            return;
+        // Overlap policy.
+        if (state.running && state.overlap === "skip") {
+            return;
+        }
+        if (state.running && state.overlap === "queue") {
+            state.queued = true;
+            return;
+        }
+        state.running = true;
+        state.lastRun = new Date();
+        state.runCount++;
+        this.emit({ type: "cron:fire", jobId: state.id, time: new Date() });
+        const startTime = Date.now();
+        try {
+            await this.runAction(state.action);
+            this.emit({
+                type: "cron:complete",
+                jobId: state.id,
+                time: new Date(),
+                durationMs: Date.now() - startTime,
+            });
+        }
+        catch (error) {
+            this.emit({
+                type: "cron:error",
+                jobId: state.id,
+                time: new Date(),
+                error: error,
+            });
+        }
+        finally {
+            state.running = false;
+            state.nextRun = computeNextTime(state.schedule);
+            // Process queued execution.
+            if (state.queued) {
+                state.queued = false;
+                void this.executeJob(id);
+            }
+        }
+    }
+    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;
+            }
+            case "exec": {
+                const cmd = action.args?.length
+                    ? `${action.command} ${action.args.join(" ")}`
+                    : action.command;
+                await this.vm.exec(cmd);
+                break;
+            }
+            case "callback": {
+                await action.fn();
+                break;
+            }
+        }
+    }
+}

package/dist/cron/index.d.ts

@@ -0,0 +1,5 @@
+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 type { CronAction, CronEvent, CronEventHandler, CronJob, CronJobInfo, CronJobOptions, } from "./types.js";

package/dist/cron/index.js

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

package/dist/cron/parse-schedule.d.ts

@@ -0,0 +1,25 @@
+import { Cron } from "croner";
+export type ParsedSchedule = {
+    kind: "date";
+    date: Date;
+} | {
+    kind: "cron";
+    cron: Cron;
+};
+export declare class InvalidScheduleError extends Error {
+    readonly schedule: string;
+    constructor(schedule: string);
+}
+export declare class PastScheduleError extends Error {
+    readonly schedule: string;
+    constructor(schedule: string);
+}
+export declare function parseSchedule(schedule: string): ParsedSchedule;
+export declare function resolveSchedule(schedule: string, now?: Date): {
+    parsed: ParsedSchedule;
+    nextRun?: Date;
+};
+export declare function validateScheduleForRegistration(schedule: string, now?: Date): {
+    parsed: ParsedSchedule;
+    nextRun?: Date;
+};

package/dist/cron/parse-schedule.js

@@ -0,0 +1,66 @@
+import { Cron } from "croner";
+const ONE_SHOT_SCHEDULE_PATTERN = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:\d{2})?)?$/;
+const DATE_TIME_WITHOUT_ZONE_PATTERN = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?$/;
+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;
+    }
+}
+function looksLikeOneShotSchedule(schedule) {
+    return ONE_SHOT_SCHEDULE_PATTERN.test(schedule);
+}
+function normalizeOneShotScheduleForDateParse(schedule) {
+    const dateParseSchedule = schedule.replace(" ", "T");
+    return DATE_TIME_WITHOUT_ZONE_PATTERN.test(schedule)
+        ? `${dateParseSchedule}Z`
+        : dateParseSchedule;
+}
+export function parseSchedule(schedule) {
+    const normalizedSchedule = schedule.trim();
+    if (looksLikeOneShotSchedule(normalizedSchedule)) {
+        const parsedTime = Date.parse(normalizeOneShotScheduleForDateParse(normalizedSchedule));
+        if (!Number.isFinite(parsedTime)) {
+            throw new InvalidScheduleError(schedule);
+        }
+        return {
+            kind: "date",
+            date: new Date(parsedTime),
+        };
+    }
+    try {
+        return {
+            kind: "cron",
+            cron: new Cron(normalizedSchedule),
+        };
+    }
+    catch {
+        throw new InvalidScheduleError(schedule);
+    }
+}
+export function resolveSchedule(schedule, now = new Date()) {
+    const parsed = parseSchedule(schedule);
+    const nextRun = parsed.kind === "cron"
+        ? (parsed.cron.nextRun() ?? undefined)
+        : parsed.date.getTime() > now.getTime()
+            ? parsed.date
+            : undefined;
+    return { parsed, nextRun };
+}
+export function validateScheduleForRegistration(schedule, now = new Date()) {
+    const resolved = resolveSchedule(schedule, now);
+    if (resolved.parsed.kind === "date" && !resolved.nextRun) {
+        throw new PastScheduleError(schedule);
+    }
+    return resolved;
+}

package/dist/cron/schedule-driver.d.ts

@@ -0,0 +1,19 @@
+export interface ScheduleEntry {
+    /** Unique ID for this job. */
+    id: string;
+    /** Standard 5-field cron expression or ISO 8601 timestamp for one-shot. */
+    schedule: string;
+    /** Called when the schedule fires. */
+    callback: () => void | Promise<void>;
+}
+export interface ScheduleHandle {
+    id: string;
+}
+export interface ScheduleDriver {
+    /** Schedule a callback to fire on a cron expression or at a specific time. */
+    schedule(entry: ScheduleEntry): ScheduleHandle;
+    /** Cancel a previously scheduled entry. */
+    cancel(handle: ScheduleHandle): void;
+    /** Tear down all scheduled work. */
+    dispose(): void;
+}

package/dist/cron/schedule-driver.js

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