@ai-ecoverse/slicc-kernel 1.152.1 → 1.153.0

package/dist/index.js

@@ -326,6 +326,111 @@ function clipboardAnswerer(port, hook) {
   };
 }
 
+// src/embedder-relay.ts
+function fresh2(bytes) {
+  return bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength ? bytes : bytes.slice();
+}
+function errorOf(err) {
+  const name = err?.name;
+  const message = err instanceof Error ? err.message : String(err);
+  return { name: typeof name === "string" ? name : "Error", message };
+}
+function bytesOf(reply) {
+  if (reply instanceof ReadableStream) return reply;
+  const bytes = typeof reply === "string" ? new TextEncoder().encode(reply) : reply instanceof Uint8Array ? reply : new Uint8Array(0);
+  return new ReadableStream({
+    start(controller) {
+      if (bytes.length > 0) controller.enqueue(bytes);
+      controller.close();
+    }
+  });
+}
+function bodyStream(id, state, post) {
+  return new ReadableStream(
+    {
+      pull: async (controller) => {
+        if (state.body.length === 0) post({ id, bodyPull: true });
+        while (state.body.length === 0 && !state.abort.signal.aborted) {
+          await new Promise((resolve) => {
+            state.wakeBody = resolve;
+          });
+        }
+        const next = state.body.shift();
+        if (next) controller.enqueue(next);
+        else controller.close();
+      }
+    },
+    { highWaterMark: 0 }
+  );
+}
+function embedderAnswerer(port, hookFor) {
+  const running = /* @__PURE__ */ new Map();
+  const post = (message, transfer = []) => port.postMessage({ embedderReply: message }, transfer);
+  const fail = (id, err) => {
+    running.delete(id);
+    post({ id, error: errorOf(err) });
+  };
+  const start = async (ask) => {
+    const state = { abort: new AbortController(), body: [], wakeBody: void 0 };
+    running.set(ask.id, state);
+    try {
+      const hook = hookFor(ask.client);
+      if (!hook || !Object.hasOwn(hook.kinds, ask.kind))
+        throw Object.assign(new Error(`this page does not answer ${ask.kind}`), {
+          name: "NotSupportedError"
+        });
+      const reply = await hook.handle({
+        kind: ask.kind,
+        options: ask.options,
+        body: bodyStream(ask.id, state, post),
+        stamp: ask.stamp,
+        signal: state.abort.signal,
+        progress: (line) => post({ id: ask.id, progress: String(line) })
+      });
+      state.reader = bytesOf(reply).getReader();
+      post({ id: ask.id, ready: true });
+    } catch (err) {
+      fail(ask.id, err);
+    }
+  };
+  const pull = async (id, state) => {
+    try {
+      const got = await state.reader.read();
+      if (got.done) {
+        running.delete(id);
+        post({ id, done: true });
+        return;
+      }
+      const bytes = fresh2(got.value);
+      post({ id, chunk: bytes }, [bytes.buffer]);
+    } catch (err) {
+      fail(id, err);
+    }
+  };
+  const step = (message) => {
+    const state = running.get(message.id);
+    if (!state) return;
+    if ("body" in message) state.body.push(message.body);
+    else if ("bodyEnd" in message) state.body.push(null);
+    else if ("pull" in message) void pull(message.id, state);
+    else {
+      running.delete(message.id);
+      state.abort.abort(new DOMException(message.cancel, "AbortError"));
+      void state.reader?.cancel(message.cancel).catch(() => void 0);
+    }
+    state.wakeBody?.();
+  };
+  return {
+    handle(data) {
+      const message = data?.embedder;
+      if (!message) return false;
+      if ("ask" in message) void start(message.ask);
+      else step(message);
+      return true;
+    }
+  };
+}
+
 // src/facade/port.ts
 function serveFacadePort(port, hook, { name, stamp }, onDone) {
   let conn;
@@ -457,6 +562,24 @@ function integrityAnswerer(port, lookup) {
   };
 }
 
