rivetkit 2.0.3 → 2.0.4

package/src/remote-manager-driver/mod.ts

@@ -0,0 +1,274 @@
+import * as cbor from "cbor-x";
+import type { Hono, Context as HonoContext } from "hono";
+import invariant from "invariant";
+import { ActorAlreadyExists } from "@/actor/errors";
+import { deserializeActorKey, serializeActorKey } from "@/actor/keys";
+import type { ClientConfig } from "@/client/client";
+import { noopNext } from "@/common/utils";
+import type {
+	ActorOutput,
+	CreateInput,
+	GetForIdInput,
+	GetOrCreateWithKeyInput,
+	GetWithKeyInput,
+	ManagerDisplayInformation,
+	ManagerDriver,
+} from "@/driver-helpers/mod";
+import type { ManagerInspector } from "@/inspector/manager";
+import type { Encoding, RegistryConfig, UniversalWebSocket } from "@/mod";
+import type { RunConfig } from "@/registry/run-config";
+import { sendHttpRequestToActor } from "./actor-http-client";
+import {
+	buildGuardHeadersForWebSocket,
+	openWebSocketToActor,
+} from "./actor-websocket-client";
+import {
+	createActor,
+	destroyActor,
+	getActor,
+	getActorById,
+	getOrCreateActorById,
+} from "./api-endpoints";
+import { EngineApiError, getEndpoint } from "./api-utils";
+import { logger } from "./log";
+import { createWebSocketProxy } from "./ws-proxy";
+
+// TODO:
+// // Lazily import the dynamic imports so we don't have to turn `createClient` in to an async fn
+// const dynamicImports = (async () => {
+// 	// Import dynamic dependencies
+// 	const [WebSocket, EventSource] = await Promise.all([
+// 		importWebSocket(),
+// 		importEventSource(),
+// 	]);
+// 	return {
+// 		WebSocket,
+// 		EventSource,
+// 	};
+// })();
+
+export class RemoteManagerDriver implements ManagerDriver {
+	#config: ClientConfig;
+
+	constructor(runConfig: ClientConfig) {
+		this.#config = runConfig;
+	}
+
+	async getForId({
+		c,
+		name,
+		actorId,
+	}: GetForIdInput): Promise<ActorOutput | undefined> {
+		// Fetch from API if not in cache
+		try {
+			const response = await getActor(this.#config, actorId);
+
+			// Validate name matches
+			if (response.actor.name !== name) {
+				logger().debug({
+					msg: "actor name mismatch from api",
+					actorId,
+					apiName: response.actor.name,
+					requestedName: name,
+				});
+				return undefined;
+			}
+
+			const keyRaw = response.actor.key;
+			invariant(keyRaw, `actor ${actorId} should have key`);
+			const key = deserializeActorKey(keyRaw);
+
+			return {
+				actorId,
+				name,
+				key,
+			};
+		} catch (error) {
+			if (
+				error instanceof EngineApiError &&
+				(error as EngineApiError).group === "actor" &&
+				(error as EngineApiError).code === "not_found"
+			) {
+				return undefined;
+			}
+			throw error;
+		}
+	}
+
+	async getWithKey({
+		c,
+		name,
+		key,
+	}: GetWithKeyInput): Promise<ActorOutput | undefined> {
+		logger().debug({ msg: "getWithKey: searching for actor", name, key });
+
+		// If not in local cache, fetch by key from API
+		try {
+			const response = await getActorById(this.#config, name, key);
+
+			if (!response.actor_id) {
+				return undefined;
+			}
+
+			const actorId = response.actor_id;
+
+			logger().debug({
+				msg: "getWithKey: found actor via api",
+				actorId,
+				name,
+				key,
+			});
+
+			return {
+				actorId,
+				name,
+				key,
+			};
+		} catch (error) {
+			if (
+				error instanceof EngineApiError &&
+				(error as EngineApiError).group === "actor" &&
+				(error as EngineApiError).code === "not_found"
+			) {
+				return undefined;
+			}
+			throw error;
+		}
+	}
+
+	async getOrCreateWithKey(
+		input: GetOrCreateWithKeyInput,
+	): Promise<ActorOutput> {
+		const { c, name, key, input: actorInput, region } = input;
+
+		logger().info({
+			msg: "getOrCreateWithKey: getting or creating actor via engine api",
+			name,
+			key,
+		});
+
+		const response = await getOrCreateActorById(this.#config, {
+			name,
+			key: serializeActorKey(key),
+			runner_name_selector: this.#config.runnerName,
+			input: input ? cbor.encode(actorInput).toString("base64") : undefined,
+			crash_policy: "sleep",
+		});
+
+		const actorId = response.actor_id;
+
+		logger().info({
+			msg: "getOrCreateWithKey: actor ready",
+			actorId,
+			name,
+			key,
+			created: response.created,
+		});
+
+		return {
+			actorId,
+			name,
+			key,
+		};
+	}
+
+	async createActor({
+		c,
+		name,
+		key,
+		input,
+	}: CreateInput): Promise<ActorOutput> {
+		logger().info({ msg: "creating actor via engine api", name, key });
+
+		// Create actor via engine API
+		const result = await createActor(this.#config, {
+			name,
+			runner_name_selector: this.#config.runnerName,
+			key: serializeActorKey(key),
+			input: input ? cbor.encode(input).toString("base64") : null,
+			crash_policy: "sleep",
+		});
+		const actorId = result.actor.actor_id;
+
+		logger().info({ msg: "actor created", actorId, name, key });
+
+		return {
+			actorId,
+			name,
+			key,
+		};
+	}
+
+	async destroyActor(actorId: string): Promise<void> {
+		logger().info({ msg: "destroying actor via engine api", actorId });
+
+		await destroyActor(this.#config, actorId);
+
+		logger().info({ msg: "actor destroyed", actorId });
+	}
+
+	async sendRequest(actorId: string, actorRequest: Request): Promise<Response> {
+		return await sendHttpRequestToActor(this.#config, actorId, actorRequest);
+	}
+
+	async openWebSocket(
+		path: string,
+		actorId: string,
+		encoding: Encoding,
+		params: unknown,
+	): Promise<UniversalWebSocket> {
+		return await openWebSocketToActor(
+			this.#config,
+			path,
+			actorId,
+			encoding,
+			params,
+		);
+	}
+
+	async proxyRequest(
+		_c: HonoContext,
+		actorRequest: Request,
+		actorId: string,
+	): Promise<Response> {
+		return await sendHttpRequestToActor(this.#config, actorId, actorRequest);
+	}
+
+	async proxyWebSocket(
+		c: HonoContext,
+		path: string,
+		actorId: string,
+		encoding: Encoding,
+		params: unknown,
+		authData: unknown,
+	): Promise<Response> {
+		const upgradeWebSocket = this.#config.getUpgradeWebSocket?.();
+		invariant(upgradeWebSocket, "missing getUpgradeWebSocket");
+
+		const endpoint = getEndpoint(this.#config);
+		const guardUrl = `${endpoint}${path}`;
+		const wsGuardUrl = guardUrl.replace("http://", "ws://");
+
+		logger().debug({
+			msg: "forwarding websocket to actor via guard",
+			actorId,
+			path,
+			guardUrl,
+		});
+
+		// Build headers
+		const headers = buildGuardHeadersForWebSocket(
+			actorId,
+			encoding,
+			params,
+			authData,
+		);
+		const args = await createWebSocketProxy(c, wsGuardUrl, headers);
+
+		return await upgradeWebSocket(() => args)(c, noopNext());
+	}
+
+	displayInformation(): ManagerDisplayInformation {
+		return { name: "Remote", properties: {} };
+	}
+}

package/src/{drivers/engine → remote-manager-driver}/ws-proxy.ts

@@ -1,7 +1,6 @@
 import type { Context as HonoContext } from "hono";
 import type { WSContext } from "hono/ws";
-import invariant from "invariant";
-import type { CloseEvent } from "ws";
+import { stringifyError } from "@/common/utils";
 import { importWebSocket } from "@/common/websocket";
 import type { UpgradeWebSocketArgs } from "@/mod";
 import { logger } from "./log";
@@ -32,10 +31,11 @@ export async function createWebSocketProxy(
 
 	return {
 		onOpen: async (event: any, clientWs: WSContext) => {
-			logger().debug("client websocket connected", { targetUrl });
+			logger().debug({ msg: "client websocket connected", targetUrl });
 
 			if (clientWs.readyState !== 1) {
-				logger().warn("client websocket not open on connection", {
+				logger().warn({
+					msg: "client websocket not open on connection",
 					targetUrl,
 					readyState: clientWs.readyState,
 				});
@@ -49,10 +49,11 @@ export async function createWebSocketProxy(
 			// Setup connection promise
 			state.connectPromise = new Promise<void>((resolve, reject) => {
 				targetWs.addEventListener("open", () => {
-					logger().debug("target websocket connected", { targetUrl });
+					logger().debug({ msg: "target websocket connected", targetUrl });
 
 					if (clientWs.readyState !== 1) {
-						logger().warn("client websocket closed before target connected", {
+						logger().warn({
+							msg: "client websocket closed before target connected",
 							targetUrl,
 							clientReadyState: clientWs.readyState,
 						});
@@ -64,7 +65,8 @@ export async function createWebSocketProxy(
 				});
 
 				targetWs.addEventListener("error", (error) => {
-					logger().warn("target websocket error during connection", {
+					logger().warn({
+						msg: "target websocket error during connection",
 						targetUrl,
 					});
 					reject(error);
@@ -86,7 +88,8 @@ export async function createWebSocketProxy(
 			});
 
 			state.targetWs.addEventListener("close", (event) => {
-				logger().debug("target websocket closed", {
+				logger().debug({
+					msg: "target websocket closed",
 					targetUrl,
 					code: event.code,
 					reason: event.reason,
@@ -95,14 +98,18 @@ export async function createWebSocketProxy(
 			});
 
 			state.targetWs.addEventListener("error", (error) => {
-				logger().error("target websocket error", { targetUrl, 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("websocket state not initialized", { targetUrl });
+				logger().error({ msg: "websocket state not initialized", targetUrl });
 				return;
 			}
 
@@ -111,13 +118,15 @@ export async function createWebSocketProxy(
 				if (state.targetWs.readyState === WebSocket.OPEN) {
 					state.targetWs.send(event.data);
 				} else {
-					logger().warn("target websocket not open", {
+					logger().warn({
+						msg: "target websocket not open",
 						targetUrl,
 						readyState: state.targetWs.readyState,
 					});
 				}
 			} catch (error) {
-				logger().error("failed to connect to target websocket", {
+				logger().error({
+					msg: "failed to connect to target websocket",
 					targetUrl,
 					error,
 				});
@@ -126,7 +135,8 @@ export async function createWebSocketProxy(
 		},
 
 		onClose: (event: any, clientWs: WSContext) => {
-			logger().debug("client websocket closed", {
+			logger().debug({
+				msg: "client websocket closed",
 				targetUrl,
 				code: event.code,
 				reason: event.reason,
@@ -144,7 +154,7 @@ export async function createWebSocketProxy(
 		},
 
 		onError: (event: any, clientWs: WSContext) => {
-			logger().error("client websocket error", { targetUrl, event });
+			logger().error({ msg: "client websocket error", targetUrl, event });
 
 			if (state.targetWs) {
 				if (state.targetWs.readyState === WebSocket.OPEN) {

package/src/serde.ts

@@ -40,13 +40,16 @@ export function wsBinaryTypeForEncoding(
 export function serializeWithEncoding<T>(
 	encoding: Encoding,
 	value: T,
-	versionedDataHandler: VersionedDataHandler<T>,
+	versionedDataHandler: VersionedDataHandler<T> | undefined,
 ): Uint8Array | string {
 	if (encoding === "json") {
 		return jsonStringifyCompat(value);
 	} else if (encoding === "cbor") {
 		return cbor.encode(value);
 	} else if (encoding === "bare") {
+		if (!versionedDataHandler) {
+			throw new Error("VersionedDataHandler is required for 'bare' encoding");
+		}
 		return versionedDataHandler.serializeWithEmbeddedVersion(value);
 	} else {
 		assertUnreachable(encoding);
@@ -56,7 +59,7 @@ export function serializeWithEncoding<T>(
 export function deserializeWithEncoding<T>(
 	encoding: Encoding,
 	buffer: Uint8Array | string,
-	versionedDataHandler: VersionedDataHandler<T>,
+	versionedDataHandler: VersionedDataHandler<T> | undefined,
 ): T {
 	if (encoding === "json") {
 		if (typeof buffer === "string") {
@@ -77,6 +80,9 @@ export function deserializeWithEncoding<T>(
 			typeof buffer !== "string",
 			"buffer cannot be string for bare encoding",
 		);
+		if (!versionedDataHandler) {
+			throw new Error("VersionedDataHandler is required for 'bare' encoding");
+		}
 		return versionedDataHandler.deserializeWithEmbeddedVersion(buffer);
 	} else {
 		assertUnreachable(encoding);

package/src/test/log.ts

@@ -1,7 +1,5 @@
 import { getLogger } from "@/common/log";
 
-export const LOGGER_NAME = "nodejs";
-
 export function logger() {
-	return getLogger(LOGGER_NAME);
+	return getLogger("test");
 }

package/src/test/mod.ts

@@ -5,7 +5,6 @@ import { type TestContext, vi } from "vitest";
 import { type Client, createClient } from "@/client/mod";
 import { chooseDefaultDriver } from "@/drivers/default";
 import { createFileSystemOrMemoryDriver } from "@/drivers/file-system/mod";
-import { createInlineClientDriver } from "@/inline-client-driver/mod";
 import { getInspectorUrl } from "@/inspector/utils";
 import { createManagerRouter } from "@/manager/router";
 import type { Registry } from "@/registry/mod";
@@ -28,11 +27,9 @@ function serve(registry: Registry<any>, inputConfig?: InputConfig): ServerType {
 	const runConfig = RunConfigSchema.parse(inputConfig);
 	const driver = inputConfig.driver ?? createFileSystemOrMemoryDriver(false);
 	const managerDriver = driver.manager(registry.config, config);
-	const inlineClientDriver = createInlineClientDriver(managerDriver);
 	const { router } = createManagerRouter(
 		registry.config,
 		runConfig,
-		inlineClientDriver,
 		managerDriver,
 		false,
 	);
@@ -48,7 +45,8 @@ function serve(registry: Registry<any>, inputConfig?: InputConfig): ServerType {
 	});
 	nodeWebSocket.injectWebSocket(server);
 
-	logger().info("rivetkit started", {
+	logger().info({
+		msg: "rivetkit started",
 		hostname: config.hostname,
 		port: config.port,
 		definitions: Object.keys(registry.config.use).length,
@@ -88,18 +86,21 @@ export async function setupTest<A extends Registry<any>>(
 		async () => await new Promise((resolve) => server.close(() => resolve())),
 	);
 
-	// Create client
-	const client = createClient<A>(`http://127.0.0.1:${port}`);
-	c.onTestFinished(async () => await client.dispose());
-
-	return {
-		client,
-		mockDriver: {
-			actorDriver: {
-				setCreateVarsContext: setDriverContextFn,
-			},
-		},
-	};
+	throw "TODO: Fix engine port";
+
+	// // TODO: Figure out how to make this the correct endpoint
+	// // Create client
+	// const client = createClient<A>(`http://127.0.0.1:${port}`);
+	// c.onTestFinished(async () => await client.dispose());
+	//
+	// return {
+	// 	client,
+	// 	mockDriver: {
+	// 		actorDriver: {
+	// 			setCreateVarsContext: setDriverContextFn,
+	// 		},
+	// 	},
+	// };
 }
 
 export async function getPort(): Promise<number> {

package/dist/tsup/chunk-2CRLFV6Z.cjs

@@ -1,202 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
-
-var _chunkOGAPU3UGcjs = require('./chunk-OGAPU3UG.cjs');
-
-// src/common/log-levels.ts
-var LogLevels = {
-  TRACE: 0,
-  DEBUG: 1,
-  INFO: 2,
-  WARN: 3,
-  ERROR: 4,
-  CRITICAL: 5
-};
-var LevelNameMap = {
-  0: "TRACE",
-  1: "DEBUG",
-  2: "INFO",
-  3: "WARN",
-  4: "ERROR",
-  5: "CRITICAL"
-};
-
-// src/common/logfmt.ts
-var LOG_LEVEL_COLORS = {
-  [LogLevels.CRITICAL]: "\x1B[31m",
-  // Red
-  [LogLevels.ERROR]: "\x1B[31m",
-  // Red
-  [LogLevels.WARN]: "\x1B[33m",
-  // Yellow
-  [LogLevels.INFO]: "\x1B[32m",
-  // Green
-  [LogLevels.DEBUG]: "\x1B[36m",
-  // Cyan
-  [LogLevels.TRACE]: "\x1B[36m"
-  // Cyan
-};
-var RESET_COLOR = "\x1B[0m";
-function stringify(...data) {
-  let line = "";
-  for (let i = 0; i < data.length; i++) {
-    const [key, valueRaw] = data[i];
-    let isNull = false;
-    let valueString;
-    if (valueRaw == null) {
-      isNull = true;
-      valueString = "";
-    } else {
-      valueString = valueRaw.toString();
-    }
-    if (valueString.length > 512 && key !== "msg" && key !== "error")
-      valueString = `${valueString.slice(0, 512)}...`;
-    const needsQuoting = valueString.indexOf(" ") > -1 || valueString.indexOf("=") > -1;
-    const needsEscaping = valueString.indexOf('"') > -1 || valueString.indexOf("\\") > -1;
-    valueString = valueString.replace(/\n/g, "\\n");
-    if (needsEscaping) valueString = valueString.replace(/["\\]/g, "\\$&");
-    if (needsQuoting || needsEscaping) valueString = `"${valueString}"`;
-    if (valueString === "" && !isNull) valueString = '""';
-    if (LOGGER_CONFIG.enableColor) {
-      let color = "\x1B[2m";
-      if (key === "level") {
-        const level = LogLevels[valueString];
-        const levelColor = LOG_LEVEL_COLORS[level];
-        if (levelColor) {
-          color = levelColor;
-        }
-      } else if (key === "msg") {
-        color = "\x1B[32m";
-      } else if (key === "trace") {
-        color = "\x1B[34m";
-      }
-      line += `\x1B[0m\x1B[1m${key}\x1B[0m\x1B[2m=\x1B[0m${color}${valueString}${RESET_COLOR}`;
-    } else {
-      line += `${key}=${valueString}`;
-    }
-    if (i !== data.length - 1) {
-      line += " ";
-    }
-  }
-  return line;
-}
-function formatTimestamp(date) {
-  const year = date.getUTCFullYear();
-  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
-  const day = String(date.getUTCDate()).padStart(2, "0");
-  const hours = String(date.getUTCHours()).padStart(2, "0");
-  const minutes = String(date.getUTCMinutes()).padStart(2, "0");
-  const seconds = String(date.getUTCSeconds()).padStart(2, "0");
-  const milliseconds = String(date.getUTCMilliseconds()).padStart(3, "0");
-  return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${milliseconds}Z`;
-}
-function castToLogValue(v) {
-  if (typeof v === "string" || typeof v === "number" || typeof v === "bigint" || typeof v === "boolean" || v === null || v === void 0) {
-    return v;
-  }
-  if (v instanceof Error) {
-    return String(v);
-  }
-  try {
-    return JSON.stringify(v);
-  } catch (e) {
-    return "[cannot stringify]";
-  }
-}
-var LOGGER_CONFIG = {
-  enableColor: false,
-  enableSpreadObject: false,
-  enableErrorStack: false
-};
-
-// src/common/log.ts
-var Logger = class {
-  
-  
-  constructor(name, level) {
-    this.name = name;
-    this.level = level;
-  }
-  log(level, message, ...args) {
-    const record = {
-      msg: message,
-      args,
-      level,
-      loggerName: this.name,
-      datetime: /* @__PURE__ */ new Date(),
-      levelName: LevelNameMap[level]
-    };
-    if (this.#shouldLog(level)) {
-      this.#logRecord(record);
-    }
-  }
-  #shouldLog(level) {
-    return level >= LogLevels[this.level];
-  }
-  #logRecord(record) {
-    console.log(formatter(record));
-  }
-  trace(message, ...args) {
-    this.log(LogLevels.TRACE, message, ...args);
-  }
-  debug(message, ...args) {
-    this.log(LogLevels.DEBUG, message, ...args);
-  }
-  info(message, ...args) {
-    this.log(LogLevels.INFO, message, ...args);
-  }
-  warn(message, ...args) {
-    this.log(LogLevels.WARN, message, ...args);
-  }
-  error(message, ...args) {
-    this.log(LogLevels.ERROR, message, ...args);
-  }
-  critical(message, ...args) {
-    this.log(LogLevels.CRITICAL, message, ...args);
-  }
-};
-var loggers = {};
-function getLogger(name = "default") {
-  const defaultLogLevelEnv = _chunkOGAPU3UGcjs.getEnvUniversal.call(void 0, 
-    "_LOG_LEVEL"
-  );
-  const defaultLogLevel = _nullishCoalesce(defaultLogLevelEnv, () => ( "INFO"));
-  if (!loggers[name]) {
-    loggers[name] = new Logger(name, defaultLogLevel);
-  }
-  return loggers[name];
-}
-function formatter(log) {
-  const args = [];
-  for (let i = 0; i < log.args.length; i++) {
-    const logArg = log.args[i];
-    if (logArg && typeof logArg === "object") {
-      for (const k in logArg) {
-        const v = logArg[k];
-        pushArg(k, v, args);
-      }
-    } else {
-      pushArg(`arg${i}`, logArg, args);
-    }
-  }
-  const logTs = _chunkOGAPU3UGcjs.getEnvUniversal.call(void 0, "_LOG_TIMESTAMP") === "1";
-  const logTarget = _chunkOGAPU3UGcjs.getEnvUniversal.call(void 0, "_LOG_TARGET") === "1";
-  return stringify(
-    ...logTs ? [["ts", formatTimestamp(/* @__PURE__ */ new Date())]] : [],
-    ["level", LevelNameMap[log.level]],
-    ...logTarget ? [["target", log.loggerName]] : [],
-    ["msg", log.msg],
-    ...args
-  );
-}
-function pushArg(k, v, args) {
-  args.push([k, castToLogValue(v)]);
-}
-function setupLogging() {
-}
-
-
-
-
-
-exports.Logger = Logger; exports.getLogger = getLogger; exports.setupLogging = setupLogging;
-//# sourceMappingURL=chunk-2CRLFV6Z.cjs.map