rivetkit 2.3.26 → 2.3.28

package/src/agent-os/actor/cron.ts

@@ -1,84 +0,0 @@
-import type { CronAction, CronJobInfo } from "@rivet-dev/agent-os-core";
-import type { AgentOsActorConfig } from "../config";
-import type {
-	AgentOsActionContext,
-	SerializableCronAction,
-	SerializableCronJobInfo,
-	SerializableCronJobOptions,
-} from "../types";
-import { ensureVm } from "./index";
-
-function serializeCronAction(action: CronAction): SerializableCronAction {
-	switch (action.type) {
-		case "session":
-			return {
-				type: "session",
-				agentType: action.agentType,
-				prompt: action.prompt,
-				cwd: action.options?.cwd,
-			};
-		case "exec":
-			return {
-				type: "exec",
-				command: action.command,
-				args: action.args,
-			};
-		case "callback":
-			throw new TypeError("callback cron actions are not serializable");
-	}
-}
-
-function serializeCronJob(job: CronJobInfo): SerializableCronJobInfo {
-	return {
-		id: job.id,
-		schedule: job.schedule,
-		action: serializeCronAction(job.action),
-		overlap: job.overlap,
-		lastRun: job.lastRun?.toISOString(),
-		nextRun: job.nextRun?.toISOString(),
-		runCount: job.runCount,
-		running: job.running,
-	};
-}
-
-// Build cron scheduling actions for the actor factory.
-export function buildCronActions<TConnParams>(
-	config: AgentOsActorConfig<TConnParams>,
-) {
-	return {
-		scheduleCron: async (
-			c: AgentOsActionContext<TConnParams>,
-			options: SerializableCronJobOptions,
-		): Promise<{ id: string }> => {
-			const agentOs = await ensureVm(c, config);
-			const job = agentOs.scheduleCron({
-				id: options.id,
-				schedule: options.schedule,
-				action: options.action as CronAction,
-				overlap: options.overlap,
-			});
-			c.log.info({
-				msg: "agent-os cron job scheduled",
-				jobId: job.id,
-				schedule: options.schedule,
-			});
-			return { id: job.id };
-		},
-
-		listCronJobs: async (
-			c: AgentOsActionContext<TConnParams>,
-		): Promise<SerializableCronJobInfo[]> => {
-			const agentOs = await ensureVm(c, config);
-			return agentOs.listCronJobs().map(serializeCronJob);
-		},
-
-		cancelCronJob: async (
-			c: AgentOsActionContext<TConnParams>,
-			id: string,
-		): Promise<void> => {
-			const agentOs = await ensureVm(c, config);
-			agentOs.cancelCronJob(id);
-			c.log.info({ msg: "agent-os cron job cancelled", jobId: id });
-		},
-	};
-}

package/src/agent-os/actor/db.ts

@@ -1,54 +0,0 @@
-import type { RawAccess } from "@/common/database/config";
-
-export async function migrateAgentOsTables(db: RawAccess): Promise<void> {
-	await db.execute(`
-		CREATE TABLE IF NOT EXISTS agent_os_preview_tokens (
-			token TEXT PRIMARY KEY,
-			port INTEGER NOT NULL,
-			created_at INTEGER NOT NULL,
-			expires_at INTEGER NOT NULL
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_preview_tokens_expires_at
-			ON agent_os_preview_tokens(expires_at);
-
-		CREATE TABLE IF NOT EXISTS agent_os_fs_entries (
-			path TEXT PRIMARY KEY,
-			is_directory INTEGER NOT NULL DEFAULT 0,
-			content BLOB,
-			mode INTEGER NOT NULL DEFAULT 33188,
-			uid INTEGER NOT NULL DEFAULT 0,
-			gid INTEGER NOT NULL DEFAULT 0,
-			size INTEGER NOT NULL DEFAULT 0,
-			atime_ms INTEGER NOT NULL,
-			mtime_ms INTEGER NOT NULL,
-			ctime_ms INTEGER NOT NULL,
-			birthtime_ms INTEGER NOT NULL,
-			symlink_target TEXT,
-			nlink INTEGER NOT NULL DEFAULT 1
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_fs_entries_parent
-			ON agent_os_fs_entries(path);
-
-		CREATE TABLE IF NOT EXISTS agent_os_sessions (
-			session_id TEXT PRIMARY KEY,
-			agent_type TEXT NOT NULL,
-			capabilities TEXT NOT NULL,
-			agent_info TEXT,
-			created_at INTEGER NOT NULL
-		);
-
-		CREATE TABLE IF NOT EXISTS agent_os_session_events (
-			id INTEGER PRIMARY KEY AUTOINCREMENT,
-			session_id TEXT NOT NULL,
-			seq INTEGER NOT NULL,
-			event TEXT NOT NULL,
-			created_at INTEGER NOT NULL,
-			FOREIGN KEY (session_id) REFERENCES agent_os_sessions(session_id) ON DELETE CASCADE
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_session_events_session_seq
-			ON agent_os_session_events(session_id, seq);
-	`);
-}

