@get-bb/plugin-sdk 0.4.45 → 0.4.48

package/dist/testing/index.js

@@ -36,6 +36,7 @@ function parseNamespacedGlyph(glyph) {
 
 // ../domain/src/plugin-cli.ts
 var RESERVED_BB_CLI_COMMANDS = [
+  "browser",
   "environment",
   "file",
   "guide",
@@ -2311,6 +2312,8 @@ function createFakePluginHostInternal(options, sharedState) {
     }
   };
   const httpRoutes = [];
+  const websocketRoutes = [];
+  const websocketSessions = /* @__PURE__ */ new Set();
   const http = {
     route(method, path, handler, opts) {
       assertLive();
@@ -2344,6 +2347,29 @@ function createFakePluginHostInternal(options, sharedState) {
         );
       }
       httpRoutes.push({ method: normalizedMethod, path, auth, handler });
+    },
+    experimental_websocket(path, handler, opts) {
+      assertLive();
+      if (typeof path !== "string" || !path.startsWith("/")) {
+        throw new Error(
+          `websocket route path must be a string starting with "/", got ${JSON.stringify(path)}`
+        );
+      }
+      if (typeof handler !== "function") {
+        throw new Error(
+          `websocket route handler for ${path} must be a function`
+        );
+      }
+      const auth = opts?.auth ?? "local";
+      if (auth !== "local" && auth !== "token" && auth !== "none") {
+        throw new Error(
+          `invalid auth mode "${String(auth)}" for websocket ${path} \u2014 use "local", "token", or "none"`
+        );
+      }
+      if (websocketRoutes.some((route) => route.path === path)) {
+        throw new Error(`websocket route ${path} is already registered`);
+      }
+      websocketRoutes.push({ path, auth, handler });
     }
   };
   const rpcHandlers = /* @__PURE__ */ new Map();
@@ -3059,6 +3085,9 @@ function createFakePluginHostInternal(options, sharedState) {
       pendingInteractions.delete(id);
       pending.resolve({ outcome: "cancelled", reason: "plugin-disposed" });
     }
+    for (const session of [...websocketSessions]) {
+      await session.closeForReload();
+    }
     for (const controller of serviceControllers) controller.abort();
     for (const hook of [...disposeHooks].reverse()) {
       try {
@@ -3104,6 +3133,7 @@ function createFakePluginHostInternal(options, sharedState) {
     registrations: {
       settingsDescriptors,
       httpRoutes,
+      websocketRoutes,
       get rpcMethods() {
         return [...rpcHandlers.keys()];
       },
@@ -3321,6 +3351,127 @@ function createFakePluginHostInternal(options, sharedState) {
       });
       return app.request(path, { ...init, method: normalizedMethod });
     },
+    async experimental_openWebSocket(path, init) {
+      assertLive();
+      const url = new URL(path, "http://plugin.test");
+      const route = websocketRoutes.find(
+        (candidate) => candidate.path === url.pathname
+      );
+      if (!route) {
+        throw new Error(
+          `no websocket route ${url.pathname} is registered \u2014 registered: ${websocketRoutes.map((candidate) => candidate.path).join(", ") || "(none)"}`
+        );
+      }
+      const request = new Request(url, { ...init, method: "GET" });
+      let handlers;
+      try {
+        handlers = route.handler({
+          request,
+          url,
+          headers: request.headers
+        });
+        if (typeof handlers !== "object" || handlers === null || Array.isArray(handlers)) {
+          throw new Error("websocket route handler must return an object");
+        }
+        for (const name of [
+          "onOpen",
+          "onMessage",
+          "onClose",
+          "onError"
+        ]) {
+          const callback = handlers[name];
+          if (callback !== void 0 && typeof callback !== "function") {
+            throw new Error(
+              `websocket route handler ${name} must be a function`
+            );
+          }
+        }
+      } catch (error) {
+        emitLog(
+          "warn",
+          `websocket ${route.path} connect failed: ${errorMessage(error)}`
+        );
+        throw error;
+      }
+      const sent = [];
+      const closeCalls = [];
+      let readyState = 0;
+      let closeNotified = false;
+      let eventQueue = Promise.resolve();
+      const invoke = async (event, run) => {
+        eventQueue = eventQueue.then(async () => {
+          try {
+            await run();
+          } catch (error) {
+            emitLog(
+              "warn",
+              `websocket ${route.path} ${event} failed: ${errorMessage(error)}`
+            );
+          }
+        });
+        await eventQueue;
+      };
+      const socket = {
+        send(data) {
+          sent.push(typeof data === "string" ? data : new Uint8Array(data));
+        },
+        close(code, reason) {
+          closeCalls.push({ code: code ?? null, reason: reason ?? null });
+          if (readyState < 2) readyState = 2;
+        },
+        get readyState() {
+          return readyState;
+        }
+      };
+      const notifyClose = async (code, reason) => {
+        if (closeNotified) return;
+        closeNotified = true;
+        readyState = 3;
+        websocketSessions.delete(session);
+        if (handlers.onClose !== void 0) {
+          await invoke(
+            "close",
+            () => handlers.onClose?.(socket, { code, reason })
+          );
+        }
+      };
+      const session = {
+        sent,
+        closeCalls,
+        get readyState() {
+          return readyState;
+        },
+        async receive(data) {
+          if (readyState !== 1) {
+            throw new Error(
+              "cannot receive a websocket message while not open"
+            );
+          }
+          if (handlers.onMessage !== void 0) {
+            await invoke("message", () => handlers.onMessage?.(socket, data));
+          }
+        },
+        async close(code = 1e3, reason = "") {
+          if (readyState < 2) socket.close(code, reason);
+          await notifyClose(code, reason);
+        },
+        async error(error) {
+          if (handlers.onError !== void 0) {
+            await invoke("error", () => handlers.onError?.(socket, error));
+          }
+        },
+        async closeForReload() {
+          socket.close(1012, "Plugin reloaded or disabled");
+          await notifyClose(1012, "Plugin reloaded or disabled");
+        }
+      };
+      websocketSessions.add(session);
+      readyState = 1;
+      if (handlers.onOpen !== void 0) {
+        await invoke("open", () => handlers.onOpen?.(socket));
+      }
+      return session;
+    },
     runService(name) {
       const service = services.find((record) => record.name === name);
       if (!service) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@get-bb/plugin-sdk",
-  "version": "0.4.45",
+  "version": "0.4.48",
   "homepage": "https://github.com/get-bb/bb#readme",
   "bugs": {
     "url": "https://github.com/get-bb/bb/issues"