@ai-ecoverse/slicc-kernel 1.88.0 → 1.88.1

package/README.md

@@ -659,7 +659,7 @@ The kernel then asks the hook `{ v: 1, op: 'materializeConsume', ticket, stamp,
 - `interpreters` is the chain of `#!` and `binfmt` interpreters the kernel will really run, outermost first, each absolute with its symlinks resolved, and empty for a program of the catalog (Emscripten, WASI or JS) and the `/usr/bin/<name>` entries for one. A plain `#!/usr/bin/env X` (or `env -S X …`) is reported as `X`: a command of the catalog as `/usr/bin/X`, a script command by its file. `env` with any other option or a `NAME=value` assignment is run and reported as `/usr/bin/env` itself;
 - `trusted` is true when the program and every interpreter are regular files owned by root and not writable by group or others, under directories that are all the same, up to `/` (for a command of the catalog, its package files). It's false unless `users` is `'enforce'`: under `'off'` files have no owners, and under `'report'` owners don't stop a write. The reply must be `{ values, placeholders }` (string maps) within 10 s; anything else is `EACCES`. Each variable of the child's environment whose value is exactly `placeholders[NAME]` gets `values[NAME]`; nothing else changes. The kernel keeps no copy and logs nothing of either. Like any environment, the values are inherited by whatever the child itself spawns or execs, as on Linux. A ticket isn't carried across `sudo`, which builds its own environment: a `sudo` run with `SLICC_SEALED_TICKET` set fails with `EACCES`, and burns the ticket.
 
-**The child's output is scrubbed (S2).** The kernel compiles a [slicc-scrub](https://github.com/ai-ecoverse/slicc-scrub) scrubber (1.0.0, bundled; the published package has no runtime dependency) over exactly the values it swapped in, and gives the child new open file descriptions for fd 1 and fd 2, for every other descriptor it holds on the same descriptions (a `dup` of them), and for every descriptor on a terminal (fd 0 of a terminal session is one), that pass every write through it into the originals (one wrapper per original description, so `2>&1` keeps its order). A value appears as its placeholder, and a fragment or encoded form of it (JSON, percent, HTML, base64, hex, wrapped) as `[redacted:NAME]`. Bytes go through at once unless they may still be the start of a match; such a tail is let out after 50 ms without a write when it's shorter than 16 bytes, and otherwise at the next write or at close. The child's descendants inherit the scrubbed descriptions through fork, spawn, exec and `dup`, and a descendant that opens its controlling terminal (`/dev/tty`, or a terminal by name) gets one scrubbed too, as does a pseudo-terminal slave (`/dev/pts/N`) or [`/dev/clipboard`](#devclipboard) it opens, and a `/dev/clipboard` descriptor it inherited is wrapped at the redeem like fd 1 and 2, so the page's clipboard gets placeholders, never the values. Files, sockets and pipes the child or a descendant opens itself are not scrubbed, so `printf %s "$T" > f` writes the value. A scrubbed fd 1 or 2 is a stream: it doesn't seek. A descendant that redeems a ticket of its own adds its values: its output is scrubbed for both sets. A value under 8 bytes is swapped but can't be scrubbed. The scrubber goes when the last process and description holding it do.
+**The child's output is scrubbed (S2).** The kernel compiles a [slicc-scrub](https://github.com/ai-ecoverse/slicc-scrub) scrubber (1.0.0, bundled; the published package has no runtime dependency) over exactly the values it swapped in, and gives the child new open file descriptions for fd 1 and fd 2, for every other descriptor it holds on the same descriptions (a `dup` of them), and for every descriptor on a terminal (fd 0 of a terminal session is one), that pass every write through it into the originals (one wrapper per original description, so `2>&1` keeps its order). A value appears as its placeholder, and a fragment or encoded form of it (JSON, percent, HTML, base64, hex, wrapped) as `[redacted:NAME]`. Bytes go through at once unless they may still be the start of a match; such a tail is let out after 50 ms without a write when it's shorter than 16 bytes, and otherwise at the next write or at close. The child's descendants inherit the scrubbed descriptions through fork, spawn, exec and `dup`, and a descendant that opens its controlling terminal (`/dev/tty`, or a terminal by name) gets one scrubbed too, as does a pseudo-terminal slave (`/dev/pts/N`) or [`/dev/clipboard`](#devclipboard) it opens, and a `/dev/clipboard` descriptor it inherited is wrapped at the redeem like fd 1 and 2, so the page's clipboard gets placeholders, never the values. Files, sockets and pipes the child or a descendant opens itself are not scrubbed, so `printf %s "$T" > f` writes the value. A scrubbed fd 1 or 2 is a stream: it doesn't seek. Under `O_NONBLOCK` it gives `EAGAIN` when the pipe or terminal under it would. A write that finds room returns at once, taking at most 64 KiB, and the scrubbed bytes the file couldn't take yet go out before anything written later. Until they have, `poll` reports it unwritable and a nonblocking write gets `EAGAIN`, taking nothing. A blocking write that waits for them, or for room, ends with `EINTR` at a signal, taking nothing; one interrupted after it began writing returns its whole count, and the rest follows. A descendant that redeems a ticket of its own adds its values: its output is scrubbed for both sets. A value under 8 bytes is swapped but can't be scrubbed. The scrubber goes when the last process and description holding it do.
 
 ### `/dev/clipboard`
 

