@ai-ecoverse/slicc-kernel 1.22.1 → 1.23.0

package/dist/kernel-worker.js

@@ -224,8 +224,51 @@ function pinScript(url) {
   }
 }
 
+// src/cdp/port.ts
+function portCdpHook(ask, gone) {
+  return (request2) => new Promise((resolve, reject) => {
+    const { port1, port2 } = new MessageChannel();
+    let closed = false;
+    const conn = {
+      send: (m) => {
+        if (!closed) port1.postMessage({ m });
+      },
+      onmessage: null,
+      onclose: null,
+      close: () => {
+        if (closed) return;
+        closed = true;
+        port1.postMessage({ close: true });
+        port1.close();
+      }
+    };
+    port1.addEventListener("message", ({ data }) => {
+      if ("m" in data) conn.onmessage?.(data.m);
+      else if ("open" in data) resolve(conn);
+      else if ("error" in data) {
+        closed = true;
+        port1.close();
+        reject(new Error(data.error));
+      } else if (!closed) {
+        closed = true;
+        port1.close();
+        conn.onclose?.(data.close ?? void 0);
+      }
+    });
+    port1.start();
+    void gone?.then(() => {
+      if (closed) return;
+      closed = true;
+      port1.close();
+      reject(new Error("the CDP host is gone"));
+      conn.onclose?.("the CDP host is gone");
+    });
+    ask(request2, port2);
+  });
+}
+
 // src/client/protocol.ts
