rivetkit 2.0.2 → 2.0.4-rc.1

package/src/remote-manager-driver/ws-proxy.ts

@@ -0,0 +1,189 @@
+import type { Context as HonoContext } from "hono";
+import type { WSContext } from "hono/ws";
+import type { UpgradeWebSocketArgs } from "@/actor/router-websocket-endpoints";
+import { stringifyError } from "@/common/utils";
+import { importWebSocket } from "@/common/websocket";
+import { logger } from "./log";
+
+/**
+ * Returns Hono `upgradeWebSocket` args that will proxy requests from the client to a destination address.
+ */
+export async function createWebSocketProxy(
+	c: HonoContext,
+	targetUrl: string,
+	protocols: string[],
+): Promise<UpgradeWebSocketArgs> {
+	const WebSocket = await importWebSocket();
+
+	// WebSocket state
+	interface WsState {
+		targetWs?: WebSocket;
+		connectPromise?: Promise<void>;
+	}
+	const state: WsState = {};
+
+	return {
+		onOpen: async (event: any, clientWs: WSContext) => {
+			logger().debug({ msg: "client websocket connected", targetUrl });
+
+			if (clientWs.readyState !== 1) {
+				logger().warn({
+					msg: "client websocket not open on connection",
+					targetUrl,
+					readyState: clientWs.readyState,
+				});
+				return;
+			}
+
+			// Create WebSocket
+			const targetWs = new WebSocket(targetUrl, protocols);
+			state.targetWs = targetWs;
+
+			// Setup connection promise
+			state.connectPromise = new Promise<void>((resolve, reject) => {
+				targetWs.addEventListener("open", () => {
+					logger().debug({
+						msg: "target websocket connected",
+						targetUrl,
+					});
+
+					if (clientWs.readyState !== 1) {
+						logger().warn({
+							msg: "client websocket closed before target connected",
+							targetUrl,
+							clientReadyState: clientWs.readyState,
+						});
+						targetWs.close(1001, "Client disconnected");
+						reject(new Error("Client disconnected"));
+						return;
+					}
+					resolve();
+				});
+
+				targetWs.addEventListener("error", (error) => {
+					logger().warn({
+						msg: "target websocket error during connection",
+						targetUrl,
+					});
+					reject(error);
+				});
+			});
+
+			// Setup bidirectional forwarding
+			state.targetWs.addEventListener("message", (event) => {
+				if (
+					typeof event.data === "string" ||
+					event.data instanceof ArrayBuffer
+				) {
+					clientWs.send(event.data);
+				} else if (event.data instanceof Blob) {
+					event.data.arrayBuffer().then((buffer) => {
+						clientWs.send(buffer);
+					});
+				}
+			});
+
+			state.targetWs.addEventListener("close", (event) => {
+				logger().debug({
+					msg: "target websocket closed",
+					targetUrl,
+					code: event.code,
+					reason: event.reason,
+				});
+				closeWebSocketIfOpen(clientWs, event.code, event.reason);
+			});
+
+			state.targetWs.addEventListener("error", (error) => {
+				logger().error({
+					msg: "target websocket error",
+					targetUrl,
+					error: stringifyError(error),
+				});
+				closeWebSocketIfOpen(clientWs, 1011, "Target WebSocket error");
+			});
+		},
+
+		onMessage: async (event: any, clientWs: WSContext) => {
+			if (!state.targetWs || !state.connectPromise) {
+				logger().error({
+					msg: "websocket state not initialized",
+					targetUrl,
+				});
+				return;
+			}
+
+			try {
+				await state.connectPromise;
+				if (state.targetWs.readyState === WebSocket.OPEN) {
+					state.targetWs.send(event.data);
+				} else {
+					logger().warn({
+						msg: "target websocket not open",
+						targetUrl,
+						readyState: state.targetWs.readyState,
+					});
+				}
+			} catch (error) {
+				logger().error({
+					msg: "failed to connect to target websocket",
+					targetUrl,
+					error,
+				});
+				closeWebSocketIfOpen(
+					clientWs,
+					1011,
+					"Failed to connect to target",
+				);
+			}
+		},
+
+		onClose: (event: any, clientWs: WSContext) => {
+			logger().debug({
+				msg: "client websocket closed",
+				targetUrl,
+				code: event.code,
+				reason: event.reason,
+				wasClean: event.wasClean,
+			});
+
+			if (state.targetWs) {
+				if (
+					state.targetWs.readyState === WebSocket.OPEN ||
+					state.targetWs.readyState === WebSocket.CONNECTING
+				) {
+					state.targetWs.close(
+						1000,
+						event.reason || "Client disconnected",
+					);
+				}
+			}
+		},
+
+		onError: (event: any, clientWs: WSContext) => {
+			logger().error({ msg: "client websocket error", targetUrl, event });
+
+			if (state.targetWs) {
+				if (state.targetWs.readyState === WebSocket.OPEN) {
+					state.targetWs.close(1011, "Client WebSocket error");
+				} else if (state.targetWs.readyState === WebSocket.CONNECTING) {
+					state.targetWs.close();
+				}
+			}
+		},
+	};
+}
+
+function closeWebSocketIfOpen(
+	ws: WebSocket | WSContext,
+	code: number,
+	reason: string,
+): void {
+	if (ws.readyState === 1) {
+		ws.close(code, reason);
+	} else if (
+		"close" in ws &&
+		(ws as WebSocket).readyState === WebSocket.OPEN
+	) {
+		ws.close(code, reason);
+	}
+}

