rivetkit 2.3.0-rc.8 → 2.3.0

package/src/common/client-protocol-versioned.ts

@@ -122,71 +122,73 @@ const v4HttpResponseErrorToV3 = (
 	return rest;
 };
 
-export const CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler<v4.ToServer>({
-	deserializeVersion: (bytes, version) => {
-		switch (version) {
-			case 1:
-				return v1.decodeToServer(bytes);
-			case 2:
-				return v2.decodeToServer(bytes);
-			case 3:
-				return v3.decodeToServer(bytes);
-			case 4:
-				return v4.decodeToServer(bytes);
-			default:
-				throw new Error(`Unknown version ${version}`);
-		}
-	},
-	serializeVersion: (data, version) => {
-		switch (version) {
-			case 1:
-				return v1.encodeToServer(data as v1.ToServer);
-			case 2:
-				return v2.encodeToServer(data as v2.ToServer);
-			case 3:
-				return v3.encodeToServer(data as v3.ToServer);
-			case 4:
-				return v4.encodeToServer(data as v4.ToServer);
-			default:
-				throw new Error(`Unknown version ${version}`);
-		}
-	},
-	deserializeConverters: () => [v1ToServerV2, v2ToServerV3, v3ToServerV4],
-	serializeConverters: () => [v4ToServerV3, v3ToServerV2, v2ToServerV1],
-});
+export const CLIENT_PROTOCOL_TO_SERVER =
+	createVersionedDataHandler<v4.ToServer>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeToServer(bytes);
+				case 2:
+					return v2.decodeToServer(bytes);
+				case 3:
+					return v3.decodeToServer(bytes);
+				case 4:
+					return v4.decodeToServer(bytes);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 1:
+					return v1.encodeToServer(data as v1.ToServer);
+				case 2:
+					return v2.encodeToServer(data as v2.ToServer);
+				case 3:
+					return v3.encodeToServer(data as v3.ToServer);
+				case 4:
+					return v4.encodeToServer(data as v4.ToServer);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [v1ToServerV2, v2ToServerV3, v3ToServerV4],
+		serializeConverters: () => [v4ToServerV3, v3ToServerV2, v2ToServerV1],
+	});
 
