rivetkit 0.0.0-codex-rivetkit-cli-preview.e0b3ae0 → 0.0.0-codex-docsrs-rivetkit-build.45929bf

package/src/registry/native.ts

@@ -2,6 +2,7 @@ import { VirtualWebSocket } from "@rivetkit/virtual-websocket";
 import {
 	ACTOR_CONTEXT_INTERNAL_SYMBOL,
 	CONN_STATE_MANAGER_SYMBOL,
+	disposeRunInspector,
 	getRunFunction,
 	getRunInspectorConfig,
 	RAW_STATE_SYMBOL,
@@ -13,6 +14,7 @@ import {
 	encodeBridgeRivetError,
 	forbiddenError,
 	INTERNAL_ERROR_CODE,
+	isActorAbortedError,
 	isRivetErrorLike,
 	RivetError,
 	type RivetErrorLike,
@@ -51,6 +53,11 @@ import type {
 } from "@/registry/config";
 import { decodeCborCompat, encodeCborCompat } from "@/serde";
 import { getEnvUniversal, VERSION } from "@/utils";
+import {
+	getNodeFsSync,
+	getNodePath,
+	importNodeDependencies,
+} from "@/utils/node";
 import { logger } from "./log";
 import { loadNapiRuntime } from "./napi-runtime";
 import {
@@ -78,12 +85,11 @@ import type {
 	WebSocketHandle,
 } from "./runtime";
 import { loadWasmRuntime } from "./wasm-runtime";
-import nodeFs from "node:fs";
-import nodePath from "node:path";
 import { createWriteThroughProxy } from "./write-through-proxy";
 
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
+
 type ResolvedRuntimeKind = Exclude<RuntimeKind, "auto">;
 type RuntimeHostKind = "node-like" | "edge-like";
 export type RuntimeLoaders = {
@@ -93,6 +99,7 @@ export type RuntimeLoaders = {
 	) => ReturnType<typeof loadWasmRuntime>;
 	detectHost: () => RuntimeHostKind;
 };
+
 type SerializeStateReason = "save" | "inspector";
 type NativeOnStateChangeHandler = (
 	ctx: ActorContextHandleAdapter,
@@ -1806,11 +1813,7 @@ class NativeQueueAdapter {
 				}
 				yield message;
 			} catch (error) {
-				if (
-					isRivetErrorLike(error) &&
-					error.group === "actor" &&
-					error.code === "aborted"
-				) {
+				if (isActorAbortedError(error)) {
 					return;
 				}
 				throw error;
@@ -2843,7 +2846,15 @@ export class ActorContextHandleAdapter {
 
 	internalKeepAwake<T>(run: Promise<T> | (() => Promise<T>)): Promise<T> {
 		const promise = typeof run === "function" ? run() : run;
-		const trackedPromise = promise.then(() => null);
+		// Track only completion, swallowing the outcome. The real result/error
+		// is delivered through the returned `promise`; without a rejection
+		// handler here every workflow yield (which rejects with SleepError)
+		// would be funneled into the registered task and logged as a spurious
+		// "keep_awake promise rejected" warning.
+		const trackedPromise = promise.then(
+			() => null,
+			() => null,
+		);
 		try {
 			callNativeSync(() =>
 				this.#runtime.actorRegisterTask(this.#ctx, trackedPromise),
@@ -3276,6 +3287,7 @@ function withConnContext(
 function buildActorConfig(
 	definition: AnyActorDefinition,
 	registryConfig: RegistryConfig,
+	runtimeKind: "napi" | "wasm",
 ): RuntimeActorConfig {
 	const config = definition.config as unknown as Record<string, unknown>;
 	const options = (config.options ?? {}) as Record<string, unknown>;
@@ -3330,12 +3342,13 @@ function buildActorConfig(
 		actions: Object.keys((config.actions ?? {}) as Record<string, unknown>)
 			.sort()
 			.map((name) => ({ name })),
-		inspectorTabs: buildInspectorTabs(config.inspector),
+		inspectorTabs: buildInspectorTabs(config.inspector, runtimeKind),
 	};
 }
 
 function buildInspectorTabs(
 	inspector: unknown,
+	runtimeKind: "napi" | "wasm",
 ): Array<RuntimeInspectorTabEntry> | undefined {
 	if (!inspector || typeof inspector !== "object") return undefined;
 	const tabs = (inspector as { tabs?: unknown }).tabs;
@@ -3351,12 +3364,28 @@ function buildInspectorTabs(
 		if (entry.hidden === true) {
 			return { id: entry.id, hidden: true };
 		}
-		// Resolve the author's source path against the current working
-		// directory so the Rust runtime gets an absolute path. The author
-		// runs the actor process from their project root by convention.
+
+		if (runtimeKind === "wasm") {
+			if (entry.source !== undefined) {
+				logger().warn(
+					{
+						tabId: entry.id,
+						runtimeKind,
+					},
+					"inspector.tabs[].source is not supported on wasm runners (current host: wasm). Tab descriptors will still appear in the dashboard strip but the tab body will render a not-available placeholder.",
+				);
+			}
+			return {
+				id: entry.id,
+				label: entry.label,
+				icon: entry.icon,
+				source: undefined,
+			};
+		}
+
 		const resolved =
 			entry.source !== undefined
-				? nodePath.resolve(entry.source)
+				? getNodePath().resolve(entry.source)
 				: undefined;
 		if (resolved !== undefined) {
 			validateInspectorTabSource(entry.id, resolved);
@@ -3371,11 +3400,7 @@ function buildInspectorTabs(
 }
 
 function validateInspectorTabSource(tabId: string, resolved: string): void {
-	// Catch obviously dangerous misconfigurations at registry construction
-	// rather than silently exposing the wrong subtree over the unauthenticated
-	// `/inspector/custom-tabs/<id>/*` route. Fail loudly so misconfigured
-	// actors never start.
-	if (resolved === nodePath.parse(resolved).root) {
+	if (resolved === getNodePath().parse(resolved).root) {
 		throw new Error(
 			`inspector.tabs[id="${tabId}"].source resolves to the filesystem root (${resolved}). ` +
 				"Point it at the tab's own static-asset directory instead.",
@@ -3383,7 +3408,7 @@ function validateInspectorTabSource(tabId: string, resolved: string): void {
 	}
 	let stat: import("node:fs").Stats;
 	try {
-		stat = nodeFs.statSync(resolved);
+		stat = getNodeFsSync().statSync(resolved);
 	} catch (err) {
 		const code = (err as NodeJS.ErrnoException)?.code;
 		if (code === "ENOENT") {
@@ -3542,15 +3567,23 @@ export function buildNativeFactory(
 				},
 			);
 		};
-		try {
-			await runtime.actorVerifyInspectorAuth(
-				ctx,
-				jsRequest.headers
-					.get("authorization")
-					?.replace(/^Bearer\s+/i, "") ?? null,
-			);
-		} catch (error) {
-			return errorResponse(error, 401);
+
+		const isPublicPerActorPath =
+			jsRequest.method === "GET" &&
+			(url.pathname === "/inspector/tab-config" ||
+				url.pathname.startsWith("/inspector/custom-tabs/"));
+
+		if (!isPublicPerActorPath) {
+			try {
+				await runtime.actorVerifyInspectorAuth(
+					ctx,
+					jsRequest.headers
+						.get("authorization")
+						?.replace(/^Bearer\s+/i, "") ?? null,
+				);
+			} catch (error) {
+				return errorResponse(error, 401);
+			}
 		}
 
 		const workflowHistory = () =>
@@ -4115,6 +4148,11 @@ export function buildNativeFactory(
 						await config.onDestroy(actorCtx);
 					}
 				} finally {
+					const actorId = callNativeSync(() => runtime.actorId(ctx));
+					// Release actorId-keyed state so it does not accumulate per
+					// destroyed actor.
+					nativeRunHandlerActiveByActorId.delete(actorId);
+					disposeRunInspector(config.run, actorId);
 					resolveNativeDestroy(runtime, ctx);
 					await actorCtx.closeDatabase();
 					clearNativeRuntimeState(runtime, ctx);
@@ -4518,7 +4556,11 @@ export function buildNativeFactory(
 					try {
 						await run(actorCtx);
 					} finally {
-						nativeRunHandlerActiveByActorId.set(actorId, false);
+						// Delete rather than set(false): an absent entry already
+						// reads as inactive, and deleting keeps this map bounded
+						// to currently-running handlers instead of accumulating an
+						// entry per actor id forever.
+						nativeRunHandlerActiveByActorId.delete(actorId);
 						await actorCtx.dispose();
 					}
 				},
@@ -4729,7 +4771,7 @@ export function buildNativeFactory(
 
 	return runtime.createActorFactory(
 		callbacks,
-		buildActorConfig(definition, registryConfig),
+		buildActorConfig(definition, registryConfig, runtime.kind),
 	);
 }
 
@@ -4756,12 +4798,29 @@ export async function buildServeConfig(
 		serverlessMaxStartPayloadBytes: config.serverless.maxStartPayloadBytes,
 	};
 
-	if (config.startEngine) {
+	// Always best-effort resolve the npm-installed engine binary and hand its
+	// path to the core. The core alone decides whether to actually spawn a local
+	// engine (its `should_manage_engine`, based on the endpoint + spawn mode), so
+	// JS must not duplicate that decision here. Only JS knows the npm
+	// `node_modules` layout, so it resolves the path; if no binary is available
+	// (remote-only install, unsupported platform, optional deps skipped), leave
+	// it unset and let the core report `engine.binary_unavailable` if it actually
+	// needs one.
+	try {
 		const { getEnginePath } = await loadEngineCli();
 		serveConfig.engineBinaryPath = getEnginePath();
-		serveConfig.engineHost = config.engineHost;
-		serveConfig.enginePort = config.enginePort;
+	} catch (error) {
+		// The npm-installed engine binary could not be resolved. The core still
+		// decides whether it needs to spawn a local engine; if it does, it will
+		// fail with engine.binary_unavailable (auto-download is off in the napi
+		// runtime). Warn so the cause is actionable.
+		logger().warn({
+			msg: "could not resolve a local engine binary; if a local engine must be spawned it will fail with engine.binary_unavailable — set RIVET_ENGINE_BINARY_PATH or install the @rivetkit/engine-cli platform package",
+			error: stringifyError(error),
+		});
 	}
+	serveConfig.engineHost = config.engineHost;
+	serveConfig.enginePort = config.enginePort;
 	if (config.test?.enabled) {
 		serveConfig.inspectorTestToken =
 			getEnvUniversal("_RIVET_TEST_INSPECTOR_TOKEN") ?? "token";
@@ -4785,6 +4844,13 @@ export async function buildRegistryWithRuntime(
 		trySetProcessEnv("_RIVET_TEST_INSPECTOR_TOKEN", "token");
 	}
 
+	// Custom inspector tab `source` paths are resolved with node:path while
+	// building actor configs below, so the Node modules must be loaded first.
+	// Native (napi) runtime only; wasm has no filesystem.
+	if (runtime.kind === "napi") {
+		importNodeDependencies();
+	}
+
 	const registry = runtime.createRegistry();
 
 	for (const [name, definition] of Object.entries(config.use)) {

package/src/registry/runtime.ts

@@ -1,5 +1,7 @@
+import { stringifyError } from "@/common/utils";
 import type { SqliteNativeMetrics } from "@/common/database/config";
 import type { RegistryConfig } from "./config";
+import { logger } from "./log";
 
 declare const handleBrand: unique symbol;
 
@@ -263,6 +265,12 @@ export interface RuntimeServeConfig {
 	serverlessMaxStartPayloadBytes: number;
 }
 
+export interface RuntimeListenerConfig {
+	port: number;
+	host?: string;
+	publicDir?: string;
+}
+
 export interface RuntimeServerlessRequest {
 	method: string;
 	url: string;
@@ -338,6 +346,11 @@ export interface CoreRuntime {
 		cancelToken: CancellationTokenHandle,
 		config: RuntimeServeConfig,
 	): Promise<RuntimeServerlessResponseHead>;
+	serveListener(
+		registry: RegistryHandle,
+		listener: RuntimeListenerConfig,
+		config: RuntimeServeConfig,
+	): Promise<void>;
 	registryHealth?(
 		registry: RegistryHandle,
 	): Promise<RuntimeRegistryRouteResponse>;
@@ -599,11 +612,25 @@ export async function buildServeConfig(
 		serverlessMaxStartPayloadBytes: config.serverless.maxStartPayloadBytes,
 	};
 
-	if (config.startEngine) {
+	// Always best-effort resolve the engine binary path and hand it to the core.
+	// The core alone decides whether to actually spawn a local engine, so JS must
+	// not duplicate that decision here. `loadEnginePath` throws when no binary is
+	// available (remote-only install, unsupported platform, optional deps
+	// skipped); in that case leave it unset and let the core report
+	// `engine.binary_unavailable` only if it actually needs one.
+	try {
 		serveConfig.engineBinaryPath = await loadEnginePath();
-		serveConfig.engineHost = config.engineHost;
-		serveConfig.enginePort = config.enginePort;
+	} catch (error) {
+		// The engine binary could not be resolved. The core still decides whether
+		// it needs to spawn a local engine; if it does, it will fail with
+		// engine.binary_unavailable (auto-download is off in the napi runtime).
+		logger().warn({
+			msg: "could not resolve a local engine binary; if a local engine must be spawned it will fail with engine.binary_unavailable — set RIVET_ENGINE_BINARY_PATH or install the @rivetkit/engine-cli platform package",
+			error: stringifyError(error),
+		});
 	}
+	serveConfig.engineHost = config.engineHost;
+	serveConfig.enginePort = config.enginePort;
 	if (config.test?.enabled) {
 		serveConfig.inspectorTestToken =
 			process.env._RIVET_TEST_INSPECTOR_TOKEN ?? "token";

package/src/registry/wasm-runtime.ts

@@ -26,6 +26,7 @@ import type {
 	RuntimeInspectorSnapshot,
 	RuntimeKvEntry,
 	RuntimeKvListOptions,
+	RuntimeListenerConfig,
 	RuntimeQueueEnqueueAndWaitOptions,
 	RuntimeQueueInspectMessage,
 	RuntimeQueueMessage,
@@ -302,6 +303,16 @@ export class WasmCoreRuntime implements CoreRuntime {
 		);
 	}
 
+	async serveListener(
+		_registry: RegistryHandle,
+		_listener: RuntimeListenerConfig,
+		_config: RuntimeServeConfig,
+	): Promise<void> {
+		throw new Error(
+			"registry.listen() is not supported on the wasm runtime; use registry.serve() and mount the handler in your platform's HTTP server instead",
+		);
+	}
+
 	createActorFactory(
 		callbacks: object,
 		config?: RuntimeActorConfig | undefined | null,

package/src/utils/env-vars.ts

@@ -50,6 +50,37 @@ export const getRivetkitStoragePath = (): string | undefined =>
 	getEnvUniversal("RIVETKIT_STORAGE_PATH");
 export const getRivetkitRuntime = (): string | undefined =>
 	getEnvUniversal("RIVETKIT_RUNTIME");
+export type RuntimeMode = "envoy" | "serverless";
+
+export const getRivetkitRuntimeMode = (): RuntimeMode => {
+	const value = getEnvUniversal("RIVETKIT_RUNTIME_MODE");
+	if (value === undefined) return "envoy";
+	if (value === "envoy" || value === "serverless") return value;
+	throw new Error(
+		`RIVETKIT_RUNTIME_MODE env var must be "envoy" or "serverless"; got "${value}"`,
+	);
+};
+
+export const getRivetkitPublicDir = (): string | undefined => {
+	const value = getEnvUniversal("RIVETKIT_PUBLIC_DIR");
+	return value === undefined || value === "" ? undefined : value;
+};
+
+export function parsePortEnv(raw: string | undefined): number | undefined {
+	if (raw === undefined || raw === "") return undefined;
+	const parsed = Number.parseInt(raw, 10);
+	if (
+		!Number.isFinite(parsed) ||
+		parsed < 1 ||
+		parsed > 65535 ||
+		String(parsed) !== raw.trim()
+	) {
+		throw new Error(
+			`RIVET_PORT env var must be an integer between 1 and 65535; got "${raw}"`,
+		);
+	}
+	return parsed;
+}
 
 // Logging configuration
 // DEPRECATED: LOG_LEVEL will be removed in a future version