package/src/agent-os/actor/filesystem.ts

@@ -1,131 +0,0 @@
-import type {
-	AgentRegistryEntry,
-	BatchReadResult,
-	BatchWriteEntry,
-	BatchWriteResult,
-	DirEntry,
-	ReaddirRecursiveOptions,
-} from "@rivet-dev/agent-os-core";
-import type { AgentOsActorConfig } from "../config";
-import type { AgentOsActionContext } from "../types";
-import { ensureVm } from "./index";
-
-// Infer types from AgentOs methods since @secure-exec/core is not a direct dep.
-type VirtualStat = Awaited<
-	ReturnType<import("@rivet-dev/agent-os-core").AgentOs["stat"]>
->;
-type DeleteOptions = Parameters<
-	import("@rivet-dev/agent-os-core").AgentOs["delete"]
->[1];
-
-// Build filesystem and agent registry actions for the actor factory.
-export function buildFilesystemActions<TConnParams>(
-	config: AgentOsActorConfig<TConnParams>,
-) {
-	return {
-		readFile: async (
-			c: AgentOsActionContext<TConnParams>,
-			path: string,
-		): Promise<Uint8Array> => {
-			const agentOs = await ensureVm(c, config);
-			return agentOs.readFile(path);
-		},
-
-		writeFile: async (
-			c: AgentOsActionContext<TConnParams>,
-			path: string,
-			content: string | Uint8Array,
-		): Promise<void> => {
-			const agentOs = await ensureVm(c, config);
-			await agentOs.writeFile(path, content);
-		},
-
-		readFiles: async (
-			c: AgentOsActionContext<TConnParams>,
-			paths: string[],
-		): Promise<BatchReadResult[]> => {
-			const agentOs = await ensureVm(c, config);
-			return agentOs.readFiles(paths);
-		},
-
-		writeFiles: async (
-			c: AgentOsActionContext<TConnParams>,
-			entries: BatchWriteEntry[],
-		): Promise<BatchWriteResult[]> => {
-			const agentOs = await ensureVm(c, config);
-			return agentOs.writeFiles(entries);
-		},
-
-		mkdir: async (
-			c: AgentOsActionContext<TConnParams>,
-			path: string,
-			options?: { recursive?: boolean },
-		): Promise<void> => {
-			const agentOs = await ensureVm(c, config);
-			await agentOs.mkdir(path, options);
-		},
-
-		readdir: async (
-			c: AgentOsActionContext<TConnParams>,
-			path: string,
-		): Promise<string[]> => {
-			const agentOs = await ensureVm(c, config);
-			return agentOs.readdir(path);
-		},
-
-		readdirRecursive: async (
-			c: AgentOsActionContext<TConnParams>,
-			path: string,
-			options?: ReaddirRecursiveOptions,
-		): Promise<DirEntry[]> => {
-			const agentOs = await ensureVm(c, config);
-			return agentOs.readdirRecursive(path, options);
-		},
-
-		stat: async (
-			c: AgentOsActionContext<TConnParams>,
-			path: string,
-		): Promise<VirtualStat> => {
-			const agentOs = await ensureVm(c, config);
-			return agentOs.stat(path);
-		},
-
-		exists: async (
-			c: AgentOsActionContext<TConnParams>,
-			path: string,
-		): Promise<boolean> => {
-			const agentOs = await ensureVm(c, config);
-			return agentOs.exists(path);
-		},
-
-		move: async (
-			c: AgentOsActionContext<TConnParams>,
-			from: string,
-			to: string,
-		): Promise<void> => {
-			const agentOs = await ensureVm(c, config);
-			await agentOs.move(from, to);
-		},
-
-		deleteFile: async (
-			c: AgentOsActionContext<TConnParams>,
-			path: string,
-			options?: DeleteOptions,
-		): Promise<void> => {
-			const agentOs = await ensureVm(c, config);
-			await agentOs.delete(path, options);
-		},
-
-		// TODO: mountFs and unmountFs are not exposed as actor actions because
-		// filesystem drivers (VirtualFileSystem) are not serializable over the
-		// network. Mount filesystems via the `options.mounts` config in agentOs()
-		// instead. See: https://github.com/rivet-dev/rivet/issues/XXXX
-
-		listAgents: async (
-			c: AgentOsActionContext<TConnParams>,
-		): Promise<AgentRegistryEntry[]> => {
-			const agentOs = await ensureVm(c, config);
-			return agentOs.listAgents();
-		},
-	};
-}