-export const CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler<v4.ToClient>({
-	deserializeVersion: (bytes, version) => {
-		switch (version) {
-			case 1:
-				return v1.decodeToClient(bytes);
-			case 2:
-				return v2.decodeToClient(bytes);
-			case 3:
-				return v3.decodeToClient(bytes);
-			case 4:
-				return v4.decodeToClient(bytes);
-			default:
-				throw new Error(`Unknown version ${version}`);
-		}
-	},
-	serializeVersion: (data, version) => {
-		switch (version) {
-			case 1:
-				return v1.encodeToClient(data as v1.ToClient);
-			case 2:
-				return v2.encodeToClient(data as v2.ToClient);
-			case 3:
-				return v3.encodeToClient(data as v3.ToClient);
-			case 4:
-				return v4.encodeToClient(data as v4.ToClient);
-			default:
-				throw new Error(`Unknown version ${version}`);
-		}
-	},
-	deserializeConverters: () => [v1ToV2, v2ToV3, v3ToV4],
-	serializeConverters: () => [v4ToV3, v3ToV2, v2ToV1],
-});
+export const CLIENT_PROTOCOL_TO_CLIENT =
+	createVersionedDataHandler<v4.ToClient>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeToClient(bytes);
+				case 2:
+					return v2.decodeToClient(bytes);
+				case 3:
+					return v3.decodeToClient(bytes);
+				case 4:
+					return v4.decodeToClient(bytes);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 1:
+					return v1.encodeToClient(data as v1.ToClient);
+				case 2:
+					return v2.encodeToClient(data as v2.ToClient);
+				case 3:
+					return v3.encodeToClient(data as v3.ToClient);
+				case 4:
+					return v4.encodeToClient(data as v4.ToClient);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [v1ToV2, v2ToV3, v3ToV4],
+		serializeConverters: () => [v4ToV3, v3ToV2, v2ToV1],
+	});
 
 export const HTTP_ACTION_REQUEST_VERSIONED =
 	createVersionedDataHandler<v4.HttpActionRequest>({

package/src/common/database/config.ts

@@ -42,10 +42,7 @@ export interface SqliteDatabase {
 		sql: string,
 		callback?: (row: unknown[], columns: string[]) => void,
 	): Promise<void>;
-	execute(
-		sql: string,
-		params?: SqliteBindings,
-	): Promise<SqliteExecuteResult>;
+	execute(sql: string, params?: SqliteBindings): Promise<SqliteExecuteResult>;
 	run(sql: string, params?: SqliteBindings): Promise<void>;
 	query(sql: string, params?: SqliteBindings): Promise<SqliteQueryResult>;
 	nativeMetrics?():
@@ -132,10 +129,7 @@ export interface RawDatabaseClient {
 /**
  * Drizzle database client interface (will be extended by drizzle-orm types)
  */
-export interface DrizzleDatabaseClient {
-	// This will be extended by BaseSQLiteDatabase from drizzle-orm
-	// For now, just a marker interface
-}
+export type DrizzleDatabaseClient = {};
 
 type ExecuteFunction = <
 	TRow extends Record<string, unknown> = Record<string, unknown>,

package/src/common/database/native-database.ts

@@ -97,7 +97,7 @@ function enrichNativeDatabaseError(
 			? error
 			: error instanceof Error
 				? error.message
-			: undefined;
+				: undefined;
 	const bridged =
 		bridgeReason === undefined
 			? undefined

package/src/common/database/shared.ts

@@ -1,4 +1,5 @@
 import type { SqliteBindings } from "./config";
+
 type SqliteBindingObject = Record<string, unknown>;
 
 function isSqliteBindingValue(value: unknown): boolean {

package/src/common/encoding.ts

@@ -1,5 +1,5 @@
-import { z } from "zod/v4";
 import type { VersionedDataHandler } from "vbare";
+import { z } from "zod/v4";
 import { serializeWithEncoding } from "@/serde";
 import { assertUnreachable } from "./utils";
 
@@ -172,7 +172,7 @@ export function assertJsonCompatValue(
 
 	const typeName =
 		typeof value === "object" && value !== null
-			? value.constructor?.name ?? typeof value
+			? (value.constructor?.name ?? typeof value)
 			: typeof value;
 	throw new TypeError(
 		`Value at ${path || "root"} of type "${typeName}" is not CBOR serializable`,
@@ -310,7 +310,11 @@ export function encodeJsonCompatValue(input: JsonCompatValue): unknown {
 	}
 
 	// Date, RegExp, and Error pass through for cbor-x native handling
-	if (input instanceof Date || input instanceof RegExp || input instanceof Error) {
+	if (
+		input instanceof Date ||
+		input instanceof RegExp ||
+		input instanceof Error
+	) {
 		return input;
 	}
 
@@ -344,7 +348,7 @@ export function encodeJsonCompatValue(input: JsonCompatValue): unknown {
 			typeof encoded[0] === "string" &&
 			(encoded[0] as string).startsWith("$")
 		) {
-			return ["$" + encoded[0], encoded[1]];
+			return [`$${encoded[0]}`, encoded[1]];
 		}
 		return encoded;
 	}
@@ -361,11 +365,9 @@ export function encodeJsonCompatValue(input: JsonCompatValue): unknown {
 	// Not serializable
 	const typeName =
 		typeof input === "object" && input !== null
-			? (input as object).constructor?.name ?? typeof input
+			? ((input as object).constructor?.name ?? typeof input)
 			: typeof input;
-	throw new TypeError(
-		`Value of type "${typeName}" is not CBOR serializable`,
-	);
+	throw new TypeError(`Value of type "${typeName}" is not CBOR serializable`);
 }
 
 export interface JsonCompatReviveOptions {
@@ -477,16 +479,10 @@ export function jsonStringifyCompat(input: any): string {
 			return [JSON_COMPAT_BIGINT, value.toString()];
 		}
 		if (value instanceof ArrayBuffer) {
-			return [
-				JSON_COMPAT_ARRAY_BUFFER,
-				base64EncodeArrayBuffer(value),
-			];
+			return [JSON_COMPAT_ARRAY_BUFFER, base64EncodeArrayBuffer(value)];
 		}
 		if (value instanceof Uint8Array) {
-			return [
-				JSON_COMPAT_UINT8_ARRAY,
-				base64EncodeUint8Array(value),
-			];
+			return [JSON_COMPAT_UINT8_ARRAY, base64EncodeUint8Array(value)];
 		}
 		if (
 			Array.isArray(value) &&
@@ -494,7 +490,7 @@ export function jsonStringifyCompat(input: any): string {
 			typeof value[0] === "string" &&
 			value[0].startsWith("$")
 		) {
-			return ["$" + value[0], value[1]];
+			return [`$${value[0]}`, value[1]];
 		}
 		return value;
 	});

package/src/common/engine.ts

@@ -1,2 +1,29 @@
+export const ENGINE_HOST = "127.0.0.1";
 export const ENGINE_PORT = 6420;
-export const ENGINE_ENDPOINT = `http://127.0.0.1:${ENGINE_PORT}`;
+export const ENGINE_ENDPOINT = buildEngineEndpoint(ENGINE_HOST, ENGINE_PORT);
+
+export function buildEngineEndpoint(host: string, port: number): string {
+	const urlHost =
+		host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+	return `http://${urlHost}:${port}`;
+}
+
+export function isLocalEngineEndpoint(endpoint: string): boolean {
+	let url: URL;
+	try {
+		url = new URL(endpoint);
+	} catch {
+		return false;
+	}
+
+	const hostname = url.hostname.toLowerCase();
+	return (
+		hostname === "localhost" ||
+		hostname === "0.0.0.0" ||
+		hostname === "::" ||
+		hostname === "[::]" ||
+		hostname === "::1" ||
+		hostname === "[::1]" ||
+		/^127(?:\.\d{1,3}){0,3}$/.test(hostname)
+	);
+}

package/src/common/eventsource.ts

@@ -25,7 +25,7 @@ export async function importEventSource(): Promise<typeof EventSource> {
 			const es = await import(/* webpackIgnore: true */ moduleName);
 			_EventSource = es.EventSource;
 			logger().debug("using eventsource from npm");
-		} catch (err) {
+		} catch (_err) {
 			// EventSource not available
 			_EventSource = class MockEventSource {
 				constructor() {

package/src/common/inline-websocket-adapter.ts

@@ -1,7 +1,7 @@
+import { VirtualWebSocket } from "@rivetkit/virtual-websocket";
 import { WSContext } from "hono/ws";
 import type { UpgradeWebSocketArgs } from "@/common/actor-websocket";
 import type { UniversalWebSocket } from "@/common/websocket-interface";
-import { VirtualWebSocket } from "@rivetkit/virtual-websocket";
 import { getLogger } from "./log";
 
 function logger() {
@@ -166,7 +166,8 @@ export class InlineWebSocketAdapter {
 		logger().error({
 			msg: "error in websocket",
 			error,
-			errorMessage: error instanceof Error ? error.message : String(error),
+			errorMessage:
+				error instanceof Error ? error.message : String(error),
 			stack: error instanceof Error ? error.stack : undefined,
 		});
 

package/src/common/router.ts

@@ -1,17 +1,11 @@
-import type { Context as HonoContext, Next } from "hono";
 import * as envoyProtocol from "@rivetkit/engine-envoy-protocol";
+import type { Context as HonoContext, Next } from "hono";
 import type { ActorSpecifier } from "@/actor/errors";
 import {
 	HEADER_ACTOR_GENERATION,
 	HEADER_ACTOR_ID,
 	HEADER_ACTOR_KEY,
 } from "@/common/actor-router-consts";
-import type { JsonCompatValue, Encoding } from "@/common/encoding";
-import {
-	getRequestEncoding,
-	getRequestExposeInternalError,
-} from "@/common/router-request";
-import { buildActorNames, type RegistryConfig } from "@/registry/config";
 import type * as protocol from "@/common/client-protocol";
 import {
 	CURRENT_VERSION as CLIENT_PROTOCOL_CURRENT_VERSION,
@@ -21,15 +15,17 @@ import {
 	type HttpResponseError as HttpResponseErrorJson,
 	HttpResponseErrorSchema,
 } from "@/common/client-protocol-zod";
+import type { Encoding, JsonCompatValue } from "@/common/encoding";
 import {
-	encodeCborCompat,
-	encodingIsBinary,
-	serializeWithEncoding,
-} from "@/serde";
+	getRequestEncoding,
+	getRequestExposeInternalError,
+} from "@/common/router-request";
+import { buildActorNames, type RegistryConfig } from "@/registry/config";
+import { encodeCborCompat, serializeWithEncoding } from "@/serde";
 import { bufferToArrayBuffer, VERSION } from "@/utils";
 import { getLogHeaders } from "@/utils/env-vars";
 import { getLogger, type Logger } from "./log";
-import { deconstructError, stringifyError } from "./utils";
+import { deconstructError } from "./utils";
 
 export function logger() {
 	return getLogger("router");
@@ -67,10 +63,8 @@ export function handleRouteNotFound(c: HonoContext) {
 export function handleRouteError(error: unknown, c: HonoContext) {
 	const exposeInternalError = getRequestExposeInternalError(c.req.raw);
 
-	const { statusCode, group, code, message, metadata, actor } = deconstructError(
-		error,
-		exposeInternalError,
-	);
+	const { statusCode, group, code, message, metadata, actor } =
+		deconstructError(error, exposeInternalError);
 
 	if (actor) {
 		logger().warn({
@@ -111,7 +105,9 @@ export function handleRouteError(error: unknown, c: HonoContext) {
 			code: value.code,
 			message: value.message,
 			metadata: value.metadata
-				? bufferToArrayBuffer(encodeCborCompat(value.metadata as JsonCompatValue))
+				? bufferToArrayBuffer(
+						encodeCborCompat(value.metadata as JsonCompatValue),
+					)
 				: null,
 			actor: value.actor
 				? {

package/src/common/utils.ts

@@ -36,7 +36,6 @@ export function safeStringify(obj: unknown, maxSize: number) {
 	return JSON.stringify(obj, replacer);
 }
 
-
 export interface DeconstructedError {
 	__type: "ActorError";
 	statusCode: ContentfulStatusCode;
@@ -135,7 +134,7 @@ export function deconstructError(
 			actor = error.actor;
 		}
 		metadata = {
-			//url: `https://hub.rivet.dev/projects/${actorMetadata.project.slug}/environments/${actorMetadata.environment.slug}/actors?actorId=${actorMetadata.actor.id}`,
+			//url: `https://dashboard.rivet.dev/projects/${actorMetadata.project.slug}/environments/${actorMetadata.environment.slug}/actors?actorId=${actorMetadata.actor.id}`,
 		} satisfies errors.InternalErrorMetadata;
 	}
 

package/src/common/websocket-interface.ts

@@ -1,7 +1,7 @@
 // Re-export everything from the virtual-websocket package
 export type {
+	RivetCloseEvent,
 	RivetEvent,
 	RivetMessageEvent,
-	RivetCloseEvent,
 	UniversalWebSocket,
 } from "@rivetkit/virtual-websocket";

package/src/db/mod.ts

@@ -1,4 +1,3 @@
-export { db } from "@/common/database/mod";
 export type {
 	AnyDatabaseProvider,
 	DatabaseProvider,
@@ -11,3 +10,4 @@ export type {
 	SqliteNativeMetrics,
 	SqliteQueryResult,
 } from "@/common/database/config";
+export { db } from "@/common/database/mod";

package/src/devtools-loader/index.ts

@@ -1,16 +1,11 @@
 import type { ClientConfigInput } from "@/client/client";
-import { VERSION } from "@/utils";
 import { logger } from "./log";
 
 declare global {
 	// Injected via tsup config
-	// biome-ignore lint/style/noVar: required for global declaration
 	var CUSTOM_RIVETKIT_DEVTOOLS_URL: string | undefined;
 }
 
-const DEFAULT_DEVTOOLS_URL = (version = VERSION) =>
-	`https://releases.rivet.dev/rivet/latest/devtools/mod.js?v=${version}`;
-
 const scriptId = "rivetkit-devtools-script";
 
 export function injectDevtools(config: ClientConfigInput) {
@@ -20,10 +15,12 @@ export function injectDevtools(config: ClientConfigInput) {
 	}
 
 	if (!document.getElementById(scriptId)) {
+		const src =
+			globalThis.CUSTOM_RIVETKIT_DEVTOOLS_URL ||
+			`${config.endpoint?.replace(/\/$/, "")}/devtools/mod.js`;
 		const script = document.createElement("script");
 		script.id = scriptId;
-		script.src =
-			globalThis.CUSTOM_RIVETKIT_DEVTOOLS_URL || DEFAULT_DEVTOOLS_URL();
+		script.src = src;
 		script.async = true;
 		document.head.appendChild(script);
 	}

package/src/devtools-loader/serve-devtools.ts

@@ -0,0 +1,26 @@
+import { getNodeFs, getNodePath, getNodeUrl } from "@/utils/node";
+
+export async function getDevtoolsPath(): Promise<string> {
+	const url = getNodeUrl();
+	const path = getNodePath();
+
+	const devtoolsPath = path.join(
+		path.dirname(url.fileURLToPath(import.meta.url)),
+		"../../dist/devtools/mod.js",
+	);
+
+	try {
+		await getNodeFs().access(devtoolsPath);
+	} catch {
+		throw new Error(
+			`Devtools bundle not found at ${devtoolsPath}. Run 'pnpm build:pack-devtools' first.`,
+		);
+	}
+
+	return devtoolsPath;
+}
+
+export async function readDevtoolsBundle(): Promise<Buffer> {
+	const devtoolsPath = await getDevtoolsPath();
+	return getNodeFs().readFile(devtoolsPath);
+}