@ricsam/isolate-client 0.1.13 → 0.1.15

package/dist/mjs/connection.mjs

@@ -10,9 +10,14 @@ import {
   STREAM_DEFAULT_CREDIT,
   marshalValue
 } from "@ricsam/isolate-protocol";
-import { createPlaywrightHandler } from "@ricsam/isolate-playwright/client";
+import {
+  getDefaultPlaywrightHandlerMetadata
+} from "@ricsam/isolate-playwright/client";
 var DEFAULT_TIMEOUT = 30000;
+var TEST_REQUEST_TIMEOUT_BUFFER_MS = 1000;
 var isolateWsCallbacks = new Map;
+var isolateClientWebSockets = new Map;
+var isolateWebSocketCallbacks = new Map;
 async function connect(options = {}) {
   const socket = await createSocket(options);
   const state = {
@@ -176,6 +181,21 @@ function handleMessage(message, state) {
       }
       break;
     }
+    case MessageType.CLIENT_WS_CONNECT: {
+      const msg = message;
+      handleClientWsConnect(msg, state);
+      break;
+    }
+    case MessageType.CLIENT_WS_SEND: {
+      const msg = message;
+      handleClientWsSend(msg, state);
+      break;
+    }
+    case MessageType.CLIENT_WS_CLOSE: {
+      const msg = message;
+      handleClientWsClose(msg, state);
+      break;
+    }
     case MessageType.RESPONSE_STREAM_START: {
       const msg = message;
       const receiver = {
@@ -411,74 +431,76 @@ async function createRuntime(state, options = {}, namespaceId) {
   const networkResponses = [];
   const pageListenerCleanups = [];
   if (options.playwright) {
-    playwrightHandler = createPlaywrightHandler(options.playwright.page, {
-      timeout: options.playwright.timeout,
-      baseUrl: options.playwright.baseUrl
-    });
+    playwrightHandler = options.playwright.handler;
+    if (!playwrightHandler) {
+      throw new Error("playwright.handler is required when using playwright options");
+    }
+    const page = getDefaultPlaywrightHandlerMetadata(playwrightHandler)?.page;
     const handlerCallbackId = state.nextCallbackId++;
     state.callbacks.set(handlerCallbackId, async (opJson) => {
       const op = JSON.parse(opJson);
       const result2 = await playwrightHandler(op);
       return JSON.stringify(result2);
     });
-    const page = options.playwright.page;
-    const onConsole = (msg) => {
-      const entry = {
-        level: msg.type(),
-        stdout: msg.text(),
-        timestamp: Date.now()
+    if (page) {
+      const onConsole = (msg) => {
+        const entry = {
+          level: msg.type(),
+          stdout: msg.text(),
+          timestamp: Date.now()
+        };
+        browserConsoleLogs.push(entry);
+        if (options.playwright.onEvent) {
+          options.playwright.onEvent({
+            type: "browserConsoleLog",
+            ...entry
+          });
+        }
+        if (options.playwright.console && options.console?.onEntry) {
+          options.console.onEntry({
+            type: "browserOutput",
+            ...entry
+          });
+        } else if (options.playwright.console) {
+          const prefix = entry.level === "error" ? "[browser:error]" : "[browser]";
+          console.log(prefix, entry.stdout);
+        }
       };
-      browserConsoleLogs.push(entry);
-      if (options.playwright.onEvent) {
-        options.playwright.onEvent({
-          type: "browserConsoleLog",
-          ...entry
-        });
-      }
-      if (options.playwright.console && options.console?.onEntry) {
-        options.console.onEntry({
-          type: "browserOutput",
-          ...entry
-        });
-      } else if (options.playwright.console) {
-        const prefix = entry.level === "error" ? "[browser:error]" : "[browser]";
-        console.log(prefix, entry.stdout);
-      }
-    };
-    const onRequest = (request2) => {
-      const info = {
-        url: request2.url(),
-        method: request2.method(),
-        headers: request2.headers(),
-        timestamp: Date.now()
+      const onRequest = (request2) => {
+        const info = {
+          url: request2.url(),
+          method: request2.method(),
+          headers: request2.headers(),
+          timestamp: Date.now()
+        };
+        networkRequests.push(info);
+        if (options.playwright.onEvent) {
+          options.playwright.onEvent({
+            type: "networkRequest",
+            ...info
+          });
+        }
       };
-      networkRequests.push(info);
-      if (options.playwright.onEvent) {
-        options.playwright.onEvent({
-          type: "networkRequest",
-          ...info
-        });
-      }
-    };
-    const onResponse = (response) => {
-      const info = {
-        url: response.url(),
-        status: response.status(),
-        headers: response.headers(),
-        timestamp: Date.now()
+      const onResponse = (response) => {
+        const info = {
+          url: response.url(),
+          status: response.status(),
+          headers: response.headers(),
+          timestamp: Date.now()
+        };
+        networkResponses.push(info);
+        if (options.playwright.onEvent) {
+          options.playwright.onEvent({
+            type: "networkResponse",
+            ...info
+          });
+        }
       };
-      networkResponses.push(info);
-      if (options.playwright.onEvent) {
-        options.playwright.onEvent({
-          type: "networkResponse",
-          ...info
-        });
-      }
-    };
-    page.on("console", onConsole);
-    page.on("request", onRequest);
-    page.on("response", onResponse);
-    pageListenerCleanups.push(() => page.removeListener("console", onConsole), () => page.removeListener("request", onRequest), () => page.removeListener("response", onResponse));
+      page.on("console", onConsole);
+      page.on("request", onRequest);
+      page.on("response", onResponse);
+      pageListenerCleanups.push(() => page.removeListener("console", onConsole), () => page.removeListener("request", onRequest), () => page.removeListener("response", onResponse));
+    }
     callbacks.playwright = {
       handlerCallbackId,
       console: options.playwright.console && !options.console?.onEntry
@@ -526,6 +548,9 @@ async function createRuntime(state, options = {}, namespaceId) {
   const reused = result.reused ?? false;
   const wsCommandCallbacks = new Set;
   isolateWsCallbacks.set(isolateId, wsCommandCallbacks);
+  if (options.webSocket) {
+    isolateWebSocketCallbacks.set(isolateId, options.webSocket);
+  }
   const fetchHandle = {
     async dispatchRequest(req, opts) {
       const reqId = state.nextRequestId++;
@@ -699,7 +724,8 @@ async function createRuntime(state, options = {}, namespaceId) {
         isolateId,
         timeout
       };
-      return sendRequest(state, req, timeout ?? DEFAULT_TIMEOUT);
+      const requestTimeout = timeout === undefined ? DEFAULT_TIMEOUT : Math.max(timeout + TEST_REQUEST_TIMEOUT_BUFFER_MS, DEFAULT_TIMEOUT);
+      return sendRequest(state, req, requestTimeout);
     },
     async hasTests() {
       if (!testEnvironmentEnabled) {
@@ -741,7 +767,7 @@ async function createRuntime(state, options = {}, namespaceId) {
   const playwrightHandle = {
     getCollectedData() {
       if (!playwrightEnabled) {
-        throw new Error("Playwright not configured. Provide playwright.page in createRuntime options.");
+        throw new Error("Playwright not configured. Provide playwright.handler in createRuntime options.");
       }
       return {
         browserConsoleLogs: [...browserConsoleLogs],
@@ -751,7 +777,7 @@ async function createRuntime(state, options = {}, namespaceId) {
     },
     clearCollectedData() {
       if (!playwrightEnabled) {
-        throw new Error("Playwright not configured. Provide playwright.page in createRuntime options.");
+        throw new Error("Playwright not configured. Provide playwright.handler in createRuntime options.");
       }
       browserConsoleLogs.length = 0;
       networkRequests.length = 0;
@@ -760,7 +786,6 @@ async function createRuntime(state, options = {}, namespaceId) {
   };
   return {
     id: isolateId,
-    isolateId,
     reused,
     fetch: fetchHandle,
     timers: timersHandle,
@@ -776,8 +801,7 @@ async function createRuntime(state, options = {}, namespaceId) {
         isolateId,
         code,
         filename: options2?.filename,
-        maxExecutionMs: options2?.maxExecutionMs,
-        module: true
+        maxExecutionMs: options2?.maxExecutionMs
       };
       await sendRequest(state, req);
     },
@@ -786,6 +810,16 @@ async function createRuntime(state, options = {}, namespaceId) {
         cleanup();
       }
       isolateWsCallbacks.delete(isolateId);
+      isolateWebSocketCallbacks.delete(isolateId);
+      const clientSockets = isolateClientWebSockets.get(isolateId);
+      if (clientSockets) {
+        for (const ws of clientSockets.values()) {
+          if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+            ws.close(1000, "Isolate disposed");
+          }
+        }
+        isolateClientWebSockets.delete(isolateId);
+      }
       const reqId = state.nextRequestId++;
       const req = {
         type: MessageType.DISPOSE_RUNTIME,
@@ -820,8 +854,15 @@ function registerFetchCallback(state, callback) {
   const callbackId = state.nextCallbackId++;
   state.callbacksNeedingRequestId.add(callbackId);
   state.callbacks.set(callbackId, async (serialized, requestId) => {
-    const request = deserializeRequest(serialized);
-    const response = await callback(request);
+    const data = serialized;
+    const init = {
+      method: data.method,
+      headers: data.headers,
+      rawBody: data.body,
+      body: data.body,
+      signal: new AbortController().signal
+    };
+    const response = await callback(data.url, init);
     const contentLength = response.headers.get("content-length");
     const knownSize = contentLength ? parseInt(contentLength, 10) : null;
     const isNetworkResponse = response.url && (response.url.startsWith("http://") || response.url.startsWith("https://"));
@@ -1179,13 +1220,6 @@ async function serializeResponse(response) {
     body
   };
 }
-function deserializeRequest(data) {
-  return new Request(data.url, {
-    method: data.method,
-    headers: data.headers,
-    body: data.body
-  });
-}
 function deserializeResponse(data) {
   return new Response(data.body, {
     status: data.status,
@@ -1291,8 +1325,155 @@ async function sendBodyStream(state, streamId, body) {
     state.uploadStreams.delete(streamId);
   }
 }
+function handleClientWsConnect(message, state) {
+  const { isolateId, socketId, url, protocols } = message;
+  let sockets = isolateClientWebSockets.get(isolateId);
+  if (!sockets) {
+    sockets = new Map;
+    isolateClientWebSockets.set(isolateId, sockets);
+  }
+  const setupWebSocket = (ws) => {
+    sockets.set(socketId, ws);
+    ws.onopen = () => {
+      const msg = {
+        type: MessageType.CLIENT_WS_OPENED,
+        isolateId,
+        socketId,
+        protocol: ws.protocol || "",
+        extensions: ws.extensions || ""
+      };
+      sendMessage(state.socket, msg);
+    };
+    ws.onmessage = (event) => {
+      let data;
+      if (typeof event.data === "string") {
+        data = event.data;
+      } else if (event.data instanceof ArrayBuffer) {
+        data = new Uint8Array(event.data);
+      } else if (event.data instanceof Blob) {
+        event.data.arrayBuffer().then((buffer) => {
+          const msg2 = {
+            type: MessageType.CLIENT_WS_MESSAGE,
+            isolateId,
+            socketId,
+            data: new Uint8Array(buffer)
+          };
+          sendMessage(state.socket, msg2);
+        });
+        return;
+      } else {
+        data = String(event.data);
+      }
+      const msg = {
+        type: MessageType.CLIENT_WS_MESSAGE,
+        isolateId,
+        socketId,
+        data
+      };
+      sendMessage(state.socket, msg);
+    };
+    ws.onerror = () => {
+      const msg = {
+        type: MessageType.CLIENT_WS_ERROR,
+        isolateId,
+        socketId
+      };
+      sendMessage(state.socket, msg);
+    };
+    ws.onclose = (event) => {
+      const msg = {
+        type: MessageType.CLIENT_WS_CLOSED,
+        isolateId,
+        socketId,
+        code: event.code,
+        reason: event.reason,
+        wasClean: event.wasClean
+      };
+      sendMessage(state.socket, msg);
+      sockets?.delete(socketId);
+      if (sockets?.size === 0) {
+        isolateClientWebSockets.delete(isolateId);
+      }
+    };
+  };
+  const sendConnectionFailed = (reason) => {
+    const errorMsg = {
+      type: MessageType.CLIENT_WS_ERROR,
+      isolateId,
+      socketId
+    };
+    sendMessage(state.socket, errorMsg);
+    const closeMsg = {
+      type: MessageType.CLIENT_WS_CLOSED,
+      isolateId,
+      socketId,
+      code: 1006,
+      reason,
+      wasClean: false
+    };
+    sendMessage(state.socket, closeMsg);
+  };
+  const callback = isolateWebSocketCallbacks.get(isolateId);
+  if (callback) {
+    try {
+      const result = callback(url, protocols || []);
+      if (result instanceof Promise) {
+        result.then((ws) => {
+          if (ws === null) {
+            sendConnectionFailed("Connection blocked");
+          } else {
+            setupWebSocket(ws);
+          }
+        }).catch(() => {
+          sendConnectionFailed("Callback error");
+        });
+      } else if (result === null) {
+        sendConnectionFailed("Connection blocked");
+      } else {
+        setupWebSocket(result);
+      }
+    } catch {
+      sendConnectionFailed("Callback error");
+    }
+  } else {
+    try {
+      const ws = protocols && protocols.length > 0 ? new WebSocket(url, protocols) : new WebSocket(url);
+      setupWebSocket(ws);
+    } catch {
+      sendConnectionFailed("Connection failed");
+    }
+  }
+}
+function handleClientWsSend(message, state) {
+  const { isolateId, socketId, data } = message;
+  const sockets = isolateClientWebSockets.get(isolateId);
+  const ws = sockets?.get(socketId);
+  if (!ws || ws.readyState !== WebSocket.OPEN) {
+    return;
+  }
+  if (typeof data === "string" && data.startsWith("__BINARY__")) {
+    const base64 = data.slice(10);
+    const binary = Buffer.from(base64, "base64");
+    ws.send(binary);
+  } else if (data instanceof Uint8Array) {
+    ws.send(data);
+  } else {
+    ws.send(data);
+  }
+}
+function handleClientWsClose(message, state) {
+  const { isolateId, socketId, code, reason } = message;
+  const sockets = isolateClientWebSockets.get(isolateId);
+  const ws = sockets?.get(socketId);
+  if (!ws) {
+    return;
+  }
+  if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+    ws.close(code ?? 1000, reason ?? "");
+  }
+}
 export {
   connect
 };
 
-//# debugId=5BC447A77FF8EEAE64756E2164756E21
+//# debugId=D4986DB48143DFE264756E2164756E21