@ai-ecoverse/slicc-kernel 1.89.0 → 1.91.0

package/dist/process-worker.js

@@ -255,6 +255,10 @@ var init_protocol = __esm({
 });
 
 // src/kernel/net/loopback-names.ts
+function isKernelLoopbackHost(hostname) {
+  const host = hostname.replace(/^\[(.*)\]$/, "$1").replace(/\.$/, "").toLowerCase();
+  return host === "localhost" || host.endsWith(".localhost") || host === "0.0.0.0" || LOOPBACK_V4.test(host) || LOOPBACK_V6.has(host) || MAPPED_V4.test(host);
+}
 function reserved(name2) {
   const lower = name2.toLowerCase();
   return lower === "localhost" || lower.endsWith(".localhost") || lower === HOST_LOOPBACK || lower === "wasmer.sh" || /^\d+(\.\d+){3}$/.test(lower);
@@ -278,7 +282,7 @@ function hostsFile(hostname = DEFAULT_HOSTNAME) {
     ""
   ].join("\n");
 }
-var HOST_LOOPBACK, HOST_LOOPBACK_ADDRESS, PAGE_LOOPBACK, PAGE_LOOPBACK_URL, DEFAULT_HOSTNAME, HOSTNAME_ADDRESS, LIBC_HOSTNAMES, LABEL;
+var HOST_LOOPBACK, HOST_LOOPBACK_ADDRESS, PAGE_LOOPBACK, PAGE_LOOPBACK_URL, LOOPBACK_V4, LOOPBACK_V6, MAPPED_V4, DEFAULT_HOSTNAME, HOSTNAME_ADDRESS, LIBC_HOSTNAMES, LABEL;
 var init_loopback_names = __esm({
   "src/kernel/net/loopback-names.ts"() {
     "use strict";
@@ -286,6 +290,9 @@ var init_loopback_names = __esm({
     HOST_LOOPBACK_ADDRESS = [10, 0, 2, 2];
     PAGE_LOOPBACK = "kernel.localhost";
     PAGE_LOOPBACK_URL = `http://{port}.${PAGE_LOOPBACK}`;
+    LOOPBACK_V4 = /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+    LOOPBACK_V6 = /* @__PURE__ */ new Set(["::1", "::", "0:0:0:0:0:0:0:1"]);
+    MAPPED_V4 = /^::ffff:7f[0-9a-f]{2}:[0-9a-f]{1,4}$/;
     DEFAULT_HOSTNAME = "slicc";
     HOSTNAME_ADDRESS = "127.0.1.1";
     LIBC_HOSTNAMES = ["emscripten", "wasmer.sh"];
@@ -1942,6 +1949,50 @@ function useLiveChown(Fs) {
     Fs.chown(target, uid, gid);
   };
 }
+function flushOne(Fs, node) {
+  const s = node.live;
+  if (!s.dirty || s.orphan || !(s.data || s.ranged)) return;
+  try {
+    if (s.ranged) s.ranged.flush();
+    else {
+      const bytes = s.data.slice(0, s.len);
+      pinnedIo(node.mount.opts.bridge, s.handle).writeFile(liveNodePath(node), bytes, true);
+    }
+  } catch (err) {
+    throw toErrno(Fs, err);
+  }
+  s.dirty = false;
+  s.stat = void 0;
+}
+function linkable(bridge, path) {
+  try {
+    return bridge.lstat(path).linkable === true;
+  } catch {
+    return false;
+  }
+}
+function linkLive(Fs, from, to, follow2) {
+  const target = to.replace(/\/+$/, "");
+  const slash = target.lastIndexOf("/");
+  const name2 = target.slice(slash + 1);
+  const source = Fs.lookupPath(from, { follow: follow2 }).node;
+  const parent = Fs.lookupPath(target.slice(0, slash) || "/", { follow: true }).node;
+  if (!source.live || !parent.live) return false;
+  flushOne(Fs, source);
+  const base = liveNodePath(parent);
+  const bridge = source.mount.opts.bridge;
+  const path = liveNodePath(source);
+  try {
+    bridge.link(path, base === "/" ? `/${name2}` : `${base}/${name2}`);
+  } catch (err) {
+    const refused = toErrno(Fs, err);
+    if (refused.errno !== wasiErrno("EPERM") || linkable(bridge, path)) throw refused;
+    throw new Fs.ErrnoError(wasiErrno("EMLINK"));
+  }
+  source.live.stat = void 0;
+  parent.live.listed = void 0;
+  return true;
+}
 function readingLinks(Fs) {
   const readlink = Fs.readlink?.bind(Fs);
   if (!readlink) return;
@@ -3302,6 +3353,32 @@ function kernelAccess(imports, fs, memory, glue) {
     }
   });
 }
+function kernelLink(imports, fs, memory, glue) {
+  wrapImport(
+    imports,
+    "linkat",
+    glue,
+    (own) => (olddirfd, oldpath, newdirfd, newpath, flags) => {
+      const Fs = fs();
+      const heap = memory();
+      if (!Fs?.lookupPath || !heap) return own(olddirfd, oldpath, newdirfd, newpath, flags);
+      const at = (dirfd, ptr) => {
+        const name2 = cString(heap, ptr);
+        return name2.startsWith("/") ? name2 : `${baseOf(Fs, dirfd)}/${name2}`;
+      };
+      try {
+        const from = at(olddirfd, oldpath);
+        const to = at(newdirfd, newpath);
+        const follow2 = (flags & AT_SYMLINK_FOLLOW) !== 0;
+        if (linkLive(Fs, from, to, follow2)) return 0;
+      } catch (err) {
+        return -errnoOf(err);
+      }
+      return own(olddirfd, oldpath, newdirfd, newpath, flags);
+    },
+    true
+  );
+}
 function kernelChdir(Fs) {
   const { chdir, lookupPath, ErrnoError } = Fs;
   if (!chdir || !lookupPath || !ErrnoError) return;
@@ -3329,7 +3406,7 @@ function linuxDevices(Fs) {
     }
   }
 }
-var O_CLOEXEC, FD_CLOEXEC, F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_DUPFD_CLOEXEC, tracked, IMPORT_NAMES, EBADF, AT_SYMLINK_NOFOLLOW, EMSCRIPTEN_EPERM, O_PATH2, LITERALS, UTIME_NOW, UTIME_OMIT, PROT_WRITE, MAP_PRIVATE, MAP_TYPE, O_WRONLY, MAP_ALIGN, DIR_MODE, LINK_MODE, CHAR_DEVICE, O_ACCMODE2, O_CREAT2, field, pinnedRoot, rootKind, NAME, AT_FDCWD, AT_EACCESS, W_ACCESS, X_ACCESS, DEVICE_MODES;
+var O_CLOEXEC, FD_CLOEXEC, F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_DUPFD_CLOEXEC, tracked, IMPORT_NAMES, EBADF, AT_SYMLINK_NOFOLLOW, EMSCRIPTEN_EPERM, O_PATH2, LITERALS, UTIME_NOW, UTIME_OMIT, PROT_WRITE, MAP_PRIVATE, MAP_TYPE, O_WRONLY, MAP_ALIGN, DIR_MODE, LINK_MODE, CHAR_DEVICE, O_ACCMODE2, O_CREAT2, field, pinnedRoot, rootKind, NAME, AT_FDCWD, AT_EACCESS, W_ACCESS, X_ACCESS, AT_SYMLINK_FOLLOW, DEVICE_MODES;
 var init_process_fds = __esm({
   "src/process/process-fds.ts"() {
     "use strict";
@@ -3364,6 +3441,7 @@ var init_process_fds = __esm({
       mknodat: "__syscall_mknodat",
       umask: "__syscall_umask",
       faccessat: "__syscall_faccessat",
+      linkat: "__syscall_linkat",
       utimensat: "__syscall_utimensat",
       getppid: "slicc_getppid_js",
       resizeHeap: "emscripten_resize_heap",
@@ -3390,6 +3468,7 @@ var init_process_fds = __esm({
     AT_EACCESS = 512;
     W_ACCESS = 2;
     X_ACCESS = 1;
+    AT_SYMLINK_FOLLOW = 1024;
     DEVICE_MODES = [
       ["/", 493],
       ["/dev", 493],
@@ -3690,12 +3769,12 @@ function anySelect(Fs, transport, read2, write2, timeoutMs) {
   const kernelRead = read2.filter((fd) => !own(fd));
   const kernelWrite = write2.filter((fd) => !own(fd));
   for (; ; ) {
-    const local2 = ownReady(Fs, read2.filter(own), write2.filter(own));
-    const pending = local2.read.length > 0 || local2.write.length > 0;
+    const local3 = ownReady(Fs, read2.filter(own), write2.filter(own));
+    const pending = local3.read.length > 0 || local3.write.length > 0;
     const slice = pending ? 0 : Math.min(SELECT_SLICE_MS, Math.max(0, deadline - Date.now()));
     const got = kernelSelect(Fs, transport, kernelRead, kernelWrite, slice);
     if (typeof got === "number") return got;
-    const ready = { read: [...local2.read, ...got.read], write: [...local2.write, ...got.write] };
+    const ready = { read: [...local3.read, ...got.read], write: [...local3.write, ...got.write] };
     if (ready.read.length > 0 || ready.write.length > 0 || Date.now() >= deadline) {
       return ready;
     }
@@ -4213,7 +4292,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.89.0" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.91.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -4884,6 +4963,7 @@ function kernelWrappers(imports, module, deps) {
   const fsOf = () => ownValue(module, "FS");
   noFollowUtimes(imports, fsOf, kernelGlue?.utimensat ?? utimensatOf(module), memory);
   kernelAccess(imports, fsOf, memory, kernelGlue);
+  kernelLink(imports, fsOf, memory, kernelGlue);
   const glue = ownValue(module, "sliccFdImports");
   syncFsync(imports, fsOf, glue);
   positionalIo(imports, { glue, fs: fsOf, sys, memory });
@@ -5182,6 +5262,7 @@ var init_process_runtime = __esm({
       "  mknodat: typeof ___syscall_mknodat === 'function' ? ___syscall_mknodat : undefined,",
       "  umask: typeof ___syscall_umask === 'function' ? ___syscall_umask : undefined,",
       "  faccessat: typeof ___syscall_faccessat === 'function' ? ___syscall_faccessat : undefined,",
+      "  linkat: typeof ___syscall_linkat === 'function' ? ___syscall_linkat : undefined,",
       "  utimensat: typeof ___syscall_utimensat === 'function' ? ___syscall_utimensat : undefined,",
       "  getppid: typeof _slicc_getppid_js === 'function' ? _slicc_getppid_js : undefined,",
       "  resizeHeap: typeof _emscripten_resize_heap === 'function' ? _emscripten_resize_heap : undefined,",
@@ -6747,34 +6828,40 @@ function readyEvents(subs, ready) {
     hangup: ready.hangup?.includes(s.fd) === true
   }));
 }
+function selectOnce(deps, read2, write2, timeoutMs) {
+  try {
+    const ready = deps.kernel.call({ op: "fd-select", read: read2, write: write2, timeoutMs });
+    return { ready, interrupted: false };
+  } catch (e) {
+    if (!deps.interruptWakes || e.code !== "EINTR") throw e;
+    return { ready: { read: [], write: [] }, interrupted: true };
+  }
+}
+function waitEvents(deps, subs, { events, read: read2, write: write2 }, entered) {
+  const earliest = subs.reduce((min, s) => Math.min(min, s.deadline), Infinity);
+  const timeout = () => {
+    if (events.length > 0 || entered) return 0;
+    return earliest === Infinity ? -1 : Math.max(0, Math.ceil(earliest - performance.now()));
+  };
+  for (; ; ) {
+    const { ready, interrupted } = selectOnce(deps, read2, write2, timeout());
+    events.push(...readyEvents(subs, ready));
+    if (interrupted) return true;
+    if (events.length > 0 || entered || earliest === Infinity) return false;
+    if (performance.now() >= earliest) return false;
+  }
+}
 function pollOneoff(deps, inPtr, outPtr, nsubs, neventsPtr) {
   if (nsubs === 0) return E.INVAL;
-  const { mem, kernel } = deps;
+  const { mem } = deps;
   const subs = readSubscriptions(mem, inPtr, nsubs, deps.now);
-  const { events, read: read2, write: write2 } = classify(deps.fds, subs);
-  let interrupted = false;
-  const earliest = subs.reduce((min, s) => Math.min(min, s.deadline), Infinity);
-  const expired = () => performance.now() >= earliest;
-  if (read2.length > 0 || write2.length > 0 || events.length === 0) {
-    do {
-      let timeoutMs = -1;
-      if (events.length > 0) timeoutMs = 0;
-      else if (earliest !== Infinity)
-        timeoutMs = Math.max(0, Math.ceil(earliest - performance.now()));
-      let ready;
-      try {
-        ready = kernel.call({ op: "fd-select", read: read2, write: write2, timeoutMs });
-      } catch (e) {
-        if (!deps.interruptWakes || e.code !== "EINTR") throw e;
-        interrupted = true;
-        ready = { read: [], write: [] };
-      }
-      events.push(
-        ...readyEvents(subs, ready)
-      );
-    } while (events.length === 0 && !interrupted && earliest !== Infinity && !expired());
-  }
+  const found = classify(deps.fds, subs);
+  const { events, read: read2, write: write2 } = found;
+  const entered = deps.entered === true && deps.interruptWakes !== true;
+  const waits = read2.length > 0 || write2.length > 0 || events.length === 0;
+  const interrupted = waits && waitEvents(deps, subs, found, entered);
   const after = performance.now();
+  if (entered && events.length === 0 && !subs.some((s) => s.deadline <= after)) return E.INTR;
   for (const s of subs) {
     if (s.type === EVENTTYPE.CLOCK && (interrupted || s.deadline <= after)) {
       events.push({ userdata: s.userdata, error: E.SUCCESS, type: s.type });
@@ -6980,6 +7067,7 @@ var init_wasi_host = __esm({
       cache;
       startCwd;
       interruptWakes = false;
+      entered = false;
       onRaise;
       muted;
       signals;
@@ -7203,7 +7291,8 @@ var init_wasi_host = __esm({
               fds: this.fds,
               kernel: this.o.kernel,
               now: (id) => this.now(id),
-              interruptWakes: this.interruptWakes
+              interruptWakes: this.interruptWakes,
+              entered: this.entered
             },
             inPtr,
             outPtr,
@@ -7220,7 +7309,7 @@ var init_wasi_host = __esm({
           this.mem.view().setUint32(nevents, 0, true);
           if (mask.deliverUnblocked()) return E.INTR;
           if (n > 0) return this.poll(inPtr, outPtr, n, nevents);
-          return this.suspend();
+          return this.entered ? E.INTR : this.suspend();
         } finally {
           mask.deliverUnblocked();
           mask.restore(old);
@@ -10527,10 +10616,8 @@ var init_wasix_host = __esm({
             const v = mem.view();
             const timed = timeoutPtr !== 0 && v.getUint8(timeoutPtr) === 1;
             const ms = timed ? Number(v.getBigUint64(timeoutPtr + 8, true)) / 1e6 : Number.POSITIVE_INFINITY;
-            v.setUint8(
-              wokenPtr,
-              futexWait(i32(), ptr >> 2, expected | 0, ms, host.interrupted) ? 1 : 0
-            );
+            const woken = host.entered || futexWait(i32(), ptr >> 2, expected | 0, ms, host.interrupted);
+            v.setUint8(wokenPtr, woken ? 1 : 0);
           },
           futex_wake: (ptr, wokenPtr) => {
             Atomics.notify(i32(), ptr >> 2, 1);
@@ -10698,9 +10785,10 @@ function delivering(ns, table, host, driver, before) {
     }
     const fn = value2;
     out[name2] = (...args) => {
+      host.entered = false;
       if (driver.idle) {
         before?.();
-        host.interrupted?.();
+        host.entered = host.interrupted?.() === true;
       }
       return fn(...args);
     };
@@ -12309,11 +12397,20 @@ function plain(status2, text) {
     headers: { "content-type": "text/plain; charset=utf-8" }
   });
 }
+function local2(url) {
+  return isKernelLoopbackHost(new URL(url).hostname);
+}
 function rewrite(hop, status2, location) {
   const next2 = new URL(location, hop.url);
   if (next2.protocol !== "http:" && next2.protocol !== "https:") {
     throw failed3(new JsCallError("EPROTONOSUPPORT", next2.protocol));
   }
+  if (local2(next2.href) && !local2(hop.url)) {
+    const from = new URL(hop.url).origin;
+    throw failed3(
+      new JsCallError("EACCES", `a redirect from ${from} into the kernel's loopback: ${next2.href}`)
+    );
+  }
   const toGet = (status2 === 301 || status2 === 302) && hop.method === "POST" || status2 === 303 && hop.method !== "GET" && hop.method !== "HEAD";
   const crossOrigin = next2.origin !== new URL(hop.url).origin;
   const headers = hop.headers.filter(
@@ -12482,13 +12579,15 @@ async function bodyOf(request, cap, signal) {
   return out;
 }
 function fetchOp(kernel) {
-  let traits;
-  const traitsOf = () => {
-    traits ??= kernel.json({ op: "net-traits" });
-    traits.catch(() => {
-      traits = void 0;
+  const traits = /* @__PURE__ */ new Map();
+  const traitsOf = (url) => {
+    const own = local2(url);
+    const known = traits.get(own) ?? kernel.json({ op: "net-traits", url });
+    traits.set(own, known);
+    known.catch(() => {
+      traits.delete(own);
     });
-    return traits;
+    return known;
   };
   const close = (handle) => kernel.raw({ op: "net-close", handle });
   const send = async (hop, signal) => {
@@ -12575,6 +12674,13 @@ function fetchOp(kernel) {
     });
     return withMeta(response, head.url, redirected);
   };
+  const traitsAt = (at) => traitsOf(at).catch((err) => {
+    throw failed3(err);
+  });
+  const redirect = async (hop, status2, location, known) => {
+    const next2 = rewrite(hop, status2, location);
+    return [next2, local2(next2.url) === local2(hop.url) ? known : await traitsAt(next2.url)];
+  };
   return async (input, init) => {
     const request = new Request(input, init);
     const { signal } = request;
@@ -12584,9 +12690,7 @@ function fetchOp(kernel) {
     if (protocol !== "http:" && protocol !== "https:") {
       throw failed3(new JsCallError("EPROTONOSUPPORT", protocol));
     }
-    const known = await traitsOf().catch((err) => {
-      throw failed3(err);
-    });
+    let known = await traitsAt(request.url);
     if (!known.manualRedirects && request.redirect !== "follow") {
       throw failed3(new JsCallError("ENOTSUP", `redirect: ${request.redirect}`));
     }
@@ -12612,7 +12716,7 @@ function fetchOp(kernel) {
       await close(head.handle);
       if (request.redirect === "error") throw failed3(new JsCallError("EREDIRECT", hop.url));
       if (hops >= MAX_REDIRECTS) throw failed3(new JsCallError("ELOOP", hop.url));
-      hop = rewrite(hop, head.status, location);
+      [hop, known] = await redirect(hop, head.status, location, known);
     }
   };
 }
@@ -12620,6 +12724,7 @@ var CHUNK2, MAX_REDIRECTS, NULL_BODY, REDIRECTS, BODY_HEADERS, DECODED, CREDENTI
 var init_js_fetch = __esm({
   "src/process/js/js-fetch.ts"() {
     "use strict";
+    init_loopback_names();
     init_js_kernel();
     CHUNK2 = 64 * 1024;
     MAX_REDIRECTS = 20;
@@ -12659,7 +12764,7 @@ function port(n) {
 function netOps(kernel, io) {
   const name2 = async (fd, peer) => addressOf(await kernel.json({ op: "sock-name", fd, peer }));
   const connection = async (fd) => {
-    const [local2, remote] = [await name2(fd, false), await name2(fd, true)];
+    const [local3, remote] = [await name2(fd, false), await name2(fd, true)];
     const stop = new AbortController();
     let closed;
     const close = () => {
@@ -12684,7 +12789,7 @@ function netOps(kernel, io) {
       close: async () => void await shut(SHUT_WR),
       abort: () => close()
     });
-    return { fd, local: local2, remote, readable: readable3, writable: writable2, close };
+    return { fd, local: local3, remote, readable: readable3, writable: writable2, close };
   };
   const resolve = async (host, signal) => {
     if (IPV4.test(host)) return host;