@ai-ecoverse/slicc-kernel 1.1.0 → 1.3.0

package/dist/process-worker.js

@@ -55,6 +55,29 @@ var SIGNAL_BY_NAME = {
   SIGCONT: SIG.CONT
 };
 
+// src/fs/types.ts
+function normalizePath(path) {
+  const parts = [];
+  for (const part of path.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") parts.pop();
+    else parts.push(part);
+  }
+  return `/${parts.join("/")}`;
+}
+function inodeOf(path) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0; i < path.length; i++) {
+    const c = path.charCodeAt(i);
+    h1 = Math.imul(h1 ^ c, 2654435761);
+    h2 = Math.imul(h2 ^ c, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return 4294967296 * (2097151 & h2) + (h1 >>> 0) || 1;
+}
+
 // src/realm/live-vfs-fs.ts
 var ERRNO_BY_CODE = {
   EACCES: 2,
@@ -90,8 +113,8 @@ function toErrno(Fs, err) {
     return err;
   }
   const code = err?.code;
-  const errno = typeof code === "string" ? ERRNO_BY_CODE[code] ?? EIO : EIO;
-  return new Fs.ErrnoError(errno);
+  const errno2 = typeof code === "string" ? ERRNO_BY_CODE[code] ?? EIO : EIO;
+  return new Fs.ErrnoError(errno2);
 }
 function liveNodePath(node) {
   const parts = [];
@@ -103,18 +126,6 @@ function liveNodePath(node) {
   const root = node.mount.opts.root.replace(/\/+$/, "");
   return parts.length === 0 ? root || "/" : `${root}/${parts.reverse().join("/")}`;
 }
-function inodeOf(path) {
-  let h1 = 3735928559;
-  let h2 = 1103547991;
-  for (let i = 0; i < path.length; i++) {
-    const c = path.charCodeAt(i);
-    h1 = Math.imul(h1 ^ c, 2654435761);
-    h2 = Math.imul(h2 ^ c, 1597334677);
-  }
-  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
-  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
-  return 4294967296 * (2097151 & h2) + (h1 >>> 0) || 1;
-}
 function modeFromStat(st) {
   const type = st.isSymbolicLink ? S_IFLNK : st.isDirectory ? S_IFDIR : S_IFREG;
   const fallback = st.isDirectory || st.isSymbolicLink ? 511 : 438;
@@ -242,9 +253,9 @@ function createNodeOps(h) {
         gid: 0,
         rdev: 0,
         size,
-        atime: mtime,
+        atime: new Date(st.atimeMs ?? mtime.getTime()),
         mtime,
-        ctime: mtime,
+        ctime: new Date(st.ctimeMs ?? mtime.getTime()),
         blksize: 4096,
         blocks: Math.ceil(size / 4096)
       };
@@ -277,10 +288,13 @@ function createNodeOps(h) {
       node.live.stat = void 0;
     },
     lookup(parent, name) {
-      const st = call(() => bridgeOf(parent).lstat(childPath(parent, name)));
+      const listed = parent.live.listed?.get(name);
+      parent.live.listed?.delete(name);
+      const st = listed ?? call(() => bridgeOf(parent).lstat(childPath(parent, name)));
       return makeNode(parent, name, st);
     },
     mknod(parent, name, mode) {
+      parent.live.listed = void 0;
       const path = childPath(parent, name);
       if (Fs.isDir(mode)) {
         call(() => bridgeOf(parent).mkdir(path));
@@ -303,6 +317,8 @@ function createNodeOps(h) {
       return node;
     },
     rename(oldNode, newDir, newName) {
+      oldNode.parent.live.listed = void 0;
+      newDir.live.listed = void 0;
       const from = liveNodePath(oldNode);
       const to = childPath(newDir, newName);
       flushNode(oldNode);
@@ -317,6 +333,7 @@ function createNodeOps(h) {
       oldNode.live.stat = void 0;
     },
     unlink(parent, name) {
+      parent.live.listed = void 0;
       let open;
       try {
         const node = Fs.lookupNode?.(parent, name);
@@ -331,19 +348,24 @@ function createNodeOps(h) {
       if (open) open.live.orphan = true;
     },
     rmdir(parent, name) {
+      parent.live.listed = void 0;
       call(() => bridgeOf(parent).rmdir(childPath(parent, name)));
     },
     readdir(node) {
-      return [".", "..", ...call(() => bridgeOf(node).readdir(liveNodePath(node)))];
+      const listed = call(() => bridgeOf(node).readdirStat(liveNodePath(node)));
+      node.live.listed = /* @__PURE__ */ new Map();
+      for (const [name, st] of listed) if (st) node.live.listed.set(name, st);
+      return [".", "..", ...listed.map(([name]) => name)];
     },
     symlink(parent, newName, target) {
+      parent.live.listed = void 0;
       const path = childPath(parent, newName);
       call(() => bridgeOf(parent).symlink(target, path));
       return makeNode(parent, newName, {
         isFile: false,
         isDirectory: false,
         isSymbolicLink: true,
-        size: target.length
+        size: new TextEncoder().encode(target).length
       });
     },
     readlink(node) {
@@ -463,6 +485,7 @@ function invalidateLiveVfs(Fs, plugin) {
       if (!ownedBy(plugin, node)) continue;
       const s = node.live;
       s.stat = void 0;
+      s.listed = void 0;
       if (s.openCount === 0) {
         if (node !== node.mount.root) drop.push(node);
       } else if (s.loaded && !s.dirty) {
@@ -481,8 +504,8 @@ function outermostDirs(dirs) {
 }
 function describeMountError(err) {
   if (err instanceof Error) return err.message;
-  const errno = err?.errno;
-  return typeof errno === "number" ? `errno ${errno}` : String(err);
+  const errno2 = err?.errno;
+  return typeof errno2 === "number" ? `errno ${errno2}` : String(err);
 }
 function mountLiveVfsDirs(Fs, bridge, dirs, warn) {
   if (typeof Fs.filesystems !== "object" || !Fs.filesystems) {
@@ -560,6 +583,8 @@ function parseSyncFsStat(json) {
     size: s.size,
     ...typeof s.mode === "number" ? { mode: s.mode } : {},
     ...typeof s.mtimeMs === "number" ? { mtimeMs: s.mtimeMs } : {},
+    ...typeof s.atimeMs === "number" ? { atimeMs: s.atimeMs } : {},
+    ...typeof s.ctimeMs === "number" ? { ctimeMs: s.ctimeMs } : {},
     ...typeof s.ino === "number" ? { ino: s.ino } : {}
   };
 }
@@ -604,8 +629,8 @@ function decodeSabResult(status2, payload) {
     case SAB_STATUS_ERRNO: {
       try {
         const parsed = JSON.parse(decoder.decode(payload));
-        const errno = typeof parsed.errno === "string" && /^E[A-Z]+$/.test(parsed.errno) ? parsed.errno : "EIO";
-        return { ok: false, errno, message: String(parsed.message ?? errno) };
+        const errno2 = typeof parsed.errno === "string" && /^E[A-Z]+$/.test(parsed.errno) ? parsed.errno : "EIO";
+        return { ok: false, errno: errno2, message: String(parsed.message ?? errno2) };
       } catch {
         return { ok: false, errno: "EIO", message: "sync-sab: malformed errno payload" };
       }
@@ -781,6 +806,7 @@ var WASI_ERRNO = {
   EAFNOSUPPORT: 5,
   EAGAIN: 6,
   ECONNREFUSED: 14,
+  EEXIST: 20,
   EINPROGRESS: 26,
   EISCONN: 30,
   ENETUNREACH: 40,
@@ -818,6 +844,7 @@ var POLLHUP = 16;
 var POLLRDNORM = 64;
 var POLLWRNORM = 256;
 var O_NONBLOCK = 2048;
+var SOCKET_MODE = 49663;
 var PTY_PATH = /^\/dev\/(?:ptmx|pts\/(\d+))$/;
 function isPtyPath(path) {
   return PTY_PATH.test(path);
@@ -865,6 +892,8 @@ function nonblocking(stream) {
 }
 var KernelStreams = class {
   refs = /* @__PURE__ */ new Map();
+  socketRoot;
+  sockets = 0;
   Fs;
   sys;
   options;
@@ -880,6 +909,27 @@ var KernelStreams = class {
     if (terminal ?? this.sys.isatty?.(kfd) ?? false) stream.tty = this.ttyOps(kfd);
     else delete stream.tty;
   }
+  attachSocket(stream, kfd) {
+    this.attach(stream, kfd, false);
+    stream.sliccKernelSocket = true;
+  }
+  socketStream(flags) {
+    const fs = this.Fs;
+    if (!fs.mount || !fs.createNode || !fs.createStream) {
+      const stream = this.Fs.open("/dev/null", 2);
+      stream.flags = flags;
+      return stream;
+    }
+    const createNode = fs.createNode;
+    this.socketRoot ??= fs.mount({ mount: () => createNode(null, "/", 16895, 0) }, {}, null);
+    const ino = ++this.sockets;
+    const node = fs.createNode(this.socketRoot, `socket:${ino}`, SOCKET_MODE, 0);
+    const now = /* @__PURE__ */ new Date();
+    const stat = { dev: 0, ino, mode: SOCKET_MODE, nlink: 1, uid: 0, gid: 0, rdev: 0, size: 0 };
+    const times = { atime: now, mtime: now, ctime: now, blksize: 4096, blocks: 0 };
+    node.node_ops = { getattr: () => ({ ...stat, ...times }) };
+    return fs.createStream({ node, flags, seekable: false, position: 0, stream_ops: {} });
+  }
   nameTerminal(stream) {
     const kfd = stream.sliccKernelFd;
     if (!stream.tty || kfd === void 0) return;
@@ -1644,6 +1694,9 @@ function describeForFork(Fs, sys, streams, livePath) {
 }
 function kernelEntry(stream, kernel) {
   const cloexec = closesOnExec(stream) ? { cloexec: true } : {};
+  if (stream.sliccKernelSocket) {
+    return { fd: stream.fd, kernel, kind: "socket", flags: stream.flags, ...cloexec };
+  }
   const kind = stream.sliccKernelFile ? "file" : stream.tty ? "tty" : "stream";
   return { fd: stream.fd, kernel, kind, ...cloexec };
 }
@@ -1685,7 +1738,8 @@ function inheritedSlot(fd, stream) {
     const access = ACCESS[stream.flags & O_ACCMODE];
     return { fd, device, ...access ? { access } : {} };
   }
-  return { fd, kernel: stream.sliccKernelFd };
+  const flags = stream.sliccKernelSocket ? { flags: stream.flags } : {};
+  return { fd, kernel: stream.sliccKernelFd, ...flags };
 }
 function place(Fs, stream, fd) {
   if (stream.fd === fd) return stream;
@@ -1693,7 +1747,8 @@ function place(Fs, stream, fd) {
   Fs.closeStream(stream.fd);
   return moved;
 }
-function placeholder(Fs, entry) {
+function placeholder(Fs, streams, entry) {
+  if (entry.kind === "socket") return streams.socketStream(entry.flags ?? O_RDWR);
   if (entry.kind === "tty") return Fs.open("/dev/tty", O_RDWR);
   if (entry.kind === "stream") return Fs.open("/dev/null", O_RDWR);
   Fs.mkdirTree(PLACEHOLDER_DIR);
@@ -1714,8 +1769,9 @@ function asFifo(stream, streams, identity) {
   };
 }
 function placeKernelStream(Fs, streams, entry) {
-  const stream = place(Fs, placeholder(Fs, entry), entry.fd);
+  const stream = place(Fs, placeholder(Fs, streams, entry), entry.fd);
   if (entry.kind === "file") streams.attachFile(stream, entry.kernel);
+  else if (entry.kind === "socket") streams.attachSocket(stream, entry.kernel);
   else streams.attach(stream, entry.kernel, entry.kind === "tty");
   if (entry.kind === "tty") streams.nameTerminal(stream);
   if (entry.kind === "stream") {
@@ -1743,6 +1799,40 @@ function restoreForkedStreams(Fs, streams, table) {
   }
 }
 
+// src/process/process-http.ts
+var HttpError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+function createHttpKernel(transport) {
+  const call = (req) => {
+    const r = transport.call(req, Number.POSITIVE_INFINITY, req.op);
+    if (!r.ok) throw new HttpError(r.errno, r.message);
+    return r;
+  };
+  return {
+    request(req) {
+      const r = call({
+        op: "net-request",
+        url: req.url,
+        method: (req.method ?? "GET").toUpperCase(),
+        headers: req.headers ?? [],
+        ...req.body ? { body: req.body } : {}
+      });
+      return r.json;
+    },
+    read(handle, max) {
+      return call({ op: "net-read", handle, max }).bytes;
+    },
+    close(handle) {
+      call({ op: "net-close", handle });
+    }
+  };
+}
+
 // src/process/process-signals.ts
 var SignalGate = class {
   reported = { caught: 0, ignored: 0 };
@@ -1805,6 +1895,160 @@ var SignalGate = class {
   }
 };
 
+// src/process/process-sockets.ts
+var O_RDWR2 = 2;
+var KILLED_BY_SIGPIPE2 = 128 + 13;
+function errno(e) {
+  if (e instanceof SyscallError) return -wasiErrno(e.code);
+  const code = e?.errno;
+  if (typeof code === "number") return -code;
+  throw e;
+}
+var O_WRONLY = 1;
+var O_CREAT3 = 64;
+var O_EXCL3 = 128;
+function resolved(Fs, addr) {
+  if (addr.family !== "unix" || !addr.path || addr.path.startsWith("\0")) return addr;
+  const path = addr.path.startsWith("/") ? addr.path : `${Fs.cwd()}/${addr.path}`;
+  return { family: "unix", path: normalizePath(path) };
+}
+function socketNode(Fs, addr) {
+  if (addr.family !== "unix" || !addr.path || addr.path.startsWith("\0")) return void 0;
+  const fs = Fs;
+  let stream;
+  try {
+    stream = Fs.open(addr.path, O_WRONLY | O_CREAT3 | O_EXCL3, 493);
+  } catch (e) {
+    if (e?.errno === wasiErrno("EEXIST")) {
+      throw new SyscallError("EADDRINUSE");
+    }
+    throw e;
+  }
+  if (Fs.close) Fs.close(stream);
+  else Fs.closeStream(stream.fd);
+  return { remove: () => fs.unlink?.(addr.path) };
+}
+function createSocketKernel(deps) {
+  const { transport, Fs, sys, streams } = deps;
+  const call = (req) => {
+    const r = transport.call(req, Number.POSITIVE_INFINITY, req.op);
+    if (!r.ok) throw new SyscallError(r.errno);
+    return r;
+  };
+  const json = (req) => {
+    const r = call(req);
+    return r.ok && r.kind === "json" ? r.json : void 0;
+  };
+  const done = (req) => {
+    call(req);
+    return 0;
+  };
+  const guard = (op) => {
+    for (; ; ) {
+      try {
+        return op();
+      } catch (e) {
+        const restart = e instanceof SyscallError && e.code === "EINTR" && deps.restartable?.();
+        if (!restart) return errno(e);
+      }
+    }
+  };
+  const socketAt = (fd) => {
+    const stream = Fs.getStream(fd);
+    if (!stream) throw new SyscallError("EBADF");
+    if (!stream.sliccKernelSocket || stream.sliccKernelFd === void 0) {
+      throw new SyscallError("ENOTSOCK");
+    }
+    return stream;
+  };
+  const kfd = (fd) => socketAt(fd).sliccKernelFd;
+  const install = (k, nonblock, cloexec = false) => {
+    let stream;
+    try {
+      stream = streams.socketStream(O_RDWR2 | (nonblock ? O_NONBLOCK : 0));
+    } catch (e) {
+      sys.close(k);
+      throw e;
+    }
+    streams.attachSocket(stream, k);
+    setCloseOnExec(stream, cloexec);
+    return stream.fd;
+  };
+  return {
+    socket: (domain, nonblock, cloexec) => guard(() => install(json({ op: "sock-open", domain }), nonblock, cloexec)),
+    socketpair: (domain, nonblock, cloexec) => guard(() => {
+      const [a, b] = json({ op: "sock-pair", domain });
+      let first;
+      try {
+        first = install(a, nonblock, cloexec);
+      } catch (e) {
+        sys.close(b);
+        throw e;
+      }
+      try {
+        return [first, install(b, nonblock, cloexec)];
+      } catch (e) {
+        const stream = Fs.getStream(first);
+        if (stream) stream.stream_ops.close?.(stream);
+        Fs.closeStream(first);
+        throw e;
+      }
+    }),
+    bind: (fd, given) => guard(() => {
+      const addr = resolved(Fs, given);
+      const node = socketNode(Fs, addr);
+      try {
+        return done({ op: "sock-bind", fd: kfd(fd), addr });
+      } catch (e) {
+        node?.remove();
+        throw e;
+      }
+    }),
+    listen: (fd, backlog) => guard(() => done({ op: "sock-listen", fd: kfd(fd), backlog })),
+    accept: (fd, nonblock, cloexec) => guard(() => {
+      const listener = socketAt(fd);
+      const req = {
+        op: "sock-accept",
+        fd: listener.sliccKernelFd,
+        nonblock: (listener.flags & O_NONBLOCK) !== 0
+      };
+      const got = json(req);
+      return { fd: install(got.fd, nonblock, cloexec), peer: got.peer };
+    }),
+    connect: (fd, addr) => guard(() => {
+      const stream = socketAt(fd);
+      const nonblock = (stream.flags & O_NONBLOCK) !== 0;
+      return done({
+        op: "sock-connect",
+        fd: stream.sliccKernelFd,
+        addr: resolved(Fs, addr),
+        nonblock
+      });
+    }),
+    shutdown: (fd, how) => guard(() => done({ op: "sock-shutdown", fd: kfd(fd), how })),
+    name: (fd, peer) => guard(() => json({ op: "sock-name", fd: kfd(fd), peer })),
+    getopt: (fd, level, name) => guard(() => ({ value: json({ op: "sock-getopt", fd: kfd(fd), level, name }) })),
+    setopt: (fd, level, name, value) => guard(() => done({ op: "sock-setopt", fd: kfd(fd), level, name, value })),
+    send: (fd, bytes, flags) => guard(() => {
+      const stream = socketAt(fd);
+      const nonblock = flags.dontwait === true || (stream.flags & O_NONBLOCK) !== 0;
+      try {
+        return sys.write(stream.sliccKernelFd, bytes, { nonblock });
+      } catch (e) {
+        const broken = e instanceof SyscallError && e.code === "EPIPE";
+        if (broken && !flags.nosignal && !deps.sigpipe?.())
+          throw new ProcessExit(KILLED_BY_SIGPIPE2);
+        throw e;
+      }
+    }),
+    recv: (fd, max, flags) => guard(() => {
+      const stream = socketAt(fd);
+      const nonblock = flags.dontwait === true || (stream.flags & O_NONBLOCK) !== 0;
+      return sys.read(stream.sliccKernelFd, max, { nonblock, peek: flags.peek === true });
+    })
+  };
+}
+
 // src/process/realm-user.ts
 var REALM_UID = 1e3;
 var REALM_GID = 1e3;
@@ -1934,10 +2178,10 @@ function wireKernelFd(Fs, streams, entry) {
   });
 }
 var O_RDONLY = 0;
-var O_WRONLY = 1;
-var O_RDWR2 = 2;
+var O_WRONLY2 = 1;
+var O_RDWR3 = 2;
 function openDevice(Fs, fd, meta) {
-  const flags = meta.access === "read" ? O_RDONLY : meta.access === "write" ? O_WRONLY : O_RDWR2;
+  const flags = meta.access === "read" ? O_RDONLY : meta.access === "write" ? O_WRONLY2 : O_RDWR3;
   let stream;
   try {
     stream = Fs.open(`/dev/${meta.device}`, flags);
@@ -2131,6 +2375,15 @@ async function runWasmProcess(init, port, deps = {}) {
     inherit: (actions) => describeInherited(running.FS, sys, streams, livePath, actions),
     stdioPromoter: () => vfsPromoter(running.FS, sys, streams, livePath)
   });
+  running.sliccKernel.http = createHttpKernel(transport);
+  running.sliccKernel.net = createSocketKernel({
+    transport,
+    Fs: running.FS,
+    sys,
+    streams,
+    sigpipe,
+    restartable
+  });
   try {
     return runMain(running, init);
   } finally {