@ai-ecoverse/slicc-kernel 1.22.1 → 1.24.0

package/dist/index.js

@@ -1,3 +1,48 @@
+// src/cdp/port.ts
+function serveCdpPort(port, hook, request, onDone) {
+  let conn;
+  let done = false;
+  const end = () => {
+    done = true;
+    port.close();
+    onDone?.();
+  };
+  const finish = (reason) => {
+    if (done) return;
+    port.postMessage({ close: reason });
+    end();
+  };
+  port.addEventListener("message", ({ data }) => {
+    if (data.m !== void 0) conn?.send(data.m);
+    else if (data.close && !done) {
+      end();
+      conn?.close();
+    }
+  });
+  port.start?.();
+  new Promise((resolve) => resolve(hook(request))).then(
+    (opened) => {
+      conn = opened;
+      if (done) return opened.close();
+      opened.onmessage = (m) => {
+        if (!done) port.postMessage({ m });
+      };
+      opened.onclose = (reason) => finish(reason ?? null);
+      port.postMessage({ open: true });
+    },
+    (e) => {
+      if (done) return;
+      port.postMessage({ error: e instanceof Error ? e.message : String(e) });
+      end();
+    }
+  );
+  return () => {
+    if (done) return;
+    conn?.close();
+    finish("the CDP host is gone");
+  };
+}
+
 // src/client/dial-stream.ts
 function errorWithCode(message) {
   const code = /^E[A-Z]+/.exec(message)?.[0];
@@ -516,7 +561,7 @@ var RemoteTransport = class {
 };
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 4];
+var PROTOCOL = [1, 5];
 function locksOf(scope = globalThis) {
   const locks = scope.navigator?.locks;
   return typeof locks?.request === "function" ? locks : void 0;
@@ -580,6 +625,8 @@ var Channel = class {
   failure;
   pending = /* @__PURE__ */ new Map();
   watching = /* @__PURE__ */ new Map();
+  cdpHooks = /* @__PURE__ */ new Map();
+  cdpOpen = /* @__PURE__ */ new Set();
   protocol = PROTOCOL;
   nextId = 0;
   port;
@@ -600,6 +647,8 @@ var Channel = class {
     this.failure = error;
     this.greeted.reject(error);
     this.remote?.fail(error);
+    for (const close of [...this.cdpOpen]) close();
+    this.cdpOpen.clear();
     for (const call of this.pending.values()) call.reject(error);
     this.pending.clear();
     this.release();
@@ -620,6 +669,10 @@ var Channel = class {
     return this.request(call).done;
   }
   receive(data) {
+    if (data.cdpOpen && data.port) {
+      this.openCdp(data);
+      return;
+    }
     if (data.watch !== void 0) {
       this.watching.get(data.watch)?.(data.change);
       return;
@@ -651,7 +704,39 @@ var Channel = class {
     if (reply.error !== void 0) call.reject(new KernelCallError(reply.error, reply.code));
     else call.resolve(reply.result);
   }
+  openCdp({ cdpOpen: { registration, ...request }, port }) {
+    const hook = registration === void 0 ? void 0 : this.cdpHooks.get(registration);
+    if (!hook || this.failure) {
+      port.postMessage({ error: "this client no longer serves CDP" });
+      port.close();
+      return;
+    }
+    const close = serveCdpPort(port, hook, request, () => this.cdpOpen.delete(close));
+    this.cdpOpen.add(close);
+  }
 };
+async function serveCdpOn(channel, hook, options) {
+  await since(channel, 5, "CDP serving", async () => {
+  });
+  const req = {
+    op: "serve-cdp",
+    ...options.runtime ? { runtime: options.runtime } : {}
+  };
+  const { id, done } = channel.request(req);
+  channel.cdpHooks.set(id, hook);
+  try {
+    await done;
+  } catch (error) {
+    channel.cdpHooks.delete(id);
+    throw error;
+  }
+  return {
+    close: () => {
+      if (!channel.cdpHooks.delete(id)) return;
+      void channel.call({ op: "unserve-cdp", registration: id }).catch(() => void 0);
+    }
+  };
+}
 async function dialOn(channel, { port, host }) {
   const req = { op: "dial", port, ...host ? { host } : {} };
   return dialStream(await since(channel, 4, "dial", () => channel.call(req)));
@@ -837,6 +922,7 @@ async function attachKernel(port, options = {}) {
     dial: (options2) => dialOn(channel, options2),
     loopbackFetch: (input, options2) => loopbackFetch((o) => dialOn(channel, o), input, options2),
     fs: fsOn(channel),
+    serveCdp: (hook, options2 = {}) => serveCdpOn(channel, hook, options2),
     async close(o = {}) {
       if (channel.failure) return;
       await channel.call({ op: "detach", ...o.kill ? { kill: true } : {} }).catch(() => void 0);
@@ -1049,6 +1135,41 @@ function dialer(call) {
   };
   return { dial, reset };
 }
+function initCall(options, transport) {
+  return {
+    op: "init",
+    ...options.root ? { root: options.root } : {},
+    ...options.modules ? { modules: options.modules } : {},
+    ...options.env ? { env: options.env } : {},
+    ...options.metadata !== void 0 ? { metadata: options.metadata } : {},
+    ...options.media !== void 0 ? { media: options.media } : {},
+    ...options.ca !== void 0 ? { ca: options.ca } : {},
+    ...transport ? { transport: transport.traits } : {},
+    ...options.hostfs ? { hostfs: true } : {},
+    ...options.cdp ? { cdp: true } : {},
+    ...options.processMounts !== void 0 ? {
+      processMounts: typeof options.processMounts === "function" ? "ask" : options.processMounts
+    } : {}
+  };
+}
+function cdpBridge(hook) {
+  const open = /* @__PURE__ */ new Set();
+  let closed = false;
+  return {
+    open({ cdpOpen, port }) {
+      if (!hook || closed) {
+        port.close();
+        return;
+      }
+      const close = serveCdpPort(port, hook, cdpOpen, () => open.delete(close));
+      open.add(close);
+    },
+    close() {
+      closed = true;
+      for (const close of [...open]) close();
+    }
+  };
+}
 async function createKernel(options = {}) {
   if (!globalThis.crossOriginIsolated) throw new Error(ISOLATION);
   const url = options.worker ?? new URL("./kernel-worker.js", import.meta.url);
@@ -1057,8 +1178,10 @@ async function createKernel(options = {}) {
   let nextId = 0;
   let failure2;
   const dials = dialer((req) => call(req));
+  const cdp = cdpBridge(options.cdp);
   const fail = (error) => {
     dials.reset();
+    cdp.close();
     failure2 = error;
     bridge?.close();
     for (const call2 of pending.values()) call2.reject(error);
@@ -1104,6 +1227,7 @@ async function createKernel(options = {}) {
       data
     }) => {
       if ("net" in data) return bridge?.answer(data);
+      if ("cdpOpen" in data) return cdp.open(data);
       if ("mountPolicy" in data) return void policy(data.mountPolicy);
       if ("medium" in data) return pendingMedium(data.medium);
       if ("hostfs" in data) return void grantHostfs(data.hostfs);
@@ -1165,20 +1289,7 @@ async function createKernel(options = {}) {
     };
   }
   const { dial } = dials;
-  await call({
-    op: "init",
-    ...options.root ? { root: options.root } : {},
-    ...options.modules ? { modules: options.modules } : {},
-    ...options.env ? { env: options.env } : {},
-    ...options.metadata !== void 0 ? { metadata: options.metadata } : {},
-    ...options.media !== void 0 ? { media: options.media } : {},
-    ...options.ca !== void 0 ? { ca: options.ca } : {},
-    ...transport ? { transport: transport.traits } : {},
-    ...options.hostfs ? { hostfs: true } : {},
-    ...options.processMounts !== void 0 ? {
-      processMounts: typeof options.processMounts === "function" ? "ask" : options.processMounts
-    } : {}
-  });
+  await call(initCall(options, transport));
   return {
     async run(argv, runOptions = {}) {
       const { onStdout, onStderr, stdin, ...rest } = runOptions;