rivetkit 2.0.2 → 2.0.4

package/src/inspector/utils.ts

@@ -0,0 +1,76 @@
+import crypto from "node:crypto";
+import { createMiddleware } from "hono/factory";
+import type { RunConfig } from "@/mod";
+import type { RunConfigInput } from "@/registry/run-config";
+import { inspectorLogger } from "./log";
+
+export function compareSecrets(providedSecret: string, validSecret: string) {
+	// Early length check to avoid unnecessary processing
+	if (providedSecret.length !== validSecret.length) {
+		return false;
+	}
+
+	const encoder = new TextEncoder();
+
+	const a = encoder.encode(providedSecret);
+	const b = encoder.encode(validSecret);
+
+	if (a.byteLength !== b.byteLength) {
+		return false;
+	}
+
+	// Perform timing-safe comparison
+	if (!crypto.timingSafeEqual(a, b)) {
+		return false;
+	}
+	return true;
+}
+
+export const secureInspector = (runConfig: RunConfig) =>
+	createMiddleware(async (c, next) => {
+		if (!runConfig.inspector.enabled) {
+			return c.text("Inspector is not enabled", 503);
+		}
+
+		const userToken = c.req.header("Authorization")?.replace("Bearer ", "");
+		if (!userToken) {
+			return c.text("Unauthorized", 401);
+		}
+
+		const inspectorToken = runConfig.inspector.token?.();
+		if (!inspectorToken) {
+			return c.text("Unauthorized", 401);
+		}
+
+		const isValid = compareSecrets(userToken, inspectorToken);
+
+		if (!isValid) {
+			return c.text("Unauthorized", 401);
+		}
+		await next();
+	});
+
+export function getInspectorUrl(runConfig: RunConfigInput | undefined) {
+	if (!runConfig?.inspector?.enabled) {
+		return "disabled";
+	}
+
+	const accessToken = runConfig?.inspector?.token?.();
+
+	if (!accessToken) {
+		inspectorLogger().warn(
+			"Inspector Token is not set, but Inspector is enabled. Please set it in the run configuration `inspector.token` or via `RIVETKIT_INSPECTOR_TOKEN` environment variable. Inspector will not be accessible.",
+		);
+		return "disabled";
+	}
+
+	const url = new URL("https://inspect.rivet.dev");
+
+	url.searchParams.set("t", accessToken);
+
+	if (runConfig?.inspector?.defaultEndpoint) {
+		url.searchParams.set("u", runConfig.inspector.defaultEndpoint);
+	}
+
+	return url.href;
+}

package/src/manager/driver.ts

@@ -0,0 +1,88 @@
+import type { Env, Hono, Context as HonoContext } from "hono";
+import type { ActorKey, Encoding, UniversalWebSocket } from "@/actor/mod";
+import type { ManagerInspector } from "@/inspector/manager";
+import type { RunConfig } from "@/mod";
+import type { RegistryConfig } from "@/registry/config";
+
+export type ManagerDriverBuilder = (
+	registryConfig: RegistryConfig,
+	runConfig: RunConfig,
+) => ManagerDriver;
+
+export interface ManagerDriver {
+	getForId(input: GetForIdInput): Promise<ActorOutput | undefined>;
+	getWithKey(input: GetWithKeyInput): Promise<ActorOutput | undefined>;
+	getOrCreateWithKey(input: GetOrCreateWithKeyInput): Promise<ActorOutput>;
+	createActor(input: CreateInput): Promise<ActorOutput>;
+
+	sendRequest(actorId: string, actorRequest: Request): Promise<Response>;
+	openWebSocket(
+		path: string,
+		actorId: string,
+		encoding: Encoding,
+		params: unknown,
+	): Promise<UniversalWebSocket>;
+	proxyRequest(
+		c: HonoContext,
+		actorRequest: Request,
+		actorId: string,
+	): Promise<Response>;
+	proxyWebSocket(
+		c: HonoContext,
+		path: string,
+		actorId: string,
+		encoding: Encoding,
+		params: unknown,
+		authData: unknown,
+	): Promise<Response>;
+
+	displayInformation(): ManagerDisplayInformation;
+
+	extraStartupLog?: () => Record<string, unknown>;
+
+	modifyManagerRouter?: (registryConfig: RegistryConfig, router: Hono) => void;
+
+	/**
+	 * @internal
+	 */
+	readonly inspector?: ManagerInspector;
+}
+
+export interface ManagerDisplayInformation {
+	name: string;
+	properties: Record<string, string>;
+}
+
+export interface GetForIdInput<E extends Env = any> {
+	c?: HonoContext | undefined;
+	name: string;
+	actorId: string;
+}
+
+export interface GetWithKeyInput<E extends Env = any> {
+	c?: HonoContext | undefined;
+	name: string;
+	key: ActorKey;
+}
+
+export interface GetOrCreateWithKeyInput<E extends Env = any> {
+	c?: HonoContext | undefined;
+	name: string;
+	key: ActorKey;
+	input?: unknown;
+	region?: string;
+}
+
+export interface CreateInput<E extends Env = any> {
+	c?: HonoContext | undefined;
+	name: string;
+	key: ActorKey;
+	input?: unknown;
+	region?: string;
+}
+
+export interface ActorOutput {
+	actorId: string;
+	name: string;
+	key: ActorKey;
+}