package/src/agent-os/actor/index.ts

@@ -1,285 +0,0 @@
-import type { AgentOsOptions, MountConfig } from "@rivet-dev/agent-os-core";
-import { AgentOs, createInMemoryFileSystem } from "@rivet-dev/agent-os-core";
-import { type ActorDefinition, actor, event } from "@/actor/mod";
-import type { DatabaseProvider, RawAccess } from "@/common/database/config";
-import { db } from "@/common/database/mod";
-import {
-	type AgentOsActorConfig,
-	type AgentOsActorConfigInput,
-	agentOsActorConfigSchema,
-} from "../config";
-import type {
-	AgentOsActionContext,
-	AgentOsActorState,
-	AgentOsActorVars,
-	CronEventPayload,
-	PermissionRequestPayload,
-	ProcessExitPayload,
-	ProcessOutputPayload,
-	SessionEventPayload,
-	ShellDataPayload,
-	VmBootedPayload,
-	VmShutdownPayload,
-} from "../types";
-import { buildCronActions } from "./cron";
-import { migrateAgentOsTables } from "./db";
-import { buildFilesystemActions } from "./filesystem";
-import { buildNetworkActions } from "./network";
-import { buildOnRequestHandler, buildPreviewActions } from "./preview";
-import { buildProcessActions } from "./process";
-import {
-	buildConfigActions,
-	buildPromptActions,
-	buildSessionActions,
-	buildSessionPersistenceActions,
-} from "./session";
-import { buildShellActions } from "./shell";
-
-// --- VM lifecycle helpers ---
-
-async function ensureVm<TConnParams>(
-	c: AgentOsActionContext<TConnParams>,
-	config: AgentOsActorConfig<TConnParams>,
-): Promise<AgentOs> {
-	if (c.vars.agentOs) {
-		return c.vars.agentOs;
-	}
-
-	const start = Date.now();
-
-	// Build options with in-memory VFS as default working directory mount.
-	const options = buildVmOptions(config.options);
-
-	const agentOs = await AgentOs.create(options);
-	c.vars.agentOs = agentOs;
-
-	// Wire cron events to actor events.
-	agentOs.onCronEvent((cronEvent) => {
-		c.broadcast("cronEvent", { event: cronEvent });
-	});
-
-	c.broadcast("vmBooted", {});
-	c.log.info({
-		msg: "agent-os vm booted",
-		bootDurationMs: Date.now() - start,
-	});
-
-	return agentOs;
-}
-
-function buildVmOptions(userOptions?: AgentOsOptions): AgentOsOptions {
-	const userMounts = userOptions?.mounts ?? [];
-
-	// Check if the user already provided a mount at /home/user. If so, respect
-	// their override and skip the default in-memory VFS mount.
-	const hasWorkdirMount = userMounts.some(
-		(m: MountConfig) => m.path === "/home/user",
-	);
-
-	if (hasWorkdirMount) {
-		return userOptions ?? {};
-	}
-
-	// TODO: Reimplement with persistent backend (SQLite-backed metadata and
-	// actor storage-backed blocks) so VM filesystem state survives sleep/wake.
-	const memMount: MountConfig = {
-		path: "/home/user",
-		driver: createInMemoryFileSystem(),
-	};
-
-	return {
-		...userOptions,
-		mounts: [memMount, ...userMounts],
-	};
-}
-
-// --- Prevent-sleep coordination ---
-
-function syncPreventSleep<TConnParams>(
-	c: AgentOsActionContext<TConnParams>,
-): void {
-	const shouldPrevent =
-		c.vars.activeSessionIds.size > 0 ||
-		c.vars.activeProcesses.size > 0 ||
-		c.vars.activeHooks.size > 0 ||
-		c.vars.activeShells.size > 0;
-
-	c.setPreventSleep(shouldPrevent);
-
-	c.log.info({
-		msg: "agent-os prevent sleep sync",
-		preventSleep: shouldPrevent,
-		activeSessions: c.vars.activeSessionIds.size,
-		activeProcesses: c.vars.activeProcesses.size,
-		activeHooks: c.vars.activeHooks.size,
-		activeShells: c.vars.activeShells.size,
-	});
-}
-
-// --- Hook tracking ---
-
-function runHook<TConnParams>(
-	c: AgentOsActionContext<TConnParams>,
-	name: string,
-	callback: () => void | Promise<void>,
-): void {
-	const promise = Promise.resolve(callback())
-		.catch((error) =>
-			c.log.error({ msg: "agent-os hook failed", hookName: name, error }),
-		)
-		.finally(() => {
-			c.vars.activeHooks.delete(promise);
-			syncPreventSleep(c);
-		});
-	c.vars.activeHooks.add(promise);
-	syncPreventSleep(c);
-	c.waitUntil(promise);
-}
-
-// --- Public API ---
-
-export function agentOs<TConnParams = undefined>(
-	config: AgentOsActorConfigInput<TConnParams>,
-): ActorDefinition<
-	AgentOsActorState,
-	TConnParams,
-	undefined,
-	AgentOsActorVars,
-	undefined,
-	DatabaseProvider<RawAccess>,
-	{
-		sessionEvent: typeof sessionEventToken;
-		permissionRequest: typeof permissionRequestToken;
-		vmBooted: typeof vmBootedToken;
-		vmShutdown: typeof vmShutdownToken;
-		processOutput: typeof processOutputToken;
-		processExit: typeof processExitToken;
-		shellData: typeof shellDataToken;
-		cronEvent: typeof cronEventToken;
-	},
-	Record<never, never>,
-	any
-> {
-	const parsedConfig = agentOsActorConfigSchema.parse(
-		config,
-	) as AgentOsActorConfig<TConnParams>;
-	const actions = {
-		...buildSessionActions(parsedConfig),
-		...buildPromptActions(parsedConfig),
-		...buildConfigActions(parsedConfig),
-		...buildSessionPersistenceActions(parsedConfig),
-		...buildProcessActions(parsedConfig),
-		...buildFilesystemActions(parsedConfig),
-		...buildPreviewActions(parsedConfig),
-		...buildShellActions(parsedConfig),
-		...buildCronActions(parsedConfig),
-		...buildNetworkActions(parsedConfig),
-	};
-
-	return actor<
-		AgentOsActorState,
-		TConnParams,
-		undefined,
-		AgentOsActorVars,
-		undefined,
-		DatabaseProvider<RawAccess>,
-		{
-			sessionEvent: typeof sessionEventToken;
-			permissionRequest: typeof permissionRequestToken;
-			vmBooted: typeof vmBootedToken;
-			vmShutdown: typeof vmShutdownToken;
-			processOutput: typeof processOutputToken;
-			processExit: typeof processExitToken;
-			shellData: typeof shellDataToken;
-			cronEvent: typeof cronEventToken;
-		},
-		Record<never, never>,
-		typeof actions
-	>({
-		options: {
-			sleepGracePeriod: 900_000,
-			actionTimeout: 900_000,
-		},
-		createState: async () => ({}),
-		createVars: () => ({
-			agentOs: null,
-			activeSessionIds: new Set<string>(),
-			activeProcesses: new Set<number>(),
-			activeHooks: new Set<Promise<void>>(),
-			activeShells: new Set<string>(),
-			sessions: new Set(),
-		}),
-		db: db({
-			onMigrate: migrateAgentOsTables,
-		}),
-		events: {
-			sessionEvent: sessionEventToken,
-			permissionRequest: permissionRequestToken,
-			vmBooted: vmBootedToken,
-			vmShutdown: vmShutdownToken,
-			processOutput: processOutputToken,
-			processExit: processExitToken,
-			shellData: shellDataToken,
-			cronEvent: cronEventToken,
-		},
-		onBeforeConnect: parsedConfig.onBeforeConnect
-			? async (ctx, params) => {
-					// Skip user auth for preview URL requests. The signed token
-					// in onRequest is the credential; browsers navigating preview
-					// URLs cannot supply actor connection params.
-					if (ctx.request) {
-						const url = new URL(ctx.request.url);
-						if (url.pathname.startsWith("/fetch/")) {
-							return;
-						}
-					}
-					await parsedConfig.onBeforeConnect?.(ctx, params);
-				}
-			: undefined,
-		onRequest: buildOnRequestHandler(parsedConfig),
-		onSleep: async (c) => {
-			c.log.info({
-				msg: "agent-os vm shutdown for sleep",
-				activeSessions: c.vars.sessions.size,
-				activeProcesses: c.vars.activeProcesses.size,
-				activeShells: c.vars.activeShells.size,
-			});
-
-			if (c.vars.agentOs) {
-				await c.vars.agentOs.dispose();
-				c.vars.agentOs = null;
-			}
-
-			c.broadcast("vmShutdown", { reason: "sleep" as const });
-		},
-		onDestroy: async (c) => {
-			c.log.info({
-				msg: "agent-os vm shutdown for destroy",
-				activeSessions: c.vars.sessions.size,
-				activeProcesses: c.vars.activeProcesses.size,
-				activeShells: c.vars.activeShells.size,
-			});
-
-			if (c.vars.agentOs) {
-				await c.vars.agentOs.dispose();
-				c.vars.agentOs = null;
-			}
-
-			c.broadcast("vmShutdown", { reason: "destroy" as const });
-		},
-		actions,
-	});
-}
-
-// Event type tokens. Declared at module level so they can be referenced in
-// the actor generic type parameters.
-const sessionEventToken = event<SessionEventPayload>();
-const permissionRequestToken = event<PermissionRequestPayload>();
-const vmBootedToken = event<VmBootedPayload>();
-const vmShutdownToken = event<VmShutdownPayload>();
-const processOutputToken = event<ProcessOutputPayload>();
-const processExitToken = event<ProcessExitPayload>();
-const shellDataToken = event<ShellDataPayload>();
-const cronEventToken = event<CronEventPayload>();
-
-export { ensureVm, syncPreventSleep, runHook };