package/dist/kernel-worker.js

@@ -4580,12 +4580,12 @@ async function interruptible(work, signal) {
   if (signal.aborted) throw new KernelError("EINTR");
   let stop = () => {
   };
-  const interrupted2 = new Promise((_, reject) => {
+  const interrupted3 = new Promise((_, reject) => {
     stop = () => reject(new KernelError("EINTR"));
     signal.addEventListener("abort", stop, { once: true });
   });
   try {
-    return await Promise.race([work, interrupted2]);
+    return await Promise.race([work, interrupted3]);
   } finally {
     signal.removeEventListener("abort", stop);
   }
@@ -9594,11 +9594,12 @@ var MountFs = class {
     });
   }
   async chmod(path, mode) {
-    const found = this.at(path);
-    if (!found) return this.base.chmod(path, mode);
-    this.writable(found.mount, normalizePath(path));
+    const real = await this.follow(path);
+    const found = this.at(real);
+    if (!found) return this.base.chmod(real, mode);
+    this.writable(found.mount, real);
     if (!found.mount.caps.chmod) return;
-    this.table.forget(found.mount, normalizePath(path));
+    this.table.forget(found.mount, real);
     await found.mount.conn.call({ op: "setattr", path: found.rel, mode });
   }
   async utimes(path, atime, mtime) {
@@ -10615,7 +10616,7 @@ function mountTable(mounts = []) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.88.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.88.1" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -12182,16 +12183,16 @@ function interruption(signal) {
 }
 async function selectFds(fds, read, write, timeoutMs, interrupt) {
   const deadline = timeoutMs < 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
-  const interrupted2 = interruption(interrupt);
-  interrupted2.promise.catch(() => {
+  const interrupted3 = interruption(interrupt);
+  interrupted3.promise.catch(() => {
   });
   try {
-    return await waitReady(fds, read, write, deadline, interrupted2.promise);
+    return await waitReady(fds, read, write, deadline, interrupted3.promise);
   } finally {
-    interrupted2.done();
+    interrupted3.done();
   }
 }
-async function waitReady(fds, read, write, deadline, interrupted2) {
+async function waitReady(fds, read, write, deadline, interrupted3) {
   for (; ; ) {
     const now = ready(fds, read, write);
     if (now.read.length > 0 || now.write.length > 0 || Date.now() >= deadline) return now;
@@ -12203,7 +12204,7 @@ async function waitReady(fds, read, write, deadline, interrupted2) {
     let timer;
     const expiry = deadline === Number.POSITIVE_INFINITY ? [] : [new Promise((resolve2) => timer = setTimeout(resolve2, deadline - Date.now()))];
     try {
-      await Promise.race([...changes, ...expiry, interrupted2]);
+      await Promise.race([...changes, ...expiry, interrupted3]);
     } finally {
       round.abort();
       clearTimeout(timer);
@@ -15132,63 +15133,137 @@ function compile(secrets, options = {}) {
 
 // src/kernel/scrub-file.ts
 var SCRUB_IDLE_MS = 50;
+var SCRUB_NONBLOCK_MAX = 64 * 1024;
 var encoder5 = new TextEncoder();
 function scrubberOf(secrets) {
   const usable = secrets.filter((s) => encoder5.encode(s.value).length >= MIN_VALUE);
   return usable.length > 0 ? compile(usable, { idleMs: SCRUB_IDLE_MS }) : void 0;
 }
-async function writeAll2(file, bytes, signal) {
+async function writeAll2(file, bytes) {
   const write = file.write;
-  for (let at = 0; at < bytes.length; ) {
-    at += await write.call(file, bytes.subarray(at), at === 0 ? signal : void 0);
-  }
+  for (let at = 0; at < bytes.length; ) at += await write.call(file, bytes.subarray(at));
 }
 function bound(file, key) {
   const method = file[key];
   return typeof method === "function" ? { [key]: method.bind(file) } : {};
 }
+function interrupted2(err) {
+  const code = err?.code;
+  return code === "EINTR" || code === "EAGAIN";
+}
 function scrubbed(inner, scrubber, idleMs = SCRUB_IDLE_MS) {
   const file = inner.file;
   const stream = scrubber.stream();
-  let queue = Promise.resolve();
+  let tail = Promise.resolve();
+  let pending = 0;
+  let busy = false;
   let timer;
   let failed3;
+  const waiters = /* @__PURE__ */ new Set();
+  const quiet = () => !busy && pending === 0;
+  const wake = () => {
+    for (const waiter of [...waiters]) waiter();
+  };
   const raise = () => {
     if (failed3 === void 0) return;
     const err = failed3;
     failed3 = void 0;
     throw err;
   };
-  const enqueue = (bytes, signal) => {
-    const next2 = queue.then(() => bytes.length > 0 ? writeAll2(file, bytes, signal) : void 0);
-    queue = next2.catch(() => void 0);
-    return next2;
+  const later = (bytes) => {
+    if (bytes.length === 0) return;
+    pending += 1;
+    tail = tail.then(() => writeAll2(file, bytes)).catch((err) => {
+      if (failed3 === void 0) failed3 = err;
+    }).finally(() => {
+      pending -= 1;
+      if (quiet()) wake();
+    });
+  };
+  const settling = (signal) => new Promise((resolve2, reject) => {
+    const done4 = () => {
+      waiters.delete(done4);
+      signal?.removeEventListener("abort", stop);
+      resolve2();
+    };
+    const stop = () => {
+      waiters.delete(done4);
+      reject(new KernelError("EINTR"));
+    };
+    if (signal?.aborted) return stop();
+    waiters.add(done4);
+    signal?.addEventListener("abort", stop, { once: true });
+  });
+  const settled = async () => {
+    while (!quiet()) await settling();
+  };
+  const changed = async (signal) => {
+    const round = new AbortController();
+    const stop = signal ? AbortSignal.any([signal, round.signal]) : round.signal;
+    try {
+      const own = settling(stop);
+      await Promise.race(file.changed ? [own, file.changed(stop)] : [own]);
+    } catch (err) {
+      throw signal?.aborted ? new KernelError("EINTR") : err;
+    } finally {
+      round.abort();
+    }
+  };
+  const turn = async (signal) => {
+    for (let waited = false; ; waited = true) {
+      if (quiet() && (pollFile(file).writable || !file.changed)) {
+        busy = true;
+        return;
+      }
+      if (signal?.aborted) throw new KernelError(waited ? "EINTR" : "EAGAIN");
+      await changed(signal);
+    }
+  };
+  const send = async (out, signal) => {
+    const write = file.write;
+    for (let at = 0; at < out.length; ) {
+      try {
+        at += await write.call(file, out.subarray(at), signal);
+      } catch (err) {
+        if (!signal?.aborted || !interrupted2(err)) throw err;
+      }
+      if (at < out.length && signal?.aborted) return later(out.subarray(at));
+    }
   };
   const release = () => {
     timer = void 0;
-    enqueue(stream.idle()).catch((err) => {
-      failed3 = err;
-    });
+    later(stream.idle());
   };
   return new OpenFile({
     ...bound(file, "read"),
     ...bound(file, "peek"),
-    ...bound(file, "poll"),
-    ...bound(file, "changed"),
     ...bound(file, "stat"),
+    poll: () => {
+      const state = pollFile(file);
+      return quiet() ? state : { ...state, writable: false };
+    },
+    changed,
     ...file.tty ? { tty: file.tty } : {},
     ...file.clipboard ? { clipboard: file.clipboard } : {},
     ...file.write ? {
       write: async (bytes, signal) => {
-        if (timer !== void 0) clearTimeout(timer);
-        raise();
-        await enqueue(stream.push(bytes), signal);
+        await turn(signal);
+        const taken = signal?.aborted && bytes.length > SCRUB_NONBLOCK_MAX ? bytes.subarray(0, SCRUB_NONBLOCK_MAX) : bytes;
+        try {
+          raise();
+          if (timer !== void 0) clearTimeout(timer);
+          timer = void 0;
+          await send(stream.push(taken), signal);
+        } finally {
+          busy = false;
+          if (quiet()) wake();
+        }
         timer = setTimeout(release, idleMs);
-        return bytes.length;
+        return taken.length;
       }
     } : {},
     flush: async () => {
-      await queue;
+      await settled();
       raise();
       await file.flush?.();
     },
@@ -15196,7 +15271,9 @@ function scrubbed(inner, scrubber, idleMs = SCRUB_IDLE_MS) {
       if (timer !== void 0) clearTimeout(timer);
       let failure2;
       try {
-        await enqueue(stream.end());
+        await settled();
+        later(stream.end());
+        await settled();
         raise();
       } catch (err) {
         failure2 = { err };
@@ -15372,12 +15449,12 @@ var SealedChannel = class {
     if (signal.aborted) throw new KernelError("EINTR");
     let stop = () => {
     };
-    const interrupted2 = new Promise((_, reject) => {
+    const interrupted3 = new Promise((_, reject) => {
       stop = () => reject(new KernelError("EINTR"));
       signal.addEventListener("abort", stop, { once: true });
     });
     try {
-      await Promise.race([flight.done, interrupted2]);
+      await Promise.race([flight.done, interrupted3]);
     } finally {
       signal.removeEventListener("abort", stop);
     }
@@ -18340,11 +18417,9 @@ var Launcher = class {
   groupSession(pgid) {
     return this.jobs.sessionOf(pgid);
   }
-  treeScrubs(pid, req) {
+  treeScrubs(req) {
     const inherited2 = req.ppid !== void 0 ? this.scrubs.get(req.ppid) : void 0;
-    const scrubs = req.scrub ? [...inherited2 ?? [], req.scrub] : inherited2;
-    if (scrubs) this.scrubs.set(pid, scrubs);
-    return scrubs;
+    return req.scrub ? [...inherited2 ?? [], req.scrub] : inherited2;
   }
   start(req) {
     this.sampling();
@@ -18352,7 +18427,7 @@ var Launcher = class {
       throw new SpawnError("ESRCH");
     }
     const pid = req.pid ?? this.nextPid++;
-    const scrubs = this.treeScrubs(pid, req);
+    const scrubs = this.treeScrubs(req);
     const stack = this.stackFor(req.tag);
     const terminal = req.fds.stdioTerminal();
     const decided = req.decided ?? Promise.resolve(true);
@@ -18422,6 +18497,7 @@ var Launcher = class {
       ...this.shownIds(req)
     });
     this.processes.set(pid, handle);
+    if (scrubs) this.scrubs.set(pid, scrubs);
     const { cred } = req;
     this.creds.set(pid, () => handle.cred?.() ?? copyCred(cred));
     if (req.tag !== void 0) this.tags.set(pid, req.tag);