package/src/manager/hono-websocket-adapter.ts

@@ -0,0 +1,342 @@
+import type { WSContext } from "hono/ws";
+import type {
+	RivetCloseEvent,
+	RivetEvent,
+	RivetMessageEvent,
+	UniversalWebSocket,
+} from "@/common/websocket-interface";
+import { logger } from "./log";
+
+/**
+ * HonoWebSocketAdapter provides a WebSocket-like interface over WSContext
+ * for raw WebSocket handling in actors
+ */
+export class HonoWebSocketAdapter implements UniversalWebSocket {
+	// WebSocket readyState values
+	readonly CONNECTING = 0 as const;
+	readonly OPEN = 1 as const;
+	readonly CLOSING = 2 as const;
+	readonly CLOSED = 3 as const;
+
+	#ws: WSContext;
+	#readyState: 0 | 1 | 2 | 3 = 1; // Start as OPEN since WSContext is already connected
+	#eventListeners: Map<string, Set<(event: any) => void>> = new Map();
+	#closeCode?: number;
+	#closeReason?: string;
+
+	constructor(ws: WSContext) {
+		this.#ws = ws;
+
+		// The WSContext is already open when we receive it
+		this.#readyState = this.OPEN;
+
+		// Immediately fire the open event
+		setTimeout(() => {
+			this.#fireEvent("open", { type: "open", target: this });
+		}, 0);
+	}
+
+	get readyState(): 0 | 1 | 2 | 3 {
+		return this.#readyState;
+	}
+
+	get binaryType(): "arraybuffer" | "blob" {
+		return "arraybuffer";
+	}
+
+	set binaryType(value: "arraybuffer" | "blob") {
+		// Ignored for now - always use arraybuffer
+	}
+
+	get bufferedAmount(): number {
+		return 0; // Not tracked in WSContext
+	}
+
+	get extensions(): string {
+		return ""; // Not available in WSContext
+	}
+
+	get protocol(): string {
+		return ""; // Not available in WSContext
+	}
+
+	get url(): string {
+		return ""; // Not available in WSContext
+	}
+
+	send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void {
+		if (this.readyState !== this.OPEN) {
+			throw new Error("WebSocket is not open");
+		}
+
+		try {
+			logger().debug({
+				msg: "bridge sending data",
+				dataType: typeof data,
+				isString: typeof data === "string",
+				isArrayBuffer: data instanceof ArrayBuffer,
+				dataStr:
+					typeof data === "string" ? data.substring(0, 100) : "<non-string>",
+			});
+
+			if (typeof data === "string") {
+				(this.#ws as any).send(data);
+			} else if (data instanceof ArrayBuffer) {
+				(this.#ws as any).send(data);
+			} else if (ArrayBuffer.isView(data)) {
+				// Convert ArrayBufferView to ArrayBuffer
+				const buffer = data.buffer.slice(
+					data.byteOffset,
+					data.byteOffset + data.byteLength,
+				);
+				// Check if it's a SharedArrayBuffer and convert to ArrayBuffer
+				if (buffer instanceof SharedArrayBuffer) {
+					const arrayBuffer = new ArrayBuffer(buffer.byteLength);
+					new Uint8Array(arrayBuffer).set(new Uint8Array(buffer));
+					(this.#ws as any).send(arrayBuffer);
+				} else {
+					(this.#ws as any).send(buffer);
+				}
+			} else if (data instanceof Blob) {
+				// Convert Blob to ArrayBuffer
+				data
+					.arrayBuffer()
+					.then((buffer) => {
+						(this.#ws as any).send(buffer);
+					})
+					.catch((error) => {
+						logger().error({
+							msg: "failed to convert blob to arraybuffer",
+							error,
+						});
+						this.#fireEvent("error", { type: "error", target: this, error });
+					});
+			} else {
+				// Try to convert to string as a fallback
+				logger().warn({
+					msg: "unsupported data type, converting to string",
+					dataType: typeof data,
+					data,
+				});
+				(this.#ws as any).send(String(data));
+			}
+		} catch (error) {
+			logger().error({ msg: "error sending websocket data", error });
+			this.#fireEvent("error", { type: "error", target: this, error });
+			throw error;
+		}
+	}
+
+	close(code = 1000, reason = ""): void {
+		if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {
+			return;
+		}
+
+		this.#readyState = this.CLOSING;
+		this.#closeCode = code;
+		this.#closeReason = reason;
+
+		try {
+			(this.#ws as any).close(code, reason);
+
+			// Update state and fire close event
+			this.#readyState = this.CLOSED;
+			this.#fireEvent("close", {
+				type: "close",
+				target: this,
+				code,
+				reason,
+				wasClean: code === 1000,
+			});
+		} catch (error) {
+			logger().error({ msg: "error closing websocket", error });
+			this.#readyState = this.CLOSED;
+			this.#fireEvent("close", {
+				type: "close",
+				target: this,
+				code: 1006,
+				reason: "Abnormal closure",
+				wasClean: false,
+			});
+		}
+	}
+
+	addEventListener(type: string, listener: (event: any) => void): void {
+		if (!this.#eventListeners.has(type)) {
+			this.#eventListeners.set(type, new Set());
+		}
+		this.#eventListeners.get(type)!.add(listener);
+	}
+
+	removeEventListener(type: string, listener: (event: any) => void): void {
+		const listeners = this.#eventListeners.get(type);
+		if (listeners) {
+			listeners.delete(listener);
+		}
+	}
+
+	dispatchEvent(event: RivetEvent): boolean {
+		const listeners = this.#eventListeners.get(event.type);
+		if (listeners) {
+			for (const listener of listeners) {
+				try {
+					listener(event);
+				} catch (error) {
+					logger().error({
+						msg: `error in ${event.type} event listener`,
+						error,
+					});
+				}
+			}
+		}
+		return true;
+	}
+
+	// Internal method to handle incoming messages from WSContext
+	_handleMessage(data: any): void {
+		// Hono may pass either raw data or a MessageEvent-like object
+		let messageData: string | ArrayBuffer | ArrayBufferView;
+
+		if (typeof data === "string") {
+			messageData = data;
+		} else if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+			messageData = data;
+		} else if (data && typeof data === "object" && "data" in data) {
+			// Handle MessageEvent-like objects
+			messageData = data.data;
+		} else {
+			// Fallback - shouldn't happen in normal operation
+			messageData = String(data);
+		}
+
+		logger().debug({
+			msg: "bridge handling message",
+			dataType: typeof messageData,
+			isArrayBuffer: messageData instanceof ArrayBuffer,
+			dataStr: typeof messageData === "string" ? messageData : "<binary>",
+		});
+
+		this.#fireEvent("message", {
+			type: "message",
+			target: this,
+			data: messageData,
+		});
+	}
+
+	// Internal method to handle close from WSContext
+	_handleClose(code: number, reason: string): void {
+		// HACK: Close socket in order to fix bug with Cloudflare leaving WS in closing state
+		// https://github.com/cloudflare/workerd/issues/2569
+		(this.#ws as any).close(1000, "hack_force_close");
+
+		if (this.readyState === this.CLOSED) return;
+
+		this.#readyState = this.CLOSED;
+		this.#closeCode = code;
+		this.#closeReason = reason;
+
+		this.#fireEvent("close", {
+			type: "close",
+			target: this,
+			code,
+			reason,
+			wasClean: code === 1000,
+		});
+	}
+
+	// Internal method to handle errors from WSContext
+	_handleError(error: any): void {
+		this.#fireEvent("error", {
+			type: "error",
+			target: this,
+			error,
+		});
+	}
+
+	#fireEvent(type: string, event: any): void {
+		const listeners = this.#eventListeners.get(type);
+		if (listeners) {
+			for (const listener of listeners) {
+				try {
+					listener(event);
+				} catch (error) {
+					logger().error({ msg: `error in ${type} event listener`, error });
+				}
+			}
+		}
+
+		// Also check for on* properties
+		switch (type) {
+			case "open":
+				if (this.#onopen) {
+					try {
+						this.#onopen(event);
+					} catch (error) {
+						logger().error({ msg: "error in onopen handler", error });
+					}
+				}
+				break;
+			case "close":
+				if (this.#onclose) {
+					try {
+						this.#onclose(event);
+					} catch (error) {
+						logger().error({ msg: "error in onclose handler", error });
+					}
+				}
+				break;
+			case "error":
+				if (this.#onerror) {
+					try {
+						this.#onerror(event);
+					} catch (error) {
+						logger().error({ msg: "error in onerror handler", error });
+					}
+				}
+				break;
+			case "message":
+				if (this.#onmessage) {
+					try {
+						this.#onmessage(event);
+					} catch (error) {
+						logger().error({ msg: "error in onmessage handler", error });
+					}
+				}
+				break;
+		}
+	}
+
+	// Event handler properties with getters/setters
+	#onopen: ((event: RivetEvent) => void) | null = null;
+	#onclose: ((event: RivetCloseEvent) => void) | null = null;
+	#onerror: ((event: RivetEvent) => void) | null = null;
+	#onmessage: ((event: RivetMessageEvent) => void) | null = null;
+
+	get onopen(): ((event: RivetEvent) => void) | null {
+		return this.#onopen;
+	}
+	set onopen(handler: ((event: RivetEvent) => void) | null) {
+		this.#onopen = handler;
+	}
+
+	get onclose(): ((event: RivetCloseEvent) => void) | null {
+		return this.#onclose;
+	}
+	set onclose(handler: ((event: RivetCloseEvent) => void) | null) {
+		this.#onclose = handler;
+	}
+
+	get onerror(): ((event: RivetEvent) => void) | null {
+		return this.#onerror;
+	}
+	set onerror(handler: ((event: RivetEvent) => void) | null) {
+		this.#onerror = handler;
+	}
+
+	get onmessage(): ((event: RivetMessageEvent) => void) | null {
+		return this.#onmessage;
+	}
+	set onmessage(handler: ((event: RivetMessageEvent) => void) | null) {
+		this.#onmessage = handler;
+	}
+}

