rivetkit 2.0.8 → 2.0.10

package/src/manager/gateway.ts

@@ -14,7 +14,7 @@ import {
 } from "@/common/actor-router-consts";
 import { deconstructError, noopNext } from "@/common/utils";
 import type { UniversalWebSocket, UpgradeWebSocketArgs } from "@/mod";
-import type { RunConfig } from "@/registry/run-config";
+import type { RunnerConfig } from "@/registry/run-config";
 import { promiseWithResolvers, stringifyError } from "@/utils";
 import type { ManagerDriver } from "./driver";
 import { logger } from "./log";
@@ -27,7 +27,7 @@ import { logger } from "./log";
  * - HTTP requests: Uses x-rivet-target and x-rivet-actor headers for routing
  */
 export async function actorGateway(
-	runConfig: RunConfig,
+	runConfig: RunnerConfig,
 	managerDriver: ManagerDriver,
 	c: HonoContext,
 	next: Next,
@@ -37,22 +37,38 @@ export async function actorGateway(
 		return next();
 	}
 
+	// Strip basePath from the request path
+	let strippedPath = c.req.path;
+	if (runConfig.basePath && strippedPath.startsWith(runConfig.basePath)) {
+		strippedPath = strippedPath.slice(runConfig.basePath.length);
+		// Ensure the path starts with /
+		if (!strippedPath.startsWith("/")) {
+			strippedPath = "/" + strippedPath;
+		}
+	}
+
 	// Check if this is a WebSocket upgrade request
 	if (c.req.header("upgrade") === "websocket") {
-		return await handleWebSocketGateway(runConfig, managerDriver, c);
+		return await handleWebSocketGateway(
+			runConfig,
+			managerDriver,
+			c,
+			strippedPath,
+		);
 	}
 
 	// Handle regular HTTP requests
-	return await handleHttpGateway(managerDriver, c, next);
+	return await handleHttpGateway(managerDriver, c, next, strippedPath);
 }
 
 /**
  * Handle WebSocket requests using sec-websocket-protocol for routing
  */
 async function handleWebSocketGateway(
-	runConfig: RunConfig,
+	runConfig: RunnerConfig,
 	managerDriver: ManagerDriver,
 	c: HonoContext,
+	strippedPath: string,
 ) {
 	const upgradeWebSocket = runConfig.getUpgradeWebSocket?.();
 	if (!upgradeWebSocket) {
@@ -100,7 +116,7 @@ async function handleWebSocketGateway(
 	logger().debug({
 		msg: "proxying websocket to actor",
 		actorId,
-		path: c.req.path,
+		path: strippedPath,
 		encoding: encodingRaw,
 	});
 
@@ -109,8 +125,8 @@ async function handleWebSocketGateway(
 
 	// Include query string if present
 	const pathWithQuery = c.req.url.includes("?")
-		? c.req.path + c.req.url.substring(c.req.url.indexOf("?"))
-		: c.req.path;
+		? strippedPath + c.req.url.substring(c.req.url.indexOf("?"))
+		: strippedPath;
 
 	return await managerDriver.proxyWebSocket(
 		c,
@@ -130,6 +146,7 @@ async function handleHttpGateway(
 	managerDriver: ManagerDriver,
 	c: HonoContext,
 	next: Next,
+	strippedPath: string,
 ) {
 	const target = c.req.header(HEADER_RIVET_TARGET);
 	const actorId = c.req.header(HEADER_RIVET_ACTOR);
@@ -145,7 +162,7 @@ async function handleHttpGateway(
 	logger().debug({
 		msg: "proxying request to actor",
 		actorId,
-		path: c.req.path,
+		path: strippedPath,
 		method: c.req.method,
 	});
 
@@ -156,14 +173,15 @@ async function handleHttpGateway(
 
 	// Build the proxy request with the actor URL format
 	const url = new URL(c.req.url);
-	const proxyUrl = new URL(`http://actor${url.pathname}${url.search}`);
+	const proxyUrl = new URL(`http://actor${strippedPath}${url.search}`);
 
 	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, actorId);
 }

package/src/manager/router-schema.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+
+export const ServerlessStartHeadersSchema = z.object({
+	endpoint: z.string({ required_error: "x-rivet-endpoint header is required" }),
+	token: z
+		.string({ invalid_type_error: "x-rivet-token header must be a string" })
+		.optional(),
+	totalSlots: z.coerce
+		.number({
+			invalid_type_error: "x-rivet-total-slots header must be a number",
+		})
+		.int("x-rivet-total-slots header must be an integer")
+		.gte(1, "x-rivet-total-slots header must be positive"),
+	runnerName: z.string({
+		required_error: "x-rivet-runner-name header is required",
+	}),
+	namespace: z.string({
+		required_error: "x-rivet-namespace-id header is required",
+	}),
+});

package/src/manager/router.ts

@@ -2,18 +2,18 @@ import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
 import * as cbor from "cbor-x";
 import {
 	Hono,
-	Context as HonoContext,
+	type Context as HonoContext,
 	type MiddlewareHandler,
-	Next,
+	type Next,
 } from "hono";
 import { cors as corsMiddleware } from "hono/cors";
 import { createMiddleware } from "hono/factory";
 import { streamSSE } from "hono/streaming";
 import invariant from "invariant";
 import { z } from "zod";
-import { ActorNotFound, Unsupported } from "@/actor/errors";
+import { ActorNotFound, InvalidRequest, Unsupported } from "@/actor/errors";
 import { serializeActorKey } from "@/actor/keys";
-import type { Encoding, Transport } from "@/client/mod";
+import type { Client, Encoding, Transport } from "@/client/mod";
 import {
 	WS_PROTOCOL_ACTOR,
 	WS_PROTOCOL_CONN_ID,
@@ -28,7 +28,12 @@ import {
 	handleRouteNotFound,
 	loggerMiddleware,
 } from "@/common/router";
-import { deconstructError, noopNext, stringifyError } from "@/common/utils";
+import {
+	assertUnreachable,
+	deconstructError,
+	noopNext,
+	stringifyError,
+} from "@/common/utils";
 import { type ActorDriver, HEADER_ACTOR_ID } from "@/driver-helpers/mod";
 import type {
 	TestInlineDriverCallRequest,
@@ -50,11 +55,14 @@ import {
 	type Actor as ApiActor,
 } from "@/manager-api/actors";
 import { RivetIdSchema } from "@/manager-api/common";
+import type { AnyClient } from "@/mod";
 import type { RegistryConfig } from "@/registry/config";
-import type { RunConfig } from "@/registry/run-config";
+import type { DriverConfig, RunnerConfig } from "@/registry/run-config";
+import { VERSION } from "@/utils";
 import type { ActorOutput, ManagerDriver } from "./driver";
 import { actorGateway, createTestWebSocketProxy } from "./gateway";
 import { logger } from "./log";
+import { ServerlessStartHeadersSchema } from "./router-schema";
 
 function buildOpenApiResponses<T>(schema: T) {
 	return {
@@ -77,81 +85,170 @@ function buildOpenApiResponses<T>(schema: T) {
 
 export function createManagerRouter(
 	registryConfig: RegistryConfig,
-	runConfig: RunConfig,
+	runConfig: RunnerConfig,
 	managerDriver: ManagerDriver,
-	serverlessActorDriverBuilder: (() => ActorDriver) | undefined,
-): { router: Hono; openapi: OpenAPIHono; cors: MiddlewareHandler } {
+	driverConfig: DriverConfig,
+	client: AnyClient,
+): { router: Hono; openapi: OpenAPIHono } {
 	const router = new OpenAPIHono({ strict: false }).basePath(
 		runConfig.basePath,
 	);
 
 	router.use("*", loggerMiddleware(logger()));
 
-	const cors = runConfig.cors
-		? corsMiddleware(runConfig.cors)
-		: createMiddleware((_c, next) => next());
+	// HACK: Add Sec-WebSocket-Protocol header to fix KIT-339
+	//
+	// Some Deno WebSocket providers do not auto-set the protocol, which
+	// will cause some WebSocket clients to fail
+	router.use(
+		"*",
+		createMiddleware(async (c, next) => {
+			const upgrade = c.req.header("upgrade");
+			const isWebSocket = upgrade?.toLowerCase() === "websocket";
+			const isGet = c.req.method === "GET";
+
+			if (isGet && isWebSocket) {
+				c.header("Sec-WebSocket-Protocol", "rivet");
+			}
 
-	if (serverlessActorDriverBuilder) {
-		addServerlessRoutes(serverlessActorDriverBuilder, router, cors);
+			await next();
+		}),
+	);
+
+	if (runConfig.runnerKind === "serverless") {
+		addServerlessRoutes(
+			driverConfig,
+			registryConfig,
+			runConfig,
+			managerDriver,
+			client,
+			router,
+		);
+	} else if (runConfig.runnerKind === "normal") {
+		addManagerRoutes(registryConfig, runConfig, managerDriver, router);
 	} else {
-		addManagerRoutes(registryConfig, runConfig, managerDriver, router, cors);
+		assertUnreachable(runConfig.runnerKind);
 	}
 
 	// Error handling
 	router.notFound(handleRouteNotFound);
 	router.onError(handleRouteError);
 
-	return { router: router as Hono, openapi: router, cors };
+	return { router: router as Hono, openapi: router };
 }
 
 function addServerlessRoutes(
-	serverlessActorDriverBuilder: (
-		token: string | undefined,
-		totalSlots: number | undefined,
-	) => ActorDriver,
+	driverConfig: DriverConfig,
+	registryConfig: RegistryConfig,
+	runConfig: RunnerConfig,
+	managerDriver: ManagerDriver,
+	client: AnyClient,
 	router: OpenAPIHono,
-	cors: MiddlewareHandler,
 ) {
+	// Apply CORS
+	if (runConfig.cors) router.use("*", corsMiddleware(runConfig.cors));
+
 	// GET /
-	router.get("/", cors, (c) => {
+	router.get("/", (c) => {
 		return c.text(
 			"This is a RivetKit server.\n\nLearn more at https://rivetkit.org",
 		);
 	});
 
 	// Serverless start endpoint
-	router.get("/start", cors, async (c) => {
-		const token = c.req.header("x-rivet-token");
-		let totalSlots: number | undefined = parseInt(
-			c.req.header("x-rivetkit-total-slots") as any,
-		);
-		if (isNaN(totalSlots)) totalSlots = undefined;
+	router.get("/start", async (c) => {
+		// Parse headers
+		const parseResult = ServerlessStartHeadersSchema.safeParse({
+			endpoint: c.req.header("x-rivet-endpoint"),
+			token: c.req.header("x-rivet-token") ?? undefined,
+			totalSlots: c.req.header("x-rivet-total-slots"),
+			runnerName: c.req.header("x-rivet-runner-name"),
+			namespace: c.req.header("x-rivet-namespace-id"),
+		});
+		if (!parseResult.success) {
+			throw new InvalidRequest(
+				parseResult.error.issues[0]?.message ??
+					"invalid serverless start headers",
+			);
+		}
+		const { endpoint, token, totalSlots, runnerName, namespace } =
+			parseResult.data;
+
+		logger().debug({
+			msg: "received serverless runner start request",
+			endpoint,
+			totalSlots,
+			runnerName,
+			namespace,
+		});
 
-		const actorDriver = serverlessActorDriverBuilder(token, totalSlots);
+		// Override config
+		//
+		// We can't do a structuredClone here since this holds functions
+		const newRunConfig = Object.assign({}, runConfig);
+		newRunConfig.endpoint = endpoint;
+		newRunConfig.token = token;
+		newRunConfig.totalSlots = totalSlots;
+		newRunConfig.runnerName = runnerName;
+		newRunConfig.namespace = namespace;
+
+		// Create new actor driver with updated config
+		const actorDriver = driverConfig.actor(
+			registryConfig,
+			newRunConfig,
+			managerDriver,
+			client,
+		);
 		invariant(
 			actorDriver.serverlessHandleStart,
 			"missing serverlessHandleStart on ActorDriver",
 		);
+
 		return await actorDriver.serverlessHandleStart(c);
 	});
 
-	router.get("/health", cors, (c) => {
-		return c.text("ok");
+	router.get("/health", (c) => {
+		return c.json({
+			status: "ok",
+			runtime: "rivetkit",
+			version: VERSION,
+		});
 	});
 }
 
 function addManagerRoutes(
 	registryConfig: RegistryConfig,
-	runConfig: RunConfig,
+	runConfig: RunnerConfig,
 	managerDriver: ManagerDriver,
 	router: OpenAPIHono,
-	cors: MiddlewareHandler,
 ) {
+	// Serve inspector BEFORE the rest of the routes, since this has a special
+	// CORS config that should take precedence for the `/inspector` path
+	if (isInspectorEnabled(runConfig, "manager")) {
+		if (!managerDriver.inspector) {
+			throw new Unsupported("inspector");
+		}
+		router.route(
+			"/inspect",
+			new Hono<{ Variables: { inspector: any } }>()
+				.use(corsMiddleware(runConfig.inspector.cors))
+				.use(secureInspector(runConfig))
+				.use((c, next) => {
+					c.set("inspector", managerDriver.inspector!);
+					return next();
+				})
+				.route("/", createManagerInspectorRouter()),
+		);
+	}
+
+	// Apply CORS
+	if (runConfig.cors) router.use("*", corsMiddleware(runConfig.cors));
+
 	// Actor gateway
-	router.use("*", cors, actorGateway.bind(undefined, runConfig, managerDriver));
+	router.use("*", actorGateway.bind(undefined, runConfig, managerDriver));
 
 	// GET /
-	router.get("/", cors, (c) => {
+	router.get("/", (c) => {
 		return c.text(
 			"This is a RivetKit server.\n\nLearn more at https://rivetkit.org",
 		);
@@ -160,7 +257,6 @@ function addManagerRoutes(
 	// GET /actors
 	{
 		const route = createRoute({
-			middleware: [cors],
 			method: "get",
 			path: "/actors",
 			request: {
@@ -233,7 +329,6 @@ function addManagerRoutes(
 	// PUT /actors
 	{
 		const route = createRoute({
-			middleware: [cors],
 			method: "put",
 			path: "/actors",
 			request: {
@@ -286,7 +381,6 @@ function addManagerRoutes(
 	// POST /actors
 	{
 		const route = createRoute({
-			middleware: [cors],
 			method: "post",
 			path: "/actors",
 			request: {
@@ -326,7 +420,6 @@ function addManagerRoutes(
 	// // DELETE /actors/{actor_id}
 	// {
 	// 	const route = createRoute({
-	// 		middleware: [cors],
 	// 		method: "delete",
 	// 		path: "/actors/{actor_id}",
 	// 		request: {
@@ -547,31 +640,19 @@ function addManagerRoutes(
 		});
 	}
 
-	router.get("/health", cors, (c) => {
-		return c.text("ok");
+	router.get("/health", (c) => {
+		return c.json({
+			status: "ok",
+			rivetkit: {
+				version: VERSION,
+			},
+		});
 	});
 
 	managerDriver.modifyManagerRouter?.(
 		registryConfig,
 		router as unknown as Hono,
 	);
-
-	if (isInspectorEnabled(runConfig, "manager")) {
-		if (!managerDriver.inspector) {
-			throw new Unsupported("inspector");
-		}
-		router.route(
-			"/inspect",
-			new Hono<{ Variables: { inspector: any } }>()
-				.use(corsMiddleware(runConfig.inspector.cors))
-				.use(secureInspector(runConfig))
-				.use((c, next) => {
-					c.set("inspector", managerDriver.inspector!);
-					return next();
-				})
-				.route("/", createManagerInspectorRouter()),
-		);
-	}
 }
 
 function createApiActor(actor: ActorOutput): ApiActor {