@ai-ecoverse/slicc-kernel 1.67.1 → 1.68.0

package/dist/kernel-worker.js

@@ -2019,6 +2019,7 @@ function kernelFdKind(file) {
   if (file.held) return "held";
   if (file.heldMeta && "device" in file.heldMeta) return "device";
   if (file.tty) return "tty";
+  if (file.sealed) return "sealed";
   return file.seek ? "file" : "stream";
 }
 var FdTable = class _FdTable {
@@ -11407,6 +11408,7 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "fd-open-tty",
   "fd-tty-names",
   "fd-tty-owner",
+  "fd-open-sealed",
   "tty-get",
   "tty-set",
   "tty-winsz",
@@ -11462,6 +11464,7 @@ var WasmProcess = class {
   ignored = 0;
   inherited = 0;
   interrupt = new AbortController();
+  gone = new AbortController();
   dying = false;
   umask = DEFAULT_UMASK;
   cred;
@@ -11684,6 +11687,7 @@ var WasmProcess = class {
   }
   async write(fd, body, nonblock = false, cancelled) {
     const file = this.fds.get(fd).file;
+    if (file.sealed) return file.sealed.send(body, await this.sealedCaller(), this.gone.signal);
     if (!file.write) throw new KernelError("EBADF");
     if (!pollFile(file).writable) {
       if (nonblock) throw new KernelError("EAGAIN");
@@ -11765,6 +11769,24 @@ var WasmProcess = class {
     if (name2 !== void 0) ttyOpenable(this.guarded(), tty);
     return this.fds.install(tty.file(), 3);
   }
+  openSealed() {
+    const broker = this.options.sealed;
+    if (!broker) throw new KernelError("ENOENT");
+    return this.fds.install(broker.open(), 3);
+  }
+  async sealedCaller() {
+    const shown = await this.options.identity?.();
+    const broker = this.options.sealed;
+    const tag = broker.tagOf(this.pid);
+    return {
+      pid: shown?.pid ?? this.pid,
+      ppid: shown?.ppid ?? 0,
+      uid: this.cred.euid,
+      gid: this.cred.egid,
+      ...tag !== void 0 ? { tag } : {},
+      users: broker.users
+    };
+  }
   guarded() {
     const { guard: guard2 } = this.options;
     return guard2 && { fs: guard2.fs, dac: guard2.dac, cred: this.cred, pid: this.pid };
@@ -11885,6 +11907,8 @@ var WasmProcess = class {
         return { ok: true, kind: "json", json: this.openTty(req.name) };
       case "fd-tty-names":
         return { ok: true, kind: "json", json: this.options.jobs?.terminalNames() ?? [] };
+      case "fd-open-sealed":
+        return { ok: true, kind: "json", json: this.openSealed() };
       case "fd-tty-owner":
         return { ok: true, kind: "json", json: this.terminalByName(req.name).owner ?? null };
       case "fd-select": {
@@ -12320,6 +12344,7 @@ var WasmProcess = class {
   async exit() {
     if (this.exited) return;
     this.exited = true;
+    this.gone.abort();
     this.die();
     this.clearAlarm();
     this.interrupt.abort();
@@ -12507,6 +12532,7 @@ function processOptions(opts, header3, hooks, created3) {
   return {
     ...inherited(opts),
     ...opts.owners ? { owners: true } : {},
+    ...opts.sealed ? { sealed: opts.sealed } : {},
     ...opts.dac ? { guard: { dac: opts.dac, fs: opts.fs, created: created3 } } : {},
     ...opts.identity ? { identity: opts.identity } : {},
     ...opts.onSyscall ? { onSyscall: opts.onSyscall } : {},
@@ -12989,6 +13015,178 @@ function replayingHops(inner, heldMs = HELD_MS) {
   };
 }
 
+// src/kernel/sealed.ts
+var SEALED_MAX_BYTES = 64 * 1024;
+var SEALED_TIMEOUT_MS = 1e4;
+var SEALED_OPS = /* @__PURE__ */ new Set([
+  "seal",
+  "placeholder",
+  "list",
+  "test",
+  "request",
+  "status",
+  "cancel",
+  "materialize"
+]);
+var encoder3 = new TextEncoder();
+var decoder2 = new TextDecoder("utf-8", { fatal: true });
+function parseSealed(bytes) {
+  try {
+    if (bytes.length > SEALED_MAX_BYTES) throw new KernelError("EMSGSIZE");
+    let parsed2;
+    try {
+      parsed2 = JSON.parse(decoder2.decode(bytes));
+    } catch {
+      throw new KernelError("EINVAL");
+    }
+    if (typeof parsed2 !== "object" || parsed2 === null || Array.isArray(parsed2))
+      throw new KernelError("EINVAL");
+    const req = parsed2;
+    if (req.v !== 1 || typeof req.op !== "string" || !SEALED_OPS.has(req.op))
+      throw new KernelError("EINVAL");
+    return req;
+  } finally {
+    bytes.fill(0);
+  }
+}
+function errorReply(code, message3) {
+  return { v: 1, error: { code, message: message3 } };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function serialized(reply) {
+  let plain;
+  try {
+    const text = JSON.stringify(reply);
+    plain = text === void 0 ? void 0 : JSON.parse(text);
+  } catch (err) {
+    return JSON.stringify(errorReply("EIO", lineOf(err)));
+  }
+  if (!isRecord(plain)) return JSON.stringify(errorReply("EIO", "the vault gave no reply"));
+  const { v: _, ...rest2 } = plain;
+  return JSON.stringify({ v: 1, ...rest2 });
+}
+function lineOf(err) {
+  const text = err instanceof Error ? err.message : String(err);
+  return (text.split("\n")[0] ?? "").slice(0, 200);
+}
+var SealedChannel = class {
+  reply;
+  offset = 0;
+  inflight;
+  broker;
+  constructor(broker) {
+    this.broker = broker;
+  }
+  send(bytes, caller, gone) {
+    const length2 = bytes.length;
+    const fields = parseSealed(bytes);
+    this.reply = void 0;
+    this.offset = 0;
+    this.inflight?.control.abort("replaced");
+    const control = new AbortController();
+    const withdraw = () => control.abort("withdrawn");
+    if (gone.aborted) withdraw();
+    else gone.addEventListener("abort", withdraw, { once: true });
+    const timer = setTimeout(() => control.abort("timeout"), this.broker.timeoutMs);
+    const req = { ...fields, v: 1, op: fields.op, caller };
+    const flight = { control, done: Promise.resolve() };
+    flight.done = this.answer(req, control.signal).then((reply) => {
+      clearTimeout(timer);
+      gone.removeEventListener("abort", withdraw);
+      if (this.inflight !== flight) return;
+      this.inflight = void 0;
+      if (reply) this.reply = encoder3.encode(serialized(reply));
+    });
+    this.inflight = flight;
+    return length2;
+  }
+  async answer(req, signal) {
+    const hook = this.broker.hook;
+    if (!hook) return errorReply("ENOTCONN", "no vault is connected");
+    const stopped = new Promise((resolve) => {
+      signal.addEventListener("abort", () => resolve(void 0), { once: true });
+    });
+    if (signal.aborted) return void 0;
+    const asked = Promise.resolve().then(() => hook(req, { signal })).then(
+      (reply2) => isRecord(reply2) ? reply2 : errorReply("EIO", "the vault gave no reply"),
+      (err) => errorReply("EIO", lineOf(err))
+    );
+    const reply = await Promise.race([asked, stopped]);
+    if (!signal.aborted) return reply;
+    return signal.reason === "timeout" ? errorReply("ETIMEDOUT", "the vault did not answer within 10 s") : void 0;
+  }
+  async read(max, signal) {
+    for (; ; ) {
+      if (this.reply) {
+        const out = this.reply.slice(this.offset, this.offset + max);
+        this.offset += out.length;
+        if (this.offset >= this.reply.length) {
+          this.reply = void 0;
+          this.offset = 0;
+        }
+        return out;
+      }
+      const flight = this.inflight;
+      if (!flight) return new Uint8Array(0);
+      await this.until(flight, signal);
+    }
+  }
+  async until(flight, signal) {
+    if (!signal) return flight.done;
+    if (signal.aborted) throw new KernelError("EINTR");
+    let stop = () => {
+    };
+    const interrupted2 = new Promise((_, reject) => {
+      stop = () => reject(new KernelError("EINTR"));
+      signal.addEventListener("abort", stop, { once: true });
+    });
+    try {
+      await Promise.race([flight.done, interrupted2]);
+    } finally {
+      signal.removeEventListener("abort", stop);
+    }
+  }
+  poll() {
+    return { readable: this.reply !== void 0 || !this.inflight, writable: true, hangup: false };
+  }
+  async changed(signal) {
+    const flight = this.inflight;
+    if (flight) await this.until(flight, signal);
+  }
+  close() {
+    this.inflight?.control.abort("withdrawn");
+    this.inflight = void 0;
+    this.reply = void 0;
+  }
+};
+var SealedBroker = class {
+  hook;
+  users;
+  timeoutMs;
+  tagOf;
+  constructor(hook, users, timeoutMs = SEALED_TIMEOUT_MS, tagOf = () => void 0) {
+    this.hook = hook;
+    this.users = users;
+    this.timeoutMs = timeoutMs;
+    this.tagOf = tagOf;
+  }
+  open() {
+    const channel = new SealedChannel(this);
+    return new OpenFile({
+      read: (max, signal) => channel.read(max, signal),
+      write: async () => {
+        throw new KernelError("EINVAL");
+      },
+      poll: () => channel.poll(),
+      changed: (signal) => channel.changed(signal),
+      close: () => channel.close(),
+      sealed: channel
+    });
+  }
+};
+
 // src/kernel/settling.ts
 var SETUP_OPS = /* @__PURE__ */ new Set([
   "proc-list",
@@ -13636,13 +13834,13 @@ var HostfsClient = class {
     const response = await this.send("/api/hostfs/watch", { method: "POST", signal });
     onOpen();
     const reader = response.body.getReader();
-    const decoder2 = new TextDecoder();
+    const decoder3 = new TextDecoder();
     let buffered = "";
     try {
       for (; ; ) {
         const { done: done4, value } = await reader.read();
         if (done4) return;
-        buffered += decoder2.decode(value, { stream: true });
+        buffered += decoder3.decode(value, { stream: true });
         let end = buffered.indexOf("\n");
         while (end >= 0) {
           const line = buffered.slice(0, end).trim();
@@ -15020,7 +15218,7 @@ var LAYOUT = [
 ];
 var LOAD_SAMPLE_MS = 5e3;
 var LOAD_WINDOWS_MS = [6e4, 3e5, 9e5];
-var encoder3 = new TextEncoder();
+var encoder4 = new TextEncoder();
 var USERS_MODES = ["off", "report", "enforce"];
 function usersMode(mode = "off") {
   if (USERS_MODES.includes(mode)) return mode;
@@ -15170,12 +15368,19 @@ var Launcher = class {
   fstab = Promise.resolve([]);
   usersMode;
   dac;
+  sealed;
   nextPid = 1e3;
   boot = Date.now();
   terminals = 0;
   constructor(options) {
     this.usersMode = usersMode(options.users);
     this.dac = this.usersMode === "off" ? void 0 : new Dac(this.usersMode, options.onDenial);
+    this.sealed = new SealedBroker(
+      options.sealed,
+      this.usersMode,
+      void 0,
+      (pid) => this.tagOf(pid)
+    );
     if (this.owners) options.fs.trackOwners?.();
     this.mounts = new MountTable({
       open: (type, spec) => this.driver(type, spec),
@@ -15575,6 +15780,7 @@ var Launcher = class {
       ...req.umask !== void 0 ? { umask: req.umask } : {},
       cred: req.cred,
       ...this.owners ? { owners: true } : {},
+      sealed: this.sealed,
       ...this.dac ? { dac: this.dac } : {},
       program: req.program,
       argv0: req.argv0,
@@ -16213,7 +16419,7 @@ var Launcher = class {
       },
       account
     );
-    const report = (message3) => options.onData(encoder3.encode(`${message3}\r
+    const report = (message3) => options.onData(encoder4.encode(`${message3}\r
 `));
     const handle = await this.launch(planned, {
       env,
@@ -16250,7 +16456,7 @@ var Launcher = class {
     };
     const stdout = collect(out, options.onStdout);
     const stderr = collect(err, options.onStderr);
-    const report = (message3) => stderr(encoder3.encode(`${message3}
+    const report = (message3) => stderr(encoder4.encode(`${message3}
 `));
     if (!planned) {
       report(`${file}: command not found`);
@@ -16275,6 +16481,33 @@ var Launcher = class {
   }
 };
 
+// src/sealed-relay.ts
+function sealedAsker(port) {
+  const asks = /* @__PURE__ */ new Map();
+  let next2 = 0;
+  const hook = (req, { signal }) => {
+    const id2 = ++next2;
+    const waiting = Promise.withResolvers();
+    asks.set(id2, waiting);
+    const abort = () => {
+      if (!asks.delete(id2)) return;
+      port.postMessage({ sealedAbort: { id: id2, reason: signal.reason } });
+      waiting.reject(new Error(String(signal.reason)));
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    port.postMessage({ sealedAsk: { id: id2, req } });
+    return waiting.promise.finally(() => signal.removeEventListener("abort", abort));
+  };
+  const answer = ({ id: id2, reply, error }) => {
+    const waiting = asks.get(id2);
+    if (!waiting) return;
+    asks.delete(id2);
+    if (reply) waiting.resolve(reply);
+    else waiting.reject(new Error(error ?? "no reply"));
+  };
+  return { hook, answer };
+}
+
 // src/serve.ts
 async function inOpfs(deps, root) {
   if (deps.syncAccess !== true) return false;
@@ -16389,11 +16622,31 @@ function usersOp(l, req) {
   if (req.op === "groups-remove-member") return l.users.removeMember(req.group, req.user);
   return l.users.list();
 }
-function hostOptions(req, port) {
+function hostOptions(req, port, sealed) {
   return {
     ...req.hostname !== void 0 ? { hostname: req.hostname } : {},
     ...req.users !== void 0 ? { users: req.users } : {},
-    ...req.denials ? { onDenial: (denial) => port.postMessage({ denial }) } : {}
+    ...req.denials ? { onDenial: (denial) => port.postMessage({ denial }) } : {},
+    ...req.sealed ? { sealed } : {}
+  };
+}
+function policyAsker(port) {
+  const policies = /* @__PURE__ */ new Map();
+  let nextPolicy = 0;
+  const askPolicy = (req) => new Promise((resolve) => {
+    const id2 = ++nextPolicy;
+    policies.set(id2, resolve);
+    port.postMessage({ mountPolicy: { id: id2, req } });
+  });
+  return {
+    mountPolicy: (policy) => policy === void 0 ? {} : { processMounts: policy === "ask" ? askPolicy : policy },
+    allowed(data) {
+      const answer = data.mountAllowed;
+      if (!answer) return false;
+      policies.get(answer.id)?.(answer.allowed);
+      policies.delete(answer.id);
+      return true;
+    }
   };
 }
 function serveKernel(port, deps) {
@@ -16403,6 +16656,7 @@ function serveKernel(port, deps) {
   const terminals = /* @__PURE__ */ new Map();
   const reply = (id2, body, transfer) => port.postMessage({ id: id2, ...body }, transfer);
   const clients = /* @__PURE__ */ new Set();
+  const sealed = sealedAsker(port);
   const approvals = sudoApprovals(port);
   const locks = deps.locks === null ? void 0 : deps.locks ?? locksOf();
   let holding;
@@ -16467,7 +16721,7 @@ function serveKernel(port, deps) {
         ...deps.createDriverWorker ? { createDriverWorker: deps.createDriverWorker } : {},
         ...req.modules ? { modules: req.modules } : {},
         ...req.env ? { env: req.env } : {},
-        ...hostOptions(req, port),
+        ...hostOptions(req, port, sealed.hook),
         ...req.approve ? { approve: approvals.ask } : {},
         ...net,
         ...media ? { media } : {},
@@ -16530,23 +16784,13 @@ function serveKernel(port, deps) {
     if (grant) waiting.resolve(grant);
     else waiting.reject(Object.assign(new Error(error ?? "no grant"), { code: "EACCES" }));
   }
-  const policies = /* @__PURE__ */ new Map();
-  let nextPolicy = 0;
-  const askPolicy = (req) => new Promise((resolve) => {
-    const id2 = ++nextPolicy;
-    policies.set(id2, resolve);
-    port.postMessage({ mountPolicy: { id: id2, req } });
-  });
-  const mountPolicy = (policy) => policy === void 0 ? {} : { processMounts: policy === "ask" ? askPolicy : policy };
+  const { mountPolicy, allowed } = policyAsker(port);
   port.addEventListener("message", (event) => {
+    const sealedReply = event.data.sealedReply;
+    if (sealedReply) return sealed.answer(sealedReply);
     const grant = event.data.hostfsGrant;
     if (grant) return granted2(grant);
-    const answer = event.data.mountAllowed;
-    if (answer) {
-      policies.get(answer.id)?.(answer.allowed);
-      policies.delete(answer.id);
-      return;
-    }
+    if (allowed(event.data)) return;
     if (answered(event.data, remote, uplink, approvals)) return;
     const req = event.data;
     handle(req).then(