rivetkit 2.0.5 → 2.0.7-rc.1

package/src/actor/generic-conn-driver.ts

@@ -1,246 +0,0 @@
-import type { SSEStreamingApi } from "hono/streaming";
-import type { WSContext } from "hono/ws";
-import type { WebSocket } from "ws";
-import {
-	type AnyConn,
-	CONNECTION_DRIVER_HTTP,
-	CONNECTION_DRIVER_SSE,
-	CONNECTION_DRIVER_WEBSOCKET,
-} from "@/actor/connection";
-import {
-	type ConnDriver,
-	type ConnectionDriversMap,
-	ConnectionReadyState,
-} from "@/actor/driver";
-import type { AnyActorInstance } from "@/actor/instance";
-import type { CachedSerializer, Encoding } from "@/actor/protocol/serde";
-import { encodeDataToString } from "@/actor/protocol/serde";
-import type * as protocol from "@/schemas/client-protocol/mod";
-import { loggerWithoutContext } from "./log";
-
-// This state is different than `PersistedConn` state since the connection-specific state is persisted & must be serializable. This is also part of the connection driver, not part of the core actor.
-//
-// This holds the actual connections, which are not serializable.
-//
-// This is scoped to each actor. Do not share between multiple actors.
-export class GenericConnGlobalState {
-	websockets = new Map<string, WSContext>();
-	sseStreams = new Map<string, SSEStreamingApi>();
-}
-
-/**
- * Exposes connection drivers for platforms that support vanilla WebSocket, SSE, and HTTP.
- */
-export function createGenericConnDrivers(
-	globalState: GenericConnGlobalState,
-): ConnectionDriversMap {
-	return {
-		[CONNECTION_DRIVER_WEBSOCKET]: createGenericWebSocketDriver(globalState),
-		[CONNECTION_DRIVER_SSE]: createGenericSseDriver(globalState),
-		[CONNECTION_DRIVER_HTTP]: createGenericHttpDriver(),
-	};
-}
-
-// MARK: WebSocket
-export interface GenericWebSocketDriverState {
-	encoding: Encoding;
-}
-
-export function createGenericWebSocketDriver(
-	globalState: GenericConnGlobalState,
-): ConnDriver<GenericWebSocketDriverState> {
-	return {
-		sendMessage: (
-			actor: AnyActorInstance,
-			conn: AnyConn,
-			state: GenericWebSocketDriverState,
-			message: CachedSerializer<protocol.ToClient>,
-		) => {
-			const ws = globalState.websockets.get(conn.id);
-			if (!ws) {
-				actor.rLog.warn({
-					msg: "missing ws for sendMessage",
-					actorId: actor.id,
-					connId: conn.id,
-					totalCount: globalState.websockets.size,
-				});
-				return;
-			}
-
-			const serialized = message.serialize(state.encoding);
-
-			actor.rLog.debug({
-				msg: "sending websocket message",
-				encoding: state.encoding,
-				dataType: typeof serialized,
-				isUint8Array: serialized instanceof Uint8Array,
-				isArrayBuffer: serialized instanceof ArrayBuffer,
-				dataLength:
-					(serialized as any).byteLength || (serialized as any).length,
-			});
-
-			// Convert Uint8Array to ArrayBuffer for proper transmission
-			if (serialized instanceof Uint8Array) {
-				const buffer = serialized.buffer.slice(
-					serialized.byteOffset,
-					serialized.byteOffset + serialized.byteLength,
-				);
-				// Handle SharedArrayBuffer case
-				if (buffer instanceof SharedArrayBuffer) {
-					const arrayBuffer = new ArrayBuffer(buffer.byteLength);
-					new Uint8Array(arrayBuffer).set(new Uint8Array(buffer));
-					actor.rLog.debug({
-						msg: "converted SharedArrayBuffer to ArrayBuffer",
-						byteLength: arrayBuffer.byteLength,
-					});
-					ws.send(arrayBuffer);
-				} else {
-					actor.rLog.debug({
-						msg: "sending ArrayBuffer",
-						byteLength: buffer.byteLength,
-					});
-					ws.send(buffer);
-				}
-			} else {
-				actor.rLog.debug({
-					msg: "sending string data",
-					length: (serialized as string).length,
-				});
-				ws.send(serialized);
-			}
-		},
-
-		disconnect: async (
-			actor: AnyActorInstance,
-			conn: AnyConn,
-			_state: GenericWebSocketDriverState,
-			reason?: string,
-		) => {
-			const ws = globalState.websockets.get(conn.id);
-			if (!ws) {
-				actor.rLog.warn({
-					msg: "missing ws for disconnect",
-					actorId: actor.id,
-					connId: conn.id,
-					totalCount: globalState.websockets.size,
-				});
-				return;
-			}
-			const raw = ws.raw as WebSocket;
-			if (!raw) {
-				actor.rLog.warn({ msg: "ws.raw does not exist" });
-				return;
-			}
-
-			// Create promise to wait for socket to close gracefully
-			const { promise, resolve } = Promise.withResolvers<void>();
-			raw.addEventListener("close", () => resolve());
-
-			// Close socket
-			ws.close(1000, reason);
-
-			await promise;
-		},
-
-		getConnectionReadyState: (
-			actor: AnyActorInstance,
-			conn: AnyConn,
-		): ConnectionReadyState | undefined => {
-			const ws = globalState.websockets.get(conn.id);
-			if (!ws) {
-				actor.rLog.warn({
-					msg: "missing ws for getConnectionReadyState",
-					connId: conn.id,
-				});
-				return undefined;
-			}
-
-			const raw = ws.raw as WebSocket;
-
-			return raw.readyState as ConnectionReadyState;
-		},
-	};
-}
-
-// MARK: SSE
-export interface GenericSseDriverState {
-	encoding: Encoding;
-}
-
-export function createGenericSseDriver(
-	globalState: GenericConnGlobalState,
-): ConnDriver<GenericSseDriverState> {
-	return {
-		sendMessage: (
-			actor: AnyActorInstance,
-			conn: AnyConn,
-			state: GenericSseDriverState,
-			message: CachedSerializer<protocol.ToClient>,
-		) => {
-			const stream = globalState.sseStreams.get(conn.id);
-			if (!stream) {
-				actor.rLog.warn({
-					msg: "missing sse stream for sendMessage",
-					connId: conn.id,
-				});
-				return;
-			}
-			stream.writeSSE({
-				data: encodeDataToString(message.serialize(state.encoding)),
-			});
-		},
-
-		disconnect: async (
-			actor: AnyActorInstance,
-			conn: AnyConn,
-			_state: GenericSseDriverState,
-			_reason?: string,
-		) => {
-			const stream = globalState.sseStreams.get(conn.id);
-			if (!stream) {
-				actor.rLog.warn({
-					msg: "missing sse stream for disconnect",
-					connId: conn.id,
-				});
-				return;
-			}
-
-			stream.close();
-		},
-
-		getConnectionReadyState: (
-			actor: AnyActorInstance,
-			conn: AnyConn,
-		): ConnectionReadyState | undefined => {
-			const stream = globalState.sseStreams.get(conn.id);
-			if (!stream) {
-				actor.rLog.warn({
-					msg: "missing sse stream for getConnectionReadyState",
-					connId: conn.id,
-				});
-				return undefined;
-			}
-
-			if (stream.aborted || stream.closed) {
-				return ConnectionReadyState.CLOSED;
-			}
-
-			return ConnectionReadyState.OPEN;
-		},
-	};
-}
-
-// MARK: HTTP
-export type GenericHttpDriverState = Record<never, never>;
-
-export function createGenericHttpDriver(): ConnDriver<GenericHttpDriverState> {
-	return {
-		getConnectionReadyState(_actor, _conn) {
-			// TODO: This might not be the correct logic
-			return ConnectionReadyState.OPEN;
-		},
-		disconnect: async () => {
-			// Noop
-		},
-	};
-}

