@ai-ecoverse/slicc-kernel 1.26.6 → 1.28.0

package/dist/index.js

@@ -282,6 +282,204 @@ async function loopbackFetch(dial, input, options) {
   }
 }
 
+// src/kernel/net/loopback-names.ts
+var HOST_LOOPBACK = "host.slicc.internal";
+var HOST_LOOPBACK_ADDRESS = [10, 0, 2, 2];
+var PAGE_LOOPBACK = "kernel.localhost";
+var PAGE_LOOPBACK_URL = `http://{port}.${PAGE_LOOPBACK}`;
+
+// src/kernel/net/routes.ts
+var HOST_ADDRESS = HOST_LOOPBACK_ADDRESS.join(".");
+function ipv4Bytes(text) {
+  const parts = text.split(".");
+  if (parts.length !== 4 || !parts.every((p) => /^\d{1,3}$/.test(p))) return void 0;
+  const bytes = parts.map(Number);
+  return bytes.every((b) => b <= 255) ? bytes : void 0;
+}
+function ipv6Groups(text) {
+  if (!text.includes(":")) return void 0;
+  let canonical;
+  try {
+    canonical = new URL(`http://[${text}]/`).hostname.slice(1, -1);
+  } catch {
+    return void 0;
+  }
+  const [head, tail] = canonical.split("::");
+  const part = (s) => s ? s.split(":").map((h) => Number.parseInt(h, 16)) : [];
+  const front = part(head);
+  const back = part(tail);
+  return tail === void 0 ? front : [...front, ...new Array(8 - front.length - back.length).fill(0), ...back];
+}
+function toBits(values, width) {
+  return values.reduce((acc, v) => acc << BigInt(width) | BigInt(v), 0n);
+}
+function addressBits(host) {
+  const v4 = ipv4Bytes(host);
+  if (v4) return { v6: false, bits: toBits(v4, 8) };
+  const v6 = ipv6Groups(host);
+  return v6 ? { v6: true, bits: toBits(v6, 16) } : void 0;
+}
+function parsePrefix(text) {
+  const parts = text.trim().split("/");
+  if (parts.length > 2) return void 0;
+  const [address = "", size] = parts;
+  const parsed = addressBits(address);
+  if (!parsed) return void 0;
+  const max = parsed.v6 ? 128 : 32;
+  const length = size === void 0 ? max : /^\d{1,3}$/.test(size) ? Number(size) : -1;
+  if (length < 0 || length > max) return void 0;
+  return { ...parsed, length };
+}
+function within(prefix, addr) {
+  if (prefix.v6 !== addr.v6) return false;
+  const shift = BigInt((prefix.v6 ? 128 : 32) - prefix.length);
+  return addr.bits >> shift === prefix.bits >> shift;
+}
+var RESERVED = [
+  "0.0.0.0/8",
+  "127.0.0.0/8",
+  "169.254.0.0/16",
+  "224.0.0.0/4",
+  "240.0.0.0/4",
+  "::/96",
+  "::ffff:0:0/96",
+  "fe80::/10",
+  "ff00::/8"
+].map((p) => parsePrefix(p));
+var Routes = class {
+  table = [];
+  exit = false;
+  ipv6;
+  constructor(ipv6 = false) {
+    this.ipv6 = ipv6;
+  }
+  set(table) {
+    const parsed = (table.prefixes ?? []).map(parsePrefix);
+    const bad = (table.prefixes ?? []).find((_, i) => !parsed[i]);
+    if (bad !== void 0) throw new Error(`not an address prefix: ${bad}`);
+    this.table = parsed;
+    this.exit = table.exit === true;
+  }
+  classify(host) {
+    const name = host.toLowerCase().replace(/\.$/, "");
+    if (name === "localhost" || name.endsWith(".localhost") || name === "0.0.0.0") {
+      return "loopback";
+    }
+    if (name === HOST_LOOPBACK || name === HOST_ADDRESS) return "host";
+    const addr = addressBits(name);
+    if (!addr) return "unreachable";
+    if (addr.v6 && addr.bits === 1n) return "loopback";
+    if (!addr.v6 && addr.bits >> 24n === 127n) return "loopback";
+    if (RESERVED.some((p) => within(p, addr))) return "reserved";
+    if (addr.v6 && !this.ipv6) return "unreachable";
+    if (this.exit || this.table.some((p) => within(p, addr))) return "uplink";
+    return "unreachable";
+  }
+};
+
+// src/kernel/net/uplink.ts
+function answerOf(result) {
+  const answer = Array.isArray(result) ? { addresses: result } : result;
+  const addresses = Array.isArray(answer?.addresses) ? answer.addresses.filter((a) => typeof a === "string") : [];
+  return {
+    addresses,
+    ...typeof answer?.ttl === "number" && answer.ttl >= 0 ? { ttl: answer.ttl } : {}
+  };
+}
+function failure(uid, e) {
+  const code = e?.code;
+  return {
+    uplink: "error",
+    uid,
+    message: e instanceof Error ? e.message : String(e),
+    ...typeof code === "string" ? { code } : {}
+  };
+}
+var NEVER = new Routes(true);
+function serveUplink(peer, uplink) {
+  const conns = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  let nextCid = 0;
+  let closed = false;
+  const run = (uid, work) => {
+    const abort = new AbortController();
+    pending.set(uid, abort);
+    void work(abort.signal).then(
+      (reply) => reply && peer.postMessage(reply, transferOf(reply)),
+      (e) => peer.postMessage(failure(uid, e))
+    ).finally(() => pending.delete(uid));
+  };
+  const conn = (cid) => {
+    const found = conns.get(cid);
+    if (!found) throw Object.assign(new Error("no such uplink connection"), { code: "EBADF" });
+    return found;
+  };
+  const dial = async (call, signal) => {
+    const kind = NEVER.classify(call.host);
+    if (kind === "loopback" || kind === "host" || kind === "reserved") {
+      throw Object.assign(new Error(`the uplink does not carry ${call.host}`), {
+        code: "ENETUNREACH"
+      });
+    }
+    const { host, port } = call;
+    const opened = await uplink.dial({ network: "tcp", host, port, signal });
+    if (signal.aborted || closed) {
+      opened.close();
+      return void 0;
+    }
+    const cid = ++nextCid;
+    conns.set(cid, opened);
+    const { localAddr, remoteAddr } = opened;
+    return { uplink: "dialled", uid: call.uid, cid, localAddr, remoteAddr };
+  };
+  const drop = (cid) => {
+    const found = conns.get(cid);
+    conns.delete(cid);
+    found?.close();
+  };
+  return {
+    answer(call) {
+      switch (call.uplink) {
+        case "resolve":
+          return run(call.uid, async (signal) => ({
+            uplink: "resolved",
+            uid: call.uid,
+            ...answerOf(await uplink.resolve(call.name, call.family, signal))
+          }));
+        case "dial":
+          return run(call.uid, (signal) => dial(call, signal));
+        case "cancel":
+          return pending.get(call.uid)?.abort();
+        case "read":
+          return run(call.uid, async () => ({
+            uplink: "data",
+            uid: call.uid,
+            bytes: (await conn(call.cid).read())?.slice() ?? null
+          }));
+        case "write":
+          return run(call.uid, async () => ({
+            uplink: "written",
+            uid: call.uid,
+            n: await conn(call.cid).write(call.bytes)
+          }));
+        case "close-write":
+          return conns.get(call.cid)?.closeWrite();
+        default:
+          return drop(call.cid);
+      }
+    },
+    close() {
+      closed = true;
+      for (const abort of pending.values()) abort.abort();
+      for (const cid of [...conns.keys()]) drop(cid);
+    }
+  };
+}
+function transferOf(reply) {
+  if (reply.uplink !== "data" || !reply.bytes) return void 0;
+  return [reply.bytes.buffer];
+}
+
 // src/body-idle.ts
 var BODY_IDLE_MS = 5 * 60 * 1e3;
 function idleFailure(ms) {
@@ -561,7 +759,7 @@ var RemoteTransport = class {
 };
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 5];
+var PROTOCOL = [1, 7];
 function locksOf(scope = globalThis) {
   const locks = scope.navigator?.locks;
   return typeof locks?.request === "function" ? locks : void 0;
@@ -657,8 +855,8 @@ var Channel = class {
   }
   request(call, handlers = {}) {
     const id = ++this.nextId;
-    const { failure: failure2 } = this;
-    if (failure2) return { id, done: Promise.reject(failure2) };
+    const { failure: failure3 } = this;
+    if (failure3) return { id, done: Promise.reject(failure3) };
     const done = new Promise((resolve, reject) => {
       this.pending.set(id, { resolve, reject, ...handlers });
       this.port.postMessage({ ...call, id });
@@ -938,7 +1136,7 @@ var MAX_HEAD = 1024 * 1024;
 var MAX_REQUEST_BODY2 = 64 * 1024 * 1024;
 var PERMISSIONS = ["loopback-network", "local-network-access"];
 var LOOPBACK_PAGE = /^(127\.\d+\.\d+\.\d+|localhost|\[::1\])$/;
-var failure = (message, status = 502) => Object.assign(new Error(`local proxy: ${message}`), { status });
+var failure2 = (message, status = 502) => Object.assign(new Error(`local proxy: ${message}`), { status });
 function encodeHead(url, method, headers) {
   return JSON.stringify({ url, method, headers }).replace(
     /[\u007f-￿]/g,
@@ -961,7 +1159,7 @@ async function refusalMessage(response) {
   return text || response.statusText || `answered ${response.status}`;
 }
 async function refusal(response) {
-  return failure(await refusalMessage(response), response.ok ? 502 : response.status);
+  return failure2(await refusalMessage(response), response.ok ? 502 : response.status);
 }
 async function permission(permissions) {
   if (!permissions) return "unknown";
@@ -990,19 +1188,19 @@ async function readHead(reader, idleMs) {
   for (; ; ) {
     if (buffer.byteLength >= 4) {
       const length = new DataView(buffer.buffer, buffer.byteOffset, 4).getUint32(0);
-      if (length > MAX_HEAD) throw failure(`response head of ${length} bytes`);
+      if (length > MAX_HEAD) throw failure2(`response head of ${length} bytes`);
       if (buffer.byteLength >= 4 + length) {
         let head;
         try {
           head = JSON.parse(new TextDecoder().decode(buffer.subarray(4, 4 + length)));
         } catch {
         }
-        if (!isHead(head)) throw failure("malformed response head");
+        if (!isHead(head)) throw failure2("malformed response head");
         return { head, rest: buffer.subarray(4 + length) };
       }
     }
     const next = await readWithin(reader, idleMs);
-    if (next.done) throw failure("closed before the response head");
+    if (next.done) throw failure2("closed before the response head");
     buffer = concat2(buffer, next.value);
   }
 }
@@ -1082,7 +1280,7 @@ function localProxyTransport(options) {
         });
       } catch (e) {
         if (request.signal.aborted) throw e;
-        throw failure(`${endpoint.origin} is unreachable or refuses this origin`);
+        throw failure2(`${endpoint.origin} is unreachable or refuses this origin`);
       }
       const type = response.headers.get("content-type") ?? "";
       if (response.status !== 200 || !type.startsWith(RAW_CONTENT_TYPE) || !response.body) {
@@ -1136,6 +1334,11 @@ function dialer(call) {
   };
   return { dial, reset };
 }
+function uplinkInit(uplink) {
+  if (!uplink) return {};
+  const traits = { tcp: true, udp: false, ipv6: uplink.traits.ipv6 === true };
+  return { uplink: { traits, ...uplink.routes ? { routes: uplink.routes } : {} } };
+}
 function initCall(options, transport) {
   return {
     op: "init",
@@ -1146,6 +1349,7 @@ function initCall(options, transport) {
     ...options.media !== void 0 ? { media: options.media } : {},
     ...options.ca !== void 0 ? { ca: options.ca } : {},
     ...transport ? { transport: transport.traits } : {},
+    ...uplinkInit(options.network?.uplink),
     ...options.hostfs ? { hostfs: true } : {},
     ...options.cdp ? { cdp: true } : {},
     ...options.processMounts !== void 0 ? {
@@ -1177,19 +1381,22 @@ async function createKernel(options = {}) {
   const worker = new Worker(url, { type: "module", name: "slicc-kernel" });
   const pending = /* @__PURE__ */ new Map();
   let nextId = 0;
-  let failure2;
+  let failure3;
   const dials = dialer((req) => call(req));
   const cdp = cdpBridge(options.cdp);
   const fail = (error) => {
     dials.reset();
     cdp.close();
-    failure2 = error;
+    failure3 = error;
     bridge?.close();
+    uplinks?.close();
     for (const call2 of pending.values()) call2.reject(error);
     pending.clear();
   };
   const transport = options.network?.transport;
   const bridge = transport ? serveTransport(worker, transport) : void 0;
+  const uplink = options.network?.uplink;
+  const uplinks = uplink ? serveUplink(worker, uplink) : void 0;
   async function chosen(handle) {
     if (handle) {
       const state = await handle.requestPermission?.({ mode: "readwrite" });
@@ -1228,6 +1435,7 @@ async function createKernel(options = {}) {
       data
     }) => {
       if ("net" in data) return bridge?.answer(data);
+      if ("uplink" in data) return uplinks?.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);
@@ -1247,7 +1455,7 @@ async function createKernel(options = {}) {
   });
   function request(req, handlers = {}) {
     const id = ++nextId;
-    if (failure2) return { id, done: Promise.reject(failure2) };
+    if (failure3) return { id, done: Promise.reject(failure3) };
     const done = new Promise((resolve, reject) => {
       pending.set(id, { resolve, reject, ...handlers });
       worker.postMessage({ ...req, id });
@@ -1309,6 +1517,7 @@ async function createKernel(options = {}) {
     },
     openTerminal,
     connect: async () => await call({ op: "connect" }),
+    setRoutes: async (routes) => void await call({ op: "routes", routes }),
     dial,
     loopbackFetch: (input, fetchOptions) => loopbackFetch(dial, input, fetchOptions),
     mount: async (spec) => await call({ op: "mount", spec }),