@ricsam/isolate-daemon 0.1.8 → 0.1.10

package/dist/cjs/connection.cjs

@@ -62,7 +62,8 @@ function handleConnection(socket, state) {
     nextCallbackId: 1,
     nextStreamId: 1,
     activeStreams: new Map,
-    streamReceivers: new Map
+    streamReceivers: new Map,
+    callbackStreamReceivers: new Map
   };
   state.connections.set(socket, connection);
   const parser = import_isolate_protocol.createFrameParser();
@@ -223,6 +224,15 @@ async function handleMessage(message, connection, state) {
     case import_isolate_protocol.MessageType.STREAM_ERROR:
       handleStreamError(message, connection);
       break;
+    case import_isolate_protocol.MessageType.CALLBACK_STREAM_START:
+      handleCallbackStreamStart(message, connection);
+      break;
+    case import_isolate_protocol.MessageType.CALLBACK_STREAM_CHUNK:
+      handleCallbackStreamChunk(message, connection);
+      break;
+    case import_isolate_protocol.MessageType.CALLBACK_STREAM_END:
+      handleCallbackStreamEnd(message, connection);
+      break;
     default:
       sendError(connection.socket, message.requestId ?? 0, import_isolate_protocol.ErrorCode.UNKNOWN_MESSAGE_TYPE, `Unknown message type: ${message.type}`);
   }
@@ -414,7 +424,12 @@ async function handleCreateRuntime(message, connection, state) {
             throw new Error("Fetch callback not available");
           }
           const serialized = await serializeRequest(request);
-          const result = await invokeClientCallback(conn, callbackId, [serialized]);
+          const result = await invokeClientCallback(conn, callbackId, [serialized], 60000);
+          if (result && typeof result === "object" && result.__streamingResponse) {
+            const response = result.response;
+            response.__isCallbackStream = true;
+            return response;
+          }
           return deserializeResponse(result);
         }
       },
@@ -517,7 +532,7 @@ async function handleCreateRuntime(message, connection, state) {
         console: playwrightCallbacks.console,
         onEvent: (event) => {
           if (event.type === "browserConsoleLog" && playwrightCallbacks.onBrowserConsoleLogCallbackId) {
-            const promise = invokeClientCallback(connection, playwrightCallbacks.onBrowserConsoleLogCallbackId, [{ level: event.level, args: event.args, timestamp: event.timestamp }]).catch(() => {});
+            const promise = invokeClientCallback(connection, playwrightCallbacks.onBrowserConsoleLogCallbackId, [{ level: event.level, stdout: event.stdout, timestamp: event.timestamp }]).catch(() => {});
             pendingCallbacks.push(promise);
           } else if (event.type === "networkRequest" && playwrightCallbacks.onNetworkRequestCallbackId) {
             const promise = invokeClientCallback(connection, playwrightCallbacks.onNetworkRequestCallbackId, [event]).catch(() => {});
@@ -1462,6 +1477,115 @@ function handleStreamError(message, connection) {
     session.state = "closed";
     connection.activeStreams.delete(message.streamId);
   }
+  const callbackReceiver = connection.callbackStreamReceivers.get(message.streamId);
+  if (callbackReceiver && callbackReceiver.state === "active") {
+    callbackReceiver.state = "errored";
+    callbackReceiver.error = new Error(message.error);
+    const resolvers = callbackReceiver.pullResolvers.splice(0);
+    for (const resolver of resolvers) {
+      resolver();
+    }
+    connection.callbackStreamReceivers.delete(message.streamId);
+  }
+}
+function handleCallbackStreamStart(message, connection) {
+  const receiver = {
+    streamId: message.streamId,
+    requestId: message.requestId,
+    metadata: message.metadata,
+    controller: null,
+    state: "active",
+    pendingChunks: [],
+    pullResolvers: [],
+    controllerFinalized: false
+  };
+  const readableStream = new ReadableStream({
+    start(controller) {
+      receiver.controller = controller;
+    },
+    pull(_controller) {
+      if (receiver.controllerFinalized) {
+        return;
+      }
+      if (receiver.pendingChunks.length > 0) {
+        const chunk = receiver.pendingChunks.shift();
+        receiver.controller.enqueue(chunk);
+        return Promise.resolve();
+      }
+      if (receiver.state === "closed") {
+        if (!receiver.controllerFinalized) {
+          receiver.controllerFinalized = true;
+          receiver.controller.close();
+        }
+        return Promise.resolve();
+      }
+      if (receiver.state === "errored") {
+        if (!receiver.controllerFinalized && receiver.error) {
+          receiver.controllerFinalized = true;
+          receiver.controller.error(receiver.error);
+        }
+        return Promise.resolve();
+      }
+      return new Promise((resolve) => {
+        receiver.pullResolvers.push(resolve);
+      });
+    },
+    cancel(_reason) {
+      receiver.state = "closed";
+      receiver.controllerFinalized = true;
+      const resolvers = receiver.pullResolvers.splice(0);
+      for (const resolver of resolvers) {
+        resolver();
+      }
+      connection.callbackStreamReceivers.delete(message.streamId);
+      return Promise.resolve();
+    }
+  });
+  connection.callbackStreamReceivers.set(message.streamId, receiver);
+  const pending = connection.pendingCallbacks.get(message.requestId);
+  if (pending) {
+    connection.pendingCallbacks.delete(message.requestId);
+    if (pending.timeoutId) {
+      clearTimeout(pending.timeoutId);
+    }
+    const response = new Response(readableStream, {
+      status: message.metadata.status,
+      statusText: message.metadata.statusText,
+      headers: message.metadata.headers
+    });
+    pending.resolve({ __streamingResponse: true, response });
+  }
+}
+function handleCallbackStreamChunk(message, connection) {
+  const receiver = connection.callbackStreamReceivers.get(message.streamId);
+  if (receiver && receiver.state === "active") {
+    if (receiver.pullResolvers.length > 0) {
+      receiver.controller.enqueue(message.chunk);
+      const resolver = receiver.pullResolvers.shift();
+      resolver();
+    } else {
+      receiver.pendingChunks.push(message.chunk);
+    }
+  }
+}
+function handleCallbackStreamEnd(message, connection) {
+  const receiver = connection.callbackStreamReceivers.get(message.streamId);
+  if (receiver) {
+    receiver.state = "closed";
+    while (receiver.pendingChunks.length > 0) {
+      const chunk = receiver.pendingChunks.shift();
+      receiver.controller.enqueue(chunk);
+    }
+    if (!receiver.controllerFinalized) {
+      receiver.controllerFinalized = true;
+      receiver.controller.close();
+    }
+    const resolvers = receiver.pullResolvers.splice(0);
+    for (const resolver of resolvers) {
+      resolver();
+    }
+    connection.callbackStreamReceivers.delete(message.streamId);
+  }
 }
 function waitForCredit(session) {
   return new Promise((resolve) => {
@@ -1686,4 +1810,4 @@ async function handleClearCollectedData(message, connection, state) {
   }
 }
 
-//# debugId=C667CC1CB551E01464756E2164756E21
+//# debugId=DE5E35C70F14FD3964756E2164756E21