@ricsam/isolate-daemon 0.1.5 → 0.1.6

package/dist/cjs/connection.cjs

@@ -83,18 +83,26 @@ function handleConnection(socket, state) {
     for (const isolateId of connection.isolates) {
       const instance = state.isolates.get(isolateId);
       if (instance) {
-        try {
-          if (instance.playwrightHandle) {
-            instance.playwrightHandle.dispose();
-          }
-          instance.runtime.dispose();
-        } catch {}
-        state.isolates.delete(isolateId);
+        if (instance.namespaceId != null && !instance.isDisposed) {
+          softDeleteRuntime(instance, state);
+        } else if (!instance.isDisposed) {
+          try {
+            if (instance.playwrightHandle) {
+              instance.playwrightHandle.dispose();
+            }
+            instance.runtime.dispose();
+          } catch {}
+          state.isolates.delete(isolateId);
+        }
       }
     }
     for (const [, pending] of connection.pendingCallbacks) {
+      if (pending.timeoutId) {
+        clearTimeout(pending.timeoutId);
+      }
       pending.reject(new Error("Connection closed"));
     }
+    connection.pendingCallbacks.clear();
     state.connections.delete(socket);
   });
   socket.on("error", (err) => {
@@ -220,10 +228,147 @@ async function handleMessage(message, connection, state) {
       sendError(connection.socket, message.requestId ?? 0, import_isolate_protocol.ErrorCode.UNKNOWN_MESSAGE_TYPE, `Unknown message type: ${message.type}`);
   }
 }
+function softDeleteRuntime(instance, state) {
+  instance.isDisposed = true;
+  instance.disposedAt = Date.now();
+  instance.ownerConnection = null;
+  instance.callbacks.clear();
+  instance.runtime.timers.clearAll();
+  instance.runtime.console.reset();
+  instance.pendingCallbacks.length = 0;
+  instance.returnedCallbacks?.clear();
+  instance.returnedPromises?.clear();
+  instance.returnedIterators?.clear();
+}
+function reuseNamespacedRuntime(instance, connection, message, state) {
+  instance.ownerConnection = connection.socket;
+  instance.isDisposed = false;
+  instance.disposedAt = undefined;
+  instance.lastActivity = Date.now();
+  connection.isolates.add(instance.isolateId);
+  const callbacks = message.options.callbacks;
+  if (instance.callbackContext) {
+    instance.callbackContext.connection = connection;
+    instance.callbackContext.consoleOnEntry = callbacks?.console?.onEntry?.callbackId;
+    instance.callbackContext.fetch = callbacks?.fetch?.callbackId;
+    instance.callbackContext.moduleLoader = callbacks?.moduleLoader?.callbackId;
+    instance.callbackContext.fs = {
+      readFile: callbacks?.fs?.readFile?.callbackId,
+      writeFile: callbacks?.fs?.writeFile?.callbackId,
+      stat: callbacks?.fs?.stat?.callbackId,
+      readdir: callbacks?.fs?.readdir?.callbackId,
+      unlink: callbacks?.fs?.unlink?.callbackId,
+      mkdir: callbacks?.fs?.mkdir?.callbackId,
+      rmdir: callbacks?.fs?.rmdir?.callbackId
+    };
+    instance.callbackContext.custom.clear();
+    if (callbacks?.custom) {
+      for (const [name, reg] of Object.entries(callbacks.custom)) {
+        if (reg) {
+          instance.callbackContext.custom.set(name, reg.callbackId);
+        }
+      }
+    }
+  }
+  instance.callbacks.clear();
+  if (callbacks?.console?.onEntry) {
+    instance.callbacks.set(callbacks.console.onEntry.callbackId, {
+      ...callbacks.console.onEntry,
+      name: "onEntry"
+    });
+  }
+  if (callbacks?.fetch) {
+    instance.callbacks.set(callbacks.fetch.callbackId, callbacks.fetch);
+  }
+  if (callbacks?.fs) {
+    for (const [name, reg] of Object.entries(callbacks.fs)) {
+      if (reg) {
+        instance.callbacks.set(reg.callbackId, { ...reg, name });
+      }
+    }
+  }
+  if (callbacks?.moduleLoader) {
+    instance.moduleLoaderCallbackId = callbacks.moduleLoader.callbackId;
+    instance.callbacks.set(callbacks.moduleLoader.callbackId, callbacks.moduleLoader);
+  }
+  if (callbacks?.custom) {
+    for (const [name, reg] of Object.entries(callbacks.custom)) {
+      if (reg) {
+        instance.callbacks.set(reg.callbackId, { ...reg, name });
+      }
+    }
+  }
+  instance.returnedCallbacks = new Map;
+  instance.returnedPromises = new Map;
+  instance.returnedIterators = new Map;
+  instance.nextLocalCallbackId = 1e6;
+  if (callbacks?.custom) {
+    const newCallbackIdMap = {};
+    for (const [name, reg] of Object.entries(callbacks.custom)) {
+      if (reg) {
+        newCallbackIdMap[name] = reg.callbackId;
+      }
+    }
+    try {
+      instance.runtime.context.global.setSync("__customFnCallbackIds", new import_isolated_vm.default.ExternalCopy(newCallbackIdMap).copyInto());
+    } catch {}
+  }
+}
+function evictOldestDisposedRuntime(state) {
+  let oldest = null;
+  let oldestTime = Infinity;
+  for (const [, instance] of state.isolates) {
+    if (instance.isDisposed && instance.disposedAt !== undefined) {
+      if (instance.disposedAt < oldestTime) {
+        oldestTime = instance.disposedAt;
+        oldest = instance;
+      }
+    }
+  }
+  if (oldest) {
+    try {
+      if (oldest.playwrightHandle) {
+        oldest.playwrightHandle.dispose();
+      }
+      oldest.runtime.dispose();
+    } catch {}
+    state.isolates.delete(oldest.isolateId);
+    if (oldest.namespaceId != null) {
+      state.namespacedRuntimes.delete(oldest.namespaceId);
+    }
+    return true;
+  }
+  return false;
+}
 async function handleCreateRuntime(message, connection, state) {
+  const namespaceId = message.options.namespaceId;
+  if (namespaceId != null) {
+    const existing = state.namespacedRuntimes.get(namespaceId);
+    if (existing) {
+      if (!existing.isDisposed) {
+        if (existing.ownerConnection === connection.socket) {
+          sendOk(connection.socket, message.requestId, {
+            isolateId: existing.isolateId,
+            reused: true
+          });
+          return;
+        }
+        sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, `Namespace "${namespaceId}" already has an active runtime`);
+        return;
+      }
+      reuseNamespacedRuntime(existing, connection, message, state);
+      sendOk(connection.socket, message.requestId, {
+        isolateId: existing.isolateId,
+        reused: true
+      });
+      return;
+    }
+  }
   if (state.isolates.size >= state.options.maxIsolates) {
-    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_MEMORY_LIMIT, `Maximum isolates (${state.options.maxIsolates}) reached`);
-    return;
+    if (!evictOldestDisposedRuntime(state)) {
+      sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_MEMORY_LIMIT, `Maximum isolates (${state.options.maxIsolates}) reached`);
+      return;
+    }
   }
   try {
     const isolateId = import_node_crypto.randomUUID();
@@ -233,32 +378,61 @@ async function handleCreateRuntime(message, connection, state) {
     const moduleLoaderCallback = message.options.callbacks?.moduleLoader;
     const customCallbacks = message.options.callbacks?.custom;
     const pendingCallbacks = [];
+    const callbackContext = {
+      connection,
+      consoleOnEntry: consoleCallbacks?.onEntry?.callbackId,
+      fetch: fetchCallback?.callbackId,
+      moduleLoader: moduleLoaderCallback?.callbackId,
+      fs: {
+        readFile: fsCallbacks?.readFile?.callbackId,
+        writeFile: fsCallbacks?.writeFile?.callbackId,
+        stat: fsCallbacks?.stat?.callbackId,
+        readdir: fsCallbacks?.readdir?.callbackId,
+        unlink: fsCallbacks?.unlink?.callbackId,
+        mkdir: fsCallbacks?.mkdir?.callbackId,
+        rmdir: fsCallbacks?.rmdir?.callbackId
+      },
+      custom: new Map(customCallbacks ? Object.entries(customCallbacks).map(([name, reg]) => [name, reg.callbackId]) : [])
+    };
     const runtime = await import_isolate_runtime.createInternalRuntime({
       memoryLimitMB: message.options.memoryLimitMB ?? state.options.defaultMemoryLimitMB,
       cwd: message.options.cwd,
-      console: consoleCallbacks?.onEntry ? {
+      console: {
         onEntry: (entry) => {
-          const promise = invokeClientCallback(connection, consoleCallbacks.onEntry.callbackId, [entry]).catch(() => {});
+          const conn = callbackContext.connection;
+          const callbackId = callbackContext.consoleOnEntry;
+          if (!conn || callbackId === undefined)
+            return;
+          const promise = invokeClientCallback(conn, callbackId, [entry]).catch(() => {});
           pendingCallbacks.push(promise);
         }
-      } : undefined,
-      fetch: fetchCallback ? {
+      },
+      fetch: {
         onFetch: async (request) => {
+          const conn = callbackContext.connection;
+          const callbackId = callbackContext.fetch;
+          if (!conn || callbackId === undefined) {
+            throw new Error("Fetch callback not available");
+          }
           const serialized = await serializeRequest(request);
-          const result = await invokeClientCallback(connection, fetchCallback.callbackId, [serialized]);
+          const result = await invokeClientCallback(conn, callbackId, [serialized]);
           return deserializeResponse(result);
         }
-      } : undefined,
-      fs: fsCallbacks ? {
+      },
+      fs: {
         getDirectory: async (path) => {
+          const conn = callbackContext.connection;
+          if (!conn) {
+            throw new Error("FS callbacks not available");
+          }
           return import_callback_fs_handler.createCallbackFileSystemHandler({
-            connection,
-            callbacks: fsCallbacks,
+            connection: conn,
+            callbackContext,
             invokeClientCallback,
             basePath: path
           });
         }
-      } : undefined
+      }
     });
     const instance = {
       isolateId,
@@ -271,7 +445,10 @@ async function handleCreateRuntime(message, connection, state) {
       returnedCallbacks: new Map,
       returnedPromises: new Map,
       returnedIterators: new Map,
-      nextLocalCallbackId: 1e6
+      nextLocalCallbackId: 1e6,
+      namespaceId,
+      isDisposed: false,
+      callbackContext
     };
     if (moduleLoaderCallback) {
       instance.moduleLoaderCallbackId = moduleLoaderCallback.callbackId;
@@ -356,6 +533,9 @@ async function handleCreateRuntime(message, connection, state) {
     state.isolates.set(isolateId, instance);
     connection.isolates.add(isolateId);
     state.stats.totalIsolatesCreated++;
+    if (namespaceId != null) {
+      state.namespacedRuntimes.set(namespaceId, instance);
+    }
     instance.runtime.fetch.onWebSocketCommand((cmd) => {
       let data;
       if (cmd.data instanceof ArrayBuffer) {
@@ -376,7 +556,7 @@ async function handleCreateRuntime(message, connection, state) {
       };
       sendMessage(connection.socket, wsCommandMsg);
     });
-    sendOk(connection.socket, message.requestId, { isolateId });
+    sendOk(connection.socket, message.requestId, { isolateId, reused: false });
   } catch (err) {
     const error = err;
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
@@ -393,12 +573,16 @@ async function handleDisposeRuntime(message, connection, state) {
     return;
   }
   try {
-    if (instance.playwrightHandle) {
-      instance.playwrightHandle.dispose();
-    }
-    instance.runtime.dispose();
-    state.isolates.delete(message.isolateId);
     connection.isolates.delete(message.isolateId);
+    if (instance.namespaceId != null) {
+      softDeleteRuntime(instance, state);
+    } else {
+      if (instance.playwrightHandle) {
+        instance.playwrightHandle.dispose();
+      }
+      instance.runtime.dispose();
+      state.isolates.delete(message.isolateId);
+    }
     sendOk(connection.socket, message.requestId);
   } catch (err) {
     const error = err;
@@ -455,22 +639,21 @@ async function handleDispatchRequest(message, connection, state) {
       body: requestBody
     });
     const response = await instance.runtime.fetch.dispatchRequest(request);
-    const contentLength = response.headers.get("content-length");
-    const knownSize = contentLength ? parseInt(contentLength, 10) : null;
-    if (knownSize !== null && knownSize > import_isolate_protocol.STREAM_THRESHOLD) {
+    if (response.body) {
       await sendStreamedResponse(connection, message.requestId, response);
     } else {
-      const clonedResponse = response.clone();
-      try {
-        const serialized = await serializeResponse(response);
-        if (serialized.body && serialized.body.length > import_isolate_protocol.STREAM_THRESHOLD) {
-          await sendStreamedResponse(connection, message.requestId, clonedResponse);
-        } else {
-          sendOk(connection.socket, message.requestId, { response: serialized });
+      const headers = [];
+      response.headers.forEach((value, key) => {
+        headers.push([key, value]);
+      });
+      sendOk(connection.socket, message.requestId, {
+        response: {
+          status: response.status,
+          statusText: response.statusText,
+          headers,
+          body: null
         }
-      } catch {
-        await sendStreamedResponse(connection, message.requestId, clonedResponse);
-      }
+      });
     }
   } catch (err) {
     const error = err;
@@ -1045,7 +1228,8 @@ async function setupCustomFunctions(context, customCallbacks, connection, instan
         }
         result = await callback(...args);
       } else {
-        result = await invokeClientCallback(connection, callbackId, args);
+        const conn = instance.callbackContext?.connection || connection;
+        result = await invokeClientCallback(conn, callbackId, args);
       }
       const ctx = createMarshalContext();
       const marshalledResult = await import_isolate_protocol.marshalValue({ ok: true, value: result }, ctx);
@@ -1061,6 +1245,11 @@ async function setupCustomFunctions(context, customCallbacks, connection, instan
   });
   global.setSync("__customFn_invoke", invokeCallbackRef);
   context.evalSync(ISOLATE_MARSHAL_CODE);
+  const callbackIdMap = {};
+  for (const [name, registration] of Object.entries(customCallbacks)) {
+    callbackIdMap[name] = registration.callbackId;
+  }
+  global.setSync("__customFnCallbackIds", new import_isolated_vm.default.ExternalCopy(callbackIdMap).copyInto());
   for (const [name, registration] of Object.entries(customCallbacks)) {
     if (name.includes(":")) {
       continue;
@@ -1068,10 +1257,11 @@ async function setupCustomFunctions(context, customCallbacks, connection, instan
     if (registration.type === "sync") {
       context.evalSync(`
         globalThis.${name} = function(...args) {
+          const callbackId = globalThis.__customFnCallbackIds["${name}"];
           const argsJson = JSON.stringify(__marshalForHost(args));
           const resultJson = __customFn_invoke.applySyncPromise(
             undefined,
-            [${registration.callbackId}, argsJson]
+            [callbackId, argsJson]
           );
           const result = JSON.parse(resultJson);
           if (result.ok) {
@@ -1094,10 +1284,11 @@ async function setupCustomFunctions(context, customCallbacks, connection, instan
       context.evalSync(`
         globalThis.${name} = function(...args) {
           // Start the iterator and get the iteratorId
+          const startCallbackId = globalThis.__customFnCallbackIds["${name}:start"];
           const argsJson = JSON.stringify(__marshalForHost(args));
           const startResultJson = __customFn_invoke.applySyncPromise(
             undefined,
-            [${startReg.callbackId}, argsJson]
+            [startCallbackId, argsJson]
           );
           const startResult = JSON.parse(startResultJson);
           if (!startResult.ok) {
@@ -1110,10 +1301,11 @@ async function setupCustomFunctions(context, customCallbacks, connection, instan
           return {
             [Symbol.asyncIterator]() { return this; },
             async next() {
+              const nextCallbackId = globalThis.__customFnCallbackIds["${name}:next"];
               const argsJson = JSON.stringify(__marshalForHost([iteratorId]));
               const resultJson = __customFn_invoke.applySyncPromise(
                 undefined,
-                [${nextReg.callbackId}, argsJson]
+                [nextCallbackId, argsJson]
               );
               const result = JSON.parse(resultJson);
               if (!result.ok) {
@@ -1125,19 +1317,21 @@ async function setupCustomFunctions(context, customCallbacks, connection, instan
               return { done: val.done, value: val.value };
             },
             async return(v) {
+              const returnCallbackId = globalThis.__customFnCallbackIds["${name}:return"];
               const argsJson = JSON.stringify(__marshalForHost([iteratorId, v]));
               const resultJson = __customFn_invoke.applySyncPromise(
                 undefined,
-                [${returnReg.callbackId}, argsJson]
+                [returnCallbackId, argsJson]
               );
               const result = JSON.parse(resultJson);
               return { done: true, value: result.ok ? __unmarshalFromHost(result.value) : undefined };
             },
             async throw(e) {
+              const throwCallbackId = globalThis.__customFnCallbackIds["${name}:throw"];
               const argsJson = JSON.stringify(__marshalForHost([iteratorId, { message: e?.message, name: e?.name }]));
               const resultJson = __customFn_invoke.applySyncPromise(
                 undefined,
-                [${throwReg.callbackId}, argsJson]
+                [throwCallbackId, argsJson]
               );
               const result = JSON.parse(resultJson);
               if (!result.ok) {
@@ -1154,10 +1348,11 @@ async function setupCustomFunctions(context, customCallbacks, connection, instan
     } else if (registration.type === "async") {
       context.evalSync(`
         globalThis.${name} = async function(...args) {
+          const callbackId = globalThis.__customFnCallbackIds["${name}"];
           const argsJson = JSON.stringify(__marshalForHost(args));
           const resultJson = __customFn_invoke.applySyncPromise(
             undefined,
-            [${registration.callbackId}, argsJson]
+            [callbackId, argsJson]
           );
           const result = JSON.parse(resultJson);
           if (result.ok) {
@@ -1206,22 +1401,6 @@ async function serializeRequest(request) {
     body
   };
 }
-async function serializeResponse(response) {
-  const headers = [];
-  response.headers.forEach((value, key) => {
-    headers.push([key, value]);
-  });
-  let body = null;
-  if (response.body) {
-    body = new Uint8Array(await response.arrayBuffer());
-  }
-  return {
-    status: response.status,
-    statusText: response.statusText,
-    headers,
-    body
-  };
-}
 function deserializeResponse(data) {
   return new Response(data.body, {
     status: data.status,
@@ -1382,14 +1561,21 @@ async function handleRunTests(message, connection, state) {
   instance.lastActivity = Date.now();
   try {
     const timeout = message.timeout ?? 30000;
+    let timeoutId;
     const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => reject(new Error("Test timeout")), timeout);
+      timeoutId = setTimeout(() => reject(new Error("Test timeout")), timeout);
     });
-    const results = await Promise.race([
-      import_isolate_test_environment.runTests(instance.runtime.context),
-      timeoutPromise
-    ]);
-    sendOk(connection.socket, message.requestId, results);
+    try {
+      const results = await Promise.race([
+        import_isolate_test_environment.runTests(instance.runtime.context),
+        timeoutPromise
+      ]);
+      sendOk(connection.socket, message.requestId, results);
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
   } catch (err) {
     const error = err;
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
@@ -1502,4 +1688,4 @@ async function handleClearCollectedData(message, connection, state) {
 }
 })
 
-//# debugId=A7BAC1A3990C35CA64756E2164756E21
+//# debugId=4B3FAD2EB54DBE6A64756E2164756E21