@ai-ecoverse/slicc-kernel 1.67.1 → 1.68.0

package/dist/node.js

@@ -866,6 +866,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 {
@@ -11182,6 +11183,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",
@@ -11237,6 +11239,7 @@ var WasmProcess = class {
   ignored = 0;
   inherited = 0;
   interrupt = new AbortController();
+  gone = new AbortController();
   dying = false;
   umask = DEFAULT_UMASK;
   cred;
@@ -11459,6 +11462,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");
@@ -11540,6 +11544,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 };
@@ -11660,6 +11682,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": {
@@ -12095,6 +12119,7 @@ var WasmProcess = class {
   async exit() {
     if (this.exited) return;
     this.exited = true;
+    this.gone.abort();
     this.die();
     this.clearAlarm();
     this.interrupt.abort();
@@ -12282,6 +12307,7 @@ function processOptions(opts, header4, 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 } : {},
@@ -12764,6 +12790,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",
@@ -13411,13 +13609,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();
@@ -14898,7 +15096,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;
@@ -15048,12 +15246,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),
@@ -15453,6 +15658,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,
@@ -16091,7 +16297,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,
@@ -16128,7 +16334,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`);
@@ -16665,7 +16871,7 @@ function dialStream(port, onClose) {
 
 // src/client/loopback-fetch.ts
 var OWN_HEADERS = /* @__PURE__ */ new Set(["host", "connection", "content-length", "transfer-encoding"]);
-var encoder4 = new TextEncoder();
+var encoder5 = new TextEncoder();
 var latin12 = new TextDecoder("latin1");
 var ByteSource = class {
   buffered = new Uint8Array(0);
@@ -16683,7 +16889,7 @@ var ByteSource = class {
     return true;
   }
   async until(marker) {
-    const needle = encoder4.encode(marker);
+    const needle = encoder5.encode(marker);
     for (; ; ) {
       const at = indexOf(this.buffered, needle);
       if (at >= 0) return this.take(at + needle.length);
@@ -16791,7 +16997,7 @@ async function requestBytes(request) {
   });
   if (body) lines2.push(`Content-Length: ${body.length}`);
   lines2.push("Connection: close", "", "");
-  const head = encoder4.encode(lines2.join("\r\n"));
+  const head = encoder5.encode(lines2.join("\r\n"));
   const out = new Uint8Array(head.length + (body?.length ?? 0));
   out.set(head);
   if (body) out.set(body, head.length);
@@ -16845,8 +17051,8 @@ var KernelCallError = class extends Error {
     this.code = code;
   }
 };
-var encoder5 = new TextEncoder();
-var bytesOf2 = (data) => typeof data === "string" ? encoder5.encode(data) : data;
+var encoder6 = new TextEncoder();
+var bytesOf2 = (data) => typeof data === "string" ? encoder6.encode(data) : data;
 var UNAVAILABLE = {
   manualRedirects: false,
   encodedBodies: false,
@@ -17264,8 +17470,8 @@ function nodeWorker(file, live, closed) {
 }
 function textOf(on) {
   if (!on) return void 0;
-  const decoder2 = new TextDecoder();
-  return (bytes) => on(decoder2.decode(bytes, { stream: true }));
+  const decoder3 = new TextDecoder();
+  return (bytes) => on(decoder3.decode(bytes, { stream: true }));
 }
 async function createNodeKernel(options = {}) {
   const root = options.root ?? memoryRoot();
@@ -17298,6 +17504,7 @@ async function createNodeKernel(options = {}) {
     ...options.hostname !== void 0 ? { hostname: options.hostname } : {},
     ...options.users !== void 0 ? { users: options.users } : {},
     ...options.onDenial ? { onDenial: options.onDenial } : {},
+    ...options.sealed ? { sealed: options.sealed } : {},
     ...options.approve ? { approve: options.approve } : {}
   });
   await launcher.prepare();
@@ -17306,7 +17513,7 @@ async function createNodeKernel(options = {}) {
     pending.add(reject);
     work().then(resolve, reject).finally(() => pending.delete(reject));
   });
-  const decoder2 = new TextDecoder();
+  const decoder3 = new TextDecoder();
   return {
     root,
     async run(argv, opts = {}) {
@@ -17323,8 +17530,8 @@ async function createNodeKernel(options = {}) {
       );
       return {
         status: result.status,
-        stdout: decoder2.decode(result.stdout),
-        stderr: decoder2.decode(result.stderr)
+        stdout: decoder3.decode(result.stdout),
+        stderr: decoder3.decode(result.stderr)
       };
     },
     async openTerminal(argv, opts = {}) {