package/src/manager/log.ts

@@ -0,0 +1,5 @@
+import { getLogger } from "@/common/log";
+
+export function logger() {
+	return getLogger("actor-manager");
+}

package/src/manager/mod.ts

@@ -0,0 +1,2 @@
+export { ManagerDisplayInformation, ManagerDriver } from "./driver";
+export { createManagerRouter } from "./router";

package/src/manager/protocol/mod.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { TransportSchema } from "@/actor/protocol/old";
+import { ActorQuerySchema } from "./query";
+
+export * from "./query";
+
+export const ActorsRequestSchema = z.object({
+	query: ActorQuerySchema,
+});
+
+export const ActorsResponseSchema = z.object({
+	actorId: z.string(),
+	supportedTransports: z.array(TransportSchema),
+});
+
+//export const RivetConfigResponseSchema = z.object({
+//	endpoint: z.string(),
+//	project: z.string().optional(),
+//	environment: z.string().optional(),
+//});
+
+export type ActorsRequest = z.infer<typeof ActorsRequestSchema>;
+export type ActorsResponse = z.infer<typeof ActorsResponseSchema>;
+//export type RivetConfigResponse = z.infer<typeof RivetConfigResponseSchema>;

package/src/manager/protocol/query.ts

@@ -0,0 +1,89 @@
+import { z } from "zod";
+import { EncodingSchema } from "@/actor/protocol/serde";
+import {
+	HEADER_ACTOR_ID,
+	HEADER_ACTOR_QUERY,
+	HEADER_CONN_ID,
+	HEADER_CONN_PARAMS,
+	HEADER_CONN_TOKEN,
+	HEADER_ENCODING,
+} from "@/actor/router-endpoints";
+
+// Maximum size of a key component in bytes
+// Set to 128 bytes to allow for separators and escape characters in the full key
+// Cloudflare's maximum key size is 512 bytes, so we need to be significantly smaller
+export const MAX_ACTOR_KEY_SIZE = 128;
+
+export const ActorKeySchema = z.array(z.string().max(MAX_ACTOR_KEY_SIZE));
+
+export type ActorKey = z.infer<typeof ActorKeySchema>;
+
+export const CreateRequestSchema = z.object({
+	name: z.string(),
+	key: ActorKeySchema,
+	input: z.unknown().optional(),
+	region: z.string().optional(),
+});
+
+export const GetForKeyRequestSchema = z.object({
+	name: z.string(),
+	key: ActorKeySchema,
+});
+
+export const GetOrCreateRequestSchema = z.object({
+	name: z.string(),
+	key: ActorKeySchema,
+	input: z.unknown().optional(),
+	region: z.string().optional(),
+});
+
+export const ActorQuerySchema = z.union([
+	z.object({
+		getForId: z.object({
+			name: z.string(),
+			actorId: z.string(),
+		}),
+	}),
+	z.object({
+		getForKey: GetForKeyRequestSchema,
+	}),
+	z.object({
+		getOrCreateForKey: GetOrCreateRequestSchema,
+	}),
+	z.object({
+		create: CreateRequestSchema,
+	}),
+]);
+
+export const ConnectRequestSchema = z.object({
+	query: ActorQuerySchema.describe(HEADER_ACTOR_QUERY),
+	encoding: EncodingSchema.describe(HEADER_ENCODING),
+	connParams: z.string().optional().describe(HEADER_CONN_PARAMS),
+});
+
+export const ConnectWebSocketRequestSchema = z.object({
+	query: ActorQuerySchema.describe("query"),
+	encoding: EncodingSchema.describe("encoding"),
+	connParams: z.unknown().optional().describe("conn_params"),
+});
+
+export const ConnMessageRequestSchema = z.object({
+	actorId: z.string().describe(HEADER_ACTOR_ID),
+	connId: z.string().describe(HEADER_CONN_ID),
+	encoding: EncodingSchema.describe(HEADER_ENCODING),
+	connToken: z.string().describe(HEADER_CONN_TOKEN),
+});
+
+export const ResolveRequestSchema = z.object({
+	query: ActorQuerySchema.describe(HEADER_ACTOR_QUERY),
+	connParams: z.string().optional().describe(HEADER_CONN_PARAMS),
+});
+
+export type ActorQuery = z.infer<typeof ActorQuerySchema>;
+export type GetForKeyRequest = z.infer<typeof GetForKeyRequestSchema>;
+export type GetOrCreateRequest = z.infer<typeof GetOrCreateRequestSchema>;
+export type ConnectQuery = z.infer<typeof ConnectRequestSchema>;
+/**
+ * Interface representing a request to create a actor.
+ */
+export type CreateRequest = z.infer<typeof CreateRequestSchema>;