rivetkit 2.0.19 → 2.0.21

package/src/drivers/engine/actor-driver.ts

@@ -1,6 +1,6 @@
 import type {
+	ActorConfig as EngineActorConfig,
 	RunnerConfig as EngineRunnerConfig,
-	ActorConfig as RunnerActorConfig,
 } from "@rivetkit/engine-runner";
 import { Runner } from "@rivetkit/engine-runner";
 import * as cbor from "cbor-x";
@@ -63,8 +63,8 @@ export class EngineActorDriver implements ActorDriver {
 	#version: number = 1; // Version for the runner protocol
 	#alarmTimeout?: LongTimeoutHandle;
 
-	#runnerStarted: PromiseWithResolvers<undefined> = Promise.withResolvers();
-	#runnerStopped: PromiseWithResolvers<undefined> = Promise.withResolvers();
+	#runnerStarted: PromiseWithResolvers<undefined> = promiseWithResolvers();
+	#runnerStopped: PromiseWithResolvers<undefined> = promiseWithResolvers();
 
 	constructor(
 		registryConfig: RegistryConfig,
@@ -153,7 +153,8 @@ export class EngineActorDriver implements ActorDriver {
 	async #loadActorHandler(actorId: string): Promise<ActorHandler> {
 		// Check if actor is already loaded
 		const handler = this.#actors.get(actorId);
-		if (!handler) throw new Error(`Actor handler does not exist ${actorId}`);
+		if (!handler)
+			throw new Error(`Actor handler does not exist ${actorId}`);
 		if (handler.actorStartPromise) await handler.actorStartPromise.promise;
 		if (!handler.actor) throw new Error("Actor should be loaded");
 		return handler;
@@ -220,20 +221,20 @@ export class EngineActorDriver implements ActorDriver {
 	async #runnerOnActorStart(
 		actorId: string,
 		generation: number,
-		runConfig: RunnerActorConfig,
+		actorConfig: EngineActorConfig,
 	): Promise<void> {
 		logger().debug({
 			msg: "runner actor starting",
 			actorId,
-			name: runConfig.name,
-			key: runConfig.key,
+			name: actorConfig.name,
+			key: actorConfig.key,
 			generation,
 		});
 
 		// Deserialize input
 		let input: any;
-		if (runConfig.input) {
-			input = cbor.decode(runConfig.input);
+		if (actorConfig.input) {
+			input = cbor.decode(actorConfig.input);
 		}
 
 		// Get or create handler
@@ -259,12 +260,15 @@ export class EngineActorDriver implements ActorDriver {
 					: serializeEmptyPersistData(input);
 		}
 
-		const name = runConfig.name as string;
-		invariant(runConfig.key, "actor should have a key");
-		const key = deserializeActorKey(runConfig.key);
+		const name = actorConfig.name as string;
+		invariant(actorConfig.key, "actor should have a key");
+		const key = deserializeActorKey(actorConfig.key);
 
 		// Create actor instance
-		const definition = lookupInRegistry(this.#registryConfig, runConfig.name);
+		const definition = lookupInRegistry(
+			this.#registryConfig,
+			actorConfig.name,
+		);
 		handler.actor = definition.instantiate();
 
 		// Start actor
@@ -284,7 +288,10 @@ export class EngineActorDriver implements ActorDriver {
 		logger().debug({ msg: "runner actor started", actorId, name, key });
 	}
 
-	async #runnerOnActorStop(actorId: string, generation: number): Promise<void> {
+	async #runnerOnActorStop(
+		actorId: string,
+		generation: number,
+	): Promise<void> {
 		logger().debug({ msg: "runner actor stopping", actorId, generation });
 
 		const handler = this.#actors.get(actorId);
@@ -296,7 +303,11 @@ export class EngineActorDriver implements ActorDriver {
 		logger().debug({ msg: "runner actor stopped", actorId });
 	}
 
-	async #runnerFetch(actorId: string, request: Request): Promise<Response> {
+	async #runnerFetch(
+		runner: Runner,
+		actorId: string,
+		request: Request,
+	): Promise<Response> {
 		logger().debug({
 			msg: "runner fetch",
 			actorId,
@@ -307,6 +318,7 @@ export class EngineActorDriver implements ActorDriver {
 	}
 
 	async #runnerWebSocket(
+		runner: Runner,
 		actorId: string,
 		websocketRaw: any,
 		request: Request,
@@ -317,10 +329,8 @@ export class EngineActorDriver implements ActorDriver {
 
 		const url = new URL(request.url);
 
-		// Parse configuration from Sec-WebSocket-Protocol header
+		// Parse configuration from Sec-WebSocket-Protocol header (optional for path-based routing)
 		const protocols = request.headers.get("sec-websocket-protocol");
-		if (protocols === null)
-			throw new Error(`Missing sec-websocket-protocol header`);
 
 		let encodingRaw: string | undefined;
 		let connParamsRaw: string | undefined;
@@ -329,7 +339,9 @@ export class EngineActorDriver implements ActorDriver {
 			const protocolList = protocols.split(",").map((p) => p.trim());
 			for (const protocol of protocolList) {
 				if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
-					encodingRaw = protocol.substring(WS_PROTOCOL_ENCODING.length);
+					encodingRaw = protocol.substring(
+						WS_PROTOCOL_ENCODING.length,
+					);
 				} else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
 					connParamsRaw = decodeURIComponent(
 						protocol.substring(WS_PROTOCOL_CONN_PARAMS.length),
@@ -339,7 +351,9 @@ export class EngineActorDriver implements ActorDriver {
 		}
 
 		const encoding = EncodingSchema.parse(encodingRaw);
-		const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : undefined;
+		const connParams = connParamsRaw
+			? JSON.parse(connParamsRaw)
+			: undefined;
 
 		// Fetch WS handler
 		//
@@ -379,7 +393,9 @@ export class EngineActorDriver implements ActorDriver {
 		});
 
 		if (websocket.readyState === 1) {
-			wsHandlerPromise.then((x) => x.onOpen?.(new Event("open"), wsContext));
+			wsHandlerPromise.then((x) =>
+				x.onOpen?.(new Event("open"), wsContext),
+			);
 		} else {
 			websocket.addEventListener("open", (event) => {
 				wsHandlerPromise.then((x) => x.onOpen?.(event, wsContext));
@@ -409,17 +425,22 @@ export class EngineActorDriver implements ActorDriver {
 	}
 
 	async serverlessHandleStart(c: HonoContext): Promise<Response> {
-		await this.#runnerStarted.promise;
-
 		return streamSSE(c, async (stream) => {
-			stream.onAbort(() => this.shutdown(true));
+			// NOTE: onAbort does not work reliably
+			stream.onAbort(() => {});
+			c.req.raw.signal.addEventListener("abort", () => {
+				logger().debug("SSE aborted, shutting down runner");
+				this.shutdown(true);
+			});
+
+			await this.#runnerStarted.promise;
 
 			// Runner id should be set if the runner started
 			const payload = this.#runner.getServerlessInitPacket();
 			invariant(payload, "runnerId not set");
 			await stream.writeSSE({ data: payload });
 
-			return this.#runnerStopped.promise;
+			await this.#runnerStopped.promise;
 		});
 	}
 }

package/src/drivers/engine/config.ts

@@ -8,7 +8,8 @@ export const EngingConfigSchema = z
 		runnerKey: z
 			.string()
 			.default(
-				() => getEnvUniversal("RIVET_RUNNER_KEY") ?? crypto.randomUUID(),
+				() =>
+					getEnvUniversal("RIVET_RUNNER_KEY") ?? crypto.randomUUID(),
 			),
 
 		/** How many actors this runner can run. */

package/src/drivers/file-system/global-state.ts

@@ -120,7 +120,10 @@ export class FileSystemGlobalState {
 			try {
 				this.#cleanupTempFilesSync();
 			} catch (err) {
-				logger().error({ msg: "failed to cleanup temp files", error: err });
+				logger().error({
+					msg: "failed to cleanup temp files",
+					error: err,
+				});
 			}
 		} else {
 			logger().debug({ msg: "memory driver ready" });
@@ -152,7 +155,9 @@ export class FileSystemGlobalState {
 				.sort();
 		}
 
-		const startIndex = params.cursor ? actorIds.indexOf(params.cursor) + 1 : 0;
+		const startIndex = params.cursor
+			? actorIds.indexOf(params.cursor) + 1
+			: 0;
 
 		for (let i = startIndex; i < actorIds.length; i++) {
 			const actorId = actorIds[i];
@@ -164,7 +169,11 @@ export class FileSystemGlobalState {
 				const state = await this.loadActorStateOrError(actorId);
 				yield state;
 			} catch (error) {
-				logger().error({ msg: "failed to load actor state", actorId, error });
+				logger().error({
+					msg: "failed to load actor state",
+					actorId,
+					error,
+				});
 			}
 		}
 	}
@@ -209,7 +218,9 @@ export class FileSystemGlobalState {
 			name,
 			key,
 			createdAt: BigInt(Date.now()),
-			persistedData: bufferToArrayBuffer(serializeEmptyPersistData(input)),
+			persistedData: bufferToArrayBuffer(
+				serializeEmptyPersistData(input),
+			),
 		};
 		await this.writeActor(actorId, entry.state);
 		return entry;
@@ -263,7 +274,9 @@ export class FileSystemGlobalState {
 			}
 
 			// For other errors, throw
-			const error = new Error(`Failed to load actor state: ${innerError}`);
+			const error = new Error(
+				`Failed to load actor state: ${innerError}`,
+			);
 			throw error;
 		}
 	}
@@ -284,7 +297,9 @@ export class FileSystemGlobalState {
 				name,
 				key: key as readonly string[],
 				createdAt: BigInt(Date.now()),
-				persistedData: bufferToArrayBuffer(serializeEmptyPersistData(input)),
+				persistedData: bufferToArrayBuffer(
+					serializeEmptyPersistData(input),
+				),
 			};
 			await this.writeActor(actorId, entry.state);
 		}
@@ -302,7 +317,8 @@ export class FileSystemGlobalState {
 
 		// Wait for actor to fully start before stopping it to avoid race conditions
 		if (actor.loadPromise) await actor.loadPromise.catch();
-		if (actor.startPromise?.promise) await actor.startPromise.promise.catch();
+		if (actor.startPromise?.promise)
+			await actor.startPromise.promise.catch();
 
 		// Mark as removed
 		actor.removed = true;
@@ -344,14 +360,20 @@ export class FileSystemGlobalState {
 					timestamp: BigInt(timestamp),
 				};
 				const data =
-					ACTOR_ALARM_VERSIONED.serializeWithEmbeddedVersion(alarmData);
+					ACTOR_ALARM_VERSIONED.serializeWithEmbeddedVersion(
+						alarmData,
+					);
 				await fs.writeFile(tempPath, data);
 				await fs.rename(tempPath, alarmPath);
 			} catch (error) {
 				try {
 					await fs.unlink(tempPath);
 				} catch {}
-				logger().error({ msg: "failed to write alarm", actorId, error });
+				logger().error({
+					msg: "failed to write alarm",
+					actorId,
+					error,
+				});
 				throw new Error(`Failed to write alarm: ${error}`);
 			}
 		}
@@ -396,7 +418,11 @@ export class FileSystemGlobalState {
 			} catch {
 				// Ignore cleanup errors
 			}
-			logger().error({ msg: "failed to save actor state", actorId, error });
+			logger().error({
+				msg: "failed to save actor state",
+				actorId,
+				error,
+			});
 			throw new Error(`Failed to save actor state: ${error}`);
 		}
 	}
@@ -430,7 +456,10 @@ export class FileSystemGlobalState {
 		try {
 			this.#loadAlarmsSync();
 		} catch (err) {
-			logger().error({ msg: "failed to load alarms on startup", error: err });
+			logger().error({
+				msg: "failed to load alarms on startup",
+				error: err,
+			});
 		}
 	}
 
@@ -466,7 +495,10 @@ export class FileSystemGlobalState {
 
 		try {
 			// Create actor
-			const definition = lookupInRegistry(registryConfig, entry.state.name);
+			const definition = lookupInRegistry(
+				registryConfig,
+				entry.state.name,
+			);
 			entry.actor = definition.instantiate();
 
 			// Start actor
@@ -531,9 +563,15 @@ export class FileSystemGlobalState {
 						);
 					const timestamp = Number(alarmData.timestamp);
 					if (Number.isFinite(timestamp)) {
-						this.#scheduleAlarmTimeout(alarmData.actorId, timestamp);
+						this.#scheduleAlarmTimeout(
+							alarmData.actorId,
+							timestamp,
+						);
 					} else {
-						logger().debug({ msg: "invalid alarm file contents", file });
+						logger().debug({
+							msg: "invalid alarm file contents",
+							file,
+						});
 					}
 				} catch (err) {
 					logger().error({
@@ -544,7 +582,10 @@ export class FileSystemGlobalState {
 				}
 			}
 		} catch (err) {
-			logger().error({ msg: "failed to list alarms directory", error: err });
+			logger().error({
+				msg: "failed to list alarms directory",
+				error: err,
+			});
 		}
 	}
 
@@ -598,7 +639,8 @@ export class FileSystemGlobalState {
 
 				// Ensure actor state exists and start actor if needed
 				const loaded = await this.loadActor(actorId);
-				if (!loaded.state) throw new Error(`Actor does not exist: ${actorId}`);
+				if (!loaded.state)
+					throw new Error(`Actor does not exist: ${actorId}`);
 
 				// Start actor if not already running
 				const runnerParams = this.#runnerParams;

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

@@ -65,7 +65,9 @@ export class FileSystemManagerDriver implements ManagerDriver {
 					name: actorState.name,
 					key: actorState.key as string[],
 					startedAt: startedAt,
-					createdAt: new Date(Number(actorState.createdAt)).toISOString(),
+					createdAt: new Date(
+						Number(actorState.createdAt),
+					).toISOString(),
 					features: [
 						ActorFeature.State,
 						ActorFeature.Connections,
@@ -92,21 +94,27 @@ export class FileSystemManagerDriver implements ManagerDriver {
 					},
 					getActorById: async (id) => {
 						try {
-							const result = await this.#state.loadActorStateOrError(id);
+							const result =
+								await this.#state.loadActorStateOrError(id);
 							return transformActor(result);
 						} catch {
 							return null;
 						}
 					},
 					getBuilds: async () => {
-						return Object.keys(this.#registryConfig.use).map((name) => ({
-							name,
-						}));
+						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);
+							const result =
+								await this.#state.loadActorStateOrError(
+									actorId,
+								);
 							return transformActor(result);
 						} catch {
 							return null;
@@ -134,7 +142,10 @@ export class FileSystemManagerDriver implements ManagerDriver {
 		);
 	}
 
-	async sendRequest(actorId: string, actorRequest: Request): Promise<Response> {
+	async sendRequest(
+		actorId: string,
+		actorRequest: Request,
+	): Promise<Response> {
 		return await this.#actorRouter.fetch(actorRequest, {
 			actorId,
 		});
@@ -150,7 +161,9 @@ export class FileSystemManagerDriver implements ManagerDriver {
 	): Promise<UniversalWebSocket> {
 		// Handle raw WebSocket paths
 		const pathOnly = path.split("?")[0];
-		const normalizedPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
+		const normalizedPath = pathOnly.startsWith("/")
+			? pathOnly
+			: `/${pathOnly}`;
 		if (normalizedPath === PATH_CONNECT_WEBSOCKET) {
 			// Handle standard connect
 			const wsHandler = await handleWebSocketConnect(
@@ -206,7 +219,9 @@ export class FileSystemManagerDriver implements ManagerDriver {
 
 		// Handle raw WebSocket paths
 		const pathOnly = path.split("?")[0];
-		const normalizedPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
+		const normalizedPath = pathOnly.startsWith("/")
+			? pathOnly
+			: `/${pathOnly}`;
 		if (normalizedPath === PATH_CONNECT_WEBSOCKET) {
 			// Handle standard connect
 			const wsHandler = await handleWebSocketConnect(
@@ -238,7 +253,9 @@ export class FileSystemManagerDriver implements ManagerDriver {
 		}
 	}
 
-	async getForId({ actorId }: GetForIdInput): Promise<ActorOutput | undefined> {
+	async getForId({
+		actorId,
+	}: GetForIdInput): Promise<ActorOutput | undefined> {
 		// Validate the actor exists
 		const actor = await this.#state.loadActor(actorId);
 		if (!actor.state) {
@@ -253,7 +270,11 @@ export class FileSystemManagerDriver implements ManagerDriver {
 				key: actor.state.key as string[],
 			};
 		} catch (error) {
-			logger().error({ msg: "failed to read actor state", actorId, error });
+			logger().error({
+				msg: "failed to read actor state",
+				actorId,
+				error,
+			});
 			return undefined;
 		}
 	}
@@ -317,7 +338,9 @@ export class FileSystemManagerDriver implements ManagerDriver {
 		return {
 			name: this.#state.persist ? "File System" : "Memory",
 			properties: {
-				...(this.#state.persist ? { Data: this.#state.storagePath } : {}),
+				...(this.#state.persist
+					? { Data: this.#state.storagePath }
+					: {}),
 				Instances: this.#state.actorCountOnStartup.toString(),
 			},
 		};

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

@@ -31,7 +31,12 @@ export function createFileSystemOrMemoryDriver(
 				state,
 			);
 
-			state.onRunnerStart(registryConfig, runConfig, inlineClient, actorDriver);
+			state.onRunnerStart(
+				registryConfig,
+				runConfig,
+				inlineClient,
+				actorDriver,
+			);
 
 			return actorDriver;
 		},

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

@@ -99,10 +99,16 @@ function getDataPath(appName: string): string {
 				appName,
 			);
 		case "darwin":
-			return path.join(homeDir, "Library", "Application Support", appName);
+			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"),
+				process.env.XDG_DATA_HOME ||
+					path.join(homeDir, ".local", "share"),
 				appName,
 			);
 	}

package/src/engine-process/mod.ts

@@ -23,7 +23,10 @@ interface EnsureEngineProcessOptions {
 export async function ensureEngineProcess(
 	options: EnsureEngineProcessOptions,
 ): Promise<void> {
-	logger().debug({ msg: "ensuring engine process", version: options.version });
+	logger().debug({
+		msg: "ensuring engine process",
+		version: options.version,
+	});
 	const storageRoot = getStoragePath();
 	const binDir = path.join(storageRoot, "bin");
 	const varDir = path.join(storageRoot, "var");
@@ -256,12 +259,18 @@ export function resolveTargetTripletFor(
 			break;
 		case "linux":
 			if (arch === "x64") {
-				return { targetTriplet: "x86_64-unknown-linux-musl", extension: "" };
+				return {
+					targetTriplet: "x86_64-unknown-linux-musl",
+					extension: "",
+				};
 			}
 			break;
 		case "win32":
 			if (arch === "x64") {
-				return { targetTriplet: "x86_64-pc-windows-gnu", extension: ".exe" };
+				return {
+					targetTriplet: "x86_64-pc-windows-gnu",
+					extension: ".exe",
+				};
 			}
 			break;
 	}
@@ -359,7 +368,9 @@ async function waitForEngineHealth(): Promise<void> {
 				attempt: i + 1,
 				maxRetries,
 			});
-			await new Promise((resolve) => setTimeout(resolve, HEALTH_INTERVAL));
+			await new Promise((resolve) =>
+				setTimeout(resolve, HEALTH_INTERVAL),
+			);
 		}
 	}