package/src/agent-os/actor/network.ts

@@ -1,58 +0,0 @@
-import type { AgentOsActorConfig } from "../config";
-import type { AgentOsActionContext } from "../types";
-import { ensureVm } from "./index";
-
-// Serializable fetch options for the actor action boundary.
-export interface VmFetchOptions {
-	method?: string;
-	headers?: Record<string, string>;
-	body?: string | Uint8Array;
-}
-
-// Serializable fetch result returned by the actor action.
-export interface VmFetchResult {
-	status: number;
-	statusText: string;
-	headers: Record<string, string>;
-	body: Uint8Array;
-}
-
-// Build network actions for the actor factory.
-export function buildNetworkActions<TConnParams>(
-	config: AgentOsActorConfig<TConnParams>,
-) {
-	return {
-		vmFetch: async (
-			c: AgentOsActionContext<TConnParams>,
-			port: number,
-			url: string,
-			options?: VmFetchOptions,
-		): Promise<VmFetchResult> => {
-			const agentOs = await ensureVm(c, config);
-
-			const headers = new Headers(options?.headers);
-			const request = new Request(url, {
-				method: options?.method ?? "GET",
-				headers,
-				body: options?.body ?? null,
-			});
-
-			const response = await agentOs.fetch(port, request);
-
-			// Serialize response headers to a plain object.
-			const responseHeaders: Record<string, string> = {};
-			response.headers.forEach((value, key) => {
-				responseHeaders[key] = value;
-			});
-
-			const body = new Uint8Array(await response.arrayBuffer());
-
-			return {
-				status: response.status,
-				statusText: response.statusText,
-				headers: responseHeaders,
-				body,
-			};
-		},
-	};
-}