@ai-ecoverse/slicc-kernel 1.2.0 → 1.3.0

package/dist/process-worker.js

@@ -56,6 +56,15 @@ var SIGNAL_BY_NAME = {
 };
 
 // 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;
@@ -104,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 = [];
@@ -495,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) {
@@ -620,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" };
       }
@@ -797,6 +806,7 @@ var WASI_ERRNO = {
   EAFNOSUPPORT: 5,
   EAGAIN: 6,
   ECONNREFUSED: 14,
+  EEXIST: 20,
   EINPROGRESS: 26,
   EISCONN: 30,
   ENETUNREACH: 40,
@@ -834,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);
@@ -881,6 +892,8 @@ function nonblocking(stream) {
 }
 var KernelStreams = class {
   refs = /* @__PURE__ */ new Map();
+  socketRoot;
+  sockets = 0;
   Fs;
   sys;
   options;
@@ -896,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;
@@ -1660,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 };
 }
@@ -1701,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;
@@ -1709,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);
@@ -1730,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") {
@@ -1759,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 };
@@ -1821,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;
@@ -1950,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);
@@ -2147,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 {