rivetkit 2.0.4 → 2.0.5

package/dist/tsup/{chunk-XJQHKJ4P.js → chunk-L7QRXNWP.js}

@@ -4,16 +4,16 @@ import {
   ForeignKeysSchema,
   PatchSchema,
   TablesSchema
-} from "./chunk-H26RP6GD.js";
+} from "./chunk-CKA54YQN.js";
 import {
   importWebSocket,
   logger as logger2
-} from "./chunk-QK72M5JB.js";
+} from "./chunk-PG3K2LI7.js";
 import {
   PERSISTED_ACTOR_VERSIONED,
   RunConfigSchema,
   serializeEmptyPersistData
-} from "./chunk-TQ62L3X7.js";
+} from "./chunk-B2QGJGZQ.js";
 import {
   CONNECTION_CHECK_LIVENESS_SYMBOL,
   CONNECTION_DRIVER_HTTP,
@@ -23,6 +23,7 @@ import {
   Conn,
   DeadlineError,
   EncodingSchema,
+  HEADER_ACTOR_ID,
   HEADER_AUTH_DATA,
   HEADER_CONN_ID,
   HEADER_CONN_PARAMS,
@@ -54,18 +55,19 @@ import {
   loggerWithoutContext,
   processMessage,
   serializeWithEncoding
-} from "./chunk-HLLF4B4Q.js";
+} from "./chunk-2MD57QF4.js";
 import {
   configureBaseLogger,
   configureDefaultLogger,
   getBaseLogger,
   getIncludeTarget,
   getLogger
-} from "./chunk-LV2S3OU3.js";
+} from "./chunk-WNGOBAA7.js";
 import {
   SinglePromiseQueue,
   assertUnreachable,
   bufferToArrayBuffer,
+  combineUrlPath,
   deconstructError,
   getEnvUniversal,
   httpUserAgent,
@@ -74,7 +76,7 @@ import {
   package_default,
   setLongTimeout,
   stringifyError
-} from "./chunk-PQY7KKTL.js";
+} from "./chunk-CFFKMUYH.js";
 import {
   ActionNotFound,
   ActionTimedOut,
@@ -92,7 +94,7 @@ import {
   UserError,
   VarsNotEnabled,
   WebSocketsNotEnabled
-} from "./chunk-NFU2BBT5.js";
+} from "./chunk-YPZFLUO6.js";
 
 // src/actor/config.ts
 import { z } from "zod";