package/src/schemas/actor-inspector/mod.ts

@@ -0,0 +1 @@
+export * from "../../../dist/schemas/actor-inspector/v3";

package/src/schemas/actor-inspector/versioned.ts

@@ -0,0 +1,233 @@
+import { createVersionedDataHandler } from "vbare";
+
+import * as v1 from "../../../dist/schemas/actor-inspector/v1";
+import * as v2 from "../../../dist/schemas/actor-inspector/v2";
+import * as v3 from "../../../dist/schemas/actor-inspector/v3";
+
+export const CURRENT_VERSION = 3;
+
+const EVENTS_DROPPED_ERROR = "inspector.events_dropped";
+const WORKFLOW_HISTORY_DROPPED_ERROR = "inspector.workflow_history_dropped";
+const QUEUE_DROPPED_ERROR = "inspector.queue_dropped";
+const TRACE_DROPPED_ERROR = "inspector.trace_dropped";
+const DATABASE_DROPPED_ERROR = "inspector.database_dropped";
+
+// Converter from v1 to v2: Drop events in Init and add new fields
+const v1ToClientToV2 = (v1Data: v1.ToClient): v2.ToClient => {
+	if (v1Data.body.tag === "Init") {
+		const init = v1Data.body.val as v1.Init;
+		return {
+			body: {
+				tag: "Init",
+				val: {
+					connections: init.connections,
+					state: init.state,
+					isStateEnabled: init.isStateEnabled,
+					rpcs: init.rpcs,
+					isDatabaseEnabled: init.isDatabaseEnabled,
+					queueSize: 0n,
+					workflowHistory: null,
+					isWorkflowEnabled: false,
+				},
+			},
+		};
+	}
+	if (
+		v1Data.body.tag === "EventsUpdated" ||
+		v1Data.body.tag === "EventsResponse"
+	) {
+		return {
+			body: {
+				tag: "Error",
+				val: {
+					message: EVENTS_DROPPED_ERROR,
+				},
+			},
+		};
+	}
+	return v1Data as unknown as v2.ToClient;
+};
+
+// Converter from v2 to v1: Add empty events to Init, drop newer updates
+const v2ToClientToV1 = (v2Data: v2.ToClient): v1.ToClient => {
+	if (v2Data.body.tag === "Init") {
+		const init = v2Data.body.val;
+		return {
+			body: {
+				tag: "Init",
+				val: {
+					connections: init.connections,
+					events: [],
+					state: init.state,
+					isStateEnabled: init.isStateEnabled,
+					rpcs: init.rpcs,
+					isDatabaseEnabled: init.isDatabaseEnabled,
+				},
+			},
+		};
+	}
+	if (
+		v2Data.body.tag === "WorkflowHistoryUpdated" ||
+		v2Data.body.tag === "WorkflowHistoryResponse"
+	) {
+		return {
+			body: {
+				tag: "Error",
+				val: {
+					message: WORKFLOW_HISTORY_DROPPED_ERROR,
+				},
+			},
+		};
+	}
+	if (v2Data.body.tag === "QueueUpdated") {
+		return {
+			body: {
+				tag: "Error",
+				val: {
+					message: QUEUE_DROPPED_ERROR,
+				},
+			},
+		};
+	}
+	if (v2Data.body.tag === "QueueResponse") {
+		return {
+			body: {
+				tag: "Error",
+				val: {
+					message: QUEUE_DROPPED_ERROR,
+				},
+			},
+		};
+	}
+	if (v2Data.body.tag === "TraceQueryResponse") {
+		return {
+			body: {
+				tag: "Error",
+				val: {
+					message: TRACE_DROPPED_ERROR,
+				},
+			},
+		};
+	}
+	return v2Data as unknown as v1.ToClient;
+};
+
+// Converter from v2 to v3: v2 messages are a subset of v3
+const v2ToClientToV3 = (v2Data: v2.ToClient): v3.ToClient => {
+	return v2Data as unknown as v3.ToClient;
+};
+
+// Converter from v3 to v2: Drop database responses
+const v3ToClientToV2 = (v3Data: v3.ToClient): v2.ToClient => {
+	if (
+		v3Data.body.tag === "DatabaseSchemaResponse" ||
+		v3Data.body.tag === "DatabaseTableRowsResponse"
+	) {
+		return {
+			body: {
+				tag: "Error",
+				val: {
+					message: DATABASE_DROPPED_ERROR,
+				},
+			},
+		};
+	}
+	return v3Data as unknown as v2.ToClient;
+};
+
+// Converter from v1 to v2: Drop events requests
+const v1ToServerToV2 = (v1Data: v1.ToServer): v2.ToServer => {
+	if (
+		v1Data.body.tag === "EventsRequest" ||
+		v1Data.body.tag === "ClearEventsRequest"
+	) {
+		throw new Error("Cannot convert events requests to v2");
+	}
+	return v1Data as unknown as v2.ToServer;
+};
+
+// Converter from v2 to v1: Drop newer requests
+const v2ToServerToV1 = (v2Data: v2.ToServer): v1.ToServer => {
+	if (
+		v2Data.body.tag === "TraceQueryRequest" ||
+		v2Data.body.tag === "QueueRequest" ||
+		v2Data.body.tag === "WorkflowHistoryRequest"
+	) {
+		throw new Error("Cannot convert v2-only requests to v1");
+	}
+	return v2Data as unknown as v1.ToServer;
+};
+
+// Converter from v2 to v3: v2 messages are a subset of v3
+const v2ToServerToV3 = (v2Data: v2.ToServer): v3.ToServer => {
+	return v2Data as unknown as v3.ToServer;
+};
+
+// Converter from v3 to v2: Drop database requests
+const v3ToServerToV2 = (v3Data: v3.ToServer): v2.ToServer => {
+	if (
+		v3Data.body.tag === "DatabaseSchemaRequest" ||
+		v3Data.body.tag === "DatabaseTableRowsRequest"
+	) {
+		throw new Error("Cannot convert v3-only database requests to v2");
+	}
+	return v3Data as unknown as v2.ToServer;
+};
+
+export const TO_SERVER_VERSIONED = createVersionedDataHandler<v3.ToServer>({
+	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);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 1:
+				return v1.decodeToServer(bytes);
+			case 2:
+				return v2.decodeToServer(bytes);
+			case 3:
+				return v3.decodeToServer(bytes);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	deserializeConverters: () => [v1ToServerToV2, v2ToServerToV3],
+	serializeConverters: () => [v3ToServerToV2, v2ToServerToV1],
+});
+
+export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v3.ToClient>({
+	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);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 1:
+				return v1.decodeToClient(bytes);
+			case 2:
+				return v2.decodeToClient(bytes);
+			case 3:
+				return v3.decodeToClient(bytes);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	deserializeConverters: () => [v1ToClientToV2, v2ToClientToV3],
+	serializeConverters: () => [v3ToClientToV2, v2ToClientToV1],
+});

