rivetkit 2.0.6 → 2.0.7-rc.1

package/src/manager-api/actors.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { RivetIdSchema } from "./common";
+
+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>;
+
+// MARK: GET /actors
+export const ActorsListResponseSchema = z.object({
+	actors: z.array(ActorSchema),
+});
+export type ActorsListResponse = z.infer<typeof ActorsListResponseSchema>;
+
+// MARK: POST /actors
+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>;
+
+// MARK: PUT /actors
+export const ActorsGetOrCreateRequestSchema = z.object({
+	name: z.string(),
+	key: z.string(),
+	runner_name_selector: z.string(),
+	crash_policy: z.string(),
+	input: z.string().nullable().optional(),
+});
+export type ActorsGetOrCreateRequest = z.infer<
+	typeof ActorsGetOrCreateRequestSchema
+>;
+
+export const ActorsGetOrCreateResponseSchema = z.object({
+	actor: ActorSchema,
+	created: z.boolean(),
+});
+export type ActorsGetOrCreateResponse = z.infer<
+	typeof ActorsGetOrCreateResponseSchema
+>;
+
+// MARK: DELETE /actors/{}
+export const ActorsDeleteResponseSchema = z.object({});
+export type ActorsDeleteResponse = z.infer<typeof ActorsDeleteResponseSchema>;

package/src/manager-api/common.ts

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

package/src/mod.ts

