rivetkit 2.0.3 → 2.0.5

package/src/actor/log.ts

@@ -1,15 +1,6 @@
-import { getLogger } from "@/common//log";
+import { getLogger } from "@/common/log";
 
-/** Logger for this library. */
-export const RUNTIME_LOGGER_NAME = "actor-runtime";
-
-/** Logger used for logs from the actor instance itself. */
-export const ACTOR_LOGGER_NAME = "actor";
-
-export function logger() {
-	return getLogger(RUNTIME_LOGGER_NAME);
-}
-
-export function instanceLogger() {
-	return getLogger(ACTOR_LOGGER_NAME);
+/** Prever to use ActorInstance.rlog child logger. This does not provide context in the log, should only be used as a last resort if you cannot pass the actor's child logger. */
+export function loggerWithoutContext() {
+	return getLogger("actor-runtime");
 }

package/src/actor/mod.ts

@@ -14,7 +14,6 @@ export function actor<
 	TConnState,
 	TVars,
 	TInput,
-	TAuthData,
 	TDatabase extends AnyDatabaseProvider,
 	TActions extends Actions<
 		TState,
@@ -22,7 +21,6 @@ export function actor<
 		TConnState,
 		TVars,
 		TInput,
-		TAuthData,
 		TDatabase
 	>,
 >(
@@ -32,7 +30,6 @@ export function actor<
 		TConnState,
 		TVars,
 		TInput,
-		TAuthData,
 		TDatabase,
 		TActions
 	>,
@@ -42,7 +39,6 @@ export function actor<
 	TConnState,
 	TVars,
 	TInput,
-	TAuthData,
 	TDatabase,
 	TActions
 > {
@@ -52,7 +48,6 @@ export function actor<
 		TConnState,
 		TVars,
 		TInput,
-		TAuthData,
 		TDatabase
 	>;
 	return new ActorDefinition(config);

package/src/actor/protocol/old.ts

@@ -18,7 +18,6 @@ import { assertUnreachable, bufferToArrayBuffer } from "../../utils";
 import { ActionContext } from "../action";
 import type { Conn } from "../connection";
 import type { ActorInstance } from "../instance";
-import { logger } from "../log";
 
 export const TransportSchema = z.enum(["websocket", "sse"]);
 
@@ -75,8 +74,17 @@ export async function parseMessage(
 		throw new errors.MessageTooLong();
 	}
 
-	// Parse & validate message
-	const buffer = await inputDataToBuffer(value);
+	// Convert value
+	let buffer = await inputDataToBuffer(value);
+
+	// HACK: For some reason, the output buffer needs to be cloned when using BARE encoding
+	//
+	// THis is likely because the input data is of type `Buffer` and there is an inconsistency in implementation that I am not aware of
+	if (buffer instanceof Buffer) {
+		buffer = new Uint8Array(buffer);
+	}
+
+	// Deserialize message
 	return deserializeWithEncoding(opts.encoding, buffer, TO_SERVER_VERSIONED);
 }
 
@@ -86,21 +94,20 @@ export interface ProcessMessageHandler<
 	CS,
 	V,
 	I,
-	AD,
 	DB extends AnyDatabaseProvider,
 > {
 	onExecuteAction?: (
-		ctx: ActionContext<S, CP, CS, V, I, AD, DB>,
+		ctx: ActionContext<S, CP, CS, V, I, DB>,
 		name: string,
 		args: unknown[],
 	) => Promise<unknown>;
 	onSubscribe?: (
 		eventName: string,
-		conn: Conn<S, CP, CS, V, I, AD, DB>,
+		conn: Conn<S, CP, CS, V, I, DB>,
 	) => Promise<void>;
 	onUnsubscribe?: (
 		eventName: string,
-		conn: Conn<S, CP, CS, V, I, AD, DB>,
+		conn: Conn<S, CP, CS, V, I, DB>,
 	) => Promise<void>;
 }
 
@@ -110,13 +117,12 @@ export async function processMessage<
 	CS,
 	V,
 	I,
-	AD,
 	DB extends AnyDatabaseProvider,
 >(
 	message: protocol.ToServer,
-	actor: ActorInstance<S, CP, CS, V, I, AD, DB>,
-	conn: Conn<S, CP, CS, V, I, AD, DB>,
-	handler: ProcessMessageHandler<S, CP, CS, V, I, AD, DB>,
+	actor: ActorInstance<S, CP, CS, V, I, DB>,
+	conn: Conn<S, CP, CS, V, I, DB>,
+	handler: ProcessMessageHandler<S, CP, CS, V, I, DB>,
 ) {
 	let actionId: bigint | undefined;
 	let actionName: string | undefined;
@@ -134,12 +140,13 @@ export async function processMessage<
 			actionName = name;
 			const args = cbor.decode(new Uint8Array(argsRaw));
 
-			logger().debug("processing action request", {
+			actor.rLog.debug({
+				msg: "processing action request",
 				actionId: id,
 				actionName: name,
 			});
 
-			const ctx = new ActionContext<S, CP, CS, V, I, AD, DB>(
+			const ctx = new ActionContext<S, CP, CS, V, I, DB>(
 				actor.actorContext,
 				conn,
 			);
@@ -148,7 +155,8 @@ export async function processMessage<
 			// This will wait for async actions to complete
 			const output = await handler.onExecuteAction(ctx, name, args);
 
-			logger().debug("sending action response", {
+			actor.rLog.debug({
+				msg: "sending action response",
 				actionId: id,
 				actionName: name,
 				outputType: typeof output,
@@ -171,7 +179,7 @@ export async function processMessage<
 				),
 			);
 
-			logger().debug("action response sent", { id, name: name });
+			actor.rLog.debug({ msg: "action response sent", id, name: name });
 		} else if (message.body.tag === "SubscriptionRequest") {
 			// Subscription request
 
@@ -183,7 +191,8 @@ export async function processMessage<
 			}
 
 			const { eventName, subscribe } = message.body.val;
-			logger().debug("processing subscription request", {
+			actor.rLog.debug({
+				msg: "processing subscription request",
 				eventName,
 				subscribe,
 			});
@@ -194,7 +203,8 @@ export async function processMessage<
 				await handler.onUnsubscribe(eventName, conn);
 			}
 
-			logger().debug("subscription request completed", {
+			actor.rLog.debug({
+				msg: "subscription request completed",
 				eventName,
 				subscribe,
 			});
@@ -202,13 +212,18 @@ export async function processMessage<
 			assertUnreachable(message.body);
 		}
 	} catch (error) {
-		const { code, message, metadata } = deconstructError(error, logger(), {
-			connectionId: conn.id,
-			actionId,
-			actionName,
-		});
+		const { group, code, message, metadata } = deconstructError(
+			error,
+			actor.rLog,
+			{
+				connectionId: conn.id,
+				actionId,
+				actionName,
+			},
+		);
 
-		logger().debug("sending error response", {
+		actor.rLog.debug({
+			msg: "sending error response",
 			actionId,
 			actionName,
 			code,
@@ -222,6 +237,7 @@ export async function processMessage<
 					body: {
 						tag: "Error",
 						val: {
+							group,
 							code,
 							message,
 							metadata: bufferToArrayBuffer(cbor.encode(metadata)),
@@ -233,7 +249,7 @@ export async function processMessage<
 			),
 		);
 
-		logger().debug("error response sent", { actionId, actionName });
+		actor.rLog.debug({ msg: "error response sent", actionId, actionName });
 	}
 }
 
@@ -255,7 +271,7 @@ export async function processMessage<
 //export async function deserialize(data: InputData, encoding: Encoding) {
 //	if (encoding === "json") {
 //		if (typeof data !== "string") {
-//			logger().warn("received non-string for json parse");
+//			actor.rLog.warn("received non-string for json parse");
 //			throw new errors.MalformedMessage();
 //		} else {
 //			return JSON.parse(data);
@@ -272,7 +288,7 @@ export async function processMessage<
 //		) {
 //			return cbor.decode(new Uint8Array(data));
 //		} else {
-//			logger().warn("received non-binary type for cbor parse");
+//			actor.rLog.warn("received non-binary type for cbor parse");
 //			throw new errors.MalformedMessage();
 //		}
 //	} else {

package/src/actor/protocol/serde.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import * as errors from "@/actor/errors";
 import type { VersionedDataHandler } from "@/common/versioned-data";
 import { serializeWithEncoding } from "@/serde";
-import { logger } from "../log";
+import { loggerWithoutContext } from "../log";
 import { assertUnreachable } from "../utils";
 
 /** Data that can be deserialized. */

package/src/actor/router-endpoints.ts

@@ -38,7 +38,7 @@ import type {
 	GenericSseDriverState,
 	GenericWebSocketDriverState,
 } from "./generic-conn-driver";
-import { logger } from "./log";
+import { loggerWithoutContext } from "./log";
 import { parseMessage } from "./protocol/old";
 
 export interface ConnectWebSocketOpts {
@@ -137,7 +137,7 @@ export async function handleWebSocketConnect(
 			onOpen: (_evt: any, ws: WSContext) => {
 				const { code } = deconstructError(
 					error,
-					logger(),
+					actor.rLog,
 					{
 						wsEvent: "open",
 					},
@@ -155,7 +155,7 @@ export async function handleWebSocketConnect(
 
 	return {
 		onOpen: (_evt: any, ws: WSContext) => {
-			logger().debug("websocket open");
+			actor.rLog.debug("websocket open");
 
 			// Run async operations in background
 			(async () => {
@@ -168,7 +168,8 @@ export async function handleWebSocketConnect(
 					const connGlobalState =
 						actorDriver.getGenericConnGlobalState(actorId);
 					connGlobalState.websockets.set(connId, ws);
-					logger().debug("registered websocket for conn", {
+					actor.rLog.debug({
+						msg: "registered websocket for conn",
 						actorId,
 						totalCount: connGlobalState.websockets.size,
 					});
@@ -191,7 +192,7 @@ export async function handleWebSocketConnect(
 
 					const { code } = deconstructError(
 						error,
-						logger(),
+						actor.rLog,
 						{
 							wsEvent: "open",
 						},
@@ -205,7 +206,7 @@ export async function handleWebSocketConnect(
 			// Handle message asynchronously
 			handlersPromise
 				.then(({ conn, actor }) => {
-					logger().debug("received message");
+					actor.rLog.debug({ msg: "received message" });
 
 					const value = evt.data.valueOf() as InputData;
 					parseMessage(value, {
@@ -216,7 +217,7 @@ export async function handleWebSocketConnect(
 							actor.processMessage(message, conn).catch((error) => {
 								const { code } = deconstructError(
 									error,
-									logger(),
+									actor.rLog,
 									{
 										wsEvent: "message",
 									},
@@ -228,7 +229,7 @@ export async function handleWebSocketConnect(
 						.catch((error) => {
 							const { code } = deconstructError(
 								error,
-								logger(),
+								actor.rLog,
 								{
 									wsEvent: "message",
 								},
@@ -240,7 +241,7 @@ export async function handleWebSocketConnect(
 				.catch((error) => {
 					const { code } = deconstructError(
 						error,
-						logger(),
+						actor.rLog,
 						{
 							wsEvent: "message",
 						},
@@ -258,13 +259,15 @@ export async function handleWebSocketConnect(
 			ws: WSContext,
 		) => {
 			if (event.wasClean) {
-				logger().info("websocket closed", {
+				actor.rLog.info({
+					msg: "websocket closed",
 					code: event.code,
 					reason: event.reason,
 					wasClean: event.wasClean,
 				});
 			} else {
-				logger().warn("websocket closed", {
+				actor.rLog.warn({
+					msg: "websocket closed",
 					code: event.code,
 					reason: event.reason,
 					wasClean: event.wasClean,
@@ -282,11 +285,13 @@ export async function handleWebSocketConnect(
 						actorDriver.getGenericConnGlobalState(actorId);
 					const didDelete = connGlobalState.websockets.delete(connId);
 					if (didDelete) {
-						logger().info("removing websocket for conn", {
+						actor.rLog.info({
+							msg: "removing websocket for conn",
 							totalCount: connGlobalState.websockets.size,
 						});
 					} else {
-						logger().warn("websocket does not exist for conn", {
+						actor.rLog.warn({
+							msg: "websocket does not exist for conn",
 							actorId,
 							totalCount: connGlobalState.websockets.size,
 						});
@@ -297,7 +302,7 @@ export async function handleWebSocketConnect(
 				.catch((error) => {
 					deconstructError(
 						error,
-						logger(),
+						actor.rLog,
 						{ wsEvent: "close" },
 						exposeInternalError,
 					);
@@ -306,11 +311,11 @@ export async function handleWebSocketConnect(
 		onError: (_error: unknown) => {
 			try {
 				// Actors don't need to know about this, since it's abstracted away
-				logger().warn("websocket error");
+				actor.rLog.warn({ msg: "websocket error" });
 			} catch (error) {
 				deconstructError(
 					error,
-					logger(),
+					actor.rLog,
 					{ wsEvent: "error" },
 					exposeInternalError,
 				);
@@ -347,7 +352,7 @@ export async function handleSseConnect(
 			connToken = generateConnToken();
 			connState = await actor.prepareConn(parameters, c.req.raw);
 
-			logger().debug("sse open");
+			actor.rLog.debug("sse open");
 
 			// Save stream
 			actorDriver
@@ -368,10 +373,16 @@ export async function handleSseConnect(
 			// Wait for close
 			const abortResolver = Promise.withResolvers();
 
+			// HACK: This is required so the abort handler below works
+			//
+			// See https://github.com/honojs/hono/issues/1770#issuecomment-2461966225
+			stream.onAbort(() => {});
+
 			// Handle stream abort (when client closes the connection)
-			stream.onAbort(async () => {
+			c.req.raw.signal.addEventListener("abort", async () => {
+				const rLog = actor?.rLog ?? loggerWithoutContext();
 				try {
-					logger().debug("sse stream aborted");
+					rLog.debug("sse stream aborted");
 
 					// Cleanup
 					if (connId) {
@@ -385,7 +396,7 @@ export async function handleSseConnect(
 
 					abortResolver.resolve(undefined);
 				} catch (error) {
-					logger().error("error closing sse connection", { error });
+					rLog.error({ msg: "error closing sse connection", error });
 					abortResolver.resolve(undefined);
 				}
 			});
@@ -398,7 +409,7 @@ export async function handleSseConnect(
 			// Wait until connection aborted
 			await abortResolver.promise;
 		} catch (error) {
-			logger().error("error in sse connection", { error });
+			loggerWithoutContext().error({ msg: "error in sse connection", error });
 
 			// Cleanup on error
 			if (connId !== undefined) {
@@ -430,8 +441,6 @@ export async function handleAction(
 	const encoding = getRequestEncoding(c.req);
 	const parameters = getRequestConnParams(c.req);
 
-	logger().debug("handling action", { actionName, encoding });
-
 	// Validate incoming request
 	const arrayBuffer = await c.req.arrayBuffer();
 	const request = deserializeWithEncoding(
@@ -448,6 +457,8 @@ export async function handleAction(
 	try {
 		actor = await actorDriver.loadActor(actorId);
 
+		actor.rLog.debug({ msg: "handling action", actionName, encoding });
+
 		// Create conn
 		const connState = await actor.prepareConn(parameters, c.req.raw);
 		conn = await actor.createConn(
@@ -544,8 +555,9 @@ export async function handleRawWebSocketHandler(
 			// Extract the path after prefix and preserve query parameters
 			// Use URL API for cleaner parsing
 			const url = new URL(path, "http://actor");
-			const pathname = url.pathname.replace(/^\/raw\/websocket/, "") || "/";
-			const normalizedPath = pathname + url.search;
+			const pathname = url.pathname.replace(/^\/raw\/websocket\/?/, "") || "/";
+			const normalizedPath =
+				(pathname.startsWith("/") ? pathname : "/" + pathname) + url.search;
 
 			let newRequest: Request;
 			if (req) {
@@ -556,15 +568,18 @@ export async function handleRawWebSocketHandler(
 				});
 			}
 
-			logger().debug("rewriting websocket url", {
+			actor.rLog.debug({
+				msg: "rewriting websocket url",
 				from: path,
 				to: newRequest.url,
+				pathname: url.pathname,
+				search: url.search,
+				normalizedPath,
 			});
 
 			// Call the actor's onWebSocket handler with the adapted WebSocket
 			actor.handleWebSocket(adapter, {
 				request: newRequest,
-				auth: authData,
 			});
 		},
 		onMessage: (event: any, ws: any) => {
@@ -606,20 +621,16 @@ export function getRequestEncoding(req: HonoRequest): Encoding {
 	return result.data;
 }
 
-export function getRequestExposeInternalError(req: Request): boolean {
-	const param = req.headers.get(HEADER_EXPOSE_INTERNAL_ERROR);
-	if (!param) {
-		return false;
-	}
-
-	return param === "true";
+export function getRequestExposeInternalError(_req: Request): boolean {
+	// Unipmlemented
+	return false;
 }
 
 export function getRequestQuery(c: HonoContext): unknown {
 	// Get query parameters for actor lookup
 	const queryParam = c.req.header(HEADER_ACTOR_QUERY);
 	if (!queryParam) {
-		logger().error("missing query parameter");
+		loggerWithoutContext().error({ msg: "missing query parameter" });
 		throw new errors.InvalidRequest("missing query");
 	}
 
@@ -628,7 +639,7 @@ export function getRequestQuery(c: HonoContext): unknown {
 		const parsed = JSON.parse(queryParam);
 		return parsed;
 	} catch (error) {
-		logger().error("invalid query json", { error });
+		loggerWithoutContext().error({ msg: "invalid query json", error });
 		throw new errors.InvalidQueryJSON(error);
 	}
 }
@@ -637,9 +648,6 @@ export const HEADER_ACTOR_QUERY = "X-RivetKit-Query";
 
 export const HEADER_ENCODING = "X-RivetKit-Encoding";
 
-// Internal header
-export const HEADER_EXPOSE_INTERNAL_ERROR = "X-RivetKit-Expose-Internal-Error";
-
 // IMPORTANT: Params must be in headers or in an E2EE part of the request (i.e. NOT the URL or query string) in order to ensure that tokens can be securely passed in params.
 export const HEADER_CONN_PARAMS = "X-RivetKit-Conn-Params";
 

package/src/actor/router.ts

@@ -1,4 +1,5 @@
 import { Hono, type Context as HonoContext } from "hono";
+import { cors } from "hono/cors";
 import invariant from "invariant";
 import { EncodingSchema } from "@/actor/protocol/serde";
 import {
@@ -34,7 +35,7 @@ import { secureInspector } from "@/inspector/utils";
 import type { RunConfig } from "@/registry/run-config";
 import type { ActorDriver } from "./driver";
 import { InternalError } from "./errors";
-import { logger } from "./log";
+import { loggerWithoutContext } from "./log";
 
 export const PATH_CONNECT_WEBSOCKET = "/connect/websocket";
 export const PATH_RAW_WEBSOCKET_PREFIX = "/raw/websocket/";
@@ -64,7 +65,7 @@ export function createActorRouter(
 ): ActorRouter {
 	const router = new Hono<{ Bindings: ActorRouterBindings }>({ strict: false });
 
-	router.use("*", loggerMiddleware(logger()));
+	router.use("*", loggerMiddleware(loggerWithoutContext()));
 
 	router.get("/", (c) => {
 		return c.text(
@@ -174,9 +175,11 @@ export function createActorRouter(
 			method: c.req.method,
 			headers: c.req.raw.headers,
 			body: c.req.raw.body,
-		});
+			duplex: "half",
+		} as RequestInit);
 
-		logger().debug("rewriting http url", {
+		loggerWithoutContext().debug({
+			msg: "rewriting http url",
 			from: c.req.url,
 			to: correctedRequest.url,
 		});
@@ -212,7 +215,8 @@ export function createActorRouter(
 				const url = new URL(c.req.url);
 				const pathWithQuery = c.req.path + url.search;
 
-				logger().debug("actor router raw websocket", {
+				loggerWithoutContext().debug({
+					msg: "actor router raw websocket",
 					path: c.req.path,
 					url: c.req.url,
 					search: url.search,
@@ -239,25 +243,24 @@ export function createActorRouter(
 		router.route(
 			"/inspect",
 			new Hono<ActorInspectorRouterEnv & { Bindings: ActorRouterBindings }>()
-				.use(secureInspector(runConfig), async (c, next) => {
-					const inspector = (await actorDriver.loadActor(c.env.actorId))
-						.inspector;
-					invariant(inspector, "inspector not supported on this platform");
-
-					c.set("inspector", inspector);
-					await next();
-				})
+				.use(
+					cors(runConfig.inspector.cors),
+					secureInspector(runConfig),
+					async (c, next) => {
+						const inspector = (await actorDriver.loadActor(c.env.actorId))
+							.inspector;
+						invariant(inspector, "inspector not supported on this platform");
+
+						c.set("inspector", inspector);
+						return next();
+					},
+				)
 				.route("/", createActorInspectorRouter()),
 		);
 	}
 
 	router.notFound(handleRouteNotFound);
-	router.onError(
-		handleRouteError.bind(undefined, {
-			// All headers to this endpoint are considered secure, so we can enable the expose internal error header for requests from the internal client
-			enableExposeInternalError: true,
-		}),
-	);
+	router.onError(handleRouteError);
 
 	return router;
 }

package/src/actor/unstable-react.ts

@@ -9,7 +9,7 @@
 // *
 // * Supports rendering React elements as action responses.
 // *
-// * @see [Documentation](https://rivet.gg/docs/client/react)
+// * @see [Documentation](https://rivet.dev/docs/client/react)
 // * @experimental
 // */
 //export class RscActor<

package/src/actor/utils.ts

@@ -1,8 +1,12 @@
 import * as errors from "./errors";
-import { logger } from "./log";
+import { loggerWithoutContext } from "./log";
 
 export function assertUnreachable(x: never): never {
-	logger().error("unreachable", { value: `${x}`, stack: new Error().stack });
+	loggerWithoutContext().error({
+		msg: "unreachable",
+		value: `${x}`,
+		stack: new Error().stack,
+	});
 	throw new errors.Unreachable(x);
 }
 

package/src/client/actor-common.ts

@@ -21,7 +21,7 @@ export type ActorActionFunction<
  */
 export type ActorDefinitionActions<AD extends AnyActorDefinition> =
 	// biome-ignore lint/suspicious/noExplicitAny: safe to use any here
-	AD extends ActorDefinition<any, any, any, any, any, any, any, infer R>
+	AD extends ActorDefinition<any, any, any, any, any, any, infer R>
 		? {
 				[K in keyof R]: R[K] extends (...args: infer Args) => infer Return
 					? ActorActionFunction<Args, Return>