+// src/kernel/embedder.ts
+var EMBEDDER_HEADER_MAX = 64 * 1024;
+var EMBEDDER_WINDOW = 1024 * 1024;
+var EMBEDDER_BUDGET = 256 * 1024 * 1024;
+function kindsOf(hook) {
+  if (typeof hook?.handle !== "function" || typeof hook.kinds !== "object" || !hook.kinds)
+    throw new TypeError("requests needs kinds and handle");
+  return Object.fromEntries(
+    Object.entries(hook.kinds).map(([kind, policy]) => [
+      kind,
+      {
+        ...policy?.group !== void 0 ? { group: String(policy.group) } : {},
+        ...policy?.users ? { users: [...policy.users] } : {}
+      }
+    ])
+  );
+}
+
 // src/kernel/net/loopback-names.ts
 var HOST_LOOPBACK = "host.slicc.internal";
 var HOST_LOOPBACK_ADDRESS = [10, 0, 2, 2];
@@ -1526,7 +1649,7 @@ var RemoteTransport = class {
 };
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 12];
+var PROTOCOL = [1, 13];
 function locksOf(scope = globalThis) {
   const locks = scope.navigator?.locks;
   return typeof locks?.request === "function" ? locks : void 0;
@@ -1554,7 +1677,7 @@ var KernelCallError = class extends Error {
   }
 };
 var encoder3 = new TextEncoder();
