@ai-ecoverse/slicc-kernel 1.19.0 → 1.20.0

package/dist/index.js

@@ -1,3 +1,242 @@
+// src/client/dial-stream.ts
+function errorWithCode(message) {
+  const code = /^E[A-Z]+/.exec(message)?.[0];
+  return Object.assign(new Error(message), code ? { code } : {});
+}
+function dialStream(port, onClose) {
+  let closed = false;
+  let reader;
+  const acks = [];
+  const readable = new ReadableStream({
+    start(controller) {
+      reader = controller;
+    },
+    pull() {
+      if (!closed) port.postMessage({ more: true });
+    },
+    cancel() {
+      reader = void 0;
+      close();
+    }
+  });
+  const finish = (fail2) => {
+    const controller = reader;
+    reader = void 0;
+    for (const ack of acks.splice(0)) {
+      if (fail2) ack.reject(fail2);
+      else ack.resolve();
+    }
+    if (!controller) return;
+    if (fail2) controller.error(fail2);
+    else controller.close();
+  };
+  function shut() {
+    if (closed) return;
+    closed = true;
+    port.close();
+    onClose?.();
+  }
+  function close() {
+    if (!closed) port.postMessage({ close: true });
+    shut();
+    finish();
+  }
+  port.addEventListener("message", ({ data }) => {
+    if (data instanceof Uint8Array) reader?.enqueue(data);
+    else if ("ack" in data) acks.shift()?.resolve();
+    else if ("end" in data) finish();
+    else finish(errorWithCode(data.error));
+  });
+  port.start?.();
+  const writable = new WritableStream({
+    write(chunk) {
+      if (closed) throw errorWithCode("EPIPE: the connection is closed");
+      const copy = chunk.slice();
+      const acked = new Promise((resolve, reject) => acks.push({ resolve, reject }));
+      port.postMessage(copy, [copy.buffer]);
+      return acked;
+    },
+    close() {
+      if (!closed) port.postMessage({ end: true });
+    },
+    abort() {
+      close();
+    }
+  });
+  const fail = (error) => {
+    shut();
+    finish(error);
+  };
+  return { readable, writable, close, fail };
+}
+
+// src/client/loopback-fetch.ts
+var OWN_HEADERS = /* @__PURE__ */ new Set(["host", "connection", "content-length", "transfer-encoding"]);
+var encoder = new TextEncoder();
+var latin1 = new TextDecoder("latin1");
+var ByteSource = class {
+  buffered = new Uint8Array(0);
+  reader;
+  constructor(reader) {
+    this.reader = reader;
+  }
+  async more() {
+    const { done, value } = await this.reader.read();
+    if (done) return false;
+    const joined = new Uint8Array(this.buffered.length + value.length);
+    joined.set(this.buffered);
+    joined.set(value, this.buffered.length);
+    this.buffered = joined;
+    return true;
+  }
+  async until(marker) {
+    const needle = encoder.encode(marker);
+    for (; ; ) {
+      const at = indexOf(this.buffered, needle);
+      if (at >= 0) return this.take(at + needle.length);
+      if (!await this.more()) return void 0;
+    }
+  }
+  async some(max) {
+    if (this.buffered.length === 0 && !await this.more()) return void 0;
+    return this.take(Math.min(max, this.buffered.length));
+  }
+  async exactly(count) {
+    while (this.buffered.length < count) if (!await this.more()) return void 0;
+    return this.take(count);
+  }
+  take(count) {
+    const out = this.buffered.slice(0, count);
+    this.buffered = this.buffered.slice(count);
+    return out;
+  }
+};
+function indexOf(haystack, needle) {
+  outer: for (let i = 0; i + needle.length <= haystack.length; i++) {
+    for (let j = 0; j < needle.length; j++) if (haystack[i + j] !== needle[j]) continue outer;
+    return i;
+  }
+  return -1;
+}
+function parseHead(bytes) {
+  const [statusLine = "", ...lines] = latin1.decode(bytes).split("\r\n");
+  const match = /^HTTP\/1\.[01] (\d{3})(?: (.*))?$/.exec(statusLine);
+  if (!match) throw errorWithCode(`EPROTO: not an HTTP/1.x response: ${statusLine.slice(0, 80)}`);
+  const headers = [];
+  for (const line of lines) {
+    const colon = line.indexOf(":");
+    if (colon > 0) headers.push([line.slice(0, colon).trim(), line.slice(colon + 1).trim()]);
+  }
+  return { status: Number(match[1]), statusText: match[2] ?? "", headers };
+}
+function header(head, name) {
+  return head.headers.find(([key]) => key.toLowerCase() === name)?.[1];
+}
+async function* chunked(source) {
+  for (; ; ) {
+    const line = await source.until("\r\n");
+    if (!line) throw errorWithCode("EPROTO: the chunked body ended early");
+    const size = Number.parseInt(latin1.decode(line).trim().split(";")[0] ?? "", 16);
+    if (!Number.isFinite(size)) throw errorWithCode("EPROTO: a malformed chunk size");
+    if (size === 0) return;
+    const data = await source.exactly(size);
+    if (!data || !await source.exactly(2)) throw errorWithCode("EPROTO: a chunk ended early");
+    yield data;
+  }
+}
+async function* counted(source, length) {
+  let left = length;
+  while (left > 0) {
+    const data = await source.some(left);
+    if (!data) throw errorWithCode("EPROTO: the body ended early");
+    left -= data.length;
+    yield data;
+  }
+}
+async function* untilClose(source) {
+  for (let data = await source.some(65536); data; data = await source.some(65536)) yield data;
+}
+function bodyOf(source, head, method) {
+  if (method === "HEAD" || head.status === 204 || head.status === 304) return void 0;
+  if (header(head, "transfer-encoding")?.toLowerCase().includes("chunked")) return chunked(source);
+  const length = header(head, "content-length");
+  if (length === void 0) return untilClose(source);
+  const size = Number(length);
+  if (!/^\d+$/.test(length.trim()) || !Number.isSafeInteger(size)) {
+    throw errorWithCode(`EPROTO: a malformed Content-Length: ${length}`);
+  }
+  return counted(source, size);
+}
+function stream(chunks3, socket, signal) {
+  return new ReadableStream({
+    start(controller) {
+      signal?.addEventListener("abort", () => controller.error(signal.reason), { once: true });
+    },
+    async pull(controller) {
+      try {
+        const next = await chunks3.next();
+        if (next.done) {
+          controller.close();
+          socket.close();
+        } else controller.enqueue(next.value);
+      } catch (err) {
+        controller.error(err);
+        socket.close();
+      }
+    },
+    cancel() {
+      socket.close();
+    }
+  });
+}
+async function requestBytes(request) {
+  const url = new URL(request.url);
+  const body = request.body ? new Uint8Array(await request.arrayBuffer()) : void 0;
+  const lines = [`${request.method} ${url.pathname}${url.search} HTTP/1.1`, `Host: ${url.host}`];
+  request.headers.forEach((value, name) => {
+    if (!OWN_HEADERS.has(name)) lines.push(`${name}: ${value}`);
+  });
+  if (body) lines.push(`Content-Length: ${body.length}`);
+  lines.push("Connection: close", "", "");
+  const head = encoder.encode(lines.join("\r\n"));
+  const out = new Uint8Array(head.length + (body?.length ?? 0));
+  out.set(head);
+  if (body) out.set(body, head.length);
+  return out;
+}
+async function loopbackFetch(dial, input, options) {
+  options.signal?.throwIfAborted();
+  const request = input instanceof Request ? input : new Request(input);
+  const bytes = await requestBytes(request);
+  const socket = await dial({
+    port: options.port,
+    ...options.host ? { host: options.host } : {}
+  });
+  options.signal?.addEventListener("abort", () => socket.close(), { once: true });
+  try {
+    const writer = socket.writable.getWriter();
+    await writer.write(bytes);
+    writer.releaseLock();
+    const source = new ByteSource(socket.readable.getReader());
+    let head;
+    do {
+      const raw = await source.until("\r\n\r\n");
+      if (!raw) throw errorWithCode("ECONNRESET: the connection closed before a response");
+      head = parseHead(raw);
+    } while (head.status >= 100 && head.status < 200);
+    const chunks3 = bodyOf(source, head, request.method);
+    if (!chunks3) socket.close();
+    return new Response(chunks3 ? stream(chunks3, socket, options.signal) : null, {
+      status: head.status,
+      statusText: head.statusText,
+      headers: head.headers
+    });
+  } catch (err) {
+    socket.close();
+    throw err;
+  }
+}
+
 // src/body-idle.ts
 var BODY_IDLE_MS = 5 * 60 * 1e3;
 function idleFailure(ms) {
@@ -277,7 +516,7 @@ var RemoteTransport = class {
 };
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 3];
+var PROTOCOL = [1, 4];
 function locksOf(scope = globalThis) {
   const locks = scope.navigator?.locks;
   return typeof locks?.request === "function" ? locks : void 0;
@@ -304,8 +543,8 @@ var KernelCallError = class extends Error {
     this.code = code;
   }
 };
