@ai-ecoverse/slicc-kernel 1.34.1 → 1.36.0

package/dist/process-worker.js

@@ -1607,7 +1607,7 @@ function ptyStat(path) {
 function nonblocking(stream) {
   return (stream.flags & O_NONBLOCK) !== 0 ? { nonblock: true } : void 0;
 }
-var POLLIN, POLLOUT, POLLERR, POLLHUP, POLLRDNORM, POLLWRNORM, O_NONBLOCK, SOCKET_MODE, PTY_PATH, TTY_PATH, O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC, KILLED_BY_SIGPIPE, ProcessExit, SyscallError, KernelStreams;
+var POLLIN, POLLOUT, POLLERR, POLLHUP, POLLRDNORM, POLLWRNORM, O_NONBLOCK, SOCKET_MODE, PTY_PATH, TTY_PATH, TTY_NAME, O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC, KILLED_BY_SIGPIPE, ProcessExit, SyscallError, KernelStreams;
 var init_kernel_streams = __esm({
   "src/process/kernel-streams.ts"() {
     "use strict";
@@ -1622,6 +1622,7 @@ var init_kernel_streams = __esm({
     SOCKET_MODE = 49663;
     PTY_PATH = /^\/dev\/(?:ptmx|pts\/(\d+))$/;
     TTY_PATH = /^\/dev\/tty\d+$/;
+    TTY_NAME = /^tty\d+$/;
     O_CREAT = 64;
     O_EXCL = 128;
     O_NOCTTY = 256;
@@ -1695,6 +1696,36 @@ var init_kernel_streams = __esm({
         if (typeof this.Fs.stat !== "function") return;
         stream.stream_ops = { ...stream.stream_ops, getattr: () => this.Fs.stat?.(name) ?? {} };
       }
+      creatingTerminal = false;
+      useTerminalNodes() {
+        const fs = this.Fs;
+        const { lookupNode, readdir, getPath, mkdev, makedev } = fs;
+        const ttyNames = this.sys.ttyNames?.bind(this.sys);
+        if (!lookupNode || !readdir || !getPath || !mkdev || !makedev || !ttyNames) return;
+        fs.lookupNode = (parent, name) => {
+          try {
+            return lookupNode.call(fs, parent, name);
+          } catch (e) {
+            const path = `/dev/${name}`;
+            if (this.creatingTerminal || !TTY_NAME.test(name) || getPath.call(fs, parent) !== "/dev")
+              throw e;
+            if (!ttyNames().includes(path)) throw e;
+            this.creatingTerminal = true;
+            try {
+              mkdev.call(fs, path, makedev.call(fs, 6, 0));
+            } finally {
+              this.creatingTerminal = false;
+            }
+            return lookupNode.call(fs, parent, name);
+          }
+        };
+        fs.readdir = (path) => {
+          const names = readdir.call(fs, path);
+          if (path.replace(/\/+$/, "") !== "/dev") return names;
+          const missing = ttyNames().map((tty) => tty.slice("/dev/".length)).filter((name) => TTY_NAME.test(name) && !names.includes(name));
+          return [...names, ...missing];
+        };
+      }
       ttyNode(name) {
         const { analyzePath, mkdev, makedev } = this.Fs;
         if (!TTY_PATH.test(name) || !analyzePath || !mkdev || !makedev) return;
@@ -1756,8 +1787,13 @@ var init_kernel_streams = __esm({
       useControllingTerminal() {
         if (typeof this.Fs.open !== "function") return;
         this.usePtyPaths();
+        this.useTerminalNodes();
         const open = this.Fs.open.bind(this.Fs);
         this.Fs.open = (path, flags, mode) => {
+          const device = typeof path === "string" ? this.devicePath(path) : void 0;
+          if (device !== void 0 && TTY_PATH.test(device) && !this.terminalExists(device)) {
+            throw new this.Fs.ErrnoError(wasiErrno("ENOENT"));
+          }
           const pty = this.openPty(open, path, flags, mode);
           if (pty) return pty;
           const stream = open(path, flags, mode);
@@ -1830,6 +1866,23 @@ var init_kernel_streams = __esm({
         const exists = n === void 0 ? this.sys.openPty !== void 0 : this.sys.ptyNumbers?.().includes(Number(n)) ?? false;
         if (!exists) throw new this.Fs.ErrnoError(wasiErrno("ENOENT"));
       }
+      devicePath(path) {
+        const name = path.slice(path.lastIndexOf("/") + 1);
+        if (!TTY_NAME.test(name)) return void 0;
+        const { lookupPath, cwd } = this.Fs;
+        const absolute = path.startsWith("/") ? path : `${cwd?.call(this.Fs) ?? "/"}/${path}`;
+        const dir = absolute.slice(0, absolute.lastIndexOf("/")) || "/";
+        try {
+          const real = lookupPath?.call(this.Fs, dir, { follow: true }).path ?? dir;
+          return `${real === "/" ? "" : real}/${name}`;
+        } catch {
+          return absolute;
+        }
+      }
+      terminalExists(path) {
+        const { analyzePath } = this.Fs;
+        return analyzePath?.call(this.Fs, path).exists ?? true;
+      }
       openNamedTerminal(path) {
         const { openTty } = this.sys;
         if (!openTty) return void 0;
@@ -2144,6 +2197,37 @@ function pathOpensLinks(Fs) {
   if (!mayOpen || !isLink) return;
   fs.mayOpen = (node, flags) => flags & O_PATH && isLink.call(fs, node.mode) ? 0 : mayOpen.call(fs, node, flags);
 }
+function kernelUmask(imports, deps) {
+  let umask = deps.initial & 511;
+  for (const ns of namespaces(imports)) {
+    const { __syscall_openat: openat, __syscall_mkdirat: mkdirat } = ns;
+    const { __syscall_mknodat: mknodat, __syscall_umask: own } = ns;
+    if (typeof openat === "function") {
+      ns.__syscall_openat = (dirfd, path, flags, varargs) => {
+        const memory = deps.memory();
+        if (flags & O_CREAT2 && varargs && memory)
+          new Int32Array(memory.buffer)[varargs >> 2] &= ~umask;
+        return openat(dirfd, path, flags, varargs);
+      };
+    }
+    if (typeof mkdirat === "function") {
+      ns.__syscall_mkdirat = (dirfd, path, mode) => mkdirat(dirfd, path, mode & ~umask);
+    }
+    if (typeof mknodat === "function") {
+      ns.__syscall_mknodat = (dirfd, path, mode, dev) => mknodat(dirfd, path, mode & ~umask, dev);
+    }
+    if (typeof own === "function") {
+      own(umask);
+      ns.__syscall_umask = (mask) => {
+        const old = umask;
+        umask = mask & 511;
+        own(umask);
+        deps.set(umask);
+        return old;
+      };
+    }
+  }
+}
 function noFollowUtimes(imports, fs, glue) {
   for (const namespace of namespaces(imports)) {
     const key = Object.keys(namespace).find(
@@ -3323,7 +3407,7 @@ function pidStatus(info) {
   const ids = `${UID}	${UID}	${UID}	${UID}`;
   return [
     `Name:	${commOf(info)}`,
-    "Umask:	0022",
+    `Umask:	${(info.umask ?? 18).toString(8).padStart(4, "0")}`,
     `State:	${state}`,
     `Tgid:	${info.pid}`,
     "Ngid:	0",
@@ -3672,6 +3756,9 @@ function kernelSys(transport) {
     size(fd) {
       return json(call2({ op: "fd-vfs-stat", fd }, `fd-vfs-stat ${fd}`)).size;
     },
+    ttyNames() {
+      return json(call2({ op: "fd-tty-names" }, "fd-tty-names"));
+    },
     openTty(name) {
       const req = name === void 0 ? { op: "fd-open-tty" } : { op: "fd-open-tty", name };
       return json(call2(req, `fd-open-tty ${name ?? ""}`));
@@ -3851,6 +3938,11 @@ async function runWasmProcess(init, port, deps = {}) {
           }
         });
         liveParent(imports, () => identify(transport, init).ppid);
+        kernelUmask(imports, {
+          initial: init.umask ?? 18,
+          memory: () => memory,
+          set: (mask) => void transport.call({ op: "proc-umask", mask }, Number.POSITIVE_INFINITY, "umask")
+        });
         noFollowUtimes(
           imports,
           () => ownValue(module, "FS"),
@@ -5191,7 +5283,7 @@ function wrap(table) {
   }
   return out;
 }
-var WasiExit, NS_PER_MS, MONOTONIC_BASE, MAX_READ, SIGPIPE_EXIT, WasiHost;
+var WasiExit, NS_PER_MS, AT_SYMLINK_NOFOLLOW2, DEFAULT_UMASK, MONOTONIC_BASE, MAX_READ, SIGPIPE_EXIT, WasiHost;
 var init_wasi_host = __esm({
   "src/process/wasi/wasi-host.ts"() {
     "use strict";
@@ -5208,6 +5300,8 @@ var init_wasi_host = __esm({
       }
     };
     NS_PER_MS = 1000000n;
+    AT_SYMLINK_NOFOLLOW2 = 1;
+    DEFAULT_UMASK = 18;
     MONOTONIC_BASE = BigInt(Math.round(performance.timeOrigin)) * NS_PER_MS;
     MAX_READ = 1024 * 1024;
     SIGPIPE_EXIT = 141;
@@ -5248,6 +5342,43 @@ var init_wasi_host = __esm({
       get cwd() {
         return this.fds.cwd() ?? this.startCwd;
       }
+      created(path, mode) {
+        const umask = this.o.kernel.call({ op: "proc-umask" });
+        if (umask !== DEFAULT_UMASK) this.o.fs.chmod(path, mode & ~umask);
+      }
+      sliccFsImports() {
+        const { mem, fds } = this;
+        const at = (dirfd, p, l) => fds.resolve(dirfd, mem.string(p, l));
+        const pathOf = (fd) => {
+          const e = fds.get(fd);
+          if (e.type === "dir") return e.path;
+          if (e.type === "file") return e.file.path;
+          const path = e.type === "kernel" && fds.kind(fd, e) === "file" ? this.kernelStat(fd).path : void 0;
+          if (path === void 0) throw new WasiError("EBADF");
+          return path;
+        };
+        const target = (path, flags) => {
+          if (flags & AT_SYMLINK_NOFOLLOW2 && this.o.fs.lstat(path).isSymbolicLink) {
+            throw new WasiError("ENOTSUP");
+          }
+          return path;
+        };
+        const modeOf = (st) => (st.mode ?? 0) & 4095;
+        return wrap({
+          fd_chmod: (fd, mode) => void this.o.fs.chmod(pathOf(fd), mode & 4095),
+          path_chmod: (dirfd, p, l, mode, flags) => void this.o.fs.chmod(target(at(dirfd, p, l), flags), mode & 4095),
+          umask: (mask, out) => {
+            const old = this.o.kernel.call({ op: "proc-umask", mask });
+            mem.view().setUint32(out, old, true);
+          },
+          fd_mode: (fd, out) => void mem.view().setUint32(out, modeOf(this.o.fs.stat(pathOf(fd))), true),
+          path_mode: (dirfd, p, l, flags, out) => {
+            const path = at(dirfd, p, l);
+            const st = flags & AT_SYMLINK_NOFOLLOW2 ? this.o.fs.lstat(path) : this.o.fs.stat(path);
+            mem.view().setUint32(out, modeOf(st), true);
+          }
+        });
+      }
       sliccImports() {
         const { mem } = this;
         const path = (p, l) => {
@@ -5397,7 +5528,12 @@ var init_wasi_host = __esm({
         const { mem, fds, o } = this;
         const at = (dirfd, p, l) => fds.resolve(dirfd, mem.string(p, l));
         return {
-          path_open: (dirfd, _lookup, p, l, oflags, rights, _inheriting, fdflags, out) => void mem.view().setUint32(out, fds.open(at(dirfd, p, l), oflags, rights, fdflags), true),
+          path_open: (dirfd, _lookup, p, l, oflags, rights, _inheriting, fdflags, out) => {
+            const path = at(dirfd, p, l);
+            const fresh = (oflags & OFLAGS.CREAT) !== 0 && !o.fs.exists(path);
+            mem.view().setUint32(out, fds.open(path, oflags, rights, fdflags), true);
+            if (fresh) this.created(path, 438);
+          },
           path_filestat_get: (dirfd, lookup, p, l, out) => void this.writeFilestat(out, this.pathFilestat(at(dirfd, p, l), lookup)),
           path_filestat_set_times: (dirfd, lookup, p, l, atim, mtim, flags) => {
             const path = at(dirfd, p, l);
@@ -5408,6 +5544,7 @@ var init_wasi_host = __esm({
             const path = at(dirfd, p, l);
             if (o.fs.exists(path)) throw new WasiError("EEXIST");
             o.fs.mkdir(path);
+            this.created(path, 511);
           },
           path_remove_directory: (dirfd, p, l) => void o.fs.rmdir(at(dirfd, p, l)),
           path_unlink_file: (dirfd, p, l) => {
@@ -7503,14 +7640,15 @@ function unsupportedImport(module, memory, extended = false, foreign = {}) {
   }
   return void 0;
 }
-function linkImports(module, preview1, wasix, memory, threads, program = {}, foreign, slicc = {}) {
+function linkImports(module, preview1, wasix, memory, threads, program = {}, foreign, slicc = {}, sliccFs = {}) {
   for (const ns of Object.keys(program)) {
-    if (RESERVED2.has(ns) || ns === SLICC)
+    if (RESERVED2.has(ns) || ns === SLICC || ns === SLICC_FS)
       throw new Error(`the imports module may not define ${ns}`);
   }
   const imports = {
     ...program,
     [SLICC]: { ...slicc },
+    [SLICC_FS]: { ...sliccFs },
     [PREVIEW1]: preview1,
     ...wasix ? { [WASIX]: { ...wasix } } : {},
     ...threads ? { wasi: { "thread-spawn": (arg) => threads.spawn(arg) } } : {}
@@ -7637,7 +7775,18 @@ async function instantiate(host, module, memory, threads, {
     () => instance
   );
   const slicc = traced(stats, "slicc", host.sliccImports());
-  const hostImports = linkImports(module, preview1, wasix, memory, threads, extra, foreign, slicc);
+  const sliccFs = traced(stats, "slicc_fs", host.sliccFsImports());
+  const hostImports = linkImports(
+    module,
+    preview1,
+    wasix,
+    memory,
+    threads,
+    extra,
+    foreign,
+    slicc,
+    sliccFs
+  );
   const imports = sync ? merge(hostImports, sync.linker.mainImports(module)) : hostImports;
   instance = await WebAssembly.instantiate(module, imports);
   stats?.phase("instantiate");
@@ -7827,7 +7976,7 @@ async function runWasiThread(init, port) {
     throw e;
   }
 }
-var TRAPPED, PREVIEW1, WASIX, SLICC, RESERVED2, noErrno, FALLBACK_MAXIMUM_PAGES, LinkSync, DL_GEN, BACKTRACE_FRAMES;
+var TRAPPED, PREVIEW1, WASIX, SLICC, SLICC_FS, RESERVED2, noErrno, FALLBACK_MAXIMUM_PAGES, LinkSync, DL_GEN, BACKTRACE_FRAMES;
 var init_wasi_runtime = __esm({
   "src/process/wasi/wasi-runtime.ts"() {
     "use strict";
@@ -7853,6 +8002,7 @@ var init_wasi_runtime = __esm({
     PREVIEW1 = "wasi_snapshot_preview1";
     WASIX = "wasix_32v1";
     SLICC = "slicc";
+    SLICC_FS = "slicc_fs";
     RESERVED2 = RESERVED_NAMESPACES;
     noErrno = (key) => `imports ${key}: its result cannot carry ENOSYS, and this host does not provide it`;
     FALLBACK_MAXIMUM_PAGES = 32768;