-var bytesOf = (data) => typeof data === "string" ? encoder3.encode(data) : data;
+var bytesOf2 = (data) => typeof data === "string" ? encoder3.encode(data) : data;
 var UNAVAILABLE = {
   manualRedirects: false,
   encodedBodies: false,
@@ -1638,7 +1761,9 @@ var Channel = class {
   call(call) {
     return this.request(call).done;
   }
+  requests;
   receive(data) {
+    if (this.requests?.handle(data)) return;
     if (data.traits && data.id === void 0) {
       if (this.remote) this.remote.traits = data.traits;
       for (const listener of [...this.traitsListeners]) listener(data.traits);
@@ -1761,7 +1886,7 @@ async function spawnOn(channel, argv, opts) {
   });
   const started = Promise.withResolvers();
   let endedBy;
-  const options = { ...rest, ...stdin !== void 0 ? { stdin: bytesOf(stdin) } : {} };
+  const options = { ...rest, ...stdin !== void 0 ? { stdin: bytesOf2(stdin) } : {} };
   const { done } = channel.request(
     { op: "spawn", argv, options },
     {
@@ -1844,7 +1969,7 @@ async function terminalOn(channel, argv, opts) {
       listener = next;
       if (next) for (const bytes of backlog.splice(0)) next(bytes);
     },
-    write: (data) => send2({ action: "write", bytes: bytesOf(data) }),
+    write: (data) => send2({ action: "write", bytes: bytesOf2(data) }),
     resize: (cols, rows) => send2({ action: "resize", cols, rows }),
     signal: (name) => send2({ action: "signal", signal: name }),
     close: () => send2({ action: "close" })
@@ -1906,8 +2031,10 @@ function since(channel, minor, what, run) {
   }
   return run();
 }
-async function greet(channel, lock, timeoutMs) {
-  channel.post({ hello: { protocol: PROTOCOL, ...lock ? { lock } : {} } });
+async function greet(channel, lock, timeoutMs, requests) {
+  channel.post({
+    hello: { protocol: PROTOCOL, ...lock ? { lock } : {}, ...requests ? { requests } : {} }
+  });
   const timer = setTimeout(
     () => channel.end(
       new KernelGoneError(`no slicc-kernel answered on this port within ${timeoutMs} ms`)
@@ -1932,7 +2059,14 @@ async function attachKernel(port, options = {}) {
   const locks = options.locks === null ? void 0 : options.locks ?? locksOf();
   const own = await holdLock(locks);
   const channel = new Channel(port, own.release);
-  const hello = await greet(channel, own.name, options.timeoutMs ?? 1e4);
+  const requests = options.requests;
+  if (requests) channel.requests = embedderAnswerer(port, () => requests);
+  const hello = await greet(
+    channel,
+    own.name,
+    options.timeoutMs ?? 1e4,
+    requests ? kindsOf(requests) : void 0
+  );
   channel.protocol = hello.protocol;
   if (hello.lock && locks) void locks.request(hello.lock, () => channel.end(new KernelGoneError()));
   const transport = new RemoteTransport(
@@ -2163,7 +2297,7 @@ function fsError2(code, message = code) {
 // src/mount/hostfs.ts
 var HOSTFS_IO = 16 * 1024 * 1024;
 var codeOf = (err) => err?.code;
-var errorOf = (err) => ({
+var errorOf2 = (err) => ({
   code: typeof codeOf(err) === "string" ? codeOf(err) : "EIO",
   message: err?.message ?? String(err)
 });
@@ -2213,7 +2347,7 @@ function serveHostfsPort(port, transport) {
         );
         send2({ id, end: true });
       } catch (err) {
-        send2({ id, error: errorOf(err) });
+        send2({ id, error: errorOf2(err) });
       } finally {
         watches.delete(id);
       }
@@ -2241,7 +2375,7 @@ function serveHostfsPort(port, transport) {
       if (op !== "call") throw fsError2("EINVAL", `unknown hostfs port op ${op}`);
       send2({ id, result: await answer(data.name, data.body) });
     } catch (err) {
-      send2({ id, error: errorOf(err) });
+      send2({ id, error: errorOf2(err) });
     }
   };
   const stop = () => {
@@ -2309,6 +2443,7 @@ function initCall(options, transport) {
     ...options.onDenial ? { denials: true } : {},
     ...options.sealed ? { sealed: true } : {},
     ...options.clipboard ? { clipboard: true } : {},
+    ...options.requests ? { requests: kindsOf(options.requests) } : {},
     ...options.approve ? { approve: true } : {},
     ...options.protect ? { protect: protectInit(options.protect) } : {},
     ...options.processMounts !== void 0 ? {
@@ -2468,12 +2603,30 @@ function checkOptions(options) {
   integrityOptions(options.protect?.integrity);
   facadesInit(options.facades);
 }
-function hookRelays(worker, options) {
+function connector(call, bound) {
+  return async (connectOptions = {}) => {
+    const { requests, ...rest } = connectOptions;
+    if (requests === void 0 || requests === "attach")
+      return await call({
+        op: "connect",
+        ...rest,
+        ...requests ? { requests } : {}
+      });
+    const made = await call({ op: "connect", ...rest, requests: kindsOf(requests) });
+    bound.set(made.client, requests);
+    return made.port;
+  };
+}
+function hookRelays(worker, options, bound) {
   const sealed = sealedAnswerer(worker, options.sealed);
   const clipboard = clipboardAnswerer(worker, options.clipboard);
   const integrity = integrityAnswerer(worker, options.protect?.integrity?.lookup);
+  const requests = embedderAnswerer(
+    worker,
+    (client) => client === 0 ? options.requests : bound.get(client)
+  );
   return {
-    handle: (data) => sealed.handle(data) || clipboard.handle(data) || integrity(data),
+    handle: (data) => sealed.handle(data) || clipboard.handle(data) || requests.handle(data) || integrity(data),
     close: () => sealed.close()
   };
 }
@@ -2514,7 +2667,8 @@ async function createKernel(options = {}) {
   );
   const cdp = cdpBridge(options.cdp);
   const facades = facadeBridge(options.facades);
-  const sealed = hookRelays(worker, options);
+  const bound = /* @__PURE__ */ new Map();
+  const sealed = hookRelays(worker, options, bound);
   const approvals = approver(options.approve, worker);
   const fail = (error) => {
     dials.reset();
@@ -2639,7 +2793,7 @@ async function createKernel(options = {}) {
       return decodedRun(result);
     },
     openTerminal,
-    connect: async (connectOptions = {}) => await call({ op: "connect", ...connectOptions }),
+    connect: connector(call, bound),
     ...accounts(call, options.users === void 0 ? DEFAULT_USERS : options.users),
     setRoutes: async (routes) => void await call({ op: "routes", routes }),
     chmod: async (path, mode) => void await call({ op: "chmod", path, mode }),