@ricsam/isolate-client 0.1.16 → 0.1.18

package/dist/mjs/connection.mjs

@@ -37,44 +37,142 @@ async function connect(options = {}) {
     streamResponses: new Map,
     uploadStreams: new Map,
     moduleSourceCache: new Map,
-    callbackStreamReaders: new Map
+    callbackStreamReaders: new Map,
+    closing: false,
+    namespacedRuntimes: new Map
   };
-  const parser = createFrameParser();
-  socket.on("data", (data) => {
-    try {
-      for (const frame of parser.feed(new Uint8Array(data))) {
-        handleMessage(frame.message, state);
+  function setupSocket(sock) {
+    const parser = createFrameParser();
+    sock.on("data", (data) => {
+      try {
+        for (const frame of parser.feed(new Uint8Array(data))) {
+          handleMessage(frame.message, state);
+        }
+      } catch (err) {
+        console.error("Error parsing frame:", err);
       }
-    } catch (err) {
-      console.error("Error parsing frame:", err);
-    }
-  });
-  socket.on("close", () => {
-    state.connected = false;
-    for (const [, pending] of state.pendingRequests) {
-      pending.reject(new Error("Connection closed"));
-    }
-    state.pendingRequests.clear();
-    for (const [, receiver] of state.streamResponses) {
-      receiver.state = "errored";
-      receiver.error = new Error("Connection closed");
-      const resolvers = receiver.pullResolvers.splice(0);
-      for (const resolver of resolvers) {
-        resolver();
+    });
+    sock.on("close", () => {
+      state.connected = false;
+      for (const [, pending] of state.pendingRequests) {
+        pending.reject(new Error("Connection closed"));
       }
-    }
-    state.streamResponses.clear();
-    for (const [, session] of state.uploadStreams) {
-      session.state = "closed";
-      if (session.creditResolver) {
-        session.creditResolver();
+      state.pendingRequests.clear();
+      for (const [, receiver] of state.streamResponses) {
+        receiver.state = "errored";
+        receiver.error = new Error("Connection closed");
+        const resolvers = receiver.pullResolvers.splice(0);
+        for (const resolver of resolvers) {
+          resolver();
+        }
+      }
+      state.streamResponses.clear();
+      for (const [, session] of state.uploadStreams) {
+        session.state = "closed";
+        if (session.creditResolver) {
+          session.creditResolver();
+        }
+      }
+      state.uploadStreams.clear();
+      if (!state.closing && state.namespacedRuntimes.size > 0) {
+        state.reconnecting = reconnect(state, options).catch(() => {
+          state.namespacedRuntimes.clear();
+          state.reconnecting = undefined;
+        });
+      }
+    });
+    sock.on("error", (err) => {
+      if (!state.closing && state.namespacedRuntimes.size > 0)
+        return;
+      console.error("Socket error:", err);
+    });
+  }
+  setupSocket(socket);
+  async function reconnect(st, opts) {
+    try {
+      const newSocket = await createSocket(opts);
+      st.socket = newSocket;
+      st.connected = true;
+      setupSocket(newSocket);
+      for (const [namespaceId, descriptor] of st.namespacedRuntimes) {
+        const runtimeOptions = descriptor.runtimeOptions;
+        const callbacks = {};
+        if (runtimeOptions.console) {
+          callbacks.console = registerConsoleCallbacks(st, runtimeOptions.console);
+        }
+        if (runtimeOptions.fetch) {
+          callbacks.fetch = registerFetchCallback(st, runtimeOptions.fetch);
+        }
+        if (runtimeOptions.fs) {
+          callbacks.fs = registerFsCallbacks(st, runtimeOptions.fs);
+        }
+        if (runtimeOptions.moduleLoader) {
+          callbacks.moduleLoader = registerModuleLoaderCallback(st, runtimeOptions.moduleLoader);
+        }
+        if (runtimeOptions.customFunctions) {
+          callbacks.custom = registerCustomFunctions(st, runtimeOptions.customFunctions);
+        }
+        if (runtimeOptions.playwright) {
+          const playwrightHandler = runtimeOptions.playwright.handler;
+          if (playwrightHandler) {
+            const handlerCallbackId = st.nextCallbackId++;
+            st.callbacks.set(handlerCallbackId, async (opJson) => {
+              const op = JSON.parse(opJson);
+              const result2 = await playwrightHandler(op);
+              return JSON.stringify(result2);
+            });
+            callbacks.playwright = {
+              handlerCallbackId,
+              console: runtimeOptions.playwright.console && !runtimeOptions.console?.onEntry
+            };
+          }
+        }
+        let testEnvironmentOption;
+        if (runtimeOptions.testEnvironment) {
+          if (typeof runtimeOptions.testEnvironment === "object") {
+            const testEnvOptions = runtimeOptions.testEnvironment;
+            const testEnvCallbacks = {};
+            if (testEnvOptions.onEvent) {
+              const userOnEvent = testEnvOptions.onEvent;
+              const onEventCallbackId = registerEventCallback(st, (eventJson) => {
+                const event = JSON.parse(eventJson);
+                userOnEvent(event);
+              });
+              testEnvCallbacks.onEvent = {
+                callbackId: onEventCallbackId,
+                name: "testEnvironment.onEvent",
+                type: "sync"
+              };
+            }
+            testEnvironmentOption = {
+              callbacks: testEnvCallbacks,
+              testTimeout: testEnvOptions.testTimeout
+            };
+          } else {
+            testEnvironmentOption = true;
+          }
+        }
+        const requestId = st.nextRequestId++;
+        const request = {
+          type: MessageType.CREATE_RUNTIME,
+          requestId,
+          options: {
+            memoryLimitMB: runtimeOptions.memoryLimitMB,
+            cwd: runtimeOptions.cwd,
+            callbacks,
+            testEnvironment: testEnvironmentOption,
+            namespaceId
+          }
+        };
+        const result = await sendRequest(st, request);
+        descriptor.isolateId = result.isolateId;
       }
+      st.reconnecting = undefined;
+    } catch {
+      st.reconnecting = undefined;
+      throw new Error("Failed to reconnect to daemon");
     }
-    state.uploadStreams.clear();
-  });
-  socket.on("error", (err) => {
-    console.error("Socket error:", err);
-  });
+  }
   return {
     createRuntime: (runtimeOptions) => createRuntime(state, runtimeOptions),
     createNamespace: (id) => ({
@@ -82,8 +180,9 @@ async function connect(options = {}) {
       createRuntime: (runtimeOptions) => createRuntime(state, runtimeOptions, id)
     }),
     close: async () => {
+      state.closing = true;
       state.connected = false;
-      socket.destroy();
+      state.socket.destroy();
     },
     isConnected: () => state.connected
   };
@@ -510,6 +609,12 @@ async function createRuntime(state, options = {}, namespaceId) {
   const result = await sendRequest(state, request);
   const isolateId = result.isolateId;
   const reused = result.reused ?? false;
+  if (namespaceId != null) {
+    state.namespacedRuntimes.set(namespaceId, {
+      isolateId,
+      runtimeOptions: options
+    });
+  }
   const wsCommandCallbacks = new Set;
   isolateWsCallbacks.set(isolateId, wsCommandCallbacks);
   if (options.onWebSocketCommand) {
@@ -524,6 +629,8 @@ async function createRuntime(state, options = {}, namespaceId) {
       if (signal?.aborted) {
         throw new DOMException("The operation was aborted", "AbortError");
       }
+      const requestSignal = req.signal;
+      const requestSignalInitiallyAborted = requestSignal?.aborted ?? false;
       const reqId = state.nextRequestId++;
       const serialized = await serializeRequestWithStreaming(state, req);
       const { bodyStream, ...serializableRequest } = serialized;
@@ -550,6 +657,23 @@ async function createRuntime(state, options = {}, namespaceId) {
         };
         signal.addEventListener("abort", onAbort, { once: true });
       }
+      let onRequestAbort;
+      if (requestSignal && !requestSignalInitiallyAborted) {
+        onRequestAbort = () => {
+          const abortMessage = {
+            type: MessageType.DISPATCH_REQUEST_ABORT,
+            isolateId,
+            targetRequestId: reqId
+          };
+          if (state.connected) {
+            sendMessage(state.socket, abortMessage);
+          }
+        };
+        requestSignal.addEventListener("abort", onRequestAbort, { once: true });
+        if (requestSignal.aborted) {
+          onRequestAbort();
+        }
+      }
       try {
         if (serialized.bodyStreamId !== undefined && bodyStream) {
           const streamId = serialized.bodyStreamId;
@@ -565,6 +689,9 @@ async function createRuntime(state, options = {}, namespaceId) {
         if (signal && onAbort) {
           signal.removeEventListener("abort", onAbort);
         }
+        if (requestSignal && onRequestAbort) {
+          requestSignal.removeEventListener("abort", onRequestAbort);
+        }
       }
     },
     async getUpgradeRequest() {
@@ -711,7 +838,22 @@ async function createRuntime(state, options = {}, namespaceId) {
         isolateId,
         timeout
       };
-      return sendRequest(state, req);
+      try {
+        return await sendRequest(state, req);
+      } catch (err) {
+        if (err instanceof Error && /connection closed|not connected/i.test(err.message) && state.reconnecting) {
+          await state.reconnecting;
+          const retryReqId = state.nextRequestId++;
+          const retryReq = {
+            type: MessageType.RUN_TESTS,
+            requestId: retryReqId,
+            isolateId,
+            timeout
+          };
+          return sendRequest(state, retryReq);
+        }
+        throw err;
+      }
     },
     async hasTests() {
       if (!testEnvironmentEnabled) {
@@ -836,6 +978,9 @@ async function createRuntime(state, options = {}, namespaceId) {
         }
         isolateClientWebSockets.delete(isolateId);
       }
+      if (namespaceId != null) {
+        state.namespacedRuntimes.delete(namespaceId);
+      }
       const reqId = state.nextRequestId++;
       const req = {
         type: MessageType.DISPOSE_RUNTIME,
@@ -877,12 +1022,16 @@ function registerFetchCallback(state, callback) {
   state.callbacksNeedingRequestId.add(callbackId);
   state.callbacks.set(callbackId, async (serialized, requestId) => {
     const data = serialized;
+    const signalController = new AbortController;
+    if (data.signalAborted) {
+      signalController.abort();
+    }
     const init = {
       method: data.method,
       headers: data.headers,
       rawBody: data.body ?? null,
       body: data.body ?? null,
-      signal: new AbortController().signal
+      signal: signalController.signal
     };
     const response = await callback(data.url, init);
     const contentLength = response.headers.get("content-length");
@@ -1027,7 +1176,7 @@ function registerModuleLoaderCallback(state, callback) {
     const specifier = moduleName;
     const importerInfo = importer;
     const result = await callback(specifier, importerInfo);
-    const resolvedPath = path.posix.join(result.resolveDir, path.posix.basename(specifier));
+    const resolvedPath = path.posix.join(result.resolveDir, result.filename);
     state.moduleSourceCache.set(resolvedPath, result.code);
     return result;
   });
@@ -1253,7 +1402,8 @@ async function serializeRequestWithStreaming(state, request) {
     method: request.method,
     url: request.url,
     headers,
-    body
+    body,
+    signalAborted: request.signal?.aborted ?? false
   };
   if (bodyStreamId !== undefined) {
     result.bodyStreamId = bodyStreamId;
@@ -1493,7 +1643,7 @@ function handleClientWsSend(isolateId, payload, state) {
     const binary = Buffer.from(base64, "base64");
     ws.send(binary);
   } else if (data instanceof Uint8Array) {
-    ws.send(data);
+    ws.send(Buffer.from(data));
   } else {
     ws.send(data);
   }
@@ -1514,4 +1664,4 @@ export {
   connect
 };
 
-//# debugId=A84790A2E8D5115464756E2164756E21
+//# debugId=7EA890CF5E7314ED64756E2164756E21