rivetkit 2.0.2 → 2.0.3

package/src/drivers/file-system/manager.ts

@@ -0,0 +1,306 @@
+import type { Context as HonoContext } from "hono";
+import invariant from "invariant";
+import { type ActorRouter, createActorRouter } from "@/actor/router";
+import {
+	handleRawWebSocketHandler,
+	handleWebSocketConnect,
+} from "@/actor/router-endpoints";
+import { createClientWithDriver } from "@/client/client";
+import { InlineWebSocketAdapter2 } from "@/common/inline-websocket-adapter2";
+import { noopNext } from "@/common/utils";
+import type {
+	ActorDriver,
+	ActorOutput,
+	CreateInput,
+	GetForIdInput,
+	GetOrCreateWithKeyInput,
+	GetWithKeyInput,
+	ManagerDriver,
+} from "@/driver-helpers/mod";
+import { createInlineClientDriver } from "@/inline-client-driver/mod";
+import { ManagerInspector } from "@/inspector/manager";
+import { type Actor, ActorFeature, type ActorId } from "@/inspector/mod";
+import {
+	type DriverConfig,
+	type Encoding,
+	PATH_CONNECT_WEBSOCKET,
+	PATH_RAW_WEBSOCKET_PREFIX,
+	type RegistryConfig,
+	type RunConfig,
+} from "@/mod";
+import type * as schema from "@/schemas/file-system-driver/mod";
+import type { FileSystemGlobalState } from "./global-state";
+import { logger } from "./log";
+import { generateActorId } from "./utils";
+
+export class FileSystemManagerDriver implements ManagerDriver {
+	#registryConfig: RegistryConfig;
+	#runConfig: RunConfig;
+	#state: FileSystemGlobalState;
+	#driverConfig: DriverConfig;
+
+	#actorDriver: ActorDriver;
+	#actorRouter: ActorRouter;
+
+	inspector?: ManagerInspector;
+
+	constructor(
+		registryConfig: RegistryConfig,
+		runConfig: RunConfig,
+		state: FileSystemGlobalState,
+		driverConfig: DriverConfig,
+	) {
+		this.#registryConfig = registryConfig;
+		this.#runConfig = runConfig;
+		this.#state = state;
+		this.#driverConfig = driverConfig;
+
+		if (runConfig.inspector.enabled) {
+			if (!this.#runConfig.inspector.token()) {
+				this.#runConfig.inspector.token = () =>
+					this.#state.getOrCreateInspectorAccessToken();
+			}
+			const startedAt = new Date().toISOString();
+			function transformActor(actorState: schema.ActorState): Actor {
+				return {
+					id: actorState.actorId as ActorId,
+					name: actorState.name,
+					key: actorState.key as string[],
+					startedAt: startedAt,
+					createdAt: new Date(Number(actorState.createdAt)).toISOString(),
+					features: [
+						ActorFeature.State,
+						ActorFeature.Connections,
+						ActorFeature.Console,
+						ActorFeature.EventsMonitoring,
+						ActorFeature.Database,
+					],
+				};
+			}
+
+			this.inspector = new ManagerInspector(() => {
+				return {
+					getAllActors: async ({ cursor, limit }) => {
+						const itr = this.#state.getActorsIterator({ cursor });
+						const actors: Actor[] = [];
+
+						for await (const actor of itr) {
+							actors.push(transformActor(actor));
+							if (limit && actors.length >= limit) {
+								break;
+							}
+						}
+						return actors;
+					},
+					getActorById: async (id) => {
+						try {
+							const result = await this.#state.loadActorStateOrError(id);
+							return transformActor(result);
+						} catch {
+							return null;
+						}
+					},
+					getBuilds: async () => {
+						return Object.keys(this.#registryConfig.use).map((name) => ({
+							name,
+						}));
+					},
+					createActor: async (input) => {
+						const { actorId } = await this.createActor(input);
+						try {
+							const result = await this.#state.loadActorStateOrError(actorId);
+							return transformActor(result);
+						} catch {
+							return null;
+						}
+					},
+				};
+			});
+		}
+
+		// Actors run on the same node as the manager, so we create a dummy actor router that we route requests to
+		const inlineClient = createClientWithDriver(createInlineClientDriver(this));
+		this.#actorDriver = this.#driverConfig.actor(
+			registryConfig,
+			runConfig,
+			this,
+			inlineClient,
+		);
+		this.#actorRouter = createActorRouter(this.#runConfig, this.#actorDriver);
+	}
+
+	async sendRequest(actorId: string, actorRequest: Request): Promise<Response> {
+		return await this.#actorRouter.fetch(actorRequest, {
+			actorId,
+		});
+	}
+
+	async openWebSocket(
+		path: string,
+		actorId: string,
+		encoding: Encoding,
+		params: unknown,
+	): Promise<WebSocket> {
+		// TODO:
+
+		// Handle raw WebSocket paths
+		if (path === PATH_CONNECT_WEBSOCKET) {
+			// Handle standard connect
+			const wsHandler = await handleWebSocketConnect(
+				undefined,
+				this.#runConfig,
+				this.#actorDriver,
+				actorId,
+				encoding,
+				params,
+				undefined,
+			);
+			return new InlineWebSocketAdapter2(wsHandler);
+		} else if (path.startsWith(PATH_RAW_WEBSOCKET_PREFIX)) {
+			// Handle websocket proxy
+			const wsHandler = await handleRawWebSocketHandler(
+				undefined,
+				path,
+				this.#actorDriver,
+				actorId,
+				undefined,
+			);
+			return new InlineWebSocketAdapter2(wsHandler);
+		} else {
+			throw new Error(`Unreachable path: ${path}`);
+		}
+	}
+
+	async proxyRequest(
+		c: HonoContext,
+		actorRequest: Request,
+		actorId: string,
+	): Promise<Response> {
+		return await this.#actorRouter.fetch(actorRequest, {
+			actorId,
+		});
+	}
+
+	async proxyWebSocket(
+		c: HonoContext,
+		path: string,
+		actorId: string,
+		encoding: Encoding,
+		connParams: unknown,
+		authData: unknown,
+	): Promise<Response> {
+		const upgradeWebSocket = this.#runConfig.getUpgradeWebSocket?.();
+		invariant(upgradeWebSocket, "missing getUpgradeWebSocket");
+
+		// Handle raw WebSocket paths
+		if (path === PATH_CONNECT_WEBSOCKET) {
+			// Handle standard connect
+			const wsHandler = await handleWebSocketConnect(
+				c.req.raw,
+				this.#runConfig,
+				this.#actorDriver,
+				actorId,
+				encoding,
+				connParams,
+				authData,
+			);
+
+			return upgradeWebSocket(() => wsHandler)(c, noopNext());
+		} else if (path.startsWith(PATH_RAW_WEBSOCKET_PREFIX)) {
+			// Handle websocket proxy
+			const wsHandler = await handleRawWebSocketHandler(
+				c.req.raw,
+				path,
+				this.#actorDriver,
+				actorId,
+				authData,
+			);
+
+			return upgradeWebSocket(() => wsHandler)(c, noopNext());
+		} else {
+			throw new Error(`Unreachable path: ${path}`);
+		}
+	}
+
+	async getForId({ actorId }: GetForIdInput): Promise<ActorOutput | undefined> {
+		// Validate the actor exists
+		const actor = await this.#state.loadActor(actorId);
+		if (!actor.state) {
+			return undefined;
+		}
+
+		try {
+			// Load actor state
+			return {
+				actorId,
+				name: actor.state.name,
+				key: actor.state.key as string[],
+			};
+		} catch (error) {
+			logger().error("failed to read actor state", { actorId, error });
+			return undefined;
+		}
+	}
+
+	async getWithKey({
+		name,
+		key,
+	}: GetWithKeyInput): Promise<ActorOutput | undefined> {
+		// Generate the deterministic actor ID
+		const actorId = generateActorId(name, key);
+
+		// Check if actor exists
+		const actor = await this.#state.loadActor(actorId);
+		if (actor.state) {
+			return {
+				actorId,
+				name,
+				key,
+			};
+		}
+
+		return undefined;
+	}
+
+	async getOrCreateWithKey(
+		input: GetOrCreateWithKeyInput,
+	): Promise<ActorOutput> {
+		// Generate the deterministic actor ID
+		const actorId = generateActorId(input.name, input.key);
+
+		// Use the atomic getOrCreateActor method
+		const actorEntry = await this.#state.loadOrCreateActor(
+			actorId,
+			input.name,
+			input.key,
+			input.input,
+		);
+		invariant(actorEntry.state, "must have state");
+
+		return {
+			actorId: actorEntry.state.actorId,
+			name: actorEntry.state.name,
+			key: actorEntry.state.key as string[],
+		};
+	}
+
+	async createActor({ name, key, input }: CreateInput): Promise<ActorOutput> {
+		// Generate the deterministic actor ID
+		const actorId = generateActorId(name, key);
+
+		await this.#state.createActor(actorId, name, key, input);
+
+		return {
+			actorId,
+			name,
+			key,
+		};
+	}
+
+	extraStartupLog() {
+		return {
+			instances: this.#state.actorCountOnStartup,
+			data: this.#state.storagePath,
+		};
+	}
+}

