@ai-ecoverse/slicc-kernel 1.110.7 → 1.111.0

package/dist/process-worker.js

@@ -2515,7 +2515,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.110.7" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.111.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -8344,6 +8344,7 @@ function decodeReceived(raw) {
   const length = view.getUint8(3);
   return {
     truncated: (view.getUint8(0) & 1) !== 0,
+    unix: (view.getUint8(0) & 2) !== 0,
     port: view.getUint16(1),
     host: new TextDecoder().decode(raw.subarray(4, 4 + length)),
     bytes: raw.subarray(4 + length)
@@ -8480,7 +8481,7 @@ function ipv4(host) {
 }
 function openRequest(af, type) {
   if (af !== INET4 && af !== INET6 && af !== UNIX) throw new WasiError("EAFNOSUPPORT");
-  if (type !== STREAM && (type !== DGRAM || af === UNIX)) throw new WasiError("EPROTONOSUPPORT");
+  if (type !== STREAM && type !== DGRAM) throw new WasiError("EPROTONOSUPPORT");
   const domain = af === UNIX ? "unix" : "inet";
   return {
     op: "sock-open",
@@ -8488,6 +8489,16 @@ function openRequest(af, type) {
     ...type === DGRAM ? { type: "dgram" } : {}
   };
 }
+function pairRequest(af, type) {
+  if (af !== UNIX)
+    throw new WasiError(af === INET4 || af === INET6 ? "EOPNOTSUPP" : "EAFNOSUPPORT");
+  if (type !== STREAM && type !== DGRAM) throw new WasiError("EPROTONOSUPPORT");
+  return {
+    op: "sock-pair",
+    domain: "unix",
+    ...type === DGRAM ? { type: "dgram" } : {}
+  };
+}
 function absolute(cwd, addr) {
   if (addr.family !== "unix" || addr.path === "" || addr.path.startsWith("\0")) return addr;
   return addr.path.startsWith("/") ? addr : { family: "unix", path: `${cwd}/${addr.path}` };
@@ -8508,12 +8519,13 @@ function datagramCalls(host) {
       const view = mem.view();
       view.setUint32(outLen, mem.scatter(iovs, n, got.bytes), true);
       view.setUint16(outFlags, got.truncated ? RECV_DATA_TRUNCATED : 0, true);
-      if (outAddr)
-        writeAddr(mem.view(), outAddr, { family: "inet", host: got.host, port: got.port });
+      const from = got.unix ? { family: "unix", path: got.host } : { family: "inet", host: got.host, port: got.port };
+      if (outAddr) writeAddr(mem.view(), outAddr, from);
       return E.SUCCESS;
     },
     sendTo(fd, nonblock, iovs, n, addr, out) {
-      const to = optionalAddr(mem.view(), addr);
+      const named = optionalAddr(mem.view(), addr);
+      const to = named && absolute(host.cwd, named);
       const body = mem.gather(iovs, n);
       const sent = call2({ op: "sock-sendto", fd, body, ...to ? { addr: to } : {}, nonblock });
       mem.view().setUint32(out, sent, true);
@@ -8547,14 +8559,12 @@ function wasixSocketImports(host, preview1) {
       mem.view().setUint32(out, fd, true);
     },
     sock_pair: (af, type, _proto, out1, out2) => {
-      if (af !== UNIX)
-        throw new WasiError(af === INET4 || af === INET6 ? "EOPNOTSUPP" : "EAFNOSUPPORT");
-      if (type !== STREAM) throw new WasiError("EPROTONOSUPPORT");
+      const req = pairRequest(af, type);
       mem.view().setUint32(out1, 0, true);
       mem.view().setUint32(out2, 0, true);
-      const [a, b] = call2({ op: "sock-pair", domain: "unix" });
-      fds.adopt(a, "socket", false);
-      fds.adopt(b, "socket", false);
+      const [a, b] = call2(req);
+      fds.adopt(a, "socket", false, "type" in req);
+      fds.adopt(b, "socket", false, "type" in req);
       mem.view().setUint32(out1, a, true);
       mem.view().setUint32(out2, b, true);
     },
@@ -8774,7 +8784,7 @@ function wrap(table) {
   }
   return out;
 }
-var WasiExit, IDS, NS_PER_MS4, AT_SYMLINK_NOFOLLOW2, AT_EACCESS2, ROOT_IDS, GONE, S_IFIFO, DEFAULT_UMASK, MONOTONIC_BASE, MAX_READ, SIGPIPE_EXIT, SIG_IGN, SEALED_MODE, WasiHost;
+var WasiExit, IDS, NS_PER_MS4, AT_SYMLINK_NOFOLLOW2, AT_EACCESS2, ROOT_IDS, GONE, S_IFIFO, S_IFLNK2, DEFAULT_UMASK, MONOTONIC_BASE, MAX_READ, FD_ALIAS, STDIO_FDS, SIGPIPE_EXIT, SIG_IGN, SEALED_MODE, WasiHost;
 var init_wasi_host = __esm({
   "src/process/wasi/wasi-host.ts"() {
     "use strict";
@@ -8809,9 +8819,12 @@ var init_wasi_host = __esm({
     ROOT_IDS = Object.freeze({ uid: 0, gid: 0 });
     GONE = /* @__PURE__ */ new Set(["ENOENT", "ENOTDIR"]);
     S_IFIFO = 4096;
+    S_IFLNK2 = 40960;
     DEFAULT_UMASK = 18;
     MONOTONIC_BASE = BigInt(Math.round(performance.timeOrigin)) * NS_PER_MS4;
     MAX_READ = 1024 * 1024;
+    FD_ALIAS = /^\/(?:dev\/(stdin|stdout|stderr)|dev\/fd\/(\d+)|proc\/(self|[1-9]\d*)\/fd\/(\d+))$/;
+    STDIO_FDS = { stdin: 0, stdout: 1, stderr: 2 };
     SIGPIPE_EXIT = 128 + SIG.PIPE;
     SIG_IGN = 1;
     SEALED_MODE = 8630;
@@ -8924,7 +8937,20 @@ var init_wasi_host = __esm({
             return void 0;
           }
         };
+        const fdMode = (fd) => {
+          const e = fds.get(fd);
+          const kind = e.type === "kernel" ? fds.kind(fd, e) : void 0;
+          if (kind === "stream") return S_IFIFO | 384;
+          if (kind === "sealed" || kind === "clipboard") return SEALED_MODE;
+          return modeOf2(this.o.fs.stat(pathOf(fd)));
+        };
         const pathOwned = (path, follow2) => {
+          const alias = this.fdAlias(path);
+          if (alias && !follow2) return alias.stdio ? ROOT_IDS : void 0;
+          if (alias) {
+            this.openFd(alias.fd);
+            return fdOwned(alias.fd);
+          }
           if (this.synthetic(path)) return ROOT_IDS;
           return follow2 ? this.o.fs.stat(path) : this.o.fs.lstat(path);
         };
@@ -8974,14 +9000,18 @@ var init_wasi_host = __esm({
             const old = this.o.kernel.call({ op: "proc-umask", mask });
             mem.view().setUint32(out, old, true);
           },
-          fd_mode: (fd, out) => {
-            const e = fds.get(fd);
-            const kind = e.type === "kernel" ? fds.kind(fd, e) : void 0;
-            const mode = kind === "stream" ? S_IFIFO | 384 : kind === "sealed" || kind === "clipboard" ? SEALED_MODE : modeOf2(this.o.fs.stat(pathOf(fd)));
-            mem.view().setUint32(out, mode, true);
-          },
+          fd_mode: (fd, out) => void mem.view().setUint32(out, fdMode(fd), true),
           path_mode: (dirfd, p, l, flags, out) => {
             const path = at(dirfd, p, l);
+            const alias = this.fdAlias(path);
+            if (alias && flags & AT_SYMLINK_NOFOLLOW2) {
+              this.fdTarget(alias);
+              return void mem.view().setUint32(out, S_IFLNK2 | 511, true);
+            }
+            if (alias) {
+              this.openFd(alias.fd);
+              return void mem.view().setUint32(out, fdMode(alias.fd), true);
+            }
             if (this.synthetic(path) && deviceOf(path) === void 0)
               return void mem.view().setUint32(out, SEALED_MODE, true);
             const st = flags & AT_SYMLINK_NOFOLLOW2 ? this.o.fs.lstat(path) : this.o.fs.stat(path);
@@ -9276,7 +9306,10 @@ var init_wasi_host = __esm({
           path_open: (dirfd, lookup2, p, l, oflags, rights, _inheriting, fdflags, out) => {
             const follow2 = (lookup2 & LOOKUP_SYMLINK_FOLLOW) !== 0;
             try {
-              const path = at(dirfd, p, l);
+              const asked = at(dirfd, p, l);
+              const alias = this.fdAlias(asked);
+              if (alias && !alias.stdio) this.openFd(alias.fd);
+              const path = alias && !alias.stdio ? `/dev/fd/${alias.fd}` : asked;
               if (deviceOf(path)) this.interrupted?.();
               const fresh = (oflags & OFLAGS.CREAT) !== 0 && !this.synthetic(path) && !o.fs.exists(path);
               mem.view().setUint32(out, fds.open(path, oflags, rights, fdflags), true);
@@ -9338,7 +9371,9 @@ var init_wasi_host = __esm({
             o.fs.symlink(mem.string(tp, tl), path);
           },
           path_readlink: (dirfd, p, l, buf, len, used) => {
-            const target = new TextEncoder().encode(o.fs.readlink(at(dirfd, p, l)));
+            const path = at(dirfd, p, l);
+            const alias = this.fdAlias(path);
+            const target = new TextEncoder().encode(alias ? this.fdTarget(alias) : o.fs.readlink(path));
             const n = Math.min(len, target.length);
             mem.bytes(buf, n).set(target.subarray(0, n));
             mem.view().setUint32(used, n, true);
@@ -9677,7 +9712,55 @@ var init_wasi_host = __esm({
           return void 0;
         }
       }
+      fdAlias(path) {
+        const m = FD_ALIAS.exec(path);
+        if (!m) return void 0;
+        if (m[1]) return { fd: STDIO_FDS[m[1]], stdio: true };
+        if (m[3] !== void 0 && m[3] !== "self" && Number(m[3]) !== this.o.pid) return void 0;
+        return { fd: Number(m[2] ?? m[4]), stdio: false };
+      }
+      openFd(fd) {
+        try {
+          this.fds.get(fd);
+        } catch {
+          throw new WasiError("ENOENT");
+        }
+      }
+      fdTarget(alias) {
+        if (alias.stdio) return `/proc/self/fd/${alias.fd}`;
+        this.openFd(alias.fd);
+        const e = this.fds.get(alias.fd);
+        if (e.type === "file") return e.file.path;
+        if (e.type === "dir") return e.path;
+        if (e.type === "device") return `/dev/${e.device}`;
+        const kind = e.type === "kernel" ? this.fds.kind(alias.fd, e) : void 0;
+        if (kind === "file") {
+          const vfs = this.kernelStat(alias.fd);
+          if (vfs.path) return vfs.path;
+        }
+        if (kind === "tty") return "/dev/tty";
+        if (kind === "device") return "/dev/null";
+        const ino = this.fdFilestat(alias.fd).ino;
+        if (kind === "stream") return `pipe:[${ino}]`;
+        if (kind === "socket") return `socket:[${ino}]`;
+        return `anon_inode:[${kind ?? "fd"}]`;
+      }
+      aliasFilestat(path, alias, lookup2) {
+        if ((lookup2 & LOOKUP_SYMLINK_FOLLOW) === 0) {
+          const target = this.fdTarget(alias);
+          return this.local({
+            filetype: FILETYPE.SYMBOLIC_LINK,
+            size: BigInt(new TextEncoder().encode(target).length),
+            ino: pathInode(path),
+            mtimeNs: 0n
+          });
+        }
+        this.openFd(alias.fd);
+        return this.fdFilestat(alias.fd);
+      }
       pathFilestat(path, lookup2) {
+        const alias = this.fdAlias(path);
+        if (alias) return this.aliasFilestat(path, alias, lookup2);
         if (this.synthetic(path)) {
           return this.local({
             filetype: FILETYPE.CHARACTER_DEVICE,