@ai-ecoverse/slicc-kernel 1.47.0 → 1.47.2

package/dist/process-worker.js

@@ -3126,7 +3126,14 @@ function createProcessKernel(deps) {
     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")),
+    setcred(change) {
+      const cred = credOf(call2({ op: "proc-setcred", change }, "setcred"));
+      if (typeof cred === "object" && deps.owner) {
+        deps.owner.uid = cred.euid;
+        deps.owner.gid = cred.egid;
+      }
+      return cred;
+    },
     tcgetpgrp(fd) {
       const kfd = Fs.getStream(fd)?.sliccKernelFd;
       if (kfd === void 0) return -wasiErrno("ENOTTY");
@@ -3805,20 +3812,19 @@ var init_procfs = __esm({
 });
 
 // src/process/realm-user.ts
-function ownByRealmUser(Fs) {
+function ownByCaller(Fs, cred) {
+  const owner = { uid: cred?.euid ?? 0, gid: cred?.egid ?? 0 };
   const { stat, fstat } = Fs;
-  const owned = (attr2) => ({ ...attr2, uid: REALM_UID, gid: REALM_GID });
+  const owned = (attr2) => ({ ...attr2, uid: owner.uid, gid: owner.gid });
   if (typeof stat === "function") {
     Fs.stat = (path, dontFollow) => owned(stat.call(Fs, path, dontFollow));
   }
   if (typeof fstat === "function") Fs.fstat = (fd) => owned(fstat.call(Fs, fd));
+  return owner;
 }
-var REALM_UID, REALM_GID;
 var init_realm_user = __esm({
   "src/process/realm-user.ts"() {
     "use strict";
-    REALM_UID = 1e3;
-    REALM_GID = 1e3;
   }
 });
 
@@ -4172,7 +4178,6 @@ async function runWasmProcess(init, port2, deps = {}) {
     memory: () => memory,
     memalign: () => exports?.emscripten_builtin_memalign
   });
-  ownByRealmUser(running.FS);
   const livePath = (s) => liveNodePath(s.node);
   running.sliccKernel = createProcessKernel({
     transport,
@@ -4187,7 +4192,8 @@ async function runWasmProcess(init, port2, deps = {}) {
     deliveries: () => signals.deliveries(),
     describeFork: () => describeForFork(running.FS, sys, streams, livePath),
     inherit: (actions) => describeInherited(running.FS, sys, streams, livePath, actions),
-    stdioPromoter: () => vfsPromoter(running.FS, sys, streams, livePath)
+    stdioPromoter: () => vfsPromoter(running.FS, sys, streams, livePath),
+    owner: ownByCaller(running.FS, init.cred)
   });
   running.sliccKernel.http = createHttpKernel(transport);
   running.sliccKernel.hostname = hostnameOf(init.env);
@@ -8883,6 +8889,58 @@ function rewrite(hop, status2, location) {
     body: toGet ? void 0 : hop.body
   };
 }
+function isHex(byte) {
+  return byte !== void 0 && /^[0-9A-Fa-f]$/.test(String.fromCharCode(byte));
+}
+function percentDecode(input) {
+  const bytes = new TextEncoder().encode(input);
+  const out = new Uint8Array(bytes.length);
+  let at = 0;
+  for (let i = 0; i < bytes.length; i++) {
+    const byte = bytes[i];
+    if (byte === 37 && isHex(bytes[i + 1]) && isHex(bytes[i + 2])) {
+      out[at++] = Number.parseInt(
+        String.fromCharCode(bytes[i + 1], bytes[i + 2]),
+        16
+      );
+      i += 2;
+    } else out[at++] = byte;
+  }
+  return out.subarray(0, at);
+}
+function latin1(bytes) {
+  let text = "";
+  for (let at = 0; at < bytes.length; at += SLICE) {
+    text += String.fromCharCode(...bytes.subarray(at, at + SLICE));
+  }
+  return text;
+}
+function dataResponse(request) {
+  const url = withoutFragment(new URL(request.url));
+  const rest2 = url.slice("data:".length);
+  const comma = rest2.indexOf(",");
+  if (comma < 0) throw failed2(new JsCallError("EINVAL", "a data: URL without a comma"));
+  let type = rest2.slice(0, comma).replace(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, "");
+  let body = percentDecode(rest2.slice(comma + 1));
+  const base642 = BASE64.exec(type);
+  if (base642) {
+    type = type.slice(0, base642.index).replace(/[\t\n\f\r ]+$/, "");
+    let binary;
+    try {
+      binary = atob(latin1(body));
+    } catch {
+      throw failed2(new JsCallError("EINVAL", "a data: URL whose base64 does not decode"));
+    }
+    body = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+  }
+  if (type.startsWith(";")) type = `text/plain${type}`;
+  if (!MIME.test(type)) type = "text/plain;charset=US-ASCII";
+  const response = new Response(body, {
+    status: 200,
+    headers: { "content-type": type }
+  });
+  return withMeta(response, url, false);
+}
 function withMeta(response, url, redirected) {
   const clone = response.clone.bind(response);
   Object.defineProperty(response, "url", { value: url });
@@ -9031,6 +9089,11 @@ function fetchOp(kernel) {
     const request = new Request(input, init);
     const { signal } = request;
     signal.throwIfAborted();
+    const { protocol } = new URL(request.url);
+    if (protocol === "data:") return dataResponse(request);
+    if (protocol !== "http:" && protocol !== "https:") {
+      throw failed2(new JsCallError("EPROTONOSUPPORT", protocol));
+    }
     const known = await traitsOf().catch((err) => {
       throw failed2(err);
     });
@@ -9063,7 +9126,7 @@ function fetchOp(kernel) {
     }
   };
 }
-var CHUNK, MAX_REDIRECTS, NULL_BODY, REDIRECTS, BODY_HEADERS, DECODED, CREDENTIALS, OVER;
+var CHUNK, MAX_REDIRECTS, NULL_BODY, REDIRECTS, BODY_HEADERS, DECODED, CREDENTIALS, OVER, MIME, BASE64, SLICE;
 var init_js_fetch = __esm({
   "src/process/js/js-fetch.ts"() {
     "use strict";
@@ -9082,6 +9145,9 @@ var init_js_fetch = __esm({
     DECODED = /* @__PURE__ */ new Set(["gzip", "x-gzip", "deflate"]);
     CREDENTIALS = /* @__PURE__ */ new Set(["authorization", "proxy-authorization", "cookie", "cookie2"]);
     OVER = /* @__PURE__ */ Symbol("over");
+    MIME = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+(?:[\t ]*;.*)?$/s;
+    BASE64 = /; *base64$/i;
+    SLICE = 32768;
   }
 });
 
@@ -9584,7 +9650,7 @@ function ttyOps(kernel) {
     }
   };
   const restore = async () => {
-    for (const [fd, original] of [...saved]) {
+    for (const [fd, original] of [...saved].reverse()) {
       saved.delete(fd);
       await setAttr(fd, original).catch(() => void 0);
     }