package/src/drivers/file-system/mod.ts

@@ -0,0 +1,48 @@
+import type { DriverConfig } from "@/registry/run-config";
+import { FileSystemActorDriver } from "./actor";
+import { FileSystemGlobalState } from "./global-state";
+import { FileSystemManagerDriver } from "./manager";
+
+export { FileSystemActorDriver } from "./actor";
+export { FileSystemGlobalState } from "./global-state";
+export { FileSystemManagerDriver } from "./manager";
+export { getStoragePath } from "./utils";
+
+export function createFileSystemOrMemoryDriver(
+	persist: boolean = true,
+	customPath?: string,
+): DriverConfig {
+	const state = new FileSystemGlobalState(persist, customPath);
+	const driverConfig: DriverConfig = {
+		name: persist ? "file-system" : "memory",
+		manager: (registryConfig, runConfig) =>
+			new FileSystemManagerDriver(
+				registryConfig,
+				runConfig,
+				state,
+				driverConfig,
+			),
+		actor: (registryConfig, runConfig, managerDriver, inlineClient) => {
+			const actorDriver = new FileSystemActorDriver(
+				registryConfig,
+				runConfig,
+				managerDriver,
+				inlineClient,
+				state,
+			);
+
+			state.onRunnerStart(registryConfig, runConfig, inlineClient, actorDriver);
+
+			return actorDriver;
+		},
+	};
+	return driverConfig;
+}
+
+export function createFileSystemDriver(opts?: { path?: string }): DriverConfig {
+	return createFileSystemOrMemoryDriver(true, opts?.path);
+}
+
+export function createMemoryDriver(): DriverConfig {
+	return createFileSystemOrMemoryDriver(false);
+}

