rivetkit 2.0.19 → 2.0.21

package/src/inspector/actor.ts

@@ -50,7 +50,9 @@ export function createActorInspectorRouter() {
 			"/state",
 			sValidator(
 				"json",
-				z.object({ patch: PatchSchema }).or(z.object({ replace: z.any() })),
+				z
+					.object({ patch: PatchSchema })
+					.or(z.object({ replace: z.any() })),
 			),
 			async (c) => {
 				if (!(await c.var.inspector.accessors.isStateEnabled())) {
@@ -77,7 +79,10 @@ export function createActorInspectorRouter() {
 				await c.var.inspector.accessors.setState(newState);
 
 				return c.json(
-					{ enabled: true, state: await c.var.inspector.accessors.getState() },
+					{
+						enabled: true,
+						state: await c.var.inspector.accessors.getState(),
+					},
 					200,
 				);
 			},
@@ -92,13 +97,16 @@ export function createActorInspectorRouter() {
 			return streamSSE(
 				c,
 				async (stream) => {
-					unsub = c.var.inspector.emitter.on("stateUpdated", async (state) => {
-						stream.writeSSE({
-							data: JSON.stringify(state) || "",
-							event: "state-update",
-							id: String(id++),
-						});
-					});
+					unsub = c.var.inspector.emitter.on(
+						"stateUpdated",
+						async (state) => {
+							stream.writeSSE({
+								data: JSON.stringify(state) || "",
+								event: "state-update",
+								id: String(id++),
+							});
+						},
+					);
 
 					const { promise } = promiseWithResolvers<void>();
 
@@ -110,7 +118,8 @@ export function createActorInspectorRouter() {
 			);
 		})
 		.get("/connections", async (c) => {
-			const connections = await c.var.inspector.accessors.getConnections();
+			const connections =
+				await c.var.inspector.accessors.getConnections();
 			return c.json({ connections }, 200);
 		})
 		.get("/connections/stream", async (c) => {
@@ -119,15 +128,18 @@ export function createActorInspectorRouter() {
 			return streamSSE(
 				c,
 				async (stream) => {
-					unsub = c.var.inspector.emitter.on("connectionUpdated", async () => {
-						stream.writeSSE({
-							data: JSON.stringify(
-								await c.var.inspector.accessors.getConnections(),
-							),
-							event: "connection-update",
-							id: String(id++),
-						});
-					});
+					unsub = c.var.inspector.emitter.on(
+						"connectionUpdated",
+						async () => {
+							stream.writeSSE({
+								data: JSON.stringify(
+									await c.var.inspector.accessors.getConnections(),
+								),
+								event: "connection-update",
+								id: String(id++),
+							});
+						},
+					);
 
 					const { promise } = promiseWithResolvers<void>();
 
@@ -154,7 +166,9 @@ export function createActorInspectorRouter() {
 				async (stream) => {
 					unsub = c.var.inspector.emitter.on("eventFired", () => {
 						stream.writeSSE({
-							data: JSON.stringify(c.var.inspector.lastRealtimeEvents),
+							data: JSON.stringify(
+								c.var.inspector.lastRealtimeEvents,
+							),
 							event: "realtime-event",
 							id: String(id++),
 						});
@@ -184,11 +198,15 @@ export function createActorInspectorRouter() {
 			// Get list of tables
 			const rows = await db.execute(`PRAGMA table_list`);
 			const tables = TablesSchema.parse(rows).filter(
-				(table) => table.schema !== "temp" && !table.name.startsWith("sqlite_"),
+				(table) =>
+					table.schema !== "temp" &&
+					!table.name.startsWith("sqlite_"),
 			);
 			// Get columns for each table
 			const tablesInfo = await Promise.all(
-				tables.map((table) => db.execute(`PRAGMA table_info(${table.name})`)),
+				tables.map((table) =>
+					db.execute(`PRAGMA table_info(${table.name})`),
+				),
 			);
 			const columns = tablesInfo.map((def) => ColumnsSchema.parse(def));
 
@@ -231,7 +249,10 @@ export function createActorInspectorRouter() {
 			"/db",
 			sValidator(
 				"json",
-				z.object({ query: z.string(), params: z.array(z.any()).optional() }),
+				z.object({
+					query: z.string(),
+					params: z.array(z.any()).optional(),
+				}),
 			),
 			async (c) => {
 				if (!(await c.var.inspector.accessors.isDbEnabled())) {
@@ -250,6 +271,24 @@ export function createActorInspectorRouter() {
 					return c.json({ error: (error as Error).message }, 500);
 				}
 			},
+		)
+		.post(
+			"/action",
+			sValidator(
+				"json",
+				z.object({
+					name: z.string(),
+					params: z.array(z.any()).optional(),
+				}),
+			),
+			async (c) => {
+				const { name, params } = c.req.valid("json");
+				const result = await c.var.inspector.accessors.executeAction(
+					name,
+					params,
+				);
+				return c.json({ result }, 200);
+			},
 		);
 }
 
@@ -261,6 +300,7 @@ interface ActorInspectorAccessors {
 	getDb: () => Promise<InferDatabaseClient<AnyDatabaseProvider>>;
 	getRpcs: () => Promise<string[]>;
 	getConnections: () => Promise<Connection[]>;
+	executeAction: (name: string, params?: unknown[]) => Promise<unknown>;
 }
 
 interface ActorInspectorEmitterEvents {

package/src/inspector/config.ts

@@ -35,7 +35,8 @@ const defaultCors: CorsOptions = {
 	origin: (origin) => {
 		if (
 			defaultInspectorOrigins.includes(origin) ||
-			(origin.startsWith("https://") && origin.endsWith("rivet-dev.vercel.app"))
+			(origin.startsWith("https://") &&
+				origin.endsWith("rivet-dev.vercel.app"))
 		) {
 			return origin;
 		} else {

package/src/inspector/manager.ts

@@ -21,7 +21,8 @@ export function createManagerInspectorRouter() {
 			return c.json({ message: "pong" }, 200);
 		})
 		.get("/actors", async (c) => {
-			const limit = Number.parseInt(c.req.query("limit") ?? "") || undefined;
+			const limit =
+				Number.parseInt(c.req.query("limit") ?? "") || undefined;
 			const cursor = c.req.query("cursor") || undefined;
 
 			if (!limit || (limit && limit <= 0)) {
@@ -35,7 +36,10 @@ export function createManagerInspectorRouter() {
 				});
 				return c.json(actors, 200);
 			} catch (error) {
-				inspectorLogger().error({ msg: "Failed to fetch actors", error });
+				inspectorLogger().error({
+					msg: "Failed to fetch actors",
+					error,
+				});
 				return c.json("Failed to fetch actors", 500);
 			}
 		})
@@ -67,7 +71,10 @@ export function createManagerInspectorRouter() {
 }
 
 interface ManagerInspectorAccessors {
-	getAllActors: (param: { cursor?: string; limit: number }) => Promise<Actor[]>;
+	getAllActors: (param: {
+		cursor?: string;
+		limit: number;
+	}) => Promise<Actor[]>;
 	getActorById: (id: string) => Promise<Actor | null>;
 	getBuilds: () => Promise<Builds>;
 	createActor: (input: CreateInput) => Promise<Actor | null>;

package/src/inspector/utils.ts

@@ -66,7 +66,8 @@ export function getInspectorUrl(runConfig: RunnerConfigInput | undefined) {
 	url.searchParams.set("t", accessToken);
 
 	const overrideDefaultEndpoint =
-		runConfig?.inspector?.defaultEndpoint ?? runConfig.overrideServerAddress;
+		runConfig?.inspector?.defaultEndpoint ??
+		runConfig.overrideServerAddress;
 	if (overrideDefaultEndpoint) {
 		url.searchParams.set("u", overrideDefaultEndpoint);
 	}

package/src/manager/driver.ts

@@ -43,7 +43,10 @@ export interface ManagerDriver {
 
 	extraStartupLog?: () => Record<string, unknown>;
 
-	modifyManagerRouter?: (registryConfig: RegistryConfig, router: Hono) => void;
+	modifyManagerRouter?: (
+		registryConfig: RegistryConfig,
+		router: Hono,
+	) => void;
 
 	/**
 	 * @internal

package/src/manager/gateway.ts

@@ -4,6 +4,7 @@ import { MissingActorHeader, WebSocketsNotEnabled } from "@/actor/errors";
 import type { Encoding, Transport } from "@/client/mod";
 import {
 	HEADER_RIVET_ACTOR,
+	HEADER_RIVET_NAMESPACE,
 	HEADER_RIVET_TARGET,
 	WS_PROTOCOL_ACTOR,
 	WS_PROTOCOL_CONN_ID,
@@ -11,6 +12,7 @@ import {
 	WS_PROTOCOL_CONN_TOKEN,
 	WS_PROTOCOL_ENCODING,
 	WS_PROTOCOL_TARGET,
+	WS_PROTOCOL_TOKEN,
 } from "@/common/actor-router-consts";
 import { deconstructError, noopNext } from "@/common/utils";
 import type { UniversalWebSocket, UpgradeWebSocketArgs } from "@/mod";
@@ -19,10 +21,123 @@ import { promiseWithResolvers, stringifyError } from "@/utils";
 import type { ManagerDriver } from "./driver";
 import { logger } from "./log";
 
+interface ActorPathInfo {
+	actorId: string;
+	token?: string;
+	remainingPath: string;
+}
+
+/**
+ * Handle path-based WebSocket routing
+ */
+async function handleWebSocketGatewayPathBased(
+	runConfig: RunnerConfig,
+	managerDriver: ManagerDriver,
+	c: HonoContext,
+	actorPathInfo: ActorPathInfo,
+): Promise<Response> {
+	const upgradeWebSocket = runConfig.getUpgradeWebSocket?.();
+	if (!upgradeWebSocket) {
+		throw new WebSocketsNotEnabled();
+	}
+
+	// NOTE: Token validation implemented in EE
+
+	// Parse additional configuration from Sec-WebSocket-Protocol header
+	const protocols = c.req.header("sec-websocket-protocol");
+	let encodingRaw: string | undefined;
+	let connParamsRaw: string | undefined;
+	let connIdRaw: string | undefined;
+	let connTokenRaw: string | undefined;
+
+	if (protocols) {
+		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);
+			} else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
+				connParamsRaw = decodeURIComponent(
+					protocol.substring(WS_PROTOCOL_CONN_PARAMS.length),
+				);
+			} else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
+				connIdRaw = protocol.substring(WS_PROTOCOL_CONN_ID.length);
+			} else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
+				connTokenRaw = protocol.substring(
+					WS_PROTOCOL_CONN_TOKEN.length,
+				);
+			}
+		}
+	}
+
+	logger().debug({
+		msg: "proxying websocket to actor via path-based routing",
+		actorId: actorPathInfo.actorId,
+		path: actorPathInfo.remainingPath,
+		encoding: encodingRaw,
+	});
+
+	const encoding = encodingRaw || "json";
+	const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : undefined;
+
+	return await managerDriver.proxyWebSocket(
+		c,
+		actorPathInfo.remainingPath,
+		actorPathInfo.actorId,
+		encoding as any, // Will be validated by driver
+		connParams,
+		connIdRaw,
+		connTokenRaw,
+	);
+}
+
+/**
+ * Handle path-based HTTP routing
+ */
+async function handleHttpGatewayPathBased(
+	managerDriver: ManagerDriver,
+	c: HonoContext,
+	actorPathInfo: ActorPathInfo,
+): Promise<Response> {
+	// NOTE: Token validation implemented in EE
+
+	logger().debug({
+		msg: "proxying request to actor via path-based routing",
+		actorId: actorPathInfo.actorId,
+		path: actorPathInfo.remainingPath,
+		method: c.req.method,
+	});
+
+	// Preserve all headers
+	const proxyHeaders = new Headers(c.req.raw.headers);
+
+	// Build the proxy request with the actor URL format
+	const proxyUrl = new URL(`http://actor${actorPathInfo.remainingPath}`);
+
+	const proxyRequest = new Request(proxyUrl, {
+		method: c.req.raw.method,
+		headers: proxyHeaders,
+		body: c.req.raw.body,
+		signal: c.req.raw.signal,
+		duplex: "half",
+	} as RequestInit);
+
+	return await managerDriver.proxyRequest(
+		c,
+		proxyRequest,
+		actorPathInfo.actorId,
+	);
+}
+
 /**
  * Provides an endpoint to connect to individual actors.
  *
- * Routes requests based on the Upgrade header:
+ * Routes requests using either path-based routing or header-based routing:
+ *
+ * Path-based routing (checked first):
+ * - /gateway/actors/{actor_id}/tokens/{token}/route/{...path}
+ * - /gateway/actors/{actor_id}/route/{...path}
+ *
+ * Header-based routing (fallback):
  * - WebSocket requests: Uses sec-websocket-protocol for routing (target.actor, actor.{id})
  * - HTTP requests: Uses x-rivet-target and x-rivet-actor headers for routing
  */
@@ -47,6 +162,40 @@ export async function actorGateway(
 		}
 	}
 
+	// Include query string if present (needed for parseActorPath to preserve query params)
+	const pathWithQuery = c.req.url.includes("?")
+		? strippedPath + c.req.url.substring(c.req.url.indexOf("?"))
+		: strippedPath;
+
+	// First, check if this is an actor path-based route
+	const actorPathInfo = parseActorPath(pathWithQuery);
+	if (actorPathInfo) {
+		logger().debug({
+			msg: "routing using path-based actor routing",
+			actorPathInfo,
+		});
+
+		// Check if this is a WebSocket upgrade request
+		const isWebSocket = c.req.header("upgrade") === "websocket";
+
+		if (isWebSocket) {
+			return await handleWebSocketGatewayPathBased(
+				runConfig,
+				managerDriver,
+				c,
+				actorPathInfo,
+			);
+		}
+
+		// Handle regular HTTP requests
+		return await handleHttpGatewayPathBased(
+			managerDriver,
+			c,
+			actorPathInfo,
+		);
+	}
+
+	// Fallback to header-based routing
 	// Check if this is a WebSocket upgrade request
 	if (c.req.header("upgrade") === "websocket") {
 		return await handleWebSocketGateway(
@@ -100,7 +249,9 @@ async function handleWebSocketGateway(
 			} else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
 				connIdRaw = protocol.substring(WS_PROTOCOL_CONN_ID.length);
 			} else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
-				connTokenRaw = protocol.substring(WS_PROTOCOL_CONN_TOKEN.length);
+				connTokenRaw = protocol.substring(
+					WS_PROTOCOL_CONN_TOKEN.length,
+				);
 			}
 		}
 	}
@@ -186,6 +337,113 @@ async function handleHttpGateway(
 	return await managerDriver.proxyRequest(c, proxyRequest, actorId);
 }
 
+/**
+ * Parse actor routing information from path
+ * Matches patterns:
+ * - /gateway/actors/{actor_id}/tokens/{token}/route/{...path}
+ * - /gateway/actors/{actor_id}/route/{...path}
+ */
+export function parseActorPath(path: string): ActorPathInfo | null {
+	// Find query string position (everything from ? onwards, but before fragment)
+	const queryPos = path.indexOf("?");
+	const fragmentPos = path.indexOf("#");
+
+	// Extract query string (excluding fragment)
+	let queryString = "";
+	if (queryPos !== -1) {
+		if (fragmentPos !== -1 && queryPos < fragmentPos) {
+			queryString = path.slice(queryPos, fragmentPos);
+		} else {
+			queryString = path.slice(queryPos);
+		}
+	}
+
+	// Extract base path (before query and fragment)
+	let basePath = path;
+	if (queryPos !== -1) {
+		basePath = path.slice(0, queryPos);
+	} else if (fragmentPos !== -1) {
+		basePath = path.slice(0, fragmentPos);
+	}
+
+	// Check for double slashes (invalid path)
+	if (basePath.includes("//")) {
+		return null;
+	}
+
+	// Split the path into segments
+	const segments = basePath.split("/").filter((s) => s.length > 0);
+
+	// Check minimum required segments: gateway, actors, {actor_id}, route
+	if (segments.length < 4) {
+		return null;
+	}
+
+	// Verify the fixed segments
+	if (segments[0] !== "gateway" || segments[1] !== "actors") {
+		return null;
+	}
+
+	// Check for empty actor_id
+	if (segments[2].length === 0) {
+		return null;
+	}
+
+	const actorId = segments[2];
+
+	// Check for token or direct route
+	let token: string | undefined;
+	let remainingPathStartIdx: number;
+
+	if (
+		segments.length >= 6 &&
+		segments[3] === "tokens" &&
+		segments[5] === "route"
+	) {
+		// Pattern with token: /gateway/actors/{actor_id}/tokens/{token}/route/{...path}
+		// Check for empty token
+		if (segments[4].length === 0) {
+			return null;
+		}
+		token = segments[4];
+		remainingPathStartIdx = 6;
+	} else if (segments.length >= 4 && segments[3] === "route") {
+		// Pattern without token: /gateway/actors/{actor_id}/route/{...path}
+		token = undefined;
+		remainingPathStartIdx = 4;
+	} else {
+		return null;
+	}
+
+	// Calculate the position in the original path where remaining path starts
+	let prefixLen = 0;
+	for (let i = 0; i < remainingPathStartIdx; i++) {
+		prefixLen += 1 + segments[i].length; // +1 for the slash
+	}
+
+	// Extract the remaining path preserving trailing slashes
+	let remainingBase: string;
+	if (prefixLen < basePath.length) {
+		remainingBase = basePath.slice(prefixLen);
+	} else {
+		remainingBase = "/";
+	}
+
+	// Ensure remaining path starts with /
+	let remainingPath: string;
+	if (remainingBase.length === 0 || !remainingBase.startsWith("/")) {
+		remainingPath = `/${remainingBase}${queryString}`;
+	} else {
+		remainingPath = `${remainingBase}${queryString}`;
+	}
+
+	return {
+		actorId,
+		token,
+		remainingPath,
+	};
+}
+
 /**
  * Creates a WebSocket proxy for test endpoints that forwards messages between server and client WebSockets
  */
@@ -212,13 +470,20 @@ export async function createTestWebSocketProxy(
 		// Wait for ws to open
 		await new Promise<void>((resolve, reject) => {
 			const onOpen = () => {
-				logger().debug({ msg: "test websocket connection to actor opened" });
+				logger().debug({
+					msg: "test websocket connection to actor opened",
+				});
 				resolve();
 			};
 			const onError = (error: any) => {
-				logger().error({ msg: "test websocket connection failed", error });
+				logger().error({
+					msg: "test websocket connection failed",
+					error,
+				});
 				reject(
-					new Error(`Failed to open WebSocket: ${error.message || error}`),
+					new Error(
+						`Failed to open WebSocket: ${error.message || error}`,
+					),
 				);
 				serverWsReject();
 			};
@@ -327,7 +592,8 @@ export async function createTestWebSocketProxy(
 			logger().debug({
 				msg: "clientWs info",
 				constructor: clientWs.constructor.name,
-				hasAddEventListener: typeof clientWs.addEventListener === "function",
+				hasAddEventListener:
+					typeof clientWs.addEventListener === "function",
 				readyState: clientWs.readyState,
 			});
 
@@ -341,7 +607,9 @@ export async function createTestWebSocketProxy(
 				isArrayBuffer: evt.data instanceof ArrayBuffer,
 				dataConstructor: evt.data?.constructor?.name,
 				dataStr:
-					typeof evt.data === "string" ? evt.data.substring(0, 100) : undefined,
+					typeof evt.data === "string"
+						? evt.data.substring(0, 100)
+						: undefined,
 			});
 
 			// Forward messages from server websocket to client websocket
@@ -369,7 +637,9 @@ export async function createTestWebSocketProxy(
 						msg: "sending data directly",
 						dataType: typeof evt.data,
 						dataLength:
-							typeof evt.data === "string" ? evt.data.length : undefined,
+							typeof evt.data === "string"
+								? evt.data.length
+								: undefined,
 					});
 					clientWs.send(evt.data);
 				}

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

@@ -76,7 +76,9 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 				isString: typeof data === "string",
 				isArrayBuffer: data instanceof ArrayBuffer,
 				dataStr:
-					typeof data === "string" ? data.substring(0, 100) : "<non-string>",
+					typeof data === "string"
+						? data.substring(0, 100)
+						: "<non-string>",
 			});
 
 			if (typeof data === "string") {
@@ -99,8 +101,7 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 				}
 			} else if (data instanceof Blob) {
 				// Convert Blob to ArrayBuffer
-				data
-					.arrayBuffer()
+				data.arrayBuffer()
 					.then((buffer) => {
 						(this.#ws as any).send(buffer);
 					})
@@ -109,7 +110,11 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 							msg: "failed to convert blob to arraybuffer",
 							error,
 						});
-						this.#fireEvent("error", { type: "error", target: this, error });
+						this.#fireEvent("error", {
+							type: "error",
+							target: this,
+							error,
+						});
 					});
 			} else {
 				// Try to convert to string as a fallback
@@ -128,7 +133,10 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 	}
 
 	close(code = 1000, reason = ""): void {
-		if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {
+		if (
+			this.readyState === this.CLOSING ||
+			this.readyState === this.CLOSED
+		) {
 			return;
 		}
 
@@ -260,7 +268,10 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 				try {
 					listener(event);
 				} catch (error) {
-					logger().error({ msg: `error in ${type} event listener`, error });
+					logger().error({
+						msg: `error in ${type} event listener`,
+						error,
+					});
 				}
 			}
 		}
@@ -272,7 +283,10 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 					try {
 						this.#onopen(event);
 					} catch (error) {
-						logger().error({ msg: "error in onopen handler", error });
+						logger().error({
+							msg: "error in onopen handler",
+							error,
+						});
 					}
 				}
 				break;
@@ -281,7 +295,10 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 					try {
 						this.#onclose(event);
 					} catch (error) {
-						logger().error({ msg: "error in onclose handler", error });
+						logger().error({
+							msg: "error in onclose handler",
+							error,
+						});
 					}
 				}
 				break;
@@ -290,7 +307,10 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 					try {
 						this.#onerror(event);
 					} catch (error) {
-						logger().error({ msg: "error in onerror handler", error });
+						logger().error({
+							msg: "error in onerror handler",
+							error,
+						});
 					}
 				}
 				break;
@@ -299,7 +319,10 @@ export class HonoWebSocketAdapter implements UniversalWebSocket {
 					try {
 						this.#onmessage(event);
 					} catch (error) {
-						logger().error({ msg: "error in onmessage handler", error });
+						logger().error({
+							msg: "error in onmessage handler",
+							error,
+						});
 					}
 				}
 				break;