package/src/schemas/actor-persist/mod.ts

@@ -0,0 +1 @@
+export * from "../../../dist/schemas/actor-persist/v3";

package/src/schemas/actor-persist/versioned.ts

@@ -0,0 +1,217 @@
+import { createVersionedDataHandler } from "vbare";
+import * as v1 from "../../../dist/schemas/actor-persist/v1";
+import * as v2 from "../../../dist/schemas/actor-persist/v2";
+import * as v3 from "../../../dist/schemas/actor-persist/v3";
+import * as v4 from "../../../dist/schemas/actor-persist/v4";
+
+export const CURRENT_VERSION = 4;
+
+// Converter from v1 to v2
+const v1ToV2 = (v1Data: v1.PersistedActor): v2.PersistedActor => ({
+	...v1Data,
+	connections: v1Data.connections.map((conn) => ({
+		...conn,
+		hibernatableRequestId: null,
+	})),
+	hibernatableWebSockets: [],
+});
+
+// Converter from v2 to v3
+const v2ToV3 = (v2Data: v2.PersistedActor): v3.Actor => {
+	// Transform scheduled events from nested structure to flat structure
+	const scheduledEvents: v3.ScheduleEvent[] = v2Data.scheduledEvents.map(
+		(event) => {
+			// Extract action and args from the kind wrapper
+			if (event.kind.tag === "GenericPersistedScheduleEvent") {
+				return {
+					eventId: event.eventId,
+					timestamp: event.timestamp,
+					action: event.kind.val.action,
+					args: event.kind.val.args,
+				};
+			}
+			// Fallback for unknown kinds
+			throw new Error(`Unknown schedule event kind: ${event.kind.tag}`);
+		},
+	);
+
+	return {
+		input: v2Data.input,
+		hasInitialized: v2Data.hasInitialized,
+		state: v2Data.state,
+		scheduledEvents,
+	};
+};
+
+// Converter from v3 to v4: No changes to Actor structure
+const v3ToV4 = (v3Data: v3.Actor): v4.Actor => {
+	return v3Data as unknown as v4.Actor;
+};
+
+// Converter from v4 to v3: No changes to Actor structure
+const v4ToV3 = (v4Data: v4.Actor): v3.Actor => {
+	return v4Data as unknown as v3.Actor;
+};
+
+// Converter from v3 to v2
+const v3ToV2 = (v3Data: v3.Actor): v2.PersistedActor => {
+	// Transform scheduled events from flat structure back to nested structure
+	const scheduledEvents: v2.PersistedScheduleEvent[] =
+		v3Data.scheduledEvents.map((event) => ({
+			eventId: event.eventId,
+			timestamp: event.timestamp,
+			kind: {
+				tag: "GenericPersistedScheduleEvent" as const,
+				val: {
+					action: event.action,
+					args: event.args,
+				},
+			},
+		}));
+
+	return {
+		input: v3Data.input,
+		hasInitialized: v3Data.hasInitialized,
+		state: v3Data.state,
+		scheduledEvents,
+		connections: [],
+		hibernatableWebSockets: [],
+	};
+};
+
+// Converter from v2 to v1
+const v2ToV1 = (v2Data: v2.PersistedActor): v1.PersistedActor => {
+	return {
+		input: v2Data.input,
+		hasInitialized: v2Data.hasInitialized,
+		state: v2Data.state,
+		scheduledEvents: v2Data.scheduledEvents,
+		connections: v2Data.connections.map((conn) => {
+			const { hibernatableRequestId, ...rest } = conn;
+			return rest;
+		}),
+	};
+};
+
+export const ACTOR_VERSIONED = createVersionedDataHandler<v4.Actor>({
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 1:
+				return v1.decodePersistedActor(bytes);
+			case 2:
+				return v2.decodePersistedActor(bytes);
+			case 3:
+				return v3.decodeActor(bytes);
+			case 4:
+				return v4.decodeActor(bytes);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	serializeVersion: (data, version) => {
+		switch (version) {
+			case 1:
+				return v1.encodePersistedActor(data as v1.PersistedActor);
+			case 2:
+				return v2.encodePersistedActor(data as v2.PersistedActor);
+			case 3:
+				return v3.encodeActor(data as v3.Actor);
+			case 4:
+				return v4.encodeActor(data as v4.Actor);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	deserializeConverters: () => [v1ToV2, v2ToV3, v3ToV4],
+	serializeConverters: () => [v4ToV3, v3ToV2, v2ToV1],
+});
+
+// Conn identity converters (Conn is identical between v3 and v4)
+const v3ConnToV4 = (v3Data: v3.Conn): v4.Conn => {
+	return v3Data as unknown as v4.Conn;
+};
+
+const v4ConnToV3 = (v4Data: v4.Conn): v3.Conn => {
+	return v4Data as unknown as v3.Conn;
+};
+
+export const CONN_VERSIONED = createVersionedDataHandler<v4.Conn>({
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 3:
+				return v3.decodeConn(bytes);
+			case 4:
+				return v4.decodeConn(bytes);
+			default:
+				throw new Error(
+					`Conn type only exists in version 3+, got version ${version}`,
+				);
+		}
+	},
+	serializeVersion: (data, version) => {
+		switch (version) {
+			case 3:
+				return v3.encodeConn(data as v3.Conn);
+			case 4:
+				return v4.encodeConn(data as v4.Conn);
+			default:
+				throw new Error(
+					`Conn type only exists in version 3+, got version ${version}`,
+				);
+		}
+	},
+	deserializeConverters: () => [v3ConnToV4],
+	serializeConverters: () => [v4ConnToV3],
+});
+
+export const QUEUE_METADATA_VERSIONED =
+	createVersionedDataHandler<v4.QueueMetadata>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 4:
+					return v4.decodeQueueMetadata(bytes);
+				default:
+					throw new Error(
+						`QueueMetadata type only exists in version 4+, got version ${version}`,
+					);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 4:
+					return v4.encodeQueueMetadata(data as v4.QueueMetadata);
+				default:
+					throw new Error(
+						`QueueMetadata type only exists in version 4+, got version ${version}`,
+					);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
+	});
+
+export const QUEUE_MESSAGE_VERSIONED =
+	createVersionedDataHandler<v4.QueueMessage>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 4:
+					return v4.decodeQueueMessage(bytes);
+				default:
+					throw new Error(
+						`QueueMessage type only exists in version 4+, got version ${version}`,
+					);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 4:
+					return v4.encodeQueueMessage(data as v4.QueueMessage);
+				default:
+					throw new Error(
+						`QueueMessage type only exists in version 4+, got version ${version}`,
+					);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
+	});

package/src/schemas/client-protocol/mod.ts

@@ -0,0 +1 @@
+export * from "../../../dist/schemas/client-protocol/v3";