@ai-ecoverse/slicc-kernel 1.51.0 → 1.52.0

package/dist/process-worker.js

@@ -4770,6 +4770,10 @@ function kernelEntry2() {
 function deviceEntry(meta) {
   return { type: "device", device: meta.device, ...meta.access ? { access: meta.access } : {} };
 }
+function refuseWrite(s, oflags, rights) {
+  const writes = (rights & RIGHTS.FD_WRITE) !== 0n || (oflags & OFLAGS.TRUNC) !== 0;
+  if (s?.readonly && writes) throw new WasiError("EROFS");
+}
 function preopenOf(e) {
   return {
     ...e.preopen ? { preopen: e.preopen } : {},
@@ -5237,6 +5241,7 @@ var init_wasi_fds = __esm({
           return this.install({ type: "dir", path });
         }
         if (!s && !(oflags & OFLAGS.CREAT)) throw new WasiError("ENOENT");
+        refuseWrite(s, oflags, rights);
         if (this.shared) return this.kernelFile(path, s, oflags, rights, fdflags);
         return this.install({ type: "file", file: this.file(path, s, oflags, rights, fdflags) });
       }
@@ -6748,6 +6753,191 @@ var init_wasi_module = __esm({
   }
 });
 
+// src/process/wasi/wasi-procfs.ts
+function inProc(path) {
+  return path === "/proc" || path.startsWith("/proc/");
+}
+function procfsBridge(fs, tree) {
+  const over = {
+    readFile: (p) => inProc(p) ? tree.read(p) : fs.readFile(p),
+    stat: (p) => inProc(p) ? tree.stat(p) : fs.stat(p),
+    lstat: (p) => inProc(p) ? tree.stat(p, false) : fs.lstat(p),
+    readdir: (p) => {
+      if (inProc(p)) return tree.readdir(p);
+      const names = fs.readdir(p);
+      return p === "/" && !names.includes("proc") ? [...names, "proc"] : names;
+    },
+    exists: (p) => inProc(p) ? tree.exists(p) : fs.exists(p),
+    readlink: (p) => inProc(p) ? tree.readlink(p) : fs.readlink(p),
+    readdirStat: (p) => {
+      if (!inProc(p)) {
+        const listed = fs.readdirStat(p);
+        if (p !== "/" || listed.some(([name2]) => name2 === "proc")) return listed;
+        return [...listed, ["proc", tree.stat("/proc")]];
+      }
+      return tree.readdir(p).map((name2) => {
+        try {
+          return [name2, tree.stat(`${p}/${name2}`, false)];
+        } catch {
+          return [name2, null];
+        }
+      });
+    },
+    rename: (from, to) => {
+      if (inProc(from) || inProc(to)) throw syncError("EROFS", from);
+      fs.rename(from, to);
+    },
+    hold: (p, ...rest2) => inProc(p) ? void 0 : fs.hold?.(p, ...rest2),
+    ...fs.pread ? {
+      pread: (p, at, n, version) => inProc(p) ? tree.read(p).subarray(at, at + n) : fs.pread(p, at, n, version)
+    } : {}
+  };
+  for (const name2 of READ_ONLY) {
+    const fn = fs[name2];
+    if (!fn) continue;
+    over[name2] = (p, ...rest2) => {
+      if (inProc(p)) throw syncError("EROFS", p);
+      return fn.call(fs, p, ...rest2);
+    };
+  }
+  return new Proxy(fs, {
+    get: (target, key, receiver) => key in over ? over[key] : Reflect.get(target, key, receiver)
+  });
+}
+var DIR_MODE3, FILE_MODE2, LINK_MODE3, PID_NAMES, SYSTEM_NAMES, ProcTree, READ_ONLY;
+var init_wasi_procfs = __esm({
+  "src/process/wasi/wasi-procfs.ts"() {
+    "use strict";
+    init_sync_fs_wire();
+    init_process_fds();
+    init_procfs();
+    DIR_MODE3 = 16749;
+    FILE_MODE2 = 33060;
+    LINK_MODE3 = 41471;
+    PID_NAMES = PID_FILES;
+    SYSTEM_NAMES = SYSTEM_FILES;
+    ProcTree = class {
+      source;
+      pid;
+      memory;
+      constructor(source, pid, memory = memorySource()) {
+        this.source = source;
+        this.pid = pid;
+        this.memory = memory;
+      }
+      listing() {
+        return this.source.procList();
+      }
+      alive(pid) {
+        return this.listing().processes.some((p) => p.pid === pid);
+      }
+      node(parts) {
+        const [top, leaf, ...rest2] = parts;
+        if (top === void 0) {
+          return {
+            kind: "dir",
+            names: () => [
+              ...SYSTEM_NAMES,
+              "mounts",
+              "self",
+              ...this.listing().processes.map((p) => String(p.pid))
+            ]
+          };
+        }
+        if (top === "self") {
+          return leaf === void 0 ? { kind: "link", target: String(this.pid) } : void 0;
+        }
+        if (leaf === void 0 && top === "mounts") {
+          return { kind: "file", content: () => mountTable(this.source.mountList()) };
+        }
+        if (leaf === void 0 && SYSTEM_NAMES.includes(top)) {
+          return {
+            kind: "file",
+            content: () => systemFile(top, this.listing(), Date.now(), this.memory)
+          };
+        }
+        if (!/^[1-9]\d*$/.test(top) || rest2.length > 0 || !this.alive(Number(top))) return void 0;
+        if (leaf === void 0) return { kind: "dir", names: () => [...PID_NAMES] };
+        if (!PID_NAMES.includes(leaf)) return void 0;
+        return {
+          kind: "file",
+          content: () => {
+            const listing = this.listing();
+            const info = listing.processes.find((p) => p.pid === Number(top));
+            if (!info) throw syncError("ENOENT", `/proc/${top}/${leaf}`);
+            return pidFile(leaf, info, listing.boot);
+          }
+        };
+      }
+      parts(path, follow2) {
+        const parts = path.split("/").filter((p) => p !== "").slice(1);
+        if (parts[0] === "self" && (follow2 || parts.length > 1)) parts[0] = String(this.pid);
+        return parts;
+      }
+      find(path, follow2) {
+        const node = this.node(this.parts(path, follow2));
+        if (!node) throw syncError("ENOENT", path);
+        return node;
+      }
+      stat(path, follow2 = true) {
+        const node = this.find(path, follow2);
+        const base = {
+          isFile: false,
+          isDirectory: false,
+          size: 0,
+          mtimeMs: Date.now(),
+          readonly: true
+        };
+        if (node.kind === "dir") return { ...base, isDirectory: true, mode: DIR_MODE3 };
+        if (node.kind === "link") {
+          return { ...base, isSymbolicLink: true, mode: LINK_MODE3, size: node.target.length };
+        }
+        return { ...base, isFile: true, mode: FILE_MODE2, size: this.bytes(node).length };
+      }
+      bytes(node) {
+        return new TextEncoder().encode(node.kind === "file" ? node.content() : "");
+      }
+      read(path) {
+        const node = this.find(path, true);
+        if (node.kind !== "file") throw syncError("EISDIR", path);
+        return this.bytes(node);
+      }
+      readdir(path) {
+        const node = this.find(path, true);
+        if (node.kind !== "dir") throw syncError("ENOTDIR", path);
+        return node.names();
+      }
+      readlink(path) {
+        const node = this.find(path, false);
+        if (node.kind !== "link") throw syncError("EINVAL", path);
+        return node.target;
+      }
+      exists(path) {
+        try {
+          this.find(path, true);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    };
+    READ_ONLY = [
+      "writeFile",
+      "mkdir",
+      "rm",
+      "unlink",
+      "rmdir",
+      "symlink",
+      "chmod",
+      "utimes",
+      "lutimes",
+      "create",
+      "pwrite",
+      "truncate"
+    ];
+  }
+});
+
 // src/process/wasi/wasi-signals.ts
 var DELIVERED_MASK, KERNEL_DEFAULTS, LIBC_DEFAULT_EXIT, SA_RESTART, DISPOSITION_IGNORE, DISPOSITION_HANDLER, withBit, WASIX_LIBC_DEFAULT_LINE, WasiSignals;
 var init_wasi_signals = __esm({
@@ -8891,6 +9081,15 @@ async function instantiate(host, module, memory, threads, {
   }
   return { instance, driver };
 }
+function procTree(call2, pid) {
+  return new ProcTree(
+    {
+      procList: () => call2({ op: "proc-list" }),
+      mountList: () => call2({ op: "mount-list" })
+    },
+    pid
+  );
+}
 function exportedTable(instance) {
   const table = instance.exports.__indirect_function_table;
   return table instanceof WebAssembly.Table ? table : void 0;
@@ -8962,7 +9161,10 @@ async function runWasiProcess(init, port2) {
     ppid: id.ppid,
     parent: () => identify(transport, init).ppid,
     kernel: { sys: traced(stats, "kernel", sys), call: call2 },
-    fs: cachingBridge(traced(stats, "fs", createSyncFsSabBridge(transport))),
+    fs: procfsBridge(
+      cachingBridge(traced(stats, "fs", createSyncFsSabBridge(transport))),
+      procTree(call2, id.pid)
+    ),
     ...descriptors(init, fork, threads)
   });
   if (threads) {
@@ -9053,7 +9255,7 @@ async function runWasiThread(init, port2) {
     ppid: id.ppid,
     parent: () => identify(transport, init).ppid,
     kernel: { sys, call: call2 },
-    fs: cachingBridge(createSyncFsSabBridge(transport)),
+    fs: procfsBridge(cachingBridge(createSyncFsSabBridge(transport)), procTree(call2, id.pid)),
     shared: threads.ids
   });
   const program = await programImports(init.program, host, transport, thread.tid);
@@ -9108,6 +9310,7 @@ var init_wasi_runtime = __esm({
     init_wasi_host();
     init_wasi_imports();
     init_wasi_module();
+    init_wasi_procfs();
     init_wasi_signals();
     init_wasi_stats();
     init_wasi_threads();
@@ -10370,10 +10573,25 @@ function ttyOps(kernel) {
       await kernel.call({ op: "tty-pgrp-set", fd, pgrp });
     }
   };
+  const openOn = async (terminal, fd) => {
+    const open = await kernel.json({ op: "fd-list" });
+    const on = open.filter((entry) => entry.terminal === terminal);
+    return (on.find((entry) => entry.fd === fd) ?? on[0])?.fd;
+  };
+  const reopened = async (terminal, termios) => {
+    const fd = await kernel.json({ op: "fd-open-tty", name: terminal });
+    try {
+      await setAttr(fd, termios);
+    } finally {
+      await kernel.call({ op: "fd-close", fd });
+    }
+  };
   const restore = async () => {
     for (const [terminal, { fd, termios }] of [...saved].reverse()) {
       saved.delete(terminal);
-      await setAttr(fd, termios).catch(() => void 0);
+      const at = await openOn(terminal, fd).catch(() => void 0);
+      const back = at === void 0 ? reopened(terminal, termios) : setAttr(at, termios);
+      await back.catch(() => void 0);
     }
   };
   return { tty, restore };