package/src/drivers/file-system/utils.ts

@@ -0,0 +1,109 @@
+import * as crypto from "node:crypto";
+import * as fsSync from "node:fs";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { ActorKey } from "@/actor/mod";
+
+/**
+ * Generate a deterministic actor ID from name and key
+ */
+export function generateActorId(name: string, key: ActorKey): string {
+	// Generate deterministic key string
+	const jsonString = JSON.stringify([name, key]);
+
+	// Hash to ensure safe file system names
+	const hash = crypto
+		.createHash("sha256")
+		.update(jsonString)
+		.digest("hex")
+		.substring(0, 16);
+
+	return hash;
+}
+
+/**
+ * Create a hash for a path, normalizing it first
+ */
+function createHashForPath(dirPath: string): string {
+	// Normalize the path first
+	const normalizedPath = path.normalize(dirPath);
+
+	// Extract the last path component for readability
+	const lastComponent = path.basename(normalizedPath);
+
+	// Create SHA-256 hash
+	const hash = crypto
+		.createHash("sha256")
+		.update(normalizedPath)
+		.digest("hex")
+		.substring(0, 8); // Take first 8 characters for brevity
+
+	return `${lastComponent}-${hash}`;
+}
+
+/**
+ * Get the storage path for the current working directory or a specified path
+ */
+export function getStoragePath(customPath?: string): string {
+	const dataPath = getDataPath("rivetkit");
+	const pathToHash = customPath || process.cwd();
+	const dirHash = createHashForPath(pathToHash);
+	return path.join(dataPath, dirHash);
+}
+
+/**
+ * Check if a path exists
+ */
+export async function pathExists(path: string): Promise<boolean> {
+	try {
+		await fs.access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Ensure a directory exists, creating it if necessary
+ */
+export async function ensureDirectoryExists(
+	directoryPath: string,
+): Promise<void> {
+	if (!(await pathExists(directoryPath))) {
+		await fs.mkdir(directoryPath, { recursive: true });
+	}
+}
+
+/**
+ * Ensure a directory exists synchronously - only used during initialization
+ * All other operations use the async version
+ */
+export function ensureDirectoryExistsSync(directoryPath: string): void {
+	if (!fsSync.existsSync(directoryPath)) {
+		fsSync.mkdirSync(directoryPath, { recursive: true });
+	}
+}
+
+/**
+ * Returns platform-specific data directory
+ */
+function getDataPath(appName: string): string {
+	const platform = process.platform;
+	const homeDir = os.homedir();
+
+	switch (platform) {
+		case "win32":
+			return path.join(
+				process.env.APPDATA || path.join(homeDir, "AppData", "Roaming"),
+				appName,
+			);
+		case "darwin":
+			return path.join(homeDir, "Library", "Application Support", appName);
+		default: // linux and others
+			return path.join(
+				process.env.XDG_DATA_HOME || path.join(homeDir, ".local", "share"),
+				appName,
+			);
+	}
+}

package/src/globals.d.ts

@@ -0,0 +1,6 @@
+declare global {
+	const Deno: any;
+	const navigator: any;
+}
+
+export {};

package/src/inline-client-driver/log.ts

@@ -0,0 +1,7 @@
+import { getLogger } from "@/common//log";
+
+export const LOGGER_NAME = "inline-client-driver";
+
+export function logger() {
+	return getLogger(LOGGER_NAME);
+}