-var PROTOCOL = [1, 4];
+var PROTOCOL = [1, 5];
 var FS_METHODS = [
   "readFile",
   "writeFile",
@@ -887,7 +930,12 @@ function keyOf(addr) {
 var LoopbackNet = class {
   bound = /* @__PURE__ */ new Map();
   activators = /* @__PURE__ */ new Map();
+  internal = /* @__PURE__ */ new Set();
   nextEphemeral = EPHEMERAL_FIRST;
+  kernelOnly(port, reserve = false) {
+    if (reserve) this.internal.add(port);
+    return this.internal.has(port);
+  }
   activate(addr, start) {
     this.activators.set(keyOf(addr), start);
   }
@@ -948,6 +996,14 @@ var LOOPBACK_NAMES = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1", "
 function dialSocket(net, port, host = "127.0.0.1") {
   if (!Number.isInteger(port) || port < 1 || port > 65535) throw new KernelError("EINVAL");
   const target = LOOPBACK_NAMES.has(host.toLowerCase()) ? "127.0.0.1" : host;
+  if (net.kernelOnly(port)) {
+    throw Object.assign(
+      new Error(`ECONNREFUSED: port ${port} only takes connections from inside the kernel`),
+      {
+        code: "ECONNREFUSED"
+      }
+    );
+  }
   return net.connect({ family: "inet", host: target, port });
 }
 var codeOf = (err) => {
@@ -1236,6 +1292,43 @@ function joinable(l, pgid, ours) {
   if (sid === void 0) throw fsError("ESRCH", `no process group ${pgid}`);
   if (!ours(sid)) throw fsError("EPERM", `process group ${pgid} is in another session`);
 }
+function cdpRegistry(send, gone) {
+  const registered = /* @__PURE__ */ new Map();
+  const drop = (id) => {
+    registered.get(id)?.();
+    return registered.delete(id);
+  };
+  return {
+    serve(l, req) {
+      const hook = portCdpHook(
+        (request2, cdp) => send({ cdpOpen: { ...request2, registration: req.id }, port: cdp }, [
+          cdp
+        ]),
+        gone
+      );
+      registered.set(req.id, l.cdp.register(hook, req.runtime));
+      return req.id;
+    },
+    drop,
+    close: () => {
+      for (const id of [...registered.keys()]) drop(id);
+    }
+  };
+}
+function watchOp(l, req, watches, send) {
+  if (req.op === "unwatch") {
+    watches.get(req.watch)?.();
+    watches.delete(req.watch);
+    return { result: true };
+  }
+  const unwatch = l.watchers.watch(
+    req.paths,
+    { recursive: req.recursive },
+    (change) => send({ watch: req.id, change })
+  );
+  watches.set(req.id, unwatch);
+  return { result: req.id };
+}
 function serveClient(port, host) {
   let state = "new";
   const terminals = /* @__PURE__ */ new Map();
@@ -1248,6 +1341,7 @@ function serveClient(port, host) {
     if (state !== "closed") port.postMessage(message2, transfer);
   };
   const reply = (id, body, transfer) => send({ id, ...body }, transfer);
+  const cdps = cdpRegistry(send, ended.promise);
   function detach(kill = false, bye = "the slicc-kernel detached this client") {
     if (state === "closed") return;
     send({ bye });
@@ -1255,6 +1349,7 @@ function serveClient(port, host) {
     net?.close();
     for (const unwatch of watches.values()) unwatch();
     watches.clear();
+    cdps.close();
     for (const session of terminals.values()) session.close();
     terminals.clear();
     if (kill) killGroups(host, [...groups]);
@@ -1349,19 +1444,9 @@ function serveClient(port, host) {
           throw new Error(`unknown file system call ${req.method}`);
         }
         return fsCall(l.fs, req.method, req.args);
-      case "watch": {
-        const unwatch = l.watchers.watch(
-          req.paths,
-          { recursive: req.recursive },
-          (change) => send({ watch: req.id, change })
-        );
-        watches.set(req.id, unwatch);
-        return { result: req.id };
-      }
+      case "watch":
       case "unwatch":
-        watches.get(req.watch)?.();
-        watches.delete(req.watch);
-        return { result: true };
+        return watchOp(l, req, watches, send);
       case "mount":
         return { result: await l.mount(req.spec) };
       case "umount":
@@ -1371,6 +1456,10 @@ function serveClient(port, host) {
         return { result: l.mounts.list() };
       case "dial":
         return dialFor(l, req, watches);
+      case "serve-cdp":
+        return { result: cdps.serve(l, req) };
+      case "unserve-cdp":
+        return { result: cdps.drop(req.registration) };
       case "detach":
         return { result: true };
       default:
@@ -1934,6 +2023,8 @@ var REASON = {
   200: "OK",
   400: "Bad Request",
   403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
   408: "Request Timeout",
   411: "Length Required",
   413: "Content Too Large",
@@ -1943,6 +2034,7 @@ var REASON = {
   501: "Not Implemented",
   502: "Bad Gateway",
   503: "Service Unavailable",
+  504: "Gateway Timeout",
   505: "HTTP Version Not Supported"
 };
 var Incoming = class {
@@ -3388,6 +3480,465 @@ var RemoteTransport = class {
   }
 };
 
+// src/cdp/types.ts
+var CDP_PORT = 9222;
+var NO_CDP_HOST = "slicc-kernel: no CDP host is attached (createKernel({ cdp }) or client.serveCdp)";
+
+// src/cdp/websocket.ts
+var GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+var MAX_MESSAGE = 256 * 1024 * 1024;
+var CLOSE = {
+  normal: 1e3,
+  protocol: 1002,
+  unsupported: 1003,
+  invalid: 1007,
+  tooBig: 1009,
+  error: 1011
+};
+var OP_TEXT = 1;
+var OP = { continuation: 0, text: OP_TEXT, binary: 2, close: 8, ping: 9, pong: 10 };
+var WsError = class extends Error {
+  code;
+  constructor(code, message2) {
+    super(message2);
+    this.code = code;
+  }
+};
+function field(headers, name2) {
+  return headers.find(([n]) => n.toLowerCase() === name2)?.[1];
+}
+async function acceptKey(headers) {
+  const tokens = (name2) => (field(headers, name2) ?? "").split(",").map((t) => t.trim().toLowerCase());
+  if (!tokens("upgrade").includes("websocket") || !tokens("connection").includes("upgrade")) {
+    throw new HttpError(400, "expected a WebSocket upgrade");
+  }
+  if (field(headers, "sec-websocket-version") !== "13") {
+    throw new HttpError(400, "Sec-WebSocket-Version must be 13");
+  }
+  const key = field(headers, "sec-websocket-key") ?? "";
+  if (!/^[A-Za-z0-9+/]{22}==$/.test(key)) throw new HttpError(400, "bad Sec-WebSocket-Key");
+  const digest = await crypto.subtle.digest("SHA-1", new TextEncoder().encode(key + GUID));
+  return btoa(String.fromCharCode(...new Uint8Array(digest)));
+}
+function isUpgrade(headers) {
+  return (field(headers, "upgrade") ?? "").toLowerCase().includes("websocket");
+}
+function frame(opcode, payload) {
+  const n = payload.length;
+  const size = n < 126 ? 2 : n < 65536 ? 4 : 10;
+  const out = new Uint8Array(size + n);
+  const view = new DataView(out.buffer);
+  out[0] = 128 | opcode;
+  if (n < 126) out[1] = n;
+  else if (n < 65536) {
+    out[1] = 126;
+    view.setUint16(2, n);
+  } else {
+    out[1] = 127;
+    view.setBigUint64(2, BigInt(n));
+  }
+  out.set(payload, size);
+  return out;
+}
+function closeFrame(code, reason = "") {
+  let bytes = new TextEncoder().encode(reason);
+  if (bytes.length > 123) bytes = bytes.subarray(0, 123);
+  const payload = new Uint8Array(2 + bytes.length);
+  new DataView(payload.buffer).setUint16(0, code);
+  payload.set(bytes, 2);
+  return frame(OP.close, payload);
+}
+function pongFrame(payload) {
+  return frame(OP.pong, payload);
+}
+async function fill(incoming, out, signal) {
+  for (let at = 0; at < out.length; ) {
+    const piece = await incoming.some(out.length - at, signal);
+    if (piece.length === 0) throw new WsError(CLOSE.protocol, "the connection closed mid-frame");
+    out.set(piece, at);
+    at += piece.length;
+  }
+}
+var fatal = new TextDecoder("utf-8", { fatal: true });
+function decode(bytes) {
+  try {
+    return fatal.decode(bytes);
+  } catch {
+    throw new WsError(CLOSE.invalid, "a text message is not UTF-8");
+  }
+}
+var WsReader = class {
+  incoming;
+  max;
+  parts = [];
+  size = 0;
+  continuing = false;
+  constructor(incoming, max = MAX_MESSAGE) {
+    this.incoming = incoming;
+    this.max = max;
+  }
+  async next(signal) {
+    for (; ; ) {
+      const first = await this.incoming.some(1, signal);
+      if (first.length === 0) return null;
+      const head = new Uint8Array(2);
+      head[0] = first[0];
+      await fill(this.incoming, head.subarray(1), signal);
+      const fin = (head[0] & 128) !== 0;
+      const opcode = head[0] & 15;
+      if ((head[0] & 112) !== 0) throw new WsError(CLOSE.protocol, "reserved bits are set");
+      if ((head[1] & 128) === 0) throw new WsError(CLOSE.protocol, "client frames must be masked");
+      const length2 = await this.length(head[1] & 127, signal);
+      const control = opcode >= 8;
+      if (control && (length2 > 125 || !fin)) {
+        throw new WsError(CLOSE.protocol, "a control frame is too long or fragmented");
+      }
+      if (!control && this.size + length2 > this.max) {
+        throw new WsError(CLOSE.tooBig, `a message is over ${this.max} bytes`);
+      }
+      const mask = new Uint8Array(4);
+      await fill(this.incoming, mask, signal);
+      const payload = new Uint8Array(length2);
+      await fill(this.incoming, payload, signal);
+      for (let i = 0; i < length2; i++) payload[i] ^= mask[i & 3];
+      const event = this.take(opcode, fin, payload);
+      if (event) return event;
+    }
+  }
+  async length(short, signal) {
+    if (short < 126) return short;
+    const ext = new Uint8Array(short === 126 ? 2 : 8);
+    await fill(this.incoming, ext, signal);
+    const view = new DataView(ext.buffer);
+    if (short === 126) return view.getUint16(0);
+    const long = view.getBigUint64(0);
+    return long > BigInt(this.max) ? this.max + 1 : Number(long);
+  }
+  take(opcode, fin, payload) {
+    switch (opcode) {
+      case OP.ping:
+        return { kind: "ping", payload };
+      case OP.pong:
+        return void 0;
+      case OP.close: {
+        if (payload.length === 1) throw new WsError(CLOSE.protocol, "a close frame is malformed");
+        const code = payload.length >= 2 ? new DataView(payload.buffer).getUint16(0) : 1005;
+        return { kind: "close", code, reason: decode(payload.subarray(2)) };
+      }
+      case OP.text:
+      case OP.continuation: {
+        if (opcode === OP.continuation !== this.continuing) {
+          throw new WsError(CLOSE.protocol, "unexpected continuation frame");
+        }
+        this.parts.push(payload);
+        this.size += payload.length;
+        this.continuing = !fin;
+        if (!fin) return void 0;
+        const whole = this.parts.length === 1 ? payload : concat(this.parts, this.size);
+        this.parts = [];
+        this.size = 0;
+        return { kind: "text", text: decode(whole) };
+      }
+      case OP.binary:
+        throw new WsError(CLOSE.unsupported, "CDP messages are text");
+      default:
+        throw new WsError(CLOSE.protocol, `unknown opcode ${opcode}`);
+    }
+  }
+};
+function switchingHead(accept2) {
+  return latin1Bytes(
+    `HTTP/1.1 101 Switching Protocols\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Accept: ${accept2}\r
+\r
+`
+  );
+}
+
+// src/cdp/facade.ts
+var MAX_HEAD = 64 * 1024;
+var LIST_TIMEOUT = 1e4;
+function respond(status, body, type = "text/plain; charset=utf-8") {
+  const bytes = new TextEncoder().encode(body);
+  const head = latin1Bytes(
+    `HTTP/1.1 ${status} ${REASON[status]}\r
+Content-Type: ${type}\r
+Content-Length: ${bytes.length}\r
+Connection: close\r
+\r
+`
+  );
+  const out = new Uint8Array(head.length + bytes.length);
+  out.set(head);
+  out.set(bytes, head.length);
+  return out;
+}
+function json(value) {
+  return respond(200, `${JSON.stringify(value, null, 2)}
+`, "application/json; charset=UTF-8");
+}
+var CdpFacade = class {
+  options;
+  listener;
+  stop = new AbortController();
+  connections = /* @__PURE__ */ new Set();
+  closed;
+  constructor(options) {
+    this.options = options;
+    this.listener = options.net.listen({
+      family: "inet",
+      host: "127.0.0.1",
+      port: options.port ?? CDP_PORT
+    });
+    this.closed = this.acceptLoop();
+  }
+  close() {
+    if (this.stop.signal.aborted) return;
+    this.stop.abort();
+    this.listener.close();
+    for (const conn of this.connections) conn.close();
+  }
+  async acceptLoop() {
+    const served = /* @__PURE__ */ new Set();
+    for (; ; ) {
+      let conn;
+      try {
+        conn = await this.listener.accept(this.stop.signal);
+      } catch {
+        break;
+      }
+      const done4 = this.serve(conn).finally(() => served.delete(done4));
+      served.add(done4);
+    }
+    await Promise.allSettled([...served]);
+  }
+  async serve(conn) {
+    this.connections.add(conn);
+    const incoming = new Incoming(conn);
+    try {
+      const head = await incoming.head(MAX_HEAD, this.stop.signal);
+      if (head) await this.route(conn, incoming, parseRequestHead(head));
+    } catch (e) {
+      if (e instanceof HttpError) await this.write(conn, respond(e.status, `${e.message}
+`));
+    } finally {
+      this.connections.delete(conn);
+      conn.close();
+    }
+  }
+  async write(conn, bytes) {
+    try {
+      await conn.write(bytes, this.stop.signal);
+    } catch {
+    }
+  }
+  async route(conn, incoming, req) {
+    const url = new URL(req.target, "http://127.0.0.1");
+    const runtime = url.searchParams.get("runtime") ?? void 0;
+    const host = req.headers.find(([n]) => n.toLowerCase() === "host")?.[1] ?? "127.0.0.1";
+    if (req.method !== "GET") throw new HttpError(405, `${req.method} is not supported here`);
+    const { hosts } = this.options;
+    if (url.pathname === hosts.path && isUpgrade(req.headers)) {
+      return this.upgrade(conn, incoming, req, runtime);
+    }
+    const path = url.pathname.replace(/\/+$/, "");
+    if (path !== "/json/version" && path !== "/json/list" && path !== "/json") {
+      throw new HttpError(404, "not found: try /json/version");
+    }
+    if (!this.options.hosts.available(runtime)) {
+      throw new HttpError(503, NO_CDP_HOST);
+    }
+    if (path === "/json/version") {
+      await this.write(
+        conn,
+        json({
+          Browser: "slicc-kernel",
+          "Protocol-Version": "1.3",
+          webSocketDebuggerUrl: `ws://${host}${hosts.path}${url.search}`
+        })
+      );
+      return;
+    }
+    await this.write(conn, json(await this.list(runtime)));
+  }
+  async list(runtime) {
+    const conn = await this.host(runtime);
+    try {
+      const reply = await new Promise(
+        (resolve, reject) => {
+          const timer = setTimeout(
+            () => reject(new HttpError(504, "the CDP host did not answer Target.getTargets")),
+            this.options.listTimeout ?? LIST_TIMEOUT
+          );
+          conn.onclose = (reason) => {
+            clearTimeout(timer);
+            reject(new HttpError(502, `the CDP host closed: ${reason ?? "no reason"}`));
+          };
+          conn.onmessage = (message2) => {
+            const parsed = JSON.parse(message2);
+            if (parsed.id !== 1) return;
+            clearTimeout(timer);
+            resolve(parsed);
+          };
+          conn.send(JSON.stringify({ id: 1, method: "Target.getTargets" }));
+        }
+      );
+      if (!reply.result) {
+        throw new HttpError(502, `Target.getTargets failed: ${JSON.stringify(reply.error)}`);
+      }
+      return (reply.result.targetInfos ?? []).map((t) => ({
+        description: "",
+        id: t.targetId,
+        title: t.title,
+        type: t.type,
+        url: t.url
+      }));
+    } finally {
+      conn.close();
+    }
+  }
+  host(runtime) {
+    return this.options.hosts.connect(runtime ? { runtime } : {});
+  }
+  async upgrade(conn, incoming, req, runtime) {
+    const accept2 = await acceptKey(req.headers);
+    const host = await this.host(runtime);
+    await new Relay(conn, incoming, host, this.options.maxMessage ?? MAX_MESSAGE, this.stop.signal).start(switchingHead(accept2)).finally(() => host.close());
+  }
+};
+var Relay = class {
+  writes = Promise.resolve();
+  ended = false;
+  conn;
+  incoming;
+  host;
+  max;
+  stop;
+  constructor(conn, incoming, host, max, stop) {
+    this.conn = conn;
+    this.incoming = incoming;
+    this.host = host;
+    this.max = max;
+    this.stop = stop;
+  }
+  send(bytes) {
+    this.writes = this.writes.then(() => this.conn.write(bytes, this.stop)).catch(() => void 0);
+    return this.writes;
+  }
+  end(code, reason) {
+    if (this.ended) return this.writes;
+    this.ended = true;
+    return this.send(closeFrame(code, reason));
+  }
+  async start(head) {
+    await this.send(head);
+    const hostGone = new Promise((resolve) => {
+      this.host.onclose = (reason) => {
+        void this.end(reason ? CLOSE.error : CLOSE.normal, reason ?? "").then(() => resolve());
+      };
+    });
+    this.host.onmessage = (message2) => {
+      if (this.ended) return;
+      const bytes = new TextEncoder().encode(message2);
+      if (bytes.length > this.max)
+        void this.end(CLOSE.tooBig, `a message is over ${this.max} bytes`);
+      else void this.send(frame(OP_TEXT, bytes));
+    };
+    await Promise.race([this.pump(), hostGone]);
+    await this.writes;
+  }
+  async pump() {
+    const reader = new WsReader(this.incoming, this.max);
+    try {
+      for (; ; ) {
+        const event = await reader.next(this.stop);
+        if (!event) return;
+        if (event.kind === "text") this.host.send(event.text);
+        else if (event.kind === "ping") void this.send(pongFrame(event.payload));
+        else {
+          await this.end(event.code === 1005 ? CLOSE.normal : event.code, "");
+          return;
+        }
+      }
+    } catch (e) {
+      if (e instanceof WsError) await this.end(e.code, e.message);
+    }
+  }
+};
+function enableCdp(net, hosts) {
+  let facade;
+  net.kernelOnly(CDP_PORT, true);
+  net.activate({ family: "inet", host: "127.0.0.1", port: CDP_PORT }, () => {
+    const started = new CdpFacade({ net, hosts });
+    facade = started;
+    void started.closed.then(() => {
+      if (facade === started) facade = void 0;
+    });
+  });
+  return () => facade;
+}
+
+// src/cdp/hosts.ts
+var CdpHosts = class {
+  embedder;
+  clients = [];
+  closed = false;
+  path = `/devtools/browser/${crypto.randomUUID()}`;
+  url = `ws://127.0.0.1:${CDP_PORT}${this.path}`;
+  constructor(hook) {
+    this.embedder = hook ? { hook, runtime: void 0, open: /* @__PURE__ */ new Set() } : void 0;
+  }
+  register(hook, runtime) {
+    const entry = { hook, runtime, open: /* @__PURE__ */ new Set() };
+    this.clients.push(entry);
+    return () => {
+      const at = this.clients.indexOf(entry);
+      if (at >= 0) this.clients.splice(at, 1);
+      closeAll(entry);
+    };
+  }
+  pick(runtime) {
+    if (this.closed) return void 0;
+    const named = runtime ? this.clients.findLast((c) => c.runtime === runtime) : void 0;
+    return named ?? this.embedder ?? this.clients.at(-1);
+  }
+  available(runtime) {
+    return this.pick(runtime) !== void 0;
+  }
+  async connect(request2) {
+    const entry = this.pick(request2.runtime);
+    if (!entry) throw new HttpError(503, NO_CDP_HOST);
+    let conn;
+    try {
+      conn = await entry.hook(request2.runtime ? { runtime: request2.runtime } : {});
+    } catch (e) {
+      throw new HttpError(502, `CDP host: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (this.closed || !(entry === this.embedder || this.clients.includes(entry))) {
+      conn.close();
+      throw new HttpError(503, NO_CDP_HOST);
+    }
+    entry.open.add(conn);
+    const close = conn.close.bind(conn);
+    conn.close = () => {
+      if (entry.open.delete(conn)) close();
+    };
+    return conn;
+  }
+  close() {
+    this.closed = true;
+    for (const entry of [this.embedder, ...this.clients]) if (entry) closeAll(entry);
+  }
+};
+function closeAll(entry) {
+  for (const conn of [...entry.open]) {
+    conn.close();
+    conn.onclose?.("the CDP host is gone");
+  }
+}
+
 // src/commands.ts
 var NAME = /^[A-Za-z0-9._+-]+$/;
 var ENV_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -4711,7 +5262,7 @@ async function storageUsage() {
   return { quota: estimate.quota, usage: estimate.usage ?? 0 };
 }
 var done = { ok: true, kind: "void" };
-function json(value) {
+function json2(value) {
   return { ok: true, kind: "json", json: value };
 }
 async function run(entry, path, req) {
@@ -4723,15 +5274,15 @@ async function run(entry, path, req) {
       await fs.writeFile(path, req.body ?? new Uint8Array(0));
       return done;
     case "exists":
-      return json(await fs.exists(path));
+      return json2(await fs.exists(path));
     case "stat":
-      return json(statJson(await fs.stat(path)));
+      return json2(statJson(await fs.stat(path)));
     case "lstat":
-      return json(statJson(await fs.lstat(path)));
+      return json2(statJson(await fs.lstat(path)));
     case "readdir":
-      return json(await fs.readdir(path));
+      return json2(await fs.readdir(path));
     case "readdir-stat":
-      return json(await readdirStat(fs, path));
+      return json2(await readdirStat(fs, path));
     case "mkdir":
       await fs.mkdir(path, { recursive: true });
       return done;
@@ -4757,7 +5308,7 @@ async function run(entry, path, req) {
       await fs.symlink(req.arg2 ?? "", path);
       return done;
     case "readlink":
-      return json(await fs.readlink(path));
+      return json2(await fs.readlink(path));
     case "chmod":
       await fs.chmod(path, req.mode ?? 0);
       return done;
@@ -4788,7 +5339,7 @@ async function dispatchSyncFs(req) {
   const { fs, cwd } = entry;
   try {
     const path = fs.resolvePath(cwd, req.path);
-    if (req.op === "statfs") return json(await entry.statfs?.(path) ?? await storageUsage());
+    if (req.op === "statfs") return json2(await entry.statfs?.(path) ?? await storageUsage());
     if (req.op === "hold") {
       entry.hold?.(path, req.mode === 1);
       return done;
@@ -4961,7 +5512,7 @@ var HOST_OPS = [
   "async-cancel",
   "async-close"
 ];
-var json2 = (value) => ({ ok: true, kind: "json", json: value });
+var json3 = (value) => ({ ok: true, kind: "json", json: value });
 var done2 = { ok: true, kind: "void" };
 var LockTable = class {
   held = /* @__PURE__ */ new Map();
@@ -5010,7 +5561,7 @@ var AsyncOps = class {
   }
   resolve(value) {
     const id = this.hold();
-    this.complete(id, json2(value));
+    this.complete(id, json3(value));
     return id;
   }
   hold() {
@@ -5092,15 +5643,15 @@ async function hostSyscall(req, ctx) {
       return done2;
     case "async-submit":
       if (!ctx.valid(req.req)) throw new KernelError("EINVAL");
-      return json2(ctx.ops.submit(req.req));
+      return json3(ctx.ops.submit(req.req));
     case "async-wait":
-      return json2(await ctx.ops.wait(req.timeoutMs, ctx.blocking()));
+      return json3(await ctx.ops.wait(req.timeoutMs, ctx.blocking()));
     case "async-take":
       return ctx.ops.take(req.id);
     case "async-resolve":
-      return json2(ctx.ops.resolve(req.value));
+      return json3(ctx.ops.resolve(req.value));
     case "async-hold":
-      return json2(ctx.ops.hold());
+      return json3(ctx.ops.hold());
     case "async-cancel":
       ctx.ops.cancel(req.id);
       return done2;
@@ -5627,23 +6178,23 @@ function terminalOf(ctx, fd) {
   if (!tty) throw new KernelError("ENOTTY");
   return tty;
 }
-var json3 = (value) => ({ ok: true, kind: "json", json: value });
+var json4 = (value) => ({ ok: true, kind: "json", json: value });
 var done3 = { ok: true, kind: "void" };
 function ptySyscall(req, ctx) {
   switch (req.op) {
     case "pty-open": {
       if (!ctx.ptys) throw new KernelError("ENOENT");
-      return json3(ctx.fds.install(ctx.ptys.open().master, 3));
+      return json4(ctx.fds.install(ctx.ptys.open().master, 3));
     }
     case "pty-slave-open": {
       if (!ctx.ptys) throw new KernelError("ENOENT");
       const pair = ctx.ptys.get(req.n);
       const fd = ctx.fds.install(pair.openSlave(), 3);
       if (!req.noctty) ctx.jobs?.acquireTerminal(ctx.pid, pair.slave);
-      return json3(fd);
+      return json4(fd);
     }
     case "pty-number":
-      return json3(masterOf(ctx, req.fd).index);
+      return json4(masterOf(ctx, req.fd).index);
     case "pty-lock":
       masterOf(ctx, req.fd).locked = req.lock;
       return done3;
@@ -5655,7 +6206,7 @@ function ptySyscall(req, ctx) {
       return done3;
     }
     case "pty-list":
-      return json3(ctx.ptys?.numbers() ?? []);
+      return json4(ctx.ptys?.numbers() ?? []);
     case "pty-packet":
       masterOf(ctx, req.fd).packet = req.on;
       return done3;
@@ -5733,7 +6284,7 @@ function socketAt(fds, fd) {
   if (!(file instanceof KernelSocket)) throw new KernelError("ENOTSOCK");
   return file;
 }
-var ok = (json4) => json4 === void 0 ? { ok: true, kind: "void" } : { ok: true, kind: "json", json: json4 };
+var ok = (json5) => json5 === void 0 ? { ok: true, kind: "void" } : { ok: true, kind: "json", json: json5 };
 async function socketSyscall(req, proc) {
   const { fds, net } = proc;
   switch (req.op) {
@@ -7697,8 +8248,8 @@ function umountCall(target, flags) {
 var FSTAB_PATH = "/etc/fstab";
 var FSTAB_RETRIES = [1e3, 4e3, 16e3];
 var FINAL = /* @__PURE__ */ new Set(["EINVAL", "EBUSY", "EPERM", "EACCES"]);
-function unescape(field) {
-  return field.replace(
+function unescape(field2) {
+  return field2.replace(
     /\\([0-7]{3})/g,
     (_, octal) => String.fromCharCode(Number.parseInt(octal, 8))
   );
@@ -8346,7 +8897,7 @@ function importedMemory(bytes) {
     const count = u32();
     for (let i = 0; i < count; i++) {
       const module = name2();
-      const field = name2();
+      const field2 = name2();
       const kind = bytes[at++];
       if (kind === 0) u32();
       else if (kind === 1) {
@@ -8354,7 +8905,7 @@ function importedMemory(bytes) {
         limits();
       } else if (kind === 2) {
         const l = limits();
-        return { module, name: field, ...l };
+        return { module, name: field2, ...l };
       } else if (kind === 3) at += 2;
       else if (kind === 4) {
         at++;
@@ -8445,12 +8996,12 @@ function readImports(r, types) {
   const foreign = {};
   for (let i = r.u32(); i > 0; i--) {
     const module = r.name();
-    const field = r.name();
+    const field2 = r.name();
     const kind = r.byte();
     if (kind !== 0) skipImport(r, kind);
     else {
       const type = types[r.u32()] ?? "other";
-      if (!RESERVED_NAMESPACES.has(module)) (foreign[module] ??= {})[field] = type;
+      if (!RESERVED_NAMESPACES.has(module)) (foreign[module] ??= {})[field2] = type;
     }
   }
   return foreign;
@@ -8557,6 +9108,7 @@ var Launcher = class {
   locks = new LockTable();
   ptys = new PtyTable((tty, sig) => this.jobs.signalOwnedForeground(tty, sig));
   net = new LoopbackNet();
+  cdp;
   ca;
   transport;
   watchers = new FsWatchers();
@@ -8593,7 +9145,8 @@ var Launcher = class {
     this.processMounts = options.processMounts ?? true;
     this.pnpmHome = options.env?.PNPM_HOME ?? PNPM_HOME;
     this.modulesDir = options.modules ?? "/node_modules";
-    this.env = { ...networkEnv(), ...options.env };
+    this.cdp = new CdpHosts(options.cdp);
+    this.env = { ...networkEnv(), SLICC_CDP_URL: this.cdp.url, ...options.env };
     this.ca = kernelCa(options.caStore ?? memoryCaStore());
     this.transport = options.transport ?? missingTransport();
     enableNetwork(this.net, {
@@ -8601,6 +9154,7 @@ var Launcher = class {
       engine: kernelTlsEngine(packageTlsEngine(options.fs, this.modulesDir)),
       ca: this.ca
     });
+    enableCdp(this.net, this.cdp);
     this.fs = withCommandDirs(this.base, async () => new Set((await this.commands()).keys()));
     this.watchers.watch([this.modulesDir, this.pnpmHome], { recursive: true }, () => {
       this.catalog = void 0;
@@ -9159,6 +9713,14 @@ async function stores(deps, name2, media) {
     ...handles === false ? {} : { media: await deps.media?.(handles) }
   };
 }
+function cdpOption(req, port) {
+  if (!req.cdp) return {};
+  return {
+    cdp: portCdpHook(
+      (request2, cdp) => port.postMessage({ cdpOpen: request2, port: cdp }, [cdp])
+    )
+  };
+}
 function serveKernel(port, deps) {
   let launcher;
   let remote;
@@ -9230,6 +9792,7 @@ function serveKernel(port, deps) {
         ...media ? { media } : {},
         onMountPending: (medium) => port.postMessage({ medium }),
         ...req.hostfs ? { hostfs: askGrant } : {},
+        ...cdpOption(req, port),
         ...mountPolicy(req.processMounts),
         caStore: caStore(deps.metadata ? caDb(req) : false)
       });