@ai-ecoverse/slicc-kernel 1.43.1 → 1.45.0

package/dist/process-worker.js

@@ -1465,7 +1465,7 @@ var init_sync_sab_wire = __esm({
 function createSyncSabTransport(sab, port2, deps = {}) {
   const views = sabViews(sab);
   const { header, window } = views;
-  const wait = deps.wait ?? ((a, i, v, t) => Atomics.wait(a, i, v, t));
+  const wait2 = deps.wait ?? ((a, i, v, t) => Atomics.wait(a, i, v, t));
   const now = deps.now ?? (() => performance.now());
   let seq = 0;
   function awaitReady(id, deadline, label) {
@@ -1476,7 +1476,7 @@ function createSyncSabTransport(sab, port2, deps = {}) {
       }
       const remaining = deadline - now();
       if (remaining <= 0) throw syncError("ETIMEDOUT", label);
-      wait(header, SAB_I_PUB, published, remaining);
+      wait2(header, SAB_I_PUB, published, remaining);
     }
   }
   return {
@@ -2896,6 +2896,9 @@ var init_process_fork = __esm({
 function status(r) {
   return r.ok ? 0 : -wasiErrno(r.errno);
 }
+function credOf(r) {
+  return r.ok ? r.json : -wasiErrno(r.errno);
+}
 function number(r) {
   if (!r.ok) return -wasiErrno(r.errno);
   return r.kind === "json" && typeof r.json === "number" ? r.json : -wasiErrno("EIO");
@@ -3103,6 +3106,8 @@ function createProcessKernel(deps) {
     setsid: () => number(call2({ op: "proc-setsid" }, "setsid")),
     getpgid: (pid) => number(call2({ op: "proc-getpgid", pid }, "getpgid")),
     getsid: (pid) => number(call2({ op: "proc-getsid", pid }, "getsid")),
+    cred: () => credOf(call2({ op: "proc-cred" }, "cred")),
+    setcred: (change) => credOf(call2({ op: "proc-setcred", change }, "setcred")),
     tcgetpgrp(fd) {
       const kfd = Fs.getStream(fd)?.sliccKernelFd;
       if (kfd === void 0) return -wasiErrno("ENOTTY");
@@ -3436,6 +3441,25 @@ var init_process_sockets = __esm({
   }
 });
 
+// src/kernel/cred.ts
+var ROOT, MAX_GROUPS;
+var init_cred = __esm({
+  "src/kernel/cred.ts"() {
+    "use strict";
+    init_types();
+    ROOT = Object.freeze({
+      ruid: 0,
+      euid: 0,
+      suid: 0,
+      rgid: 0,
+      egid: 0,
+      sgid: 0,
+      groups: [0]
+    });
+    MAX_GROUPS = 65536;
+  }
+});
+
 // src/process/procfs.ts
 function commOf(info) {
   const name = info.argv[0] ?? "";
@@ -3496,7 +3520,8 @@ function pidStat(info, boot) {
 }
 function pidStatus(info) {
   const state = info.state === "Z" ? "Z (zombie)" : "S (sleeping)";
-  const ids = `${UID}	${UID}	${UID}	${UID}`;
+  const c = info.cred ?? ROOT;
+  const ids = (r, e, s) => `${r}	${e}	${s}	${e}`;
   return [
     `Name:	${commOf(info)}`,
     `Umask:	${(info.umask ?? 18).toString(8).padStart(4, "0")}`,
@@ -3506,12 +3531,12 @@ function pidStatus(info) {
     `Pid:	${info.pid}`,
     `PPid:	${info.ppid}`,
     "TracerPid:	0",
-    `Uid:	${ids}`,
-    `Gid:	${ids}`,
+    `Uid:	${ids(c.ruid, c.euid, c.suid)}`,
+    `Gid:	${ids(c.rgid, c.egid, c.sgid)}`,
     "FDSize:	64",
     `VmSize:	${Math.ceil(info.memory / KIB)} kB`,
     `VmRSS:	${Math.ceil(info.memory / KIB)} kB`,
-    "Groups:	",
+    `Groups:	${c.groups.join(" ")}`,
     `NSpid:	${info.pid}`,
     `NSpgid:	${info.pgid}`,
     `NSsid:	${info.sid}`,
@@ -3730,6 +3755,7 @@ var HZ, DIR_MODE2, FILE_MODE, LINK_MODE2, ENOENT, ESRCH, EINVAL, UID, KIB, FALLB
 var init_procfs = __esm({
   "src/process/procfs.ts"() {
     "use strict";
+    init_cred();
     init_process_fds();
     HZ = 100;
     DIR_MODE2 = 16749;
@@ -4007,12 +4033,12 @@ async function runWasmProcess(init, port2, deps = {}) {
   const say = (fd) => (text) => sys.write(fd, encoder4.encode(`${text}
 `));
   let ready;
-  let failed2;
+  let failed3;
   let memory;
   let exports;
   const initialized = new Promise((resolve, reject) => {
     ready = resolve;
-    failed2 = reject;
+    failed3 = reject;
   });
   const id = identify(transport, init);
   const module = {
@@ -4065,7 +4091,7 @@ async function runWasmProcess(init, port2, deps = {}) {
         exports = instance.exports;
         publishMemory(init.sab, memory?.buffer.byteLength ?? 0);
         done(instance, init.program.module);
-      }, failed2);
+      }, failed3);
       return {};
     },
     preRun: [
@@ -5453,10 +5479,11 @@ function wrap(table) {
   }
   return out;
 }
-var WasiExit, NS_PER_MS, AT_SYMLINK_NOFOLLOW2, DEFAULT_UMASK, MONOTONIC_BASE, MAX_READ, SIGPIPE_EXIT, WasiHost;
+var WasiExit, IDS, 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";
+    init_cred();
     init_wasi_abi();
     init_wasi_fds();
     init_wasi_files();
@@ -5469,6 +5496,7 @@ var init_wasi_host = __esm({
         this.code = code2;
       }
     };
+    IDS = ["ruid", "euid", "suid", "rgid", "egid", "sgid"];
     NS_PER_MS = 1000000n;
     AT_SYMLINK_NOFOLLOW2 = 1;
     DEFAULT_UMASK = 18;
@@ -5567,6 +5595,35 @@ var init_wasi_host = __esm({
             data: mem.string(dp, dl)
           }),
           umount2: (tp, tl, flags) => void this.o.kernel.call({ op: "umount", target: path(tp, tl), flags }),
+          cred_get: (out) => {
+            const cred = this.o.kernel.call({ op: "proc-cred" });
+            const view = mem.view();
+            view.getUint32(out + 20, true);
+            IDS.forEach((key, i) => void view.setUint32(out + i * 4, cred[key], true));
+          },
+          cred_set: (...ids) => {
+            const change = {};
+            IDS.forEach((key, i) => {
+              if (ids[i] !== -1) change[key] = ids[i] >>> 0;
+            });
+            void this.o.kernel.call({ op: "proc-setcred", change });
+          },
+          groups_get: (buf, cap, count) => {
+            const { groups } = this.o.kernel.call({ op: "proc-cred" });
+            if (cap !== 0 && cap < groups.length) throw new WasiError("EINVAL");
+            const shown = cap === 0 ? [] : groups;
+            const view = mem.view();
+            view.getUint32(count, true);
+            if (shown.length > 0) view.getUint32(buf + (shown.length - 1) * 4, true);
+            shown.forEach((g, i) => void view.setUint32(buf + i * 4, g, true));
+            view.setUint32(count, groups.length, true);
+          },
+          groups_set: (buf, n) => {
+            if (n < 0 || n > MAX_GROUPS) throw new WasiError("EINVAL");
+            const view = mem.view();
+            const groups = Array.from({ length: n }, (_, i) => view.getUint32(buf + i * 4, true));
+            void this.o.kernel.call({ op: "proc-setcred", change: { groups } });
+          },
           sigaction_set: (sig, disposition, flags) => this.signals ? this.signals.disposition(sig, disposition, flags) : E.NOSYS
         });
       }
@@ -7691,7 +7748,7 @@ var init_wasix_host = __esm({
       }
       dlImports() {
         const { mem, host } = this;
-        const failed2 = (message2, buf, len) => {
+        const failed3 = (message2, buf, len) => {
           if (len > 0) {
             const bytes = new TextEncoder().encode(message2).subarray(0, len - 1);
             mem.bytes(buf, bytes.length).set(bytes);
@@ -7700,12 +7757,12 @@ var init_wasix_host = __esm({
           return E.NOEXEC;
         };
         const linked = (buf, len, op, out) => {
-          if (!this.linker) return failed2("not a dynamically-linked program", buf, len);
+          if (!this.linker) return failed3("not a dynamically-linked program", buf, len);
           try {
             out(op(this.linker));
             return E.SUCCESS;
           } catch (e) {
-            if (e instanceof DlError) return failed2(e.message, buf, len);
+            if (e instanceof DlError) return failed3(e.message, buf, len);
             throw e;
           }
         };
@@ -8623,7 +8680,7 @@ function writable(io, fd) {
   });
 }
 function childOps(kernel, io, defaults) {
-  const wait = async (pid) => {
+  const wait2 = async (pid) => {
     const r = await kernel.blocking({ op: "proc-wait", pid, nohang: false });
     const [, status2] = r.ok && r.kind === "json" ? r.json : [0, 0];
     return exitedOf(status2);
@@ -8638,7 +8695,7 @@ function childOps(kernel, io, defaults) {
       ...stdin !== void 0 ? { stdin: writable(io, stdin) } : {},
       ...stdout !== void 0 ? { stdout: readable(io, stdout) } : {},
       ...stderr !== void 0 ? { stderr: readable(io, stderr) } : {},
-      wait: () => wait(pid),
+      wait: () => wait2(pid),
       kill: (signal) => kill(pid, signal)
     };
   };
@@ -8665,7 +8722,7 @@ function childOps(kernel, io, defaults) {
       await closeAll(io, theirs);
     }
   };
-  return { spawn, wait, kill };
+  return { spawn, wait: wait2, kill };
 }
 async function closeAll(io, fds) {
   for (const fd of fds) if (fd !== void 0) await io.close(fd).catch(() => void 0);
@@ -8909,13 +8966,13 @@ function netOps(kernel, io) {
         const r = await kernel.raw({ op: "sock-connect", fd, addr, nonblock: true });
         if (!r.ok && r.errno !== "EINPROGRESS") throw new JsCallError(r.errno, "connect");
         await kernel.blocking({ op: "fd-select", read: [], write: [fd], timeoutMs: -1 }, signal);
-        const failed2 = await kernel.json({
+        const failed3 = await kernel.json({
           op: "sock-getopt",
           fd,
           level: SOL_SOCKET,
           name: SO_ERROR
         });
-        if (failed2 !== 0) throw new JsCallError(errnoName(failed2), "connect");
+        if (failed3 !== 0) throw new JsCallError(errnoName(failed3), "connect");
         return connection(fd);
       });
     }
@@ -9159,6 +9216,156 @@ var init_js_sync = __esm({
   }
 });
 
+// src/process/js/js-websocket.ts
+function failed2(err) {
+  return new TypeError("websocket failed", { cause: err });
+}
+function socketUrl(input) {
+  const url = new URL(input);
+  if (url.protocol === "http:") url.protocol = "ws:";
+  else if (url.protocol === "https:") url.protocol = "wss:";
+  if (url.protocol !== "ws:" && url.protocol !== "wss:") {
+    throw new SyntaxError(`not a WebSocket URL: ${url.href}`);
+  }
+  url.hash = "";
+  return url.href;
+}
+function closeCode(code2) {
+  if (code2 === void 0) return 1e3;
+  if (code2 === 1e3 || code2 >= 3e3 && code2 <= 4999) return code2;
+  throw new JsCallError("EINVAL", `close code ${code2}`);
+}
+function closeReason(reason) {
+  if (reason === void 0) return "";
+  if (new TextEncoder().encode(reason).length > MAX_REASON) {
+    throw new JsCallError("EINVAL", `close reason over ${MAX_REASON} bytes`);
+  }
+  return reason;
+}
+function websocketOp(kernel) {
+  return async (input, options = {}) => {
+    const url = socketUrl(input);
+    const signal = options.signal ?? NEVER2;
+    signal.throwIfAborted();
+    const protocols = typeof options.protocols === "string" ? [options.protocols] : options.protocols ?? [];
+    const handle = await kernel.json({
+      op: "net-ws-open",
+      url,
+      protocols,
+      headers: [...new Headers(options.headers)]
+    });
+    const free = () => kernel.raw({ op: "net-close", handle });
+    let protocol;
+    try {
+      const r = await kernel.blocking({ op: "net-ws-ready", handle }, signal);
+      protocol = (r.ok && r.kind === "json" ? r.json : {}).protocol;
+    } catch (err) {
+      await free();
+      throw signal.aborted ? signal.reason : failed2(err);
+    }
+    let settle;
+    let lose;
+    const closed = new Promise((resolve, reject) => {
+      settle = resolve;
+      lose = reject;
+    });
+    closed.catch(() => void 0);
+    const stop = new AbortController();
+    let freed = false;
+    const onAbort = () => hardStop(signal.reason);
+    const finish = () => {
+      freed = true;
+      signal.removeEventListener("abort", onAbort);
+      void free();
+    };
+    const hardStop = (reason) => {
+      if (stop.signal.aborted) return;
+      stop.abort(reason);
+      lose(reason);
+      finish();
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    let settled = false;
+    let readDone = false;
+    const release = () => {
+      if (!settled || !readDone || freed) return;
+      finish();
+    };
+    kernel.blocking({ op: "net-ws-wait", handle }, stop.signal).then((r) => {
+      settled = true;
+      settle(r.json);
+      release();
+    }).catch(lose);
+    const close = (how = {}) => {
+      void kernel.raw({
+        op: "net-ws-close",
+        handle,
+        code: closeCode(how.code),
+        reason: closeReason(how.reason)
+      });
+    };
+    const readable2 = new ReadableStream(
+      {
+        async pull(controller) {
+          let r;
+          try {
+            r = await kernel.blocking({ op: "net-ws-recv", handle }, stop.signal);
+          } catch (err) {
+            hardStop(stop.signal.aborted ? stop.signal.reason : failed2(err));
+            throw stop.signal.reason;
+          }
+          stop.signal.throwIfAborted();
+          if (r.ok && r.kind === "bytes") {
+            controller.enqueue(r.bytes);
+            return;
+          }
+          const text = (r.ok && r.kind === "json" ? r.json : {}).text;
+          if (text !== void 0) {
+            controller.enqueue(text);
+            return;
+          }
+          controller.close();
+          readDone = true;
+          release();
+        },
+        cancel: () => {
+          close();
+          readDone = true;
+          release();
+        }
+      },
+      { highWaterMark: 0 }
+    );
+    const writable2 = new WritableStream({
+      async write(chunk, controller) {
+        stop.signal.throwIfAborted();
+        const body = typeof chunk === "string" ? { text: chunk } : { body: chunk };
+        let buffered = await kernel.json({ op: "net-ws-send", handle, ...body });
+        while (buffered > SEND_BUFFER) {
+          await wait(10);
+          stop.signal.throwIfAborted();
+          controller.signal.throwIfAborted();
+          buffered = await kernel.json({ op: "net-ws-send", handle });
+        }
+      },
+      close: () => close(),
+      abort: () => close({ code: 1e3, reason: "" })
+    });
+    return { url, protocol, readable: readable2, writable: writable2, closed, close };
+  };
+}
+var SEND_BUFFER, MAX_REASON, NEVER2, wait;
+var init_js_websocket = __esm({
+  "src/process/js/js-websocket.ts"() {
+    "use strict";
+    init_js_kernel();
+    SEND_BUFFER = 1024 * 1024;
+    MAX_REASON = 123;
+    NEVER2 = new AbortController().signal;
+    wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  }
+});
+
 // src/process/js/js-context.ts
 function identityOf(answer2, fallback) {
   const id = answer2;
@@ -9324,6 +9531,7 @@ function createContext(o) {
     sync,
     ...children,
     net: netOps(kernel, io),
+    websocket: websocketOp(kernel),
     exit
   };
   const drain2 = async () => {
@@ -9461,6 +9669,7 @@ var init_js_context = __esm({
     init_js_kernel();
     init_js_net();
     init_js_sync();
+    init_js_websocket();
     JsExit = class extends Error {
       status;
       constructor(status2) {
@@ -9657,20 +9866,20 @@ function started(init, port2, run, wasi, js) {
   return run(wasmInit, port2);
 }
 function processEntry(port2, run = runWasmProcess, wasi = loadWasi, js = loadJs) {
-  const failed2 = (err) => port2.postMessage({
+  const failed3 = (err) => port2.postMessage({
     type: WASM_PROCESS_ERROR,
     message: err instanceof Error ? err.stack ?? err.message : String(err)
   });
   return (data) => {
     const type = data?.type;
     if (type === WASM_THREAD_INIT) {
-      wasi().then((m) => m.runWasiThread(data, port2)).catch(failed2);
+      wasi().then((m) => m.runWasiThread(data, port2)).catch(failed3);
       return;
     }
     if (type !== WASM_PROCESS_INIT) return;
     started(data, port2, run, wasi, js).then(
       (code2) => port2.postMessage({ type: WASM_PROCESS_EXIT, code: code2 }),
-      failed2
+      failed3
     );
   };
 }