@@ -2258,7 +2260,8 @@ function createActorRouter(runConfig, actorDriver) {
     const correctedRequest = new Request(correctedUrl, {
       method: c.req.method,
       headers: c.req.raw.headers,
-      body: c.req.raw.body
+      body: c.req.raw.body,
+      duplex: "half"
     });
     loggerWithoutContext().debug({
       msg: "rewriting http url",
@@ -3184,7 +3187,7 @@ async function rawHttpFetch(driver, actorQuery, params, input, init) {
       proxyRequestHeaders.set(HEADER_CONN_PARAMS, JSON.stringify(params));
     }
     const proxyRequest = new Request(url, {
-      ...init,
+      ...mergedInit,
       headers: proxyRequestHeaders
     });
     return driver.sendRequest(actorId, proxyRequest);
@@ -4020,7 +4023,9 @@ function getEndpoint(config2) {
 }
 async function apiCall(config2, method, path3, body) {
   const endpoint = getEndpoint(config2);
-  const url = `${endpoint}${path3}${path3.includes("?") ? "&" : "?"}namespace=${encodeURIComponent(config2.namespace)}`;
+  const url = combineUrlPath(endpoint, path3, {
+    namespace: config2.namespace
+  });
   logger5().debug({ msg: "making api call", method, url });
   return await sendHttpRequest({
     method,
@@ -4038,7 +4043,7 @@ async function apiCall(config2, method, path3, body) {
 async function sendHttpRequestToActor(runConfig, actorId, actorRequest) {
   const url = new URL(actorRequest.url);
   const endpoint = getEndpoint(runConfig);
-  const guardUrl = `${endpoint}${url.pathname}${url.search}`;
+  const guardUrl = combineUrlPath(endpoint, url.pathname + url.search);
   let bodyToSend = null;
   const guardHeaders = buildGuardHeadersForHttp(actorRequest, actorId);
   if (actorRequest.body && actorRequest.method !== "GET" && actorRequest.method !== "HEAD") {
@@ -4056,7 +4061,8 @@ async function sendHttpRequestToActor(runConfig, actorId, actorRequest) {
   const guardRequest = new Request(guardUrl, {
     method: actorRequest.method,
     headers: guardHeaders,
-    body: bodyToSend
+    body: bodyToSend,
+    signal: actorRequest.signal
   });
   return mutableResponse(await fetch(guardRequest));
 }
@@ -4078,7 +4084,7 @@ function buildGuardHeadersForHttp(actorRequest, actorId) {
 async function openWebSocketToActor(runConfig, path3, actorId, encoding, params) {
   const WebSocket2 = await importWebSocket();
   const endpoint = getEndpoint(runConfig);
-  const guardUrl = `${endpoint}${path3}`;
+  const guardUrl = combineUrlPath(endpoint, path3);
   logger5().debug({
     msg: "opening websocket to actor via guard",
     actorId,
@@ -4420,7 +4426,7 @@ var RemoteManagerDriver = class {
     const upgradeWebSocket = (_b = (_a = this.#config).getUpgradeWebSocket) == null ? void 0 : _b.call(_a);
     invariant7(upgradeWebSocket, "missing getUpgradeWebSocket");
     const endpoint = getEndpoint(this.#config);
-    const guardUrl = `${endpoint}${path3}`;
+    const guardUrl = combineUrlPath(endpoint, path3);
     const wsGuardUrl = guardUrl.replace("http://", "ws://");
     logger5().debug({
       msg: "forwarding websocket to actor via guard",
@@ -5255,7 +5261,9 @@ var FileSystemGlobalState = class {
     var _a;
     const entry = await this.loadActor(actorId);
     if (!entry.state) {
-      throw new Error(`Actor does exist and cannot be started: ${actorId}`);
+      throw new Error(
+        `Actor does not exist and cannot be started: "${actorId}"`
+      );
     }
     if (entry.startPromise) {
       await entry.startPromise.promise;
@@ -5588,7 +5596,9 @@ var FileSystemManagerDriver = class {
     });
   }
   async openWebSocket(path3, actorId, encoding, params) {
-    if (path3 === PATH_CONNECT_WEBSOCKET) {
+    const pathOnly = path3.split("?")[0];
+    const normalizedPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
+    if (normalizedPath === PATH_CONNECT_WEBSOCKET) {
       const wsHandler = await handleWebSocketConnect(
         void 0,
         this.#runConfig,
@@ -5599,11 +5609,10 @@ var FileSystemManagerDriver = class {
         void 0
       );
       return new InlineWebSocketAdapter2(wsHandler);
-    } else if (path3.startsWith(PATH_RAW_WEBSOCKET_PREFIX) || path3 === "/raw/websocket") {
-      const normalizedPath = path3 === "/raw/websocket" ? "/raw/websocket/" : path3;
+    } else if (normalizedPath.startsWith(PATH_RAW_WEBSOCKET_PREFIX) || normalizedPath === "/raw/websocket") {
       const wsHandler = await handleRawWebSocketHandler(
         void 0,
-        normalizedPath,
+        path3,
         this.#actorDriver,
         actorId,
         void 0
@@ -5618,11 +5627,13 @@ var FileSystemManagerDriver = class {
       actorId
     });
   }
-  async proxyWebSocket(c, path3, actorId, encoding, connParams, authData) {
+  async proxyWebSocket(c, path3, actorId, encoding, connParams) {
     var _a, _b;
     const upgradeWebSocket = (_b = (_a = this.#runConfig).getUpgradeWebSocket) == null ? void 0 : _b.call(_a);
     invariant10(upgradeWebSocket, "missing getUpgradeWebSocket");
-    if (path3 === PATH_CONNECT_WEBSOCKET) {
+    const pathOnly = path3.split("?")[0];
+    const normalizedPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
+    if (normalizedPath === PATH_CONNECT_WEBSOCKET) {
       const wsHandler = await handleWebSocketConnect(
         c.req.raw,
         this.#runConfig,
@@ -5630,17 +5641,16 @@ var FileSystemManagerDriver = class {
         actorId,
         encoding,
         connParams,
-        authData
+        void 0
       );
       return upgradeWebSocket(() => wsHandler)(c, noopNext());
-    } else if (path3.startsWith(PATH_RAW_WEBSOCKET_PREFIX) || path3 === "/raw/websocket") {
-      const normalizedPath = path3 === "/raw/websocket" ? "/raw/websocket/" : path3;
+    } else if (normalizedPath.startsWith(PATH_RAW_WEBSOCKET_PREFIX) || normalizedPath === "/raw/websocket") {
       const wsHandler = await handleRawWebSocketHandler(
         c.req.raw,
-        normalizedPath,
+        path3,
         this.#actorDriver,
         actorId,
-        authData
+        void 0
       );
       return upgradeWebSocket(() => wsHandler)(c, noopNext());
     } else {
@@ -5779,6 +5789,7 @@ import * as cbor8 from "cbor-x";
 import { Hono as Hono4 } from "hono";
 import { cors as corsMiddleware } from "hono/cors";
 import { createMiddleware as createMiddleware2 } from "hono/factory";
+import invariant11 from "invariant";
 import { z as z9 } from "zod";
 
 // src/manager-api/routes/actors-create.ts
@@ -5862,7 +5873,7 @@ function buildOpenApiResponses(schema, validateBody) {
   };
 }
 function createManagerRouter(registryConfig, runConfig, managerDriver, validateBody) {
-  var _a;
+  var _a, _b;
   const router = new OpenAPIHono({ strict: false }).basePath(
     runConfig.basePath
   );
@@ -5907,9 +5918,10 @@ function createManagerRouter(registryConfig, runConfig, managerDriver, validateB
       const url = new URL(c.req.url);
       const proxyUrl = new URL(`http://actor${url.pathname}${url.search}`);
       const proxyRequest = new Request(proxyUrl, {
-        method: c.req.method,
+        method: c.req.raw.method,
         headers: proxyHeaders,
-        body: c.req.raw.body
+        body: c.req.raw.body,
+        signal: c.req.raw.signal
       });
       return await managerDriver.proxyRequest(c, proxyRequest, actorId);
     }
@@ -6027,10 +6039,10 @@ function createManagerRouter(registryConfig, runConfig, managerDriver, validateB
         actor_id: actorOutput.actorId,
         name: actorOutput.name,
         key: actorOutput.key,
-        namespace_id: "",
-        // Not available from driver
-        runner_name_selector: "",
-        // Not available from driver
+        namespace_id: "default",
+        // Assert default namespace
+        runner_name_selector: "rivetkit",
+        // Assert rivetkit runner
         create_ts: Date.now(),
         // Not available from driver
         connectable_ts: null,
@@ -6078,9 +6090,10 @@ function createManagerRouter(registryConfig, runConfig, managerDriver, validateB
         actor_id: actorOutput.actorId,
         name: actorOutput.name,
         key: actorOutput.key,
-        namespace_id: "",
-        // Not available from driver
-        runner_name_selector: body.runner_name_selector,
+        namespace_id: "default",
+        // Assert default namespace
+        runner_name_selector: "rivetkit",
+        // Assert rivetkit runner
         create_ts: Date.now(),
         connectable_ts: null,
         destroy_ts: null,
@@ -6090,7 +6103,104 @@ function createManagerRouter(registryConfig, runConfig, managerDriver, validateB
       return c.json({ actor: actor2 });
     });
   }
-  if ((_a = runConfig.inspector) == null ? void 0 : _a.enabled) {
+  if (registryConfig.test.enabled) {
+    router.post(".test/inline-driver/call", async (c) => {
+      const buffer = await c.req.arrayBuffer();
+      const { encoding, transport, method, args } = cbor8.decode(new Uint8Array(buffer));
+      logger().debug({
+        msg: "received inline request",
+        encoding,
+        transport,
+        method,
+        args
+      });
+      let response;
+      try {
+        const output = await managerDriver[method](...args);
+        response = { ok: output };
+      } catch (rawErr) {
+        const err = deconstructError(rawErr, logger(), {}, true);
+        response = { err };
+      }
+      return c.body(cbor8.encode(response));
+    });
+    router.get(".test/inline-driver/connect-websocket/*", async (c) => {
+      var _a2;
+      const upgradeWebSocket = (_a2 = runConfig.getUpgradeWebSocket) == null ? void 0 : _a2.call(runConfig);
+      invariant11(upgradeWebSocket, "websockets not supported on this platform");
+      return upgradeWebSocket(async (c2) => {
+        const {
+          path: path3,
+          actorId,
+          params: paramsRaw,
+          encodingKind
+        } = c2.req.query();
+        const params = paramsRaw !== void 0 ? JSON.parse(paramsRaw) : void 0;
+        logger().debug({
+          msg: "received test inline driver websocket",
+          actorId,
+          params,
+          encodingKind,
+          path: path3
+        });
+        const clientWsPromise = managerDriver.openWebSocket(
+          path3,
+          actorId,
+          encodingKind,
+          params
+        );
+        return await createTestWebSocketProxy(clientWsPromise, "standard");
+      })(c, noopNext());
+    });
+    router.all(".test/inline-driver/send-request/*", async (c) => {
+      const actorId = c.req.header(HEADER_ACTOR_ID);
+      if (!actorId) {
+        return c.text("Missing required headers", 400);
+      }
+      const pathOnly = c.req.path.split("/.test/inline-driver/send-request/")[1] || "";
+      const url = new URL(c.req.url);
+      const pathWithQuery = pathOnly + url.search;
+      logger().debug({
+        msg: "received test inline driver raw http",
+        actorId,
+        path: pathWithQuery,
+        method: c.req.method
+      });
+      try {
+        const response = await managerDriver.sendRequest(
+          actorId,
+          new Request(`http://actor/${pathWithQuery}`, {
+            method: c.req.method,
+            headers: c.req.raw.headers,
+            body: c.req.raw.body
+          })
+        );
+        return response;
+      } catch (error) {
+        logger().error({
+          msg: "error in test inline raw http",
+          error: stringifyError(error)
+        });
+        const err = deconstructError(error, logger(), {}, true);
+        return c.json(
+          {
+            error: {
+              code: err.code,
+              message: err.message,
+              metadata: err.metadata
+            }
+          },
+          err.statusCode
+        );
+      }
+    });
+  }
+  (_a = managerDriver.modifyManagerRouter) == null ? void 0 : _a.call(
+    managerDriver,
+    registryConfig,
+    router
+  );
+  if ((_b = runConfig.inspector) == null ? void 0 : _b.enabled) {
     if (!managerDriver.inspector) {
       throw new Unsupported("inspector");
     }
@@ -6106,6 +6216,166 @@ function createManagerRouter(registryConfig, runConfig, managerDriver, validateB
   router.onError(handleRouteError);
   return { router, openapi: router };
 }
+async function createTestWebSocketProxy(clientWsPromise, connectionType) {
+  let clientWs = null;
+  try {
+    logger().debug({ msg: "awaiting client websocket promise" });
+    const ws = await clientWsPromise;
+    clientWs = ws;
+    logger().debug({
+      msg: "client websocket promise resolved",
+      constructor: ws == null ? void 0 : ws.constructor.name
+    });
+    await new Promise((resolve, reject) => {
+      const onOpen = () => {
+        logger().debug({ msg: "test websocket connection opened" });
+        resolve();
+      };
+      const onError = (error) => {
+        logger().error({ msg: "test websocket connection failed", error });
+        reject(
+          new Error(`Failed to open WebSocket: ${error.message || error}`)
+        );
+      };
+      ws.addEventListener("open", onOpen);
+      ws.addEventListener("error", onError);
+    });
+  } catch (error) {
+    logger().error({
+      msg: `failed to establish client ${connectionType} websocket connection`,
+      error
+    });
+    return {
+      onOpen: (_evt, serverWs) => {
+        serverWs.close(1011, "Failed to establish connection");
+      },
+      onMessage: () => {
+      },
+      onError: () => {
+      },
+      onClose: () => {
+      }
+    };
+  }
+  return {
+    onOpen: (_evt, serverWs) => {
+      logger().debug({
+        msg: `test ${connectionType} websocket connection opened`
+      });
+      logger().debug({
+        msg: "clientWs info",
+        constructor: clientWs.constructor.name,
+        hasAddEventListener: typeof clientWs.addEventListener === "function",
+        readyState: clientWs.readyState
+      });
+      clientWs.addEventListener("message", (clientEvt) => {
+        var _a, _b;
+        logger().debug({
+          msg: `test ${connectionType} websocket connection message from client`,
+          dataType: typeof clientEvt.data,
+          isBlob: clientEvt.data instanceof Blob,
+          isArrayBuffer: clientEvt.data instanceof ArrayBuffer,
+          dataConstructor: (_b = (_a = clientEvt.data) == null ? void 0 : _a.constructor) == null ? void 0 : _b.name,
+          dataStr: typeof clientEvt.data === "string" ? clientEvt.data.substring(0, 100) : void 0
+        });
+        if (serverWs.readyState === 1) {
+          if (clientEvt.data instanceof Blob) {
+            clientEvt.data.arrayBuffer().then((buffer) => {
+              logger().debug({
+                msg: "converted client blob to arraybuffer, sending to server",
+                bufferSize: buffer.byteLength
+              });
+              serverWs.send(buffer);
+            }).catch((error) => {
+              logger().error({
+                msg: "failed to convert blob to arraybuffer",
+                error
+              });
+            });
+          } else {
+            logger().debug({
+              msg: "sending client data directly to server",
+              dataType: typeof clientEvt.data,
+              dataLength: typeof clientEvt.data === "string" ? clientEvt.data.length : void 0
+            });
+            serverWs.send(clientEvt.data);
+          }
+        }
+      });
+      clientWs.addEventListener("close", (clientEvt) => {
+        logger().debug({
+          msg: `test ${connectionType} websocket connection closed`
+        });
+        if (serverWs.readyState !== 3) {
+          serverWs.close(clientEvt.code, clientEvt.reason);
+        }
+      });
+      clientWs.addEventListener("error", () => {
+        logger().debug({
+          msg: `test ${connectionType} websocket connection error`
+        });
+        if (serverWs.readyState !== 3) {
+          serverWs.close(1011, "Error in client websocket");
+        }
+      });
+    },
+    onMessage: (evt) => {
+      var _a, _b;
+      logger().debug({
+        msg: "received message from server",
+        dataType: typeof evt.data,
+        isBlob: evt.data instanceof Blob,
+        isArrayBuffer: evt.data instanceof ArrayBuffer,
+        dataConstructor: (_b = (_a = evt.data) == null ? void 0 : _a.constructor) == null ? void 0 : _b.name,
+        dataStr: typeof evt.data === "string" ? evt.data.substring(0, 100) : void 0
+      });
+      if (clientWs.readyState === 1) {
+        if (evt.data instanceof Blob) {
+          evt.data.arrayBuffer().then((buffer) => {
+            logger().debug({
+              msg: "converted blob to arraybuffer, sending",
+              bufferSize: buffer.byteLength
+            });
+            clientWs.send(buffer);
+          }).catch((error) => {
+            logger().error({
+              msg: "failed to convert blob to arraybuffer",
+              error
+            });
+          });
+        } else {
+          logger().debug({
+            msg: "sending data directly",
+            dataType: typeof evt.data,
+            dataLength: typeof evt.data === "string" ? evt.data.length : void 0
+          });
+          clientWs.send(evt.data);
+        }
+      }
+    },
+    onClose: (event, serverWs) => {
+      logger().debug({
+        msg: `server ${connectionType} websocket closed`,
+        wasClean: event.wasClean,
+        code: event.code,
+        reason: event.reason
+      });
+      serverWs.close(1e3, "hack_force_close");
+      if (clientWs && clientWs.readyState !== clientWs.CLOSED && clientWs.readyState !== clientWs.CLOSING) {
+        clientWs.close(1e3, event.reason);
+      }
+    },
+    onError: (error) => {
+      logger().error({
+        msg: `error in server ${connectionType} websocket`,
+        error
+      });
+      if (clientWs && clientWs.readyState !== clientWs.CLOSED && clientWs.readyState !== clientWs.CLOSING) {
+        clientWs.close(1011, "Error in server websocket");
+      }
+    }
+  };
+}
 
 // src/registry/config.ts
 import { z as z10 } from "zod";
@@ -6180,7 +6450,7 @@ var Registry = class {
   /**
    * Runs the registry for a server.
    */
-  createServer(inputConfig) {
+  start(inputConfig) {
     var _a, _b, _c, _d, _e;
     const config2 = RunConfigSchema.parse(inputConfig);
     if ((_a = config2.logging) == null ? void 0 : _a.baseLogger) {
@@ -6191,6 +6461,13 @@ var Registry = class {
     const driver = chooseDefaultDriver(config2);
     if (driver.name === "engine") {
       config2.inspector.enabled = false;
+      config2.disableServer = true;
+    }
+    if (driver.name === "cloudflare-workers") {
+      config2.inspector.enabled = false;
+      config2.disableServer = true;
+      config2.disableActorDriver = true;
+      config2.noWelcome = true;
     }
     let upgradeWebSocket;
     if (!config2.getUpgradeWebSocket) {
@@ -6228,33 +6505,25 @@ var Registry = class {
       }
       console.log();
     }
-    const _actorDriver = driver.actor(
-      this.#config,
-      config2,
-      managerDriver,
-      client
-    );
+    if (!config2.disableActorDriver) {
+      const _actorDriver = driver.actor(
+        this.#config,
+        config2,
+        managerDriver,
+        client
+      );
+    }
+    if (!config2.disableServer) {
+      (async () => {
+        const out = await crossPlatformServe(hono, void 0);
+        upgradeWebSocket = out.upgradeWebSocket;
+      })();
+    }
     return {
-      config: config2,
-      driver,
       client,
-      hono,
-      handler: async (req) => await hono.fetch(req),
-      serve: async (app) => {
-        const out = await crossPlatformServe(hono, app);
-        upgradeWebSocket = out.upgradeWebSocket;
-      }
+      fetch: hono.fetch.bind(hono)
     };
   }
-  /**
-   * Runs the registry as a standalone server.
-   */
-  async runServer(inputConfig) {
-    const { driver, serve } = this.createServer(inputConfig);
-    if (driver.name !== "engine") {
-      serve();
-    }
-  }
 };
 function setup(input) {
   const config2 = RegistryConfigSchema.parse(input);
@@ -6290,4 +6559,4 @@ export {
   setup
 };
 //! These configs configs hold anything that's not platform-specific about running actors.
-//# sourceMappingURL=chunk-XJQHKJ4P.js.map
+//# sourceMappingURL=chunk-L7QRXNWP.js.map