package/src/common/fake-event-source.ts

@@ -1,267 +0,0 @@
-import type { EventListener } from "eventsource";
-import type { SSEStreamingApi } from "hono/streaming";
-import { getLogger } from "@/common//log";
-import type {
-	UniversalEvent,
-	UniversalEventSource,
-	UniversalMessageEvent,
-} from "@/common/eventsource-interface";
-
-export function logger() {
-	return getLogger("fake-event-source");
-}
-
-/**
- * FakeEventSource provides a minimal implementation of an SSE stream
- * that handles events for the inline client driver
- */
-export class FakeEventSource implements UniversalEventSource {
-	// EventSource readyState values
-	readonly CONNECTING = 0 as const;
-	readonly OPEN = 1 as const;
-	readonly CLOSED = 2 as const;
-
-	url = "http://internal-sse-endpoint";
-	readyState: 0 | 1 | 2 = 1; // OPEN
-	withCredentials = false;
-
-	// Event handlers
-	onopen: ((event: UniversalEvent) => void) | null = null;
-	onmessage: ((event: UniversalMessageEvent) => void) | null = null;
-	onerror: ((event: UniversalEvent) => void) | null = null;
-
-	// Private event listeners
-	#listeners: Record<string, Set<EventListener>> = {
-		open: new Set(),
-		message: new Set(),
-		error: new Set(),
-		close: new Set(),
-	};
-
-	// Stream that will be passed to the handler
-	#stream: SSEStreamingApi;
-	#onCloseCallback: () => Promise<void>;
-
-	/**
-	 * Creates a new FakeEventSource
-	 */
-	constructor(onCloseCallback: () => Promise<void>) {
-		this.#onCloseCallback = onCloseCallback;
-
-		this.#stream = this.#createStreamApi();
-
-		// Trigger open event on next tick
-		setTimeout(() => {
-			if (this.readyState === 1) {
-				this.#dispatchEvent("open");
-			}
-		}, 0);
-
-		logger().debug("FakeEventSource created");
-	}
-
-	// Creates the SSE streaming API implementation
-	#createStreamApi(): SSEStreamingApi {
-		// Create self-reference for closures
-		const self = this;
-
-		const streamApi: SSEStreamingApi = {
-			write: async (input) => {
-				const data =
-					typeof input === "string" ? input : new TextDecoder().decode(input);
-				self.#dispatchEvent("message", { data });
-				return streamApi;
-			},
-
-			writeln: async (input: string) => {
-				await streamApi.write(input + "\n");
-				return streamApi;
-			},
-
-			writeSSE: async (message: {
-				data: string | Promise<string>;
-				event?: string;
-				id?: string;
-				retry?: number;
-			}): Promise<void> => {
-				const data = await message.data;
-
-				if (message.event) {
-					self.#dispatchEvent(message.event, { data });
-				} else {
-					self.#dispatchEvent("message", { data });
-				}
-			},
-
-			sleep: async (ms: number) => {
-				await new Promise((resolve) => setTimeout(resolve, ms));
-				return streamApi;
-			},
-
-			close: async () => {
-				self.close();
-			},
-
-			pipe: async (_body: ReadableStream) => {
-				// No-op implementation
-			},
-
-			onAbort: async (cb: () => void) => {
-				self.addEventListener("error", () => {
-					cb();
-				});
-				return streamApi;
-			},
-
-			abort: async () => {
-				self.#dispatchEvent("error");
-				return streamApi;
-			},
-
-			// Additional required properties
-			get responseReadable() {
-				return null as unknown as ReadableStream;
-			},
-
-			get aborted() {
-				return self.readyState === 2; // CLOSED
-			},
-
-			get closed() {
-				return self.readyState === 2; // CLOSED
-			},
-		};
-
-		return streamApi;
-	}
-
-	/**
-	 * Closes the connection
-	 */
-	close(): void {
-		if (this.readyState === 2) {
-			// CLOSED
-			return;
-		}
-
-		logger().debug({ msg: "closing FakeEventSource" });
-		this.readyState = 2; // CLOSED
-
-		// Call the close callback
-		this.#onCloseCallback().catch((err) => {
-			logger().error({ msg: "error in onClose callback", error: err });
-		});
-
-		// Dispatch close event
-		this.#dispatchEvent("close");
-	}
-
-	/**
-	 * Get the stream API to pass to the handler
-	 */
-	getStream(): SSEStreamingApi {
-		return this.#stream;
-	}
-
-	// Implementation of EventTarget-like interface
-	addEventListener(type: string, listener: EventListener): void {
-		if (!this.#listeners[type]) {
-			this.#listeners[type] = new Set();
-		}
-		this.#listeners[type].add(listener);
-	}
-
-	removeEventListener(type: string, listener: EventListener): void {
-		if (this.#listeners[type]) {
-			this.#listeners[type].delete(listener);
-		}
-	}
-
-	dispatchEvent(event: UniversalEvent): boolean {
-		this.#dispatchEvent(event.type, event);
-		return true;
-	}
-
-	// Internal method to dispatch events
-	#dispatchEvent(type: string, detail?: Record<string, any>): void {
-		// Create appropriate event object
-		let event: any;
-		if (type === "message") {
-			event = {
-				type: "message",
-				target: this,
-				data: detail?.data || "",
-				origin: "",
-				lastEventId: "",
-			};
-		} else if (type === "close") {
-			event = {
-				type: "close",
-				target: this,
-				code: detail?.code || 1000,
-				reason: detail?.reason || "",
-				wasClean: detail?.wasClean ?? true,
-			};
-		} else if (type === "error") {
-			event = {
-				type: "error",
-				target: this,
-				error: detail?.error,
-			};
-		} else {
-			event = {
-				type: type,
-				target: this,
-			};
-		}
-
-		// Call all listeners first
-		if (this.#listeners[type]) {
-			for (const listener of this.#listeners[type]) {
-				try {
-					listener.call(this, event);
-				} catch (err) {
-					logger().error({
-						msg: `error in ${type} event listener`,
-						error: err,
-					});
-				}
-			}
-		}
-
-		// Then call specific handler
-		switch (type) {
-			case "open":
-				if (this.onopen) {
-					try {
-						this.onopen.call(this as any, event);
-					} catch (err) {
-						logger().error({ msg: "error in onopen handler", error: err });
-					}
-				}
-				break;
-			case "message":
-				if (this.onmessage) {
-					try {
-						this.onmessage.call(this as any, event);
-					} catch (err) {
-						logger().error({ msg: "error in onmessage handler", error: err });
-					}
-				}
-				break;
-			case "error":
-				if (this.onerror) {
-					try {
-						this.onerror.call(this as any, event);
-					} catch (err) {
-						logger().error({ msg: "error in onerror handler", error: err });
-					}
-				}
-				break;
-			case "close":
-				// Note: EventSource doesn't have onclose in the standard API
-				// but we handle it here for consistency
-				break;
-		}
-	}
-}

