@ai-ecoverse/slicc-kernel 1.8.11 → 1.9.0

package/dist/process-worker.js

@@ -265,31 +265,31 @@ function createNodeOps(h) {
         mtime,
         ctime: new Date(st.ctimeMs ?? mtime.getTime()),
         blksize: 4096,
-        blocks: Math.ceil(size / 4096)
+        blocks: Math.ceil(size / 4096) * 8
       };
     },
-    setattr(node, attr) {
+    setattr(node, attr2) {
       if (node.live.orphan) {
-        if (attr.mode !== void 0 && attr.mode !== null) {
-          node.mode = node.mode & ~PERM_MASK | attr.mode & PERM_MASK;
+        if (attr2.mode !== void 0 && attr2.mode !== null) {
+          node.mode = node.mode & ~PERM_MASK | attr2.mode & PERM_MASK;
         }
-        if (attr.size !== void 0 && attr.size !== null) truncate(node, attr.size);
+        if (attr2.size !== void 0 && attr2.size !== null) truncate(node, attr2.size);
         return;
       }
       const path = liveNodePath(node);
-      if (attr.mode !== void 0 && attr.mode !== null) {
-        const perm = attr.mode & PERM_MASK;
+      if (attr2.mode !== void 0 && attr2.mode !== null) {
+        const perm = attr2.mode & PERM_MASK;
         if (perm !== (node.mode & PERM_MASK)) {
           metadataCall(() => bridgeOf(node).chmod(path, perm));
           node.mode = node.mode & ~PERM_MASK | perm;
         }
       }
-      if (attr.size !== void 0 && attr.size !== null && Fs.isFile(node.mode)) {
-        truncate(node, attr.size);
+      if (attr2.size !== void 0 && attr2.size !== null && Fs.isFile(node.mode)) {
+        truncate(node, attr2.size);
       }
-      const mtime = toMs(attr.mtime) ?? attr.timestamp;
+      const mtime = toMs(attr2.mtime) ?? attr2.timestamp;
       if (mtime !== void 0) {
-        const atime = toMs(attr.atime) ?? mtime;
+        const atime = toMs(attr2.atime) ?? mtime;
         flushNode(node);
         metadataCall(() => bridgeOf(node).utimes(path, atime, mtime));
       }
@@ -524,6 +524,7 @@ function mountLiveVfsDirs(Fs, bridge, dirs, warn) {
   }
   const plugin = Fs.filesystems.SLICC_LIVE_FS ?? createLiveVfsPlugin(Fs);
   Fs.filesystems.SLICC_LIVE_FS = plugin;
+  guardStatfs(Fs);
   const mounted = [];
   for (const dir of outermostDirs(dirs)) {
     if (dir === "/") continue;
@@ -546,6 +547,7 @@ function liveRoot(Fs, bridge) {
   plugin.mounts.add(root.mount);
   invalidateLiveVfs(Fs, plugin);
   guardRenames(Fs);
+  guardStatfs(Fs);
   const memfs = root.memfs ?? root.node_ops;
   const live = plugin.node_ops;
   root.memfs = memfs;
@@ -577,6 +579,30 @@ function crosses(Fs, from, to) {
     return false;
   }
 }
+function guardStatfs(Fs) {
+  const statfsNode = Fs.statfsNode?.bind(Fs);
+  if (!statfsNode || Fs.sliccStatfs) return;
+  Fs.sliccStatfs = true;
+  Fs.statfsNode = (node) => {
+    const defaults = statfsNode(node);
+    let usage;
+    try {
+      usage = node.live ? node.mount?.opts?.bridge?.statfs?.() : void 0;
+    } catch {
+      return defaults;
+    }
+    if (!usage) return defaults;
+    const free = Math.max(0, Math.floor((usage.quota - usage.usage) / 4096));
+    return {
+      ...defaults,
+      bsize: 4096,
+      frsize: 4096,
+      blocks: Math.ceil(usage.quota / 4096),
+      bfree: free,
+      bavail: free
+    };
+  };
+}
 function guardRenames(Fs) {
   const rename = Fs.rename?.bind(Fs);
   if (!rename || Fs.sliccRename) return;
@@ -670,6 +696,11 @@ var init_emscripten_vfs_hook = __esm({
 });
 
 // src/realm/sync-fs-wire.ts
+function parseSyncFsUsage(json) {
+  const u = json;
+  if (!u || typeof u.quota !== "number" || typeof u.usage !== "number") return null;
+  return { quota: u.quota, usage: u.usage };
+}
 function syncError(code2, label) {
   return Object.assign(new Error(`${code2}: ${label}`), { code: code2 });
 }
@@ -911,7 +942,8 @@ function createSyncFsSabBridge(transport, opts = {}) {
     },
     utimes: (path, atimeMs, mtimeMs) => {
       run({ op: "utimes", path, atimeMs, mtimeMs }, path);
-    }
+    },
+    statfs: () => parseSyncFsUsage(json({ op: "statfs", path: "/" }, "/"))
   };
 }
 var init_sync_sab_bridge = __esm({
@@ -1878,7 +1910,34 @@ function useDevFd(Fs) {
     return fstat.call(Fs, fd);
   };
 }
-var O_CLOEXEC, FD_CLOEXEC, F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_DUPFD_CLOEXEC, tracked, IMPORT_NAMES, EBADF, DIR_MODE, LINK_MODE;
+function mountTable() {
+  const root = globalThis.navigator?.storage ? "opfs" : "memory";
+  return [`${root} / ${root} rw 0 0`, "devfs /dev devfs rw 0 0", "proc /proc proc rw 0 0", ""].join(
+    "\n"
+  );
+}
+function useMounts(Fs) {
+  const { writeFile } = Fs;
+  if (typeof Fs.open !== "function" || typeof writeFile !== "function") return;
+  try {
+    writeFile.call(Fs, "/proc/mounts", mountTable());
+  } catch {
+    return;
+  }
+  const open = Fs.open.bind(Fs);
+  Fs.open = (path, flags, mode) => {
+    if (path !== "/etc/mtab" || (flags & (O_ACCMODE | O_CREAT2)) !== 0) {
+      return open(path, flags, mode);
+    }
+    try {
+      return open(path, flags, mode);
+    } catch (e) {
+      if (e?.errno !== wasiErrno("ENOENT")) throw e;
+      return open("/proc/mounts", flags, mode);
+    }
+  };
+}
+var O_CLOEXEC, FD_CLOEXEC, F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_DUPFD_CLOEXEC, tracked, IMPORT_NAMES, EBADF, DIR_MODE, LINK_MODE, O_ACCMODE, O_CREAT2;
 var init_process_fds = __esm({
   "src/process/process-fds.ts"() {
     "use strict";
@@ -1904,6 +1963,8 @@ var init_process_fds = __esm({
     EBADF = 8;
     DIR_MODE = 16749;
     LINK_MODE = 41408;
+    O_ACCMODE = 3;
+    O_CREAT2 = 64;
   }
 });
 
@@ -1986,7 +2047,7 @@ function inheritedSlot(fd, stream) {
   if (stream.sliccKernelFd === void 0) {
     const device = stream.path === void 0 ? void 0 : DEVICES[stream.path];
     if (!device) return void 0;
-    const access = ACCESS[stream.flags & O_ACCMODE];
+    const access = ACCESS[stream.flags & O_ACCMODE2];
     return { fd, device, ...access ? { access } : {} };
   }
   const flags = stream.sliccKernelSocket ? { flags: stream.flags } : {};
@@ -2003,7 +2064,7 @@ function placeholder(Fs, streams, entry) {
   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);
-  return Fs.open(`${PLACEHOLDER_DIR}/${entry.fd}`, O_RDWR | O_CREAT2);
+  return Fs.open(`${PLACEHOLDER_DIR}/${entry.fd}`, O_RDWR | O_CREAT3);
 }
 function asFifo(stream, streams, identity) {
   const inos = streamInos.get(streams) ?? /* @__PURE__ */ new Map();
@@ -2037,7 +2098,7 @@ function restoreForkedStreams(Fs, streams, table) {
       } else {
         const placed = place(
           Fs,
-          Fs.open(entry.path, entry.flags & ~(O_CREAT2 | O_EXCL2 | O_TRUNC2)),
+          Fs.open(entry.path, entry.flags & ~(O_CREAT3 | O_EXCL2 | O_TRUNC2)),
           entry.fd
         );
         setCloseOnExec(placed, (entry.flags & O_CLOEXEC) !== 0);
@@ -2046,14 +2107,14 @@ function restoreForkedStreams(Fs, streams, table) {
     }
   }
 }
-var O_RDWR, O_ACCMODE, O_CREAT2, O_EXCL2, O_TRUNC2, PLACEHOLDER_DIR, ACCESS, DEVICES, FIFO_MODE, nextStreamIno, streamInos;
+var O_RDWR, O_ACCMODE2, O_CREAT3, O_EXCL2, O_TRUNC2, PLACEHOLDER_DIR, ACCESS, DEVICES, FIFO_MODE, nextStreamIno, streamInos;
 var init_process_fork = __esm({
   "src/process/process-fork.ts"() {
     "use strict";
     init_process_fds();
     O_RDWR = 2;
-    O_ACCMODE = 3;
-    O_CREAT2 = 64;
+    O_ACCMODE2 = 3;
+    O_CREAT3 = 64;
     O_EXCL2 = 128;
     O_TRUNC2 = 512;
     PLACEHOLDER_DIR = "/dev/slicc-fd";
@@ -2197,7 +2258,7 @@ function socketNode(Fs, addr) {
   const fs = Fs;
   let stream;
   try {
-    stream = Fs.open(addr.path, O_WRONLY | O_CREAT3 | O_EXCL3, 493);
+    stream = Fs.open(addr.path, O_WRONLY | O_CREAT4 | O_EXCL3, 493);
   } catch (e) {
     if (e?.errno === wasiErrno("EEXIST")) {
       throw new SyscallError("EADDRINUSE");
@@ -2328,7 +2389,7 @@ function createSocketKernel(deps) {
     })
   };
 }
-var O_RDWR2, KILLED_BY_SIGPIPE2, O_WRONLY, O_CREAT3, O_EXCL3;
+var O_RDWR2, KILLED_BY_SIGPIPE2, O_WRONLY, O_CREAT4, O_EXCL3;
 var init_process_sockets = __esm({
   "src/process/process-sockets.ts"() {
     "use strict";
@@ -2339,15 +2400,302 @@ var init_process_sockets = __esm({
     O_RDWR2 = 2;
     KILLED_BY_SIGPIPE2 = 128 + 13;
     O_WRONLY = 1;
-    O_CREAT3 = 64;
+    O_CREAT4 = 64;
     O_EXCL3 = 128;
   }
 });
 
+// src/process/procfs.ts
+function commOf(info) {
+  const name = info.argv[0] ?? "";
+  return name.slice(name.lastIndexOf("/") + 1).slice(0, 15);
+}
+function ttyNumber(tty) {
+  const pts = tty && /^\/dev\/pts\/(\d+)$/.exec(tty);
+  if (pts) return 136 << 8 | Number(pts[1]);
+  const vt = tty && /^\/dev\/tty(\d+)$/.exec(tty);
+  return vt ? 4 << 8 | Number(vt[1]) : 0;
+}
+function ticks(ms) {
+  return Math.max(0, Math.floor(ms * HZ / 1e3));
+}
+function pidStat(info, boot) {
+  const fields = [
+    info.pid,
+    `(${commOf(info)})`,
+    info.state,
+    info.ppid,
+    info.pgid,
+    info.sid,
+    ttyNumber(info.tty),
+    info.tty ? info.pgid : -1,
+    4194304,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    20,
+    0,
+    1,
+    0,
+    ticks(info.started - boot),
+    0,
+    0,
+    "18446744073709551615",
+    ...Array(12).fill(0),
+    17,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    ...Array(7).fill(0),
+    0
+  ];
+  return `${fields.join(" ")}
+`;
+}
+function pidStatus(info) {
+  const state = info.state === "Z" ? "Z (zombie)" : "S (sleeping)";
+  const ids = `${UID}	${UID}	${UID}	${UID}`;
+  return [
+    `Name:	${commOf(info)}`,
+    "Umask:	0022",
+    `State:	${state}`,
+    `Tgid:	${info.pid}`,
+    "Ngid:	0",
+    `Pid:	${info.pid}`,
+    `PPid:	${info.ppid}`,
+    "TracerPid:	0",
+    `Uid:	${ids}`,
+    `Gid:	${ids}`,
+    "FDSize:	64",
+    "Groups:	",
+    `NSpid:	${info.pid}`,
+    `NSpgid:	${info.pgid}`,
+    `NSsid:	${info.sid}`,
+    "Threads:	1",
+    "SigQ:	0/0",
+    "SigPnd:	0000000000000000",
+    "ShdPnd:	0000000000000000",
+    "SigBlk:	0000000000000000",
+    "SigIgn:	0000000000000000",
+    "SigCgt:	0000000000000000",
+    ""
+  ].join("\n");
+}
+function pidFile(name, info, boot) {
+  if (name === "cmdline") return info.state === "Z" ? "" : `${info.argv.join("\0")}\0`;
+  if (name === "comm") return `${commOf(info)}
+`;
+  if (name === "stat") return pidStat(info, boot);
+  if (name === "statm") return "0 0 0 0 0 0 0\n";
+  return pidStatus(info);
+}
+function memoryInfo(source) {
+  const total = source.deviceMemory ? source.deviceMemory * KIB * KIB * KIB : FALLBACK_MEMORY;
+  const free = Math.max(0, total - (source.usedHeap ?? 0));
+  const kb = (bytes) => `${Math.floor(bytes / KIB)} kB`;
+  return [
+    ["MemTotal", kb(total)],
+    ["MemFree", kb(free)],
+    ["MemAvailable", kb(free)],
+    ["Buffers", kb(0)],
+    ["Cached", kb(0)],
+    ["SwapCached", kb(0)],
+    ["Shmem", kb(0)],
+    ["SReclaimable", kb(0)],
+    ["SwapTotal", kb(0)],
+    ["SwapFree", kb(0)]
+  ].map(([key, value2]) => `${`${key}:`.padEnd(16)}${value2.padStart(12)}`).concat("").join("\n");
+}
+function systemFile(name, listing, now, memory) {
+  const up = Math.max(0, now - listing.boot) / 1e3;
+  if (name === "uptime") return `${up.toFixed(2)} ${up.toFixed(2)}
+`;
+  if (name === "meminfo") return memoryInfo(memory);
+  const live = listing.processes.filter((p) => p.state !== "Z");
+  if (name === "loadavg") {
+    const last = Math.max(0, ...listing.processes.map((p) => p.pid));
+    return `0.00 0.00 0.00 1/${live.length} ${last}
+`;
+  }
+  const idle = ticks(now - listing.boot);
+  return [
+    `cpu  0 0 0 ${idle} 0 0 0 0 0 0`,
+    `cpu0 0 0 0 ${idle} 0 0 0 0 0 0`,
+    "intr 0",
+    "ctxt 0",
+    `btime ${Math.floor(listing.boot / 1e3)}`,
+    `processes ${listing.processes.length}`,
+    "procs_running 1",
+    "procs_blocked 0",
+    ""
+  ].join("\n");
+}
+function memorySource(scope2 = globalThis) {
+  const nav = scope2.navigator;
+  const perf = scope2.performance;
+  const deviceMemory = nav?.deviceMemory;
+  const used = perf?.memory?.usedJSHeapSize;
+  return {
+    ...typeof deviceMemory === "number" && deviceMemory > 0 ? { deviceMemory } : {},
+    ...typeof used === "number" ? { usedHeap: used } : {}
+  };
+}
+function attr(node) {
+  const now = /* @__PURE__ */ new Date();
+  return {
+    dev: 3,
+    ino: node.id,
+    mode: node.mode,
+    nlink: 1,
+    uid: UID,
+    gid: UID,
+    rdev: 0,
+    size: 0,
+    atime: now,
+    mtime: now,
+    ctime: now,
+    blksize: 4096,
+    blocks: 0
+  };
+}
+function useProcfs(Fs, sys, pid, memory = memorySource()) {
+  const { lookupPath, createNode, hashRemoveNode } = Fs;
+  const procList = sys.procList?.bind(sys);
+  if (!lookupPath || !createNode || !hashRemoveNode || !procList) return;
+  let proc;
+  let self;
+  try {
+    proc = lookupPath.call(Fs, "/proc", { follow: true }).node;
+    self = lookupPath.call(Fs, "/proc/self", { follow: true }).node;
+  } catch {
+    return;
+  }
+  const error = (errno2 = ENOENT) => new Fs.ErrnoError(errno2);
+  const fresh = (parent, name, mode) => {
+    const node = createNode.call(Fs, parent, name, mode, 0);
+    hashRemoveNode.call(Fs, node);
+    node.node_ops = { getattr: attr, setattr: () => {
+    } };
+    node.stream_ops = {
+      llseek: (stream, offset, whence) => {
+        const at = (whence === 1 ? stream.position : 0) + offset;
+        if (at < 0) throw error(EINVAL);
+        return at;
+      }
+    };
+    return node;
+  };
+  const file = (parent, name, content) => {
+    const node = fresh(parent, name, FILE_MODE);
+    node.stream_ops = {
+      open: (stream) => {
+        stream.sliccProc = new TextEncoder().encode(content());
+      },
+      read: (stream, buffer, offset, length, at) => {
+        const data = stream.sliccProc ?? new Uint8Array(0);
+        const chunk = data.subarray(at, at + length);
+        buffer.set(chunk, offset);
+        return chunk.length;
+      },
+      llseek: (stream, offset, whence) => {
+        const end = stream.sliccProc?.length ?? 0;
+        const at = (whence === 1 ? stream.position : whence === 2 ? end : 0) + offset;
+        if (at < 0) throw error(EINVAL);
+        return at;
+      }
+    };
+    return node;
+  };
+  const find = (processes2, target, own) => processes2.find((p) => own ? p.tid === target : p.pid === target || p.tid === target);
+  const infoOf = (target) => find(procList().processes, target, false);
+  const pidContent = (target, name, own = false) => () => {
+    const listing = procList();
+    const info = find(listing.processes, target, own);
+    if (!info) throw error(ESRCH);
+    return pidFile(name, info, listing.boot);
+  };
+  const pidNames = (names) => [.../* @__PURE__ */ new Set([...names, ...PID_FILES])];
+  const pidDir = (name, target) => {
+    const dir = fresh(proc, name, DIR_MODE2);
+    dir.node_ops.lookup = (parent, child) => {
+      if (!PID_FILES.includes(child)) throw error();
+      return file(parent, child, pidContent(target, child));
+    };
+    dir.node_ops.readdir = () => [".", "..", ...PID_FILES];
+    return dir;
+  };
+  const procOps = proc.node_ops;
+  const lookup = procOps.lookup?.bind(procOps);
+  const readdir = procOps.readdir?.bind(procOps);
+  proc.node_ops = {
+    ...procOps,
+    lookup: (parent, name) => {
+      if (/^[1-9]\d*$/.test(name)) {
+        if (!infoOf(Number(name))) throw error();
+        return pidDir(name, Number(name));
+      }
+      if (SYSTEM_FILES.includes(name)) {
+        return file(
+          parent,
+          name,
+          () => systemFile(name, procList(), Date.now(), memory)
+        );
+      }
+      if (!lookup) throw error();
+      return lookup(parent, name);
+    },
+    readdir: (node) => {
+      const names = new Set(readdir ? readdir(node) : [".", ".."]);
+      for (const name of SYSTEM_FILES) names.add(name);
+      for (const p of procList().processes) names.add(String(p.pid));
+      return [...names];
+    }
+  };
+  const selfOps = self.node_ops;
+  const selfLookup = selfOps.lookup?.bind(selfOps);
+  const selfReaddir = selfOps.readdir?.bind(selfOps);
+  self.node_ops = {
+    ...selfOps,
+    lookup: (parent, name) => {
+      if (PID_FILES.includes(name)) {
+        return file(parent, name, pidContent(pid, name, true));
+      }
+      if (!selfLookup) throw error();
+      return selfLookup(parent, name);
+    },
+    readdir: (node) => pidNames(selfReaddir ? selfReaddir(node) : [".", ".."])
+  };
+}
+var HZ, DIR_MODE2, FILE_MODE, ENOENT, ESRCH, EINVAL, UID, KIB, FALLBACK_MEMORY, PID_FILES, SYSTEM_FILES;
+var init_procfs = __esm({
+  "src/process/procfs.ts"() {
+    "use strict";
+    HZ = 100;
+    DIR_MODE2 = 16749;
+    FILE_MODE = 33060;
+    ENOENT = 44;
+    ESRCH = 71;
+    EINVAL = 28;
+    UID = 1e3;
+    KIB = 1024;
+    FALLBACK_MEMORY = 4 * KIB * KIB * KIB;
+    PID_FILES = ["cmdline", "comm", "stat", "statm", "status"];
+    SYSTEM_FILES = ["loadavg", "meminfo", "stat", "uptime"];
+  }
+});
+
 // src/process/realm-user.ts
 function ownByRealmUser(Fs) {
   const { stat, fstat } = Fs;
-  const owned = (attr) => ({ ...attr, uid: REALM_UID, gid: REALM_GID });
+  const owned = (attr2) => ({ ...attr2, uid: REALM_UID, gid: REALM_GID });
   if (typeof stat === "function") {
     Fs.stat = (path, dontFollow) => owned(stat.call(Fs, path, dontFollow));
   }
@@ -2458,6 +2806,9 @@ function kernelSys(transport) {
     ptyNumbers() {
       return json(call2({ op: "pty-list" }, "pty-list"));
     },
+    procList() {
+      return json(call2({ op: "proc-list" }, "proc-list"));
+    },
     ptyNumber(fd) {
       return json(call2({ op: "pty-number", fd }, `pty-number ${fd}`));
     },
@@ -2618,6 +2969,8 @@ async function runWasmProcess(init, port, deps = {}) {
   if (pipefs) streams.usePipes(pipefs);
   streams.useControllingTerminal();
   useDevFd(running.FS);
+  useMounts(running.FS);
+  useProcfs(running.FS, sys, init.pid);
   ownByRealmUser(running.FS);
   const livePath = (s) => liveNodePath(s.node);
   running.sliccKernel = createProcessKernel({
@@ -2684,6 +3037,7 @@ var init_process_runtime = __esm({
     init_process_http();
     init_process_signals();
     init_process_sockets();
+    init_procfs();
     init_realm_user();
     init_kernel_streams();
     O_RDONLY = 0;
@@ -4391,7 +4745,7 @@ function importsContext({
       const path = pathOf(fd);
       if (path === void 0) {
         const kind = e.type === "device" ? "device" : "stream";
-        return { kind, mode: kind === "device" ? 8630 : 4480, uid: UID, gid: UID, size: 0 };
+        return { kind, mode: kind === "device" ? 8630 : 4480, uid: UID2, gid: UID2, size: 0 };
       }
       host.fds.flushPath(path);
       const s = fs.stat(path);
@@ -4399,8 +4753,8 @@ function importsContext({
         kind: s.isDirectory ? "dir" : "file",
         path,
         mode: s.mode ?? (s.isDirectory ? 16877 : 33188),
-        uid: UID,
-        gid: UID,
+        uid: UID2,
+        gid: UID2,
         size: s.size,
         ...s.ino !== void 0 ? { ino: s.ino } : {},
         ...s.mtimeMs !== void 0 ? { mtimeMs: s.mtimeMs } : {}
@@ -4518,13 +4872,13 @@ function processes(host, call2) {
     }
   };
 }
-var UID, STDIO;
+var UID2, STDIO;
 var init_wasi_imports = __esm({
   "src/process/wasi/wasi-imports.ts"() {
     "use strict";
     init_wasi_abi();
     init_wasi_files();
-    UID = 1e3;
+    UID2 = 1e3;
     STDIO = ["stdin", "stdout", "stderr"];
   }
 });