rivetkit 2.0.9 → 2.0.11

package/src/drivers/engine/mod.ts

@@ -1,17 +1,19 @@
 import type { Client } from "@/client/client";
 import type { ManagerDriver } from "@/manager/driver";
 import type { RegistryConfig } from "@/registry/config";
-import type { DriverConfig, RunConfig } from "@/registry/run-config";
+import type { DriverConfig, RunnerConfig } from "@/registry/run-config";
 import { RemoteManagerDriver } from "@/remote-manager-driver/mod";
 import { EngineActorDriver } from "./actor-driver";
-import { ConfigSchema, type InputConfig } from "./config";
+import { type EngineConfigInput, EngingConfigSchema } from "./config";
 
 export { EngineActorDriver } from "./actor-driver";
-export { type Config, ConfigSchema, type InputConfig } from "./config";
-
-export function createEngineDriver(inputConfig?: InputConfig): DriverConfig {
-	const config = ConfigSchema.parse(inputConfig);
+export {
+	type EngineConfig as Config,
+	type EngineConfigInput as InputConfig,
+	EngingConfigSchema as ConfigSchema,
+} from "./config";
 
+export function createEngineDriver(): DriverConfig {
 	return {
 		name: "engine",
 		manager: (_registryConfig, runConfig) => {
@@ -19,7 +21,7 @@ export function createEngineDriver(inputConfig?: InputConfig): DriverConfig {
 		},
 		actor: (
 			registryConfig: RegistryConfig,
-			runConfig: RunConfig,
+			runConfig: RunnerConfig,
 			managerDriver: ManagerDriver,
 			inlineClient: Client<any>,
 		) => {
@@ -28,7 +30,6 @@ export function createEngineDriver(inputConfig?: InputConfig): DriverConfig {
 				runConfig,
 				managerDriver,
 				inlineClient,
-				config,
 			);
 		},
 	};

package/src/drivers/file-system/global-state.ts

@@ -14,7 +14,7 @@ import {
 	serializeEmptyPersistData,
 } from "@/driver-helpers/mod";
 import type { RegistryConfig } from "@/registry/config";
-import type { RunConfig } from "@/registry/run-config";
+import type { RunnerConfig } from "@/registry/run-config";
 import type * as schema from "@/schemas/file-system-driver/mod";
 import {
 	ACTOR_ALARM_VERSIONED,
@@ -73,7 +73,7 @@ export class FileSystemGlobalState {
 
 	#runnerParams?: {
 		registryConfig: RegistryConfig;
-		runConfig: RunConfig;
+		runConfig: RunnerConfig;
 		inlineClient: AnyClient;
 		actorDriver: ActorDriver;
 	};
@@ -410,7 +410,7 @@ export class FileSystemGlobalState {
 	 */
 	onRunnerStart(
 		registryConfig: RegistryConfig,
-		runConfig: RunConfig,
+		runConfig: RunnerConfig,
 		inlineClient: AnyClient,
 		actorDriver: ActorDriver,
 	) {
@@ -436,7 +436,7 @@ export class FileSystemGlobalState {
 
 	async startActor(
 		registryConfig: RegistryConfig,
-		runConfig: RunConfig,
+		runConfig: RunnerConfig,
 		inlineClient: AnyClient,
 		actorDriver: ActorDriver,
 		actorId: string,

package/src/engine-process/log.ts

@@ -0,0 +1,5 @@
+import { getLogger } from "@/common/log";
+
+export function logger() {
+	return getLogger("engine-process");
+}

package/src/engine-process/mod.ts

@@ -0,0 +1,316 @@
+import { spawn } from "node:child_process";
+import { createWriteStream } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { pipeline } from "node:stream/promises";
+import {
+	ensureDirectoryExists,
+	getStoragePath,
+} from "@/drivers/file-system/utils";
+import { logger } from "./log";
+
+export const ENGINE_PORT = 6420;
+export const ENGINE_ENDPOINT = `http://localhost:${ENGINE_PORT}`;
+
+const ENGINE_BASE_URL = "https://releases.rivet.gg/engine";
+const ENGINE_BINARY_NAME = "rivet-engine";
+
+interface EnsureEngineProcessOptions {
+	version: string;
+}
+
+export async function ensureEngineProcess(
+	options: EnsureEngineProcessOptions,
+): Promise<void> {
+	logger().debug({ msg: "ensuring engine process", version: options.version });
+	const storageRoot = getStoragePath();
+	const binDir = path.join(storageRoot, "bin");
+	const varDir = path.join(storageRoot, "var");
+	const logsDir = path.join(varDir, "logs", "rivet-engine");
+	await ensureDirectoryExists(binDir);
+	await ensureDirectoryExists(varDir);
+	await ensureDirectoryExists(logsDir);
+
+	const executableName =
+		process.platform === "win32"
+			? `${ENGINE_BINARY_NAME}-${options.version}.exe`
+			: `${ENGINE_BINARY_NAME}-${options.version}`;
+	const binaryPath = path.join(binDir, executableName);
+	await downloadEngineBinaryIfNeeded(binaryPath, options.version, varDir);
+
+	// Check if the engine is already running on the port
+	if (await isEngineRunning()) {
+		try {
+			await waitForEngineHealth();
+			logger().debug({
+				msg: "engine already running and healthy",
+				version: options.version,
+			});
+			return;
+		} catch (error) {
+			logger().warn({
+				msg: "existing engine process not healthy, cannot restart automatically",
+				error,
+			});
+			throw new Error(
+				"Engine process exists but is not healthy. Please manually stop the process on port 6420 and retry.",
+			);
+		}
+	}
+
+	// Create log file streams with timestamp in the filename
+	const timestamp = new Date()
+		.toISOString()
+		.replace(/:/g, "-")
+		.replace(/\./g, "-");
+	const stdoutLogPath = path.join(logsDir, `engine-${timestamp}-stdout.log`);
+	const stderrLogPath = path.join(logsDir, `engine-${timestamp}-stderr.log`);
+
+	const stdoutStream = createWriteStream(stdoutLogPath, { flags: "a" });
+	const stderrStream = createWriteStream(stderrLogPath, { flags: "a" });
+
+	logger().debug({
+		msg: "creating engine log files",
+		stdout: stdoutLogPath,
+		stderr: stderrLogPath,
+	});
+
+	const child = spawn(binaryPath, ["start"], {
+		cwd: path.dirname(binaryPath),
+		stdio: ["inherit", "pipe", "pipe"],
+		env: {
+			...process.env,
+		},
+	});
+
+	if (!child.pid) {
+		throw new Error("failed to spawn rivet engine process");
+	}
+
+	// Pipe stdout and stderr to log files
+	if (child.stdout) {
+		child.stdout.pipe(stdoutStream);
+	}
+	if (child.stderr) {
+		child.stderr.pipe(stderrStream);
+	}
+
+	logger().debug({
+		msg: "spawned engine process",
+		pid: child.pid,
+		cwd: path.dirname(binaryPath),
+	});
+
+	child.once("exit", (code, signal) => {
+		logger().warn({
+			msg: "engine process exited",
+			code,
+			signal,
+		});
+		// Clean up log streams
+		stdoutStream.end();
+		stderrStream.end();
+	});
+
+	child.once("error", (error) => {
+		logger().error({
+			msg: "engine process failed",
+			error,
+		});
+		// Clean up log streams on error
+		stdoutStream.end();
+		stderrStream.end();
+	});
+
+	// Wait for engine to be ready
+	await waitForEngineHealth();
+
+	logger().info({
+		msg: "engine process started",
+		pid: child.pid,
+		version: options.version,
+		logs: {
+			stdout: stdoutLogPath,
+			stderr: stderrLogPath,
+		},
+	});
+}
+
+async function downloadEngineBinaryIfNeeded(
+	binaryPath: string,
+	version: string,
+	varDir: string,
+): Promise<void> {
+	const binaryExists = await fileExists(binaryPath);
+	if (binaryExists) {
+		logger().debug({
+			msg: "engine binary already cached",
+			version,
+			path: binaryPath,
+		});
+		return;
+	}
+
+	const { targetTriplet, extension } = resolveTargetTriplet();
+	const remoteFile = `${ENGINE_BINARY_NAME}-${targetTriplet}${extension}`;
+	const downloadUrl = `${ENGINE_BASE_URL}/${version}/${remoteFile}`;
+	logger().info({
+		msg: "downloading engine binary",
+		url: downloadUrl,
+		path: binaryPath,
+		version,
+	});
+
+	const response = await fetch(downloadUrl);
+	if (!response.ok || !response.body) {
+		throw new Error(
+			`failed to download rivet engine binary from ${downloadUrl}: ${response.status} ${response.statusText}`,
+		);
+	}
+
+	const tempPath = `${binaryPath}.${process.pid}.tmp`;
+	await pipeline(response.body, createWriteStream(tempPath));
+	if (process.platform !== "win32") {
+		await fs.chmod(tempPath, 0o755);
+	}
+	await fs.rename(tempPath, binaryPath);
+	logger().debug({
+		msg: "engine binary download complete",
+		version,
+		path: binaryPath,
+	});
+	logger().info({
+		msg: "engine binary downloaded",
+		version,
+		path: binaryPath,
+	});
+}
+
+function resolveTargetTriplet(): { targetTriplet: string; extension: string } {
+	return resolveTargetTripletFor(process.platform, process.arch);
+}
+
+export function resolveTargetTripletFor(
+	platform: NodeJS.Platform,
+	arch: typeof process.arch,
+): { targetTriplet: string; extension: string } {
+	switch (platform) {
+		case "darwin":
+			if (arch === "arm64") {
+				return { targetTriplet: "aarch64-apple-darwin", extension: "" };
+			}
+			if (arch === "x64") {
+				return { targetTriplet: "x86_64-apple-darwin", extension: "" };
+			}
+			break;
+		case "linux":
+			if (arch === "x64") {
+				return { targetTriplet: "x86_64-unknown-linux-musl", extension: "" };
+			}
+			break;
+		case "win32":
+			if (arch === "x64") {
+				return { targetTriplet: "x86_64-pc-windows-gnu", extension: ".exe" };
+			}
+			break;
+	}
+
+	throw new Error(
+		`unsupported platform for rivet engine binary: ${platform}/${arch}`,
+	);
+}
+
+async function isEngineRunning(): Promise<boolean> {
+	// Check if the engine is running on the port
+	return await checkIfEngineAlreadyRunningOnPort(ENGINE_PORT);
+}
+
+async function checkIfEngineAlreadyRunningOnPort(
+	port: number,
+): Promise<boolean> {
+	let response: Response;
+	try {
+		response = await fetch(`http://localhost:${port}/health`);
+	} catch (err) {
+		// Nothing is running on this port
+		return false;
+	}
+
+	if (response.ok) {
+		const health = (await response.json()) as {
+			status?: string;
+			runtime?: string;
+			version?: string;
+		};
+
+		// Check what's running on this port
+		if (health.runtime === "engine") {
+			logger().debug({
+				msg: "rivet engine already running on port",
+				port,
+			});
+			return true;
+		} else if (health.runtime === "rivetkit") {
+			logger().error({
+				msg: "another rivetkit process is already running on port",
+				port,
+			});
+			throw new Error(
+				"RivetKit process already running on port 6420, stop that process and restart this.",
+			);
+		} else {
+			throw new Error(
+				"Unknown process running on port 6420, cannot identify what it is.",
+			);
+		}
+	}
+
+	// Port responded but not with OK status
+	return false;
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+const HEALTH_MAX_WAIT = 10_000;
+const HEALTH_INTERVAL = 100;
+
+async function waitForEngineHealth(): Promise<void> {
+	const maxRetries = Math.ceil(HEALTH_MAX_WAIT / HEALTH_INTERVAL);
+
+	logger().debug({ msg: "waiting for engine health check" });
+
+	for (let i = 0; i < maxRetries; i++) {
+		try {
+			const response = await fetch(`${ENGINE_ENDPOINT}/health`);
+			if (response.ok) {
+				logger().debug({ msg: "engine health check passed" });
+				return;
+			}
+		} catch (error) {
+			// Expected to fail while engine is starting up
+			if (i === maxRetries - 1) {
+				throw new Error(
+					`engine health check failed after ${maxRetries} retries: ${error}`,
+				);
+			}
+		}
+
+		if (i < maxRetries - 1) {
+			logger().trace({
+				msg: "engine not ready, retrying",
+				attempt: i + 1,
+				maxRetries,
+			});
+			await new Promise((resolve) => setTimeout(resolve, HEALTH_INTERVAL));
+		}
+	}
+
+	throw new Error(`engine health check failed after ${maxRetries} retries`);
+}

package/src/inspector/utils.ts

@@ -2,7 +2,7 @@ import crypto from "node:crypto";
 import { createMiddleware } from "hono/factory";
 import type { ManagerDriver } from "@/driver-helpers/mod";
 import type { RunConfig } from "@/mod";
-import type { RunConfigInput } from "@/registry/run-config";
+import type { RunnerConfigInput } from "@/registry/run-config";
 import { inspectorLogger } from "./log";
 
 export function compareSecrets(providedSecret: string, validSecret: string) {
@@ -47,7 +47,7 @@ export const secureInspector = (runConfig: RunConfig) =>
 		await next();
 	});
 
-export function getInspectorUrl(runConfig: RunConfigInput | undefined) {
+export function getInspectorUrl(runConfig: RunnerConfigInput | undefined) {
 	if (!runConfig?.inspector?.enabled) {
 		return "disabled";
 	}
@@ -65,8 +65,10 @@ export function getInspectorUrl(runConfig: RunConfigInput | undefined) {
 
 	url.searchParams.set("t", accessToken);
 
-	if (runConfig?.inspector?.defaultEndpoint) {
-		url.searchParams.set("u", runConfig.inspector.defaultEndpoint);
+	const overrideDefaultEndpoint =
+		runConfig?.inspector?.defaultEndpoint ?? runConfig.overrideServerAddress;
+	if (overrideDefaultEndpoint) {
+		url.searchParams.set("u", overrideDefaultEndpoint);
 	}
 
 	return url.href;

package/src/manager/driver.ts

@@ -2,11 +2,11 @@ import type { Env, Hono, Context as HonoContext } from "hono";
 import type { ActorKey, Encoding, UniversalWebSocket } from "@/actor/mod";
 import type { ManagerInspector } from "@/inspector/manager";
 import type { RegistryConfig } from "@/registry/config";
-import type { RunConfig } from "@/registry/run-config";
+import type { RunnerConfig } from "@/registry/run-config";
 
 export type ManagerDriverBuilder = (
 	registryConfig: RegistryConfig,
-	runConfig: RunConfig,
+	runConfig: RunnerConfig,
 ) => ManagerDriver;
 
 export interface ManagerDriver {

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",
+	}),
+});