@@ -1,4 +1,4 @@
-export { generateConnId, generateConnToken } from "@/actor/connection";
+export { generateConnId, generateConnToken } from "@/actor/conn";
 export * from "@/actor/mod";
 export {
 	type AnyClient,

package/src/registry/mod.ts

@@ -1,7 +1,12 @@
 import { type Client, createClientWithDriver } from "@/client/client";
 import { configureBaseLogger, configureDefaultLogger } from "@/common/log";
+import type { ActorDriver } from "@/driver-helpers/mod";
 import { chooseDefaultDriver } from "@/drivers/default";
-import { getInspectorUrl } from "@/inspector/utils";
+import {
+	configureInspectorAccessToken,
+	getInspectorUrl,
+	isInspectorEnabled,
+} from "@/inspector/utils";
 import { createManagerRouter } from "@/manager/router";
 import pkg from "../../package.json" with { type: "json" };
 import {
@@ -58,11 +63,11 @@ export class Registry<A extends RegistryActors> {
 
 		// TODO: Find cleaner way of disabling by default
 		if (driver.name === "engine") {
-			config.inspector.enabled = false;
+			config.inspector.enabled = { manager: false, actor: true };
 			config.disableServer = true;
 		}
 		if (driver.name === "cloudflare-workers") {
-			config.inspector.enabled = false;
+			config.inspector.enabled = { manager: false, actor: true };
 			config.disableServer = true;
 			config.disableActorDriver = true;
 			config.noWelcome = true;
@@ -76,13 +81,110 @@ export class Registry<A extends RegistryActors> {
 
 		// Create router
 		const managerDriver = driver.manager(this.#config, config);
+		configureInspectorAccessToken(config, managerDriver);
+
+		// Create client
+		const client = createClientWithDriver<this>(managerDriver, config);
+
+		const driverLog = managerDriver.extraStartupLog?.() ?? {};
+		logger().info({
+			msg: "rivetkit ready",
+			driver: driver.name,
+			definitions: Object.keys(this.#config.use).length,
+			...driverLog,
+		});
+		if (isInspectorEnabled(config, "manager") && managerDriver.inspector) {
+			logger().info({ msg: "inspector ready", url: getInspectorUrl(config) });
+		}
+
+		// Print welcome information
+		if (!config.noWelcome) {
+			const displayInfo = managerDriver.displayInformation();
+			console.log();
+			console.log(`  RivetKit ${pkg.version} (${displayInfo.name})`);
+			console.log(`  - Endpoint:     http://127.0.0.1:6420`);
+			for (const [k, v] of Object.entries(displayInfo.properties)) {
+				const padding = " ".repeat(Math.max(0, 13 - k.length));
+				console.log(`  - ${k}:${padding}${v}`);
+			}
+			if (isInspectorEnabled(config, "manager") && managerDriver.inspector) {
+				console.log(`  - Inspector:     ${getInspectorUrl(config)}`);
+			}
+			console.log();
+		}
+
+		// HACK: We need to find a better way to let the driver itself decide when to start the actor driver
+		// Create runner
+		//
+		// Even though we do not use the return value, this is required to start the code that will handle incoming actors
+		if (!config.disableActorDriver) {
+			const _actorDriver = driver.actor(
+				this.#config,
+				config,
+				managerDriver,
+				client,
+			);
+		}
+
 		const { router: hono } = createManagerRouter(
 			this.#config,
 			config,
 			managerDriver,
-			false,
+			undefined,
 		);
 
+		// Start server
+		if (!config.disableServer) {
+			(async () => {
+				const out = await crossPlatformServe(hono, undefined);
+				upgradeWebSocket = out.upgradeWebSocket;
+			})();
+		}
+
+		return {
+			client,
+			fetch: hono.fetch.bind(hono),
+		};
+	}
+
+	public startServerless(inputConfig?: RunConfigInput): ServerOutput<this> {
+		const config = RunConfigSchema.parse(inputConfig);
+
+		// Configure logger
+		if (config.logging?.baseLogger) {
+			// Use provided base logger
+			configureBaseLogger(config.logging.baseLogger);
+		} else {
+			// Configure default logger with log level from config
+			// getPinoLevel will handle env variable priority
+			configureDefaultLogger(config.logging?.level);
+		}
+
+		// Choose the driver based on configuration
+		const driver = chooseDefaultDriver(config);
+
+		// TODO: Find cleaner way of disabling by default
+		if (driver.name === "engine") {
+			config.inspector.enabled = false;
+			config.disableServer = true;
+			config.disableActorDriver = true;
+		}
+		if (driver.name === "cloudflare-workers") {
+			config.inspector.enabled = false;
+			config.disableServer = true;
+			config.disableActorDriver = true;
+			config.noWelcome = true;
+		}
+
+		// Configure getUpgradeWebSocket lazily so we can assign it in crossPlatformServe
+		let upgradeWebSocket: any;
+		if (!config.getUpgradeWebSocket) {
+			config.getUpgradeWebSocket = () => upgradeWebSocket!;
+		}
+
+		// Create router
+		const managerDriver = driver.manager(this.#config, config);
+
 		// Create client
 		const client = createClientWithDriver<this>(managerDriver, config);
 
@@ -113,19 +215,26 @@ export class Registry<A extends RegistryActors> {
 			console.log();
 		}
 
+		let serverlessActorDriverBuilder: (() => ActorDriver) | undefined = () => {
+			return driver.actor(this.#config, config, managerDriver, client);
+		};
+
 		// HACK: We need to find a better way to let the driver itself decide when to start the actor driver
 		// Create runner
 		//
 		// Even though we do not use the return value, this is required to start the code that will handle incoming actors
 		if (!config.disableActorDriver) {
-			const _actorDriver = driver.actor(
-				this.#config,
-				config,
-				managerDriver,
-				client,
-			);
+			const _actorDriver = serverlessActorDriverBuilder();
+			serverlessActorDriverBuilder = undefined;
 		}
 
+		const { router: hono } = createManagerRouter(
+			this.#config,
+			config,
+			managerDriver,
+			serverlessActorDriverBuilder,
+		);
+
 		// Start server
 		if (!config.disableServer) {
 			(async () => {

package/src/remote-manager-driver/actor-http-client.ts

@@ -1,4 +1,9 @@
 import type { ClientConfig } from "@/client/config";
+import {
+	HEADER_RIVET_ACTOR,
+	HEADER_RIVET_TARGET,
+	HEADER_RIVET_TOKEN,
+} from "@/common/actor-router-consts";
 import { combineUrlPath } from "@/utils";
 import { getEndpoint } from "./api-utils";
 
@@ -14,30 +19,29 @@ export async function sendHttpRequestToActor(
 
 	// Handle body properly based on method and presence
 	let bodyToSend: ArrayBuffer | null = null;
-	const guardHeaders = buildGuardHeadersForHttp(actorRequest, actorId);
+	const guardHeaders = buildGuardHeadersForHttp(
+		runConfig,
+		actorRequest,
+		actorId,
+	);
 
-	if (
-		actorRequest.body &&
-		actorRequest.method !== "GET" &&
-		actorRequest.method !== "HEAD"
-	) {
+	if (actorRequest.method !== "GET" && actorRequest.method !== "HEAD") {
 		if (actorRequest.bodyUsed) {
 			throw new Error("Request body has already been consumed");
 		}
 
 		// TODO: This buffers the entire request in memory every time. We
 		// need to properly implement streaming bodies.
-		// Clone and read the body to ensure it can be sent
-		const clonedRequest = actorRequest.clone();
-		bodyToSend = await clonedRequest.arrayBuffer();
+		const reqBody = await actorRequest.arrayBuffer();
 
-		// If this is a streaming request, we need to convert the headers
-		// for the basic array buffer
-		guardHeaders.delete("transfer-encoding");
-		guardHeaders.set(
-			"content-length",
-			String((bodyToSend as ArrayBuffer).byteLength),
-		);
+		if (reqBody.byteLength !== 0) {
+			bodyToSend = reqBody;
+
+			// If this is a streaming request, we need to convert the headers
+			// for the basic array buffer
+			guardHeaders.delete("transfer-encoding");
+			guardHeaders.set("content-length", String(bodyToSend.byteLength));
+		}
 	}
 
 	const guardRequest = new Request(guardUrl, {
@@ -58,6 +62,7 @@ function mutableResponse(fetchRes: Response): Response {
 }
 
 function buildGuardHeadersForHttp(
+	runConfig: ClientConfig,
 	actorRequest: Request,
 	actorId: string,
 ): Headers {
@@ -66,9 +71,15 @@ function buildGuardHeadersForHttp(
 	for (const [key, value] of actorRequest.headers.entries()) {
 		headers.set(key, value);
 	}
+	// Add extra headers from config
+	for (const [key, value] of Object.entries(runConfig.headers)) {
+		headers.set(key, value);
+	}
 	// Add guard-specific headers
-	headers.set("x-rivet-target", "actor");
-	headers.set("x-rivet-actor", actorId);
-	headers.set("x-rivet-port", "main");
+	headers.set(HEADER_RIVET_TARGET, "actor");
+	headers.set(HEADER_RIVET_ACTOR, actorId);
+	if (runConfig.token) {
+		headers.set(HEADER_RIVET_TOKEN, runConfig.token);
+	}
 	return headers;
 }

package/src/remote-manager-driver/actor-websocket-client.ts

@@ -1,8 +1,15 @@
 import type { ClientConfig } from "@/client/config";
 import {
-	HEADER_AUTH_DATA,
 	HEADER_CONN_PARAMS,
 	HEADER_ENCODING,
+	WS_PROTOCOL_ACTOR,
+	WS_PROTOCOL_CONN_ID,
+	WS_PROTOCOL_CONN_PARAMS,
+	WS_PROTOCOL_CONN_TOKEN,
+	WS_PROTOCOL_ENCODING,
+	WS_PROTOCOL_STANDARD as WS_PROTOCOL_RIVETKIT,
+	WS_PROTOCOL_TARGET,
+	WS_PROTOCOL_TOKEN,
 } from "@/common/actor-router-consts";
 import { importWebSocket } from "@/common/websocket";
 import type { Encoding, UniversalWebSocket } from "@/mod";
@@ -16,6 +23,8 @@ export async function openWebSocketToActor(
 	actorId: string,
 	encoding: Encoding,
 	params: unknown,
+	connId?: string,
+	connToken?: string,
 ): Promise<UniversalWebSocket> {
 	const WebSocket = await importWebSocket();
 
@@ -31,9 +40,17 @@ export async function openWebSocketToActor(
 	});
 
 	// Create WebSocket connection
-	const ws = new WebSocket(guardUrl, {
-		headers: buildGuardHeadersForWebSocket(actorId, encoding, params),
-	});
+	const ws = new WebSocket(
+		guardUrl,
+		buildWebSocketProtocols(
+			runConfig,
+			actorId,
+			encoding,
+			params,
+			connId,
+			connToken,
+		),
+	);
 
 	// Set binary type to arraybuffer for proper encoding support
 	ws.binaryType = "arraybuffer";
@@ -43,22 +60,32 @@ export async function openWebSocketToActor(
 	return ws as UniversalWebSocket;
 }
 
-export function buildGuardHeadersForWebSocket(
+export function buildWebSocketProtocols(
+	runConfig: ClientConfig,
 	actorId: string,
 	encoding: Encoding,
 	params?: unknown,
-	authData?: unknown,
-): Record<string, string> {
-	const headers: Record<string, string> = {};
-	headers["x-rivet-target"] = "actor";
-	headers["x-rivet-actor"] = actorId;
-	headers["x-rivet-port"] = "main";
-	headers[HEADER_ENCODING] = encoding;
+	connId?: string,
+	connToken?: string,
+): string[] {
+	const protocols: string[] = [];
+	protocols.push(WS_PROTOCOL_RIVETKIT);
+	protocols.push(`${WS_PROTOCOL_TARGET}actor`);
+	protocols.push(`${WS_PROTOCOL_ACTOR}${actorId}`);
+	protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
+	if (runConfig.token) {
+		protocols.push(`${WS_PROTOCOL_TOKEN}${runConfig.token}`);
+	}
 	if (params) {
-		headers[HEADER_CONN_PARAMS] = JSON.stringify(params);
+		protocols.push(
+			`${WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`,
+		);
+	}
+	if (connId) {
+		protocols.push(`${WS_PROTOCOL_CONN_ID}${connId}`);
 	}
-	if (authData) {
-		headers[HEADER_AUTH_DATA] = JSON.stringify(authData);
+	if (connToken) {
+		protocols.push(`${WS_PROTOCOL_CONN_TOKEN}${connToken}`);
 	}
-	return headers;
+	return protocols;
 }

package/src/remote-manager-driver/api-endpoints.ts

@@ -3,52 +3,50 @@ import type { ClientConfig } from "@/client/client";
 import type {
 	ActorsCreateRequest,
 	ActorsCreateResponse,
-} from "@/manager-api/routes/actors-create";
-import type { ActorsDeleteResponse } from "@/manager-api/routes/actors-delete";
-import type { ActorsGetResponse } from "@/manager-api/routes/actors-get";
-import type { ActorsGetByIdResponse } from "@/manager-api/routes/actors-get-by-id";
-import type {
-	ActorsGetOrCreateByIdRequest,
-	ActorsGetOrCreateByIdResponse,
-} from "@/manager-api/routes/actors-get-or-create-by-id";
-import type { RivetId } from "@/manager-api/routes/common";
+	ActorsDeleteResponse,
+	ActorsGetOrCreateRequest,
+	ActorsGetOrCreateResponse,
+	ActorsListResponse,
+} from "@/manager-api/actors";
+import type { RivetId } from "@/manager-api/common";
 import { apiCall } from "./api-utils";
 
 // MARK: Get actor
 export async function getActor(
 	config: ClientConfig,
+	name: string,
 	actorId: RivetId,
-): Promise<ActorsGetResponse> {
-	return apiCall<never, ActorsGetResponse>(
+): Promise<ActorsListResponse> {
+	return apiCall<never, ActorsListResponse>(
 		config,
 		"GET",
-		`/actors/${encodeURIComponent(actorId)}`,
+		`/actors?name=${name}&actor_ids=${encodeURIComponent(actorId)}`,
 	);
 }
 
 // MARK: Get actor by id
-export async function getActorById(
+export async function getActorByKey(
 	config: ClientConfig,
 	name: string,
 	key: string[],
-): Promise<ActorsGetByIdResponse> {
+): Promise<ActorsListResponse> {
 	const serializedKey = serializeActorKey(key);
-	return apiCall<never, ActorsGetByIdResponse>(
+	return apiCall<never, ActorsListResponse>(
 		config,
 		"GET",
-		`/actors/by-id?name=${encodeURIComponent(name)}&key=${encodeURIComponent(serializedKey)}`,
+		`/actors?name=${encodeURIComponent(name)}&key=${encodeURIComponent(serializedKey)}`,
 	);
 }
 
 // MARK: Get or create actor by id
-export async function getOrCreateActorById(
+export async function getOrCreateActor(
 	config: ClientConfig,
-	request: ActorsGetOrCreateByIdRequest,
-): Promise<ActorsGetOrCreateByIdResponse> {
-	return apiCall<ActorsGetOrCreateByIdRequest, ActorsGetOrCreateByIdResponse>(
+	request: ActorsGetOrCreateRequest,
+): Promise<ActorsGetOrCreateResponse> {
+	return apiCall<ActorsGetOrCreateRequest, ActorsGetOrCreateResponse>(
 		config,
 		"PUT",
-		`/actors/by-id`,
+		`/actors`,
 		request,
 	);
 }

package/src/remote-manager-driver/api-utils.ts

@@ -33,10 +33,19 @@ export async function apiCall<TInput = unknown, TOutput = unknown>(
 
 	logger().debug({ msg: "making api call", method, url });
 
+	const headers: Record<string, string> = {
+		...config.headers,
+	};
+
+	// Add Authorization header if token is provided
+	if (config.token) {
+		headers.Authorization = `Bearer ${config.token}`;
+	}
+
 	return await sendHttpRequest<TInput, TOutput>({
 		method,
 		url,
-		headers: {},
+		headers,
 		body,
 		encoding: "json",
 		skipParseResponse: false,