@ai-ecoverse/slicc-kernel 1.132.1 → 1.133.1

package/dist/process-worker.js

@@ -2664,7 +2664,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.132.1" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.133.1" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -8413,6 +8413,10 @@ function stdioAlias(path) {
 function deviceOf(path) {
   return deviceAt(path);
 }
+function namedDevice(path) {
+  if (deviceOf(path) || stdioAlias(path) !== void 0) return true;
+  return path === SEALED_PATH2 || path === CLIPBOARD_PATH2 || path === "/dev/tty";
+}
 function within(path, root) {
   return path === root || path.startsWith(root === "/" ? "/" : `${root}/`);
 }
@@ -8534,6 +8538,14 @@ var init_wasi_fds = __esm({
           this.table.set(3 + i, entry);
         });
       }
+      adoptCopy(fd) {
+        const at = this.kernel.call({ op: "fd-dup", fd, min: 3 });
+        this.table.set(at, this.stdioEntry(at));
+        return at;
+      }
+      preopenAt(path, name2) {
+        return this.install({ type: "dir", path: normalize(path), preopen: name2 });
+      }
       preopens(cwd, root) {
         const here = normalize(cwd);
         const dot = { type: "dir", path: here, preopen: "." };
@@ -9061,8 +9073,19 @@ var init_wasi_fds = __esm({
           fd = this.openCharDevice(openClipboard, oflags, rights);
           kind = "clipboard";
         } else if (path === "/dev/tty" || /^\/dev\/tty\d+$/.test(path)) {
-          fd = openTty?.call(this.kernel.sys, path === "/dev/tty" ? void 0 : path);
+          const exclusive = (oflags & OFLAGS.CREAT) !== 0 && (oflags & OFLAGS.EXCL) !== 0;
+          try {
+            fd = openTty?.call(this.kernel.sys, path === "/dev/tty" ? void 0 : path);
+          } catch (err) {
+            if (exclusive && err.code === "EACCES")
+              throw new WasiError("EEXIST");
+            throw err;
+          }
           if (fd === void 0) throw new WasiError("ENXIO");
+          if (exclusive) {
+            this.kernel.sys.close(fd);
+            throw new WasiError("EEXIST");
+          }
           kind = "tty";
         } else return void 0;
         this.adopt(fd, kind, nonblock);
@@ -9078,13 +9101,14 @@ var init_wasi_fds = __esm({
       open(path, oflags, rights, fdflags, mode) {
         this.made = void 0;
         this.created = false;
+        const exclusive = (oflags & OFLAGS.CREAT) !== 0 && (oflags & OFLAGS.EXCL) !== 0;
+        if (exclusive && namedDevice(path)) throw new WasiError("EEXIST");
         const device2 = deviceOf(path);
         if (device2) return this.install({ type: "device", device: device2 });
         const kernelDevice = this.openKernelDevice(path, oflags, fdflags, rights);
         if (kernelDevice !== void 0) return kernelDevice;
         const alias = stdioAlias(path);
         if (alias !== void 0) return this.reopen(alias);
-        const exclusive = (oflags & OFLAGS.CREAT) !== 0 && (oflags & OFLAGS.EXCL) !== 0;
         if (exclusive && !(oflags & OFLAGS.DIRECTORY) && this.madeAtOnce(path, mode)) {
           return this.regular(path, void 0, oflags, rights, fdflags, mode, true);
         }
@@ -10344,7 +10368,7 @@ var init_wasi_host = __esm({
         );
         if (o.shared) this.fds.share(o.shared, true);
         else if (o.forked) this.fds.restore(o.forked.fds, o.forked.cloexec);
-        else this.fds.setup(o.cwd, o.inherited ?? [], o.preopenRoot === true);
+        else if (!o.bare) this.fds.setup(o.cwd, o.inherited ?? [], o.preopenRoot === true);
         this.listening = o.shared ? [] : this.fds.sockets();
       }
       get cwd() {
@@ -10757,6 +10781,7 @@ var init_wasi_host = __esm({
         return (localCpuNanos() ?? BigInt(Math.round((performance.now() - this.started) * 1e6))) + 1n;
       }
       environ() {
+        if (this.o.bare) return Object.entries(this.o.env).map(([k, v]) => `${k}=${v}`);
         const listen2 = this.listening.length > 0 ? { SLICC_LISTEN_FDS: this.listening.join(" ") } : {};
         const env = { PWD: this.cwd, ...this.o.env, ...listen2 };
         return Object.entries(env).map(([k, v]) => `${k}=${v}`);
@@ -16762,6 +16787,288 @@ var init_js_tty = __esm({
   }
 });
 
+// src/process/js/js-wasi.ts
+function ownedFds(sab) {
+  if (!sab) return { add: () => {
+  }, remove: () => {
+  } };
+  const view = new Int32Array(sab);
+  const fds = /* @__PURE__ */ new Set();
+  const publish = () => {
+    Atomics.store(view, 0, 0);
+    let n = 0;
+    for (const fd of fds) {
+      if (1 + n >= view.length) break;
+      view[1 + n++] = fd;
+    }
+    Atomics.store(view, 0, n);
+  };
+  return {
+    add(fd) {
+      fds.add(fd);
+      publish();
+    },
+    remove(fd) {
+      if (fds.delete(fd)) publish();
+    }
+  };
+}
+function fdArgsOf(name2) {
+  const paths = PATHS[name2];
+  if (paths) return paths.map(([fd]) => fd);
+  return /^(fd|sock)_/.test(name2) ? [0] : [];
+}
+function laneTransport(lane) {
+  return { call: (req) => lane(req) };
+}
+function within2(root, dir, path) {
+  if (path.startsWith("/")) return false;
+  const base = dir === root ? [] : dir.slice(root === "/" ? 1 : root.length + 1).split("/");
+  const parts = [...base];
+  for (const seg of path.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      if (parts.length === 0) return false;
+      parts.pop();
+    } else parts.push(seg);
+  }
+  return true;
+}
+function preopensOf(given, resolve) {
+  if (given === void 0) return [];
+  if (typeof given !== "object" || given === null) throw new JsCallError("EINVAL", "wasi preopens");
+  return Object.entries(given).map(([name2, path]) => {
+    if (typeof path !== "string" || path === "") throw new JsCallError("EINVAL", "wasi preopens");
+    return [name2, normalize(resolve(path))];
+  });
+}
+function createJsWasi(deps, o = {}) {
+  const transport = laneTransport(deps.lane);
+  const sys = kernelSys(transport);
+  const call2 = (req) => {
+    const r = deps.lane(req);
+    if (!r.ok) throw new JsCallError(r.errno, req.op);
+    return r.kind === "json" ? r.json : r.kind === "bytes" ? r.bytes : void 0;
+  };
+  const host = new WasiHost({
+    args: [...o.args ?? []],
+    env: { ...o.env ?? {} },
+    cwd: deps.cwd,
+    pid: deps.pid,
+    kernel: { sys, call: call2 },
+    fs: createSyncFsSabBridge(transport, { ...deps.fs, direct: true }),
+    bare: true
+  });
+  const owned = deps.owned;
+  const guest = /* @__PURE__ */ new Map();
+  const own = (g, k) => {
+    guest.set(g, k);
+    owned.add(k);
+  };
+  const roots = /* @__PURE__ */ new Map();
+  const opened2 = [];
+  const closeKernel = (fd) => {
+    owned.remove(fd);
+    try {
+      host.fds.close(fd);
+    } catch {
+    }
+  };
+  try {
+    (o.stdio ?? [0, 1, 2]).forEach((fd, i) => {
+      const k = host.fds.adoptCopy(fd);
+      opened2.push(k);
+      own(i, k);
+    });
+    for (const [name2, path] of preopensOf(o.preopens, deps.resolve)) {
+      const k = host.fds.preopenAt(path, name2);
+      opened2.push(k);
+      const g = 3 + roots.size;
+      own(g, k);
+      roots.set(g, path);
+    }
+  } catch (err) {
+    for (const k of opened2) closeKernel(k);
+    throw err;
+  }
+  const table = host.imports();
+  const view = () => host.mem.view();
+  const free = () => {
+    let g = 3;
+    while (guest.has(g)) g++;
+    return g;
+  };
+  const confined = (name2, args) => {
+    for (const [fdAt, ptrAt, lenAt] of PATHS[name2] ?? []) {
+      const g = args[fdAt];
+      const root = roots.get(g);
+      const dir = host.fds.find(guest.get(g));
+      if (root === void 0 || dir?.type !== "dir") continue;
+      if (!within2(root, dir.path, host.mem.string(args[ptrAt], args[lenAt]))) return false;
+    }
+    return true;
+  };
+  const opens = (out, root) => {
+    const k = view().getUint32(out, true);
+    const g = free();
+    own(g, k);
+    if (root !== void 0) roots.set(g, root);
+    view().setUint32(out, g, true);
+  };
+  const imports = {};
+  for (const [name2, fn] of Object.entries(table)) {
+    if (SPECIAL.has(name2)) continue;
+    const fdArgs = fdArgsOf(name2);
+    imports[name2] = ((...raw) => {
+      const args = [...raw];
+      for (const at of fdArgs) {
+        const k = guest.get(args[at]);
+        if (k === void 0) return E.BADF;
+        args[at] = k;
+      }
+      if (!confined(name2, raw)) return E.NOTCAPABLE;
+      const out = RESULTS[name2];
+      if (out !== void 0 && (raw[out] >>> 0) + 4 > host.mem.size()) return E.FAULT;
+      const errno2 = fn(...args);
+      if (errno2 !== E.SUCCESS) return errno2;
+      if (out !== void 0) opens(raw[out] >>> 0, roots.get(raw[0]));
+      return errno2;
+    });
+  }
+  imports.fd_close = ((g) => {
+    const k = guest.get(g);
+    if (k === void 0) return E.BADF;
+    guest.delete(g);
+    roots.delete(g);
+    owned.remove(k);
+    return table.fd_close(k);
+  });
+  imports.fd_renumber = ((from, to) => {
+    const kf = guest.get(from);
+    const kt = guest.get(to);
+    if (kf === void 0 || kt === void 0) return E.BADF;
+    if (from === to) return E.SUCCESS;
+    closeKernel(kt);
+    guest.set(to, kf);
+    const root = roots.get(from);
+    if (root === void 0) roots.delete(to);
+    else roots.set(to, root);
+    guest.delete(from);
+    roots.delete(from);
+    return E.SUCCESS;
+  });
+  imports.poll_oneoff = ((inPtr, outPtr, n, nevents) => {
+    const v = view();
+    const swapped = [];
+    for (let i = 0; i < n; i++) {
+      const at = inPtr + i * SUB_SIZE;
+      const tag = v.getUint8(at + SUB_TAG);
+      if (tag !== EVENTTYPE.FD_READ && tag !== EVENTTYPE.FD_WRITE) continue;
+      const g = v.getUint32(at + SUB_FD, true);
+      swapped.push([at + SUB_FD, g]);
+      v.setUint32(at + SUB_FD, guest.get(g) ?? NO_FD, true);
+    }
+    try {
+      return table.poll_oneoff(inPtr, outPtr, n, nevents);
+    } finally {
+      const after = view();
+      for (const [at, g] of swapped) after.setUint32(at, g, true);
+    }
+  });
+  imports.proc_exit = ((code2) => {
+    throw new JsWasiExit(code2);
+  });
+  let closed = false;
+  const run = (instance, entry) => {
+    const memory = instance.exports.memory;
+    if (memory instanceof WebAssembly.Memory) host.mem.bind(memory);
+    const fn = instance.exports[entry];
+    if (typeof fn !== "function") {
+      if (entry === "_initialize") return 0;
+      throw new JsCallError("EINVAL", `wasi: the instance exports no ${entry}`);
+    }
+    try {
+      fn();
+      return 0;
+    } catch (err) {
+      if (err instanceof JsWasiExit && o.returnOnExit !== false) return err.code;
+      throw err;
+    }
+  };
+  const wasi = {
+    imports: { wasi_snapshot_preview1: imports },
+    wasiImport: imports,
+    bind: (memory) => {
+      if (!(memory instanceof WebAssembly.Memory)) throw new JsCallError("EINVAL", "wasi bind");
+      host.mem.bind(memory);
+    },
+    start: (instance) => run(instance, "_start"),
+    initialize: (instance) => void run(instance, "_initialize"),
+    close: () => {
+      if (closed) return;
+      closed = true;
+      deps.live.delete(wasi);
+      for (const k of guest.values()) closeKernel(k);
+      guest.clear();
+      roots.clear();
+    }
+  };
+  deps.live.add(wasi);
+  return wasi;
+}
+function wasiFor(o) {
+  const deps = { ...o, live: /* @__PURE__ */ new Set(), owned: ownedFds(o.owned) };
+  return {
+    create: (options) => createJsWasi(deps, options),
+    closeAll: () => {
+      for (const wasi of [...deps.live]) wasi.close();
+    }
+  };
+}
+var JsWasiExit, SUB_SIZE, SUB_TAG, SUB_FD, NO_FD, PATHS, RESULTS, SPECIAL;
+var init_js_wasi = __esm({
+  "src/process/js/js-wasi.ts"() {
+    "use strict";
+    init_sync_sab_bridge();
+    init_process_runtime();
+    init_wasi_abi();
+    init_wasi_files();
+    init_wasi_host();
+    init_js_kernel();
+    JsWasiExit = class extends Error {
+      code;
+      constructor(code2) {
+        super(`wasi exit ${code2}`);
+        this.code = code2;
+      }
+    };
+    SUB_SIZE = 48;
+    SUB_TAG = 8;
+    SUB_FD = 16;
+    NO_FD = 2147483647;
+    PATHS = {
+      path_open: [[0, 2, 3]],
+      path_filestat_get: [[0, 2, 3]],
+      path_filestat_set_times: [[0, 2, 3]],
+      path_create_directory: [[0, 1, 2]],
+      path_remove_directory: [[0, 1, 2]],
+      path_unlink_file: [[0, 1, 2]],
+      path_readlink: [[0, 1, 2]],
+      path_symlink: [[2, 3, 4]],
+      path_rename: [
+        [0, 1, 2],
+        [3, 4, 5]
+      ],
+      path_link: [
+        [0, 2, 3],
+        [4, 5, 6]
+      ]
+    };
+    RESULTS = { path_open: 8, sock_accept: 2 };
+    SPECIAL = /* @__PURE__ */ new Set(["fd_close", "fd_renumber", "poll_oneoff", "proc_exit"]);
+  }
+});
+
 // src/process/js/js-watch.ts
 function watchRequest(path, options) {
   return { op: "watch-open", path, ...options?.recursive ? { recursive: true } : {} };
@@ -17311,14 +17618,17 @@ function createContext(o) {
   const syncKernel = new JsSyncKernel(lane, kernel, unwind);
   const terminal = ttyOps(kernel, syncKernel);
   const shared = { pid: o.pid, resolve, random, infos, handles, closing };
+  const wasi = wasiFor({ lane, pid: o.pid, cwd: o.cwd, resolve, fs: o.fs, owned: o.owned });
   const sync = {
     kernel: KERNEL_INFO,
     tty: terminal.syncTty,
     ...watchingSyncOps(kernel, syncKernel, shared),
     run: (options) => runSync(syncKernel, { env: o.env, cwd: o.cwd, resolve, signal: signalNumber }, options),
     spawn: (options) => spawnSync(options),
+    wasi: { create: wasi.create },
     exit: (status2 = 0) => {
       exiting ??= status2 & 255;
+      wasi.closeAll();
       return exitAtOnce(lane, [...writes], terminal.modes(), exiting);
     },
     kill: killer({ self: o.pid, kernel, syncKernel, lane, writes, modes: terminal.modes }),
@@ -17390,6 +17700,7 @@ function createContext(o) {
     onUnhandledRejection: (listener) => listen(strays.rejection, listener)
   };
   const drain2 = async () => {
+    wasi.closeAll();
     for (; ; ) {
       await Promise.all([...pending]);
       await new Promise((resolve2) => setTimeout(resolve2, 0));
@@ -17601,6 +17912,7 @@ var init_js_context = __esm({
     init_js_run();
     init_js_sync();
     init_js_tty();
+    init_js_wasi();
     init_js_watch();
     init_js_websocket();
     KERNEL_INFO = Object.freeze({ version: KERNEL_VERSION });
@@ -17782,8 +18094,10 @@ async function runJs(init, port2, deps, thread) {
     cwd: init.cwd,
     exit: (status3) => exited(statusOf(status3)),
     lane: laneOf(init.lane),
+    fs: { owners: init.owners === true, links: init.links === true },
     strays,
-    thread: threadContext(port2, thread)
+    thread: threadContext(port2, thread),
+    ...thread?.owned ? { owned: thread.owned } : {}
   });
   const say = (text) => ctx.write(2, `${init.argv0}: ${text}
 `).catch(() => void 0);