rivetkit 2.0.3 → 2.0.5

package/src/remote-manager-driver/mod.ts

@@ -0,0 +1,275 @@
+import * as cbor from "cbor-x";
+import type { Hono, Context as HonoContext } from "hono";
+import invariant from "invariant";
+import { ActorAlreadyExists } from "@/actor/errors";
+import { deserializeActorKey, serializeActorKey } from "@/actor/keys";
+import type { ClientConfig } from "@/client/client";
+import { noopNext } from "@/common/utils";
+import type {
+	ActorOutput,
+	CreateInput,
+	GetForIdInput,
+	GetOrCreateWithKeyInput,
+	GetWithKeyInput,
+	ManagerDisplayInformation,
+	ManagerDriver,
+} from "@/driver-helpers/mod";
+import type { ManagerInspector } from "@/inspector/manager";
+import type { Encoding, RegistryConfig, UniversalWebSocket } from "@/mod";
+import type { RunConfig } from "@/registry/run-config";
+import { combineUrlPath } from "@/utils";
+import { sendHttpRequestToActor } from "./actor-http-client";
+import {
+	buildGuardHeadersForWebSocket,
+	openWebSocketToActor,
+} from "./actor-websocket-client";
+import {
+	createActor,
+	destroyActor,
+	getActor,
+	getActorById,
+	getOrCreateActorById,
+} from "./api-endpoints";
+import { EngineApiError, getEndpoint } from "./api-utils";
+import { logger } from "./log";
+import { createWebSocketProxy } from "./ws-proxy";
+
+// TODO:
+// // Lazily import the dynamic imports so we don't have to turn `createClient` in to an async fn
+// const dynamicImports = (async () => {
+// 	// Import dynamic dependencies
+// 	const [WebSocket, EventSource] = await Promise.all([
+// 		importWebSocket(),
+// 		importEventSource(),
+// 	]);
+// 	return {
+// 		WebSocket,
+// 		EventSource,
+// 	};
+// })();
+
+export class RemoteManagerDriver implements ManagerDriver {
+	#config: ClientConfig;
+
+	constructor(runConfig: ClientConfig) {
+		this.#config = runConfig;
+	}
+
+	async getForId({
+		c,
+		name,
+		actorId,
+	}: GetForIdInput): Promise<ActorOutput | undefined> {
+		// Fetch from API if not in cache
+		try {
+			const response = await getActor(this.#config, actorId);
+
+			// Validate name matches
+			if (response.actor.name !== name) {
+				logger().debug({
+					msg: "actor name mismatch from api",
+					actorId,
+					apiName: response.actor.name,
+					requestedName: name,
+				});
+				return undefined;
+			}
+
+			const keyRaw = response.actor.key;
+			invariant(keyRaw, `actor ${actorId} should have key`);
+			const key = deserializeActorKey(keyRaw);
+
+			return {
+				actorId,
+				name,
+				key,
+			};
+		} catch (error) {
+			if (
+				error instanceof EngineApiError &&
+				(error as EngineApiError).group === "actor" &&
+				(error as EngineApiError).code === "not_found"
+			) {
+				return undefined;
+			}
+			throw error;
+		}
+	}
+
+	async getWithKey({
+		c,
+		name,
+		key,
+	}: GetWithKeyInput): Promise<ActorOutput | undefined> {
+		logger().debug({ msg: "getWithKey: searching for actor", name, key });
+
+		// If not in local cache, fetch by key from API
+		try {
+			const response = await getActorById(this.#config, name, key);
+
+			if (!response.actor_id) {
+				return undefined;
+			}
+
+			const actorId = response.actor_id;
+
+			logger().debug({
+				msg: "getWithKey: found actor via api",
+				actorId,
+				name,
+				key,
+			});
+
+			return {
+				actorId,
+				name,
+				key,
+			};
+		} catch (error) {
+			if (
+				error instanceof EngineApiError &&
+				(error as EngineApiError).group === "actor" &&
+				(error as EngineApiError).code === "not_found"
+			) {
+				return undefined;
+			}
+			throw error;
+		}
+	}
+
+	async getOrCreateWithKey(
+		input: GetOrCreateWithKeyInput,
+	): Promise<ActorOutput> {
+		const { c, name, key, input: actorInput, region } = input;
+
+		logger().info({
+			msg: "getOrCreateWithKey: getting or creating actor via engine api",
+			name,
+			key,
+		});
+
+		const response = await getOrCreateActorById(this.#config, {
+			name,
+			key: serializeActorKey(key),
+			runner_name_selector: this.#config.runnerName,
+			input: input ? cbor.encode(actorInput).toString("base64") : undefined,
+			crash_policy: "sleep",
+		});
+
+		const actorId = response.actor_id;
+
+		logger().info({
+			msg: "getOrCreateWithKey: actor ready",
+			actorId,
+			name,
+			key,
+			created: response.created,
+		});
+
+		return {
+			actorId,
+			name,
+			key,
+		};
+	}
+
+	async createActor({
+		c,
+		name,
+		key,
+		input,
+	}: CreateInput): Promise<ActorOutput> {
+		logger().info({ msg: "creating actor via engine api", name, key });
+
+		// Create actor via engine API
+		const result = await createActor(this.#config, {
+			name,
+			runner_name_selector: this.#config.runnerName,
+			key: serializeActorKey(key),
+			input: input ? cbor.encode(input).toString("base64") : null,
+			crash_policy: "sleep",
+		});
+		const actorId = result.actor.actor_id;
+
+		logger().info({ msg: "actor created", actorId, name, key });
+
+		return {
+			actorId,
+			name,
+			key,
+		};
+	}
+
+	async destroyActor(actorId: string): Promise<void> {
+		logger().info({ msg: "destroying actor via engine api", actorId });
+
+		await destroyActor(this.#config, actorId);
+
+		logger().info({ msg: "actor destroyed", actorId });
+	}
+
+	async sendRequest(actorId: string, actorRequest: Request): Promise<Response> {
+		return await sendHttpRequestToActor(this.#config, actorId, actorRequest);
+	}
+
+	async openWebSocket(
+		path: string,
+		actorId: string,
+		encoding: Encoding,
+		params: unknown,
+	): Promise<UniversalWebSocket> {
+		return await openWebSocketToActor(
+			this.#config,
+			path,
+			actorId,
+			encoding,
+			params,
+		);
+	}
+
+	async proxyRequest(
+		_c: HonoContext,
+		actorRequest: Request,
+		actorId: string,
+	): Promise<Response> {
+		return await sendHttpRequestToActor(this.#config, actorId, actorRequest);
+	}
+
+	async proxyWebSocket(
+		c: HonoContext,
+		path: string,
+		actorId: string,
+		encoding: Encoding,
+		params: unknown,
+		authData: unknown,
+	): Promise<Response> {
+		const upgradeWebSocket = this.#config.getUpgradeWebSocket?.();
+		invariant(upgradeWebSocket, "missing getUpgradeWebSocket");
+
+		const endpoint = getEndpoint(this.#config);
+		const guardUrl = combineUrlPath(endpoint, path);
+		const wsGuardUrl = guardUrl.replace("http://", "ws://");
+
+		logger().debug({
+			msg: "forwarding websocket to actor via guard",
+			actorId,
+			path,
+			guardUrl,
+		});
+
+		// Build headers
+		const headers = buildGuardHeadersForWebSocket(
+			actorId,
+			encoding,
+			params,
+			authData,
+		);
+		const args = await createWebSocketProxy(c, wsGuardUrl, headers);
+
+		return await upgradeWebSocket(() => args)(c, noopNext());
+	}
+
+	displayInformation(): ManagerDisplayInformation {
+		return { name: "Remote", properties: {} };
+	}
+}

package/src/{drivers/engine → remote-manager-driver}/ws-proxy.ts

@@ -1,7 +1,6 @@
 import type { Context as HonoContext } from "hono";
 import type { WSContext } from "hono/ws";
-import invariant from "invariant";
-import type { CloseEvent } from "ws";
+import { stringifyError } from "@/common/utils";
 import { importWebSocket } from "@/common/websocket";
 import type { UpgradeWebSocketArgs } from "@/mod";
 import { logger } from "./log";
@@ -32,10 +31,11 @@ export async function createWebSocketProxy(
 
 	return {
 		onOpen: async (event: any, clientWs: WSContext) => {
-			logger().debug("client websocket connected", { targetUrl });
+			logger().debug({ msg: "client websocket connected", targetUrl });
 
 			if (clientWs.readyState !== 1) {
-				logger().warn("client websocket not open on connection", {
+				logger().warn({
+					msg: "client websocket not open on connection",
 					targetUrl,
 					readyState: clientWs.readyState,
 				});
@@ -49,10 +49,11 @@ export async function createWebSocketProxy(
 			// Setup connection promise
 			state.connectPromise = new Promise<void>((resolve, reject) => {
 				targetWs.addEventListener("open", () => {
-					logger().debug("target websocket connected", { targetUrl });
+					logger().debug({ msg: "target websocket connected", targetUrl });
 
 					if (clientWs.readyState !== 1) {
-						logger().warn("client websocket closed before target connected", {
+						logger().warn({
+							msg: "client websocket closed before target connected",
 							targetUrl,
 							clientReadyState: clientWs.readyState,
 						});
@@ -64,7 +65,8 @@ export async function createWebSocketProxy(
 				});
 
 				targetWs.addEventListener("error", (error) => {
-					logger().warn("target websocket error during connection", {
+					logger().warn({
+						msg: "target websocket error during connection",
 						targetUrl,
 					});
 					reject(error);
@@ -86,7 +88,8 @@ export async function createWebSocketProxy(
 			});
 
 			state.targetWs.addEventListener("close", (event) => {
-				logger().debug("target websocket closed", {
+				logger().debug({
+					msg: "target websocket closed",
 					targetUrl,
 					code: event.code,
 					reason: event.reason,
@@ -95,14 +98,18 @@ export async function createWebSocketProxy(
 			});
 
 			state.targetWs.addEventListener("error", (error) => {
-				logger().error("target websocket error", { targetUrl, error });
+				logger().error({
+					msg: "target websocket error",
+					targetUrl,
+					error: stringifyError(error),
+				});
 				closeWebSocketIfOpen(clientWs, 1011, "Target WebSocket error");
 			});
 		},
 
 		onMessage: async (event: any, clientWs: WSContext) => {
 			if (!state.targetWs || !state.connectPromise) {
-				logger().error("websocket state not initialized", { targetUrl });
+				logger().error({ msg: "websocket state not initialized", targetUrl });
 				return;
 			}
 
@@ -111,13 +118,15 @@ export async function createWebSocketProxy(
 				if (state.targetWs.readyState === WebSocket.OPEN) {
 					state.targetWs.send(event.data);
 				} else {
-					logger().warn("target websocket not open", {
+					logger().warn({
+						msg: "target websocket not open",
 						targetUrl,
 						readyState: state.targetWs.readyState,
 					});
 				}
 			} catch (error) {
-				logger().error("failed to connect to target websocket", {
+				logger().error({
+					msg: "failed to connect to target websocket",
 					targetUrl,
 					error,
 				});
@@ -126,7 +135,8 @@ export async function createWebSocketProxy(
 		},
 
 		onClose: (event: any, clientWs: WSContext) => {
-			logger().debug("client websocket closed", {
+			logger().debug({
+				msg: "client websocket closed",
 				targetUrl,
 				code: event.code,
 				reason: event.reason,
@@ -144,7 +154,7 @@ export async function createWebSocketProxy(
 		},
 
 		onError: (event: any, clientWs: WSContext) => {
-			logger().error("client websocket error", { targetUrl, event });
+			logger().error({ msg: "client websocket error", targetUrl, event });
 
 			if (state.targetWs) {
 				if (state.targetWs.readyState === WebSocket.OPEN) {

package/src/serde.ts

@@ -40,13 +40,16 @@ export function wsBinaryTypeForEncoding(
 export function serializeWithEncoding<T>(
 	encoding: Encoding,
 	value: T,
-	versionedDataHandler: VersionedDataHandler<T>,
+	versionedDataHandler: VersionedDataHandler<T> | undefined,
 ): Uint8Array | string {
 	if (encoding === "json") {
 		return jsonStringifyCompat(value);
 	} else if (encoding === "cbor") {
 		return cbor.encode(value);
 	} else if (encoding === "bare") {
+		if (!versionedDataHandler) {
+			throw new Error("VersionedDataHandler is required for 'bare' encoding");
+		}
 		return versionedDataHandler.serializeWithEmbeddedVersion(value);
 	} else {
 		assertUnreachable(encoding);
@@ -56,7 +59,7 @@ export function serializeWithEncoding<T>(
 export function deserializeWithEncoding<T>(
 	encoding: Encoding,
 	buffer: Uint8Array | string,
-	versionedDataHandler: VersionedDataHandler<T>,
+	versionedDataHandler: VersionedDataHandler<T> | undefined,
 ): T {
 	if (encoding === "json") {
 		if (typeof buffer === "string") {
@@ -77,6 +80,9 @@ export function deserializeWithEncoding<T>(
 			typeof buffer !== "string",
 			"buffer cannot be string for bare encoding",
 		);
+		if (!versionedDataHandler) {
+			throw new Error("VersionedDataHandler is required for 'bare' encoding");
+		}
 		return versionedDataHandler.deserializeWithEmbeddedVersion(buffer);
 	} else {
 		assertUnreachable(encoding);

package/src/test/log.ts

@@ -1,7 +1,5 @@
 import { getLogger } from "@/common/log";
 
-export const LOGGER_NAME = "nodejs";
-
 export function logger() {
-	return getLogger(LOGGER_NAME);
+	return getLogger("test");
 }

package/src/test/mod.ts

@@ -5,7 +5,6 @@ import { type TestContext, vi } from "vitest";
 import { type Client, createClient } from "@/client/mod";
 import { chooseDefaultDriver } from "@/drivers/default";
 import { createFileSystemOrMemoryDriver } from "@/drivers/file-system/mod";
-import { createInlineClientDriver } from "@/inline-client-driver/mod";
 import { getInspectorUrl } from "@/inspector/utils";
 import { createManagerRouter } from "@/manager/router";
 import type { Registry } from "@/registry/mod";
@@ -28,11 +27,9 @@ function serve(registry: Registry<any>, inputConfig?: InputConfig): ServerType {
 	const runConfig = RunConfigSchema.parse(inputConfig);
 	const driver = inputConfig.driver ?? createFileSystemOrMemoryDriver(false);
 	const managerDriver = driver.manager(registry.config, config);
-	const inlineClientDriver = createInlineClientDriver(managerDriver);
 	const { router } = createManagerRouter(
 		registry.config,
 		runConfig,
-		inlineClientDriver,
 		managerDriver,
 		false,
 	);
@@ -48,7 +45,8 @@ function serve(registry: Registry<any>, inputConfig?: InputConfig): ServerType {
 	});
 	nodeWebSocket.injectWebSocket(server);
 
-	logger().info("rivetkit started", {
+	logger().info({
+		msg: "rivetkit started",
 		hostname: config.hostname,
 		port: config.port,
 		definitions: Object.keys(registry.config.use).length,
@@ -88,18 +86,21 @@ export async function setupTest<A extends Registry<any>>(
 		async () => await new Promise((resolve) => server.close(() => resolve())),
 	);
 
-	// Create client
-	const client = createClient<A>(`http://127.0.0.1:${port}`);
-	c.onTestFinished(async () => await client.dispose());
-
-	return {
-		client,
-		mockDriver: {
-			actorDriver: {
-				setCreateVarsContext: setDriverContextFn,
-			},
-		},
-	};
+	throw "TODO: Fix engine port";
+
+	// // TODO: Figure out how to make this the correct endpoint
+	// // Create client
+	// const client = createClient<A>(`http://127.0.0.1:${port}`);
+	// c.onTestFinished(async () => await client.dispose());
+	//
+	// return {
+	// 	client,
+	// 	mockDriver: {
+	// 		actorDriver: {
+	// 			setCreateVarsContext: setDriverContextFn,
+	// 		},
+	// 	},
+	// };
 }
 
 export async function getPort(): Promise<number> {

package/src/utils.ts

@@ -170,3 +170,56 @@ export function bufferToArrayBuffer(buf: Buffer | Uint8Array): ArrayBuffer {
 		buf.byteOffset + buf.byteLength,
 	) as ArrayBuffer;
 }
+
+/**
+ * Properly combines a base URL endpoint with a path, preserving any base path in the endpoint.
+ *
+ * @example
+ * combineUrlPath("http://localhost:8787/rivet", "/actors/action")
+ * // Returns: "http://localhost:8787/rivet/actors/action"
+ *
+ * @example
+ * combineUrlPath("http://localhost:8787/rivet", "/actors?type=foo", { namespace: "test" })
+ * // Returns: "http://localhost:8787/rivet/actors?type=foo&namespace=test"
+ *
+ * @param endpoint The base URL endpoint that may contain a path component
+ * @param path The path to append to the endpoint (may include query parameters)
+ * @param queryParams Optional additional query parameters to append
+ * @returns The properly combined URL string
+ */
+export function combineUrlPath(
+	endpoint: string,
+	path: string,
+	queryParams?: Record<string, string | undefined>,
+): string {
+	const baseUrl = new URL(endpoint);
+
+	// Extract path and query from the provided path
+	const pathParts = path.split("?");
+	const pathOnly = pathParts[0];
+	const existingQuery = pathParts[1] || "";
+
+	// Remove trailing slash from base path and ensure path starts with /
+	const basePath = baseUrl.pathname.replace(/\/$/, "");
+	const cleanPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
+	// Combine paths and remove any double slashes
+	const fullPath = (basePath + cleanPath).replace(/\/\//g, "/");
+
+	// Build query string
+	const queryParts: string[] = [];
+	if (existingQuery) {
+		queryParts.push(existingQuery);
+	}
+	if (queryParams) {
+		for (const [key, value] of Object.entries(queryParams)) {
+			if (value !== undefined) {
+				queryParts.push(
+					`${encodeURIComponent(key)}=${encodeURIComponent(value)}`,
+				);
+			}
+		}
+	}
+
+	const fullQuery = queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
+	return `${baseUrl.protocol}//${baseUrl.host}${fullPath}${fullQuery}`;
+}