-var encoder = new TextEncoder();
-var bytesOf = (data) => typeof data === "string" ? encoder.encode(data) : data;
+var encoder2 = new TextEncoder();
+var bytesOf = (data) => typeof data === "string" ? encoder2.encode(data) : data;
 var UNAVAILABLE = {
   manualRedirects: false,
   encodedBodies: false,
@@ -413,6 +652,10 @@ var Channel = class {
     else call.resolve(reply.result);
   }
 };
+async function dialOn(channel, { port, host }) {
+  const req = { op: "dial", port, ...host ? { host } : {} };
+  return dialStream(await since(channel, 4, "dial", () => channel.call(req)));
+}
 async function spawnOn(channel, argv, opts) {
   const { onStdout, onStderr, stdin, group: _, ...rest } = opts;
   if (opts.pgid !== void 0)
@@ -591,6 +834,8 @@ async function attachKernel(port, options = {}) {
       const { signal, ...rest } = req;
       return transport.fetch({ ...rest, signal: signal ?? new AbortController().signal });
     },
+    dial: (options2) => dialOn(channel, options2),
+    loopbackFetch: (input, options2) => loopbackFetch((o) => dialOn(channel, o), input, options2),
     fs: fsOn(channel),
     async close(o = {}) {
       if (channel.failure) return;
@@ -717,7 +962,9 @@ async function checkLocalProxy(options) {
     probe: {
       rawFetch: reply.rawFetch,
       requestBodyStreaming: reply.requestBodyStreaming,
-      maxRequestBodyBytes: reply.maxRequestBodyBytes
+      maxRequestBodyBytes: reply.maxRequestBodyBytes,
+      ...typeof reply.kernelTunnel === "number" ? { kernelTunnel: reply.kernelTunnel } : {},
+      ...typeof reply.kernelPort === "number" ? { kernelPort: reply.kernelPort } : {}
     }
   };
 }
@@ -784,6 +1031,24 @@ function streamer(callback) {
   const decoder = new TextDecoder();
   return (bytes) => callback?.(decoder.decode(bytes, { stream: true }));
 }
+function dialer(call) {
+  const open = /* @__PURE__ */ new Set();
+  const dial = async ({ port, host }) => {
+    let reply;
+    try {
+      reply = await call({ op: "dial", port, ...host ? { host } : {} });
+    } catch (err) {
+      throw errorWithCode(err.message);
+    }
+    const handle = dialStream(reply, () => open.delete(handle));
+    open.add(handle);
+    return handle;
+  };
+  const reset = () => {
+    for (const handle of [...open]) handle.fail(errorWithCode("ECONNRESET: the kernel is gone"));
+  };
+  return { dial, reset };
+}
 async function createKernel(options = {}) {
   if (!globalThis.crossOriginIsolated) throw new Error(ISOLATION);
   const url = options.worker ?? new URL("./kernel-worker.js", import.meta.url);
@@ -791,7 +1056,9 @@ async function createKernel(options = {}) {
   const pending = /* @__PURE__ */ new Map();
   let nextId = 0;
   let failure2;
+  const dials = dialer((req) => call(req));
   const fail = (error) => {
+    dials.reset();
     failure2 = error;
     bridge?.close();
     for (const call2 of pending.values()) call2.reject(error);
@@ -897,6 +1164,7 @@ async function createKernel(options = {}) {
       close: () => send2({ action: "close" })
     };
   }
+  const { dial } = dials;
   await call({
     op: "init",
     ...options.root ? { root: options.root } : {},
@@ -928,6 +1196,8 @@ async function createKernel(options = {}) {
     },
     openTerminal,
     connect: async () => await call({ op: "connect" }),
+    dial,
+    loopbackFetch: (input, fetchOptions) => loopbackFetch(dial, input, fetchOptions),
     mount: async (spec) => await call({ op: "mount", spec }),
     umount: async (target) => void await call({ op: "umount", target }),
     mounts: async () => await call({ op: "mounts" }),