package/src/manager-api/routes/actors-create.ts

@@ -1,16 +0,0 @@
-import { z } from "zod";
-import { ActorSchema } from "./common";
-
-export const ActorsCreateRequestSchema = z.object({
-	name: z.string(),
-	runner_name_selector: z.string(),
-	crash_policy: z.string(),
-	key: z.string().nullable().optional(),
-	input: z.string().nullable().optional(),
-});
-export type ActorsCreateRequest = z.infer<typeof ActorsCreateRequestSchema>;
-
-export const ActorsCreateResponseSchema = z.object({
-	actor: ActorSchema,
-});
-export type ActorsCreateResponse = z.infer<typeof ActorsCreateResponseSchema>;

package/src/manager-api/routes/actors-delete.ts

@@ -1,4 +0,0 @@
-import { z } from "zod";
-
-export const ActorsDeleteResponseSchema = z.object({});
-export type ActorsDeleteResponse = z.infer<typeof ActorsDeleteResponseSchema>;

package/src/manager-api/routes/actors-get-by-id.ts

@@ -1,7 +0,0 @@
-import { z } from "zod";
-import { RivetIdSchema } from "./common";
-
-export const ActorsGetByIdResponseSchema = z.object({
-	actor_id: RivetIdSchema.nullable().optional(),
-});
-export type ActorsGetByIdResponse = z.infer<typeof ActorsGetByIdResponseSchema>;

package/src/manager-api/routes/actors-get-or-create-by-id.ts

@@ -1,29 +0,0 @@
-import { z } from "zod";
-import { ActorSchema, RivetIdSchema } from "./common";
-
-export const ActorsGetOrCreateResponseSchema = z.object({
-	actor: ActorSchema,
-	created: z.boolean(),
-});
-export type ActorsGetOrCreateResponse = z.infer<
-	typeof ActorsGetOrCreateResponseSchema
->;
-
-export const ActorsGetOrCreateByIdResponseSchema = z.object({
-	actor_id: RivetIdSchema,
-	created: z.boolean(),
-});
-export type ActorsGetOrCreateByIdResponse = z.infer<
-	typeof ActorsGetOrCreateByIdResponseSchema
->;
-
-export const ActorsGetOrCreateByIdRequestSchema = z.object({
-	name: z.string(),
-	key: z.string(),
-	runner_name_selector: z.string(),
-	crash_policy: z.string(),
-	input: z.string().nullable().optional(),
-});
-export type ActorsGetOrCreateByIdRequest = z.infer<
-	typeof ActorsGetOrCreateByIdRequestSchema
->;

package/src/manager-api/routes/actors-get.ts

@@ -1,7 +0,0 @@
-import { z } from "zod";
-import { ActorSchema } from "./common";
-
-export const ActorsGetResponseSchema = z.object({
-	actor: ActorSchema,
-});
-export type ActorsGetResponse = z.infer<typeof ActorsGetResponseSchema>;

package/src/manager-api/routes/common.ts

@@ -1,18 +0,0 @@
-import { z } from "zod";
-
-export const RivetIdSchema = z.string();
-export type RivetId = z.infer<typeof RivetIdSchema>;
-
-export const ActorSchema = z.object({
-	actor_id: RivetIdSchema,
-	name: z.string(),
-	key: z.string(),
-	namespace_id: RivetIdSchema,
-	runner_name_selector: z.string(),
-	create_ts: z.number(),
-	connectable_ts: z.number().nullable().optional(),
-	destroy_ts: z.number().nullable().optional(),
-	sleep_ts: z.number().nullable().optional(),
-	start_ts: z.number().nullable().optional(),
-});
-export type Actor = z.infer<typeof ActorSchema>;