rivetkit 2.3.0-rc.6 → 2.3.0-rc.7

package/src/registry/index.ts

@@ -1,6 +1,8 @@
+import { Hono } from "hono";
 import { ENGINE_ENDPOINT } from "@/common/engine";
 import { configureServerlessPool } from "@/serverless/configure";
-import { VERSION } from "@/utils";
+import { detectRuntime, VERSION } from "@/utils";
+import { crossPlatformServe, loadRuntimeServeStatic } from "@/utils/serve";
 import {
 	type RegistryActors,
 	type RegistryConfig,
@@ -38,15 +40,13 @@ export interface ServerlessHandler {
 	fetch: FetchHandler;
 }
 
-export interface RegistryRoutes {
-	health(): Promise<Response>;
-	metadata(): Promise<Response>;
-	prometheusMetrics(request?: Request): Promise<Response>;
+export interface RegistryDiagnostics {
+	mode: string;
+	envoyActiveActorCount?: number | null;
 }
 
 export class Registry<A extends RegistryActors> {
 	#config: RegistryConfigInput<A>;
-	public readonly routes: RegistryRoutes;
 
 	get config(): RegistryConfigInput<A> {
 		return this.#config;
@@ -67,12 +67,6 @@ export class Registry<A extends RegistryActors> {
 
 	constructor(config: RegistryConfigInput<A>) {
 		this.#config = config;
-		this.routes = {
-			health: () => this.#healthRoute(),
-			metadata: () => this.#metadataRoute(),
-			prometheusMetrics: (request?: Request) =>
-				this.#prometheusMetricsRoute(request),
-		};
 	}
 
 	#ensureServerlessPoolConfigured(config: RegistryConfig): Promise<void> | undefined {
@@ -304,91 +298,36 @@ export class Registry<A extends RegistryActors> {
 	}
 
 	/**
-	 * Returns a health response suitable for mounting in a user-owned router.
-	 */
-	async #healthRoute(): Promise<Response> {
-		const configured = await this.#activeConfiguredRegistry();
-		if (!configured) {
-			return jsonRouteResponse(503, {
-				status: "not_started",
-				runtime: "rivetkit",
-				version: VERSION,
-			});
-		}
-
-		const { runtime, registry } = configured;
-		if (!runtime.registryHealth) {
-			return jsonRouteResponse(501, {
-				status: "unsupported",
-				runtime: "rivetkit",
-				version: VERSION,
-			});
-		}
-
-		const response = await runtime.registryHealth(registry);
-		return new Response(new Uint8Array(response.body), {
-			status: response.status,
-			headers: response.headers,
-		});
-	}
-
-	/**
-	 * Returns serverless metadata suitable for mounting in a user-owned router.
-	 */
-	async #metadataRoute(): Promise<Response> {
-		const configured = await this.#activeConfiguredRegistry();
-		if (!configured) {
-			return new Response("registry not started\n", {
-				status: 503,
-				headers: { "content-type": "text/plain; charset=utf-8" },
-			});
-		}
-
-		const { runtime, registry } = configured;
-		if (!runtime.registryMetadata) {
-			return new Response("metadata is not supported by this runtime\n", {
-				status: 501,
-				headers: { "content-type": "text/plain; charset=utf-8" },
-			});
-		}
-
-		const response = await runtime.registryMetadata(registry);
-		return new Response(new Uint8Array(response.body), {
-			status: response.status,
-			headers: response.headers,
-		});
-	}
-
-	/**
-	 * Returns a Prometheus metrics response suitable for mounting in a user-owned router.
+	 * Starts an HTTP server that dispatches every request through the
+	 * serverless handler. Uses `crossPlatformServe` to pick the right
+	 * runtime (Node, Bun, Deno).
+	 *
+	 * @param opts.port      Port to listen on. Defaults to 3000.
+	 * @param opts.publicDir If set, serves static files from this directory
+	 *                       before falling through to the registry handler.
+	 *
+	 * @example
+	 * ```ts
+	 * await registry.listen();
+	 * await registry.listen({ port: 8080, publicDir: "./public" });
+	 * ```
 	 */
-	async #prometheusMetricsRoute(_request?: Request): Promise<Response> {
-		const configured = await this.#activeConfiguredRegistry();
-		if (!configured) {
-			return new Response("registry not started\n", {
-				status: 503,
-				headers: { "content-type": "text/plain; charset=utf-8" },
-			});
-		}
-
-		const { runtime, registry } = configured;
-		if (!runtime.registryMetrics) {
-			return new Response("metrics are not supported by this runtime\n", {
-				status: 501,
-				headers: { "content-type": "text/plain; charset=utf-8" },
-			});
+	public async listen(
+		opts: { port?: number; publicDir?: string } = {},
+	): Promise<void> {
+		const port = opts.port ?? 3000;
+		const config = this.parseConfig();
+		const runtime = detectRuntime();
+		const app = new Hono();
+		if (opts.publicDir) {
+			const serveStatic = await loadRuntimeServeStatic(runtime);
+			app.use("*", serveStatic({ root: opts.publicDir }));
 		}
-
-		const response = await runtime.registryMetrics(registry);
-		return new Response(new Uint8Array(response.body), {
-			status: response.status,
-			headers: response.headers,
-		});
+		app.all("*", (c) => this.handler(c.req.raw));
+		await crossPlatformServe(config, port, app, runtime);
 	}
 
-	async #activeConfiguredRegistry(): Promise<
-		Awaited<ReturnType<typeof buildConfiguredRegistry>> | undefined
-	> {
+	public async diagnostics(): Promise<RegistryDiagnostics> {
 		const candidates = [
 			this.#runtimeServerlessPromise,
 			this.#runtimeServeConfiguredPromise,
@@ -396,8 +335,13 @@ export class Registry<A extends RegistryActors> {
 			candidate !== undefined
 		);
 
-		if (candidates.length === 0) return undefined;
-		return await candidates[0]!;
+		for (const candidate of candidates) {
+			const { runtime, registry } = await candidate;
+			const diagnostics = await runtime.registryDiagnostics?.(registry);
+			if (diagnostics) return diagnostics;
+		}
+
+		return { mode: "not_started", envoyActiveActorCount: null };
 	}
 
 	/**
@@ -411,12 +355,12 @@ export class Registry<A extends RegistryActors> {
 				.then(async ({ runtime, registry, serveConfig }) => {
 					await runtime.serveRegistry(registry, serveConfig);
 				})
-				.catch((err) => {
+				.catch((error) => {
 					// Always-attached catch so the stored promise never leaves a
 					// rejection unhandled. Downstream awaits (e.g. #runShutdown's
 					// Promise.race) attach their own catches and still observe
 					// resolution via the race.
-					logger().warn({ err }, "runtime registry serve errored");
+					logger().warn({ error }, "runtime registry serve errored");
 				});
 			// Install signal handlers once an envoy lifecycle has begun. Only
 			// Mode A ever reaches here. Mode B (handler(request)) intentionally
@@ -479,8 +423,8 @@ export class Registry<A extends RegistryActors> {
 			signal,
 			config,
 			configuredRegistryPromise,
-		).catch((err) => {
-			logger().warn({ err }, "shutdown error");
+		).catch((error) => {
+			logger().warn({ error }, "shutdown error");
 		});
 	}
 
@@ -507,9 +451,9 @@ export class Registry<A extends RegistryActors> {
 						const { runtime, registry } =
 							await configuredRegistryPromise;
 						await runtime.shutdownRegistry(registry);
-					} catch (err) {
+					} catch (error) {
 						logger().warn(
-							{ err },
+							{ error },
 							"runtime registry shutdown errored (mode A)",
 						);
 					}
@@ -525,7 +469,7 @@ export class Registry<A extends RegistryActors> {
 							await runtime.shutdownRegistry(registry);
 						} catch (err) {
 							logger().warn(
-								{ err },
+								{ error: err },
 								"runtime registry shutdown errored (mode B)",
 							);
 						}
@@ -654,13 +598,6 @@ function isServerlessMetadataRequest(request: Request, basePath: string): boolea
 	return parsed.pathname === `${normalizedBase}/metadata`;
 }
 
-function jsonRouteResponse(status: number, body: unknown): Response {
-	return new Response(JSON.stringify(body), {
-		status,
-		headers: { "content-type": "application/json" },
-	});
-}
-
 export function setup<A extends RegistryActors>(
 	input: RegistryConfigInput<A>,
 ): Registry<A> {

package/src/registry/napi-runtime.ts

@@ -24,7 +24,7 @@ import type {
 	RuntimeQueueTryNextBatchOptions,
 	RuntimeQueueWaitOptions,
 	RuntimeRequestSaveOpts,
-	RuntimeRegistryRouteResponse,
+	RuntimeRegistryDiagnostics,
 	RuntimeServeConfig,
 	RuntimeServerlessRequest,
 	RuntimeServerlessResponseHead,
@@ -202,6 +202,16 @@ export class NapiCoreRuntime implements CoreRuntime {
 		await asNativeRegistry(registry).shutdown();
 	}
 
+	async registryDiagnostics(
+		registry: RegistryHandle,
+	): Promise<RuntimeRegistryDiagnostics> {
+		const diagnostics = await asNativeRegistry(registry).diagnostics();
+		return {
+			mode: diagnostics.mode,
+			envoyActiveActorCount: diagnostics.envoyActiveActorCount,
+		};
+	}
+
 	async registryActorStopThresholdMs(
 		registry: RegistryHandle,
 	): Promise<number | undefined> {
@@ -211,39 +221,6 @@ export class NapiCoreRuntime implements CoreRuntime {
 		);
 	}
 
-	async registryHealth(
-		registry: RegistryHandle,
-	): Promise<RuntimeRegistryRouteResponse> {
-		const response = await asNativeRegistry(registry).health();
-		return {
-			status: response.status,
-			headers: response.headers,
-			body: response.body,
-		};
-	}
-
-	async registryMetadata(
-		registry: RegistryHandle,
-	): Promise<RuntimeRegistryRouteResponse> {
-		const response = asNativeRegistry(registry).metadata();
-		return {
-			status: response.status,
-			headers: response.headers,
-			body: response.body,
-		};
-	}
-
-	async registryMetrics(
-		registry: RegistryHandle,
-	): Promise<RuntimeRegistryRouteResponse> {
-		const response = asNativeRegistry(registry).metrics();
-		return {
-			status: response.status,
-			headers: response.headers,
-			body: response.body,
-		};
-	}
-
 	async handleServerlessRequest(
 		registry: RegistryHandle,
 		req: RuntimeServerlessRequest,