@ai-ecoverse/slicc-kernel 1.139.0 → 1.140.0

package/README.md

@@ -610,7 +610,7 @@ The kernel answers DNS itself, so DNS clients (BIND's `dig`, `host` and `nslooku
 ### Node name
 
 The kernel has one node name, `slicc` unless `createKernel({ hostname })` (or `createNodeKernel`) names another; it must be a valid host name, and not `localhost`, a `*.localhost` name, `host.slicc.internal`, `wasmer.sh` or an IPv4 address, or `createKernel` rejects. `no_proxy` lists it (and `emscripten`), so HTTP clients reach the kernel's own servers by it directly.
-- **Where programs see it:** every process gets it in `HOSTNAME`, which the kernel sets on every start whatever the caller's environment says. Emscripten programs also see it in `/etc/hostname` (next to the synthetic `/etc/hosts` and `/etc/passwd`, which only they have; WASI programs resolve names through the kernel instead) and in `Module.sliccKernel.hostname`.
+- **Where programs see it:** every process gets it in `HOSTNAME`, which the kernel sets on every start whatever the caller's environment says. Every program can read it from `/etc/hostname`: the node name and a newline, a `0644` root-owned file that a real `/etc/hostname` in the root replaces ([#1297](https://github.com/ai-ecoverse/slicc-kernel/issues/1297)). Emscripten programs also have the synthetic `/etc/hosts` and `/etc/passwd`, which only they have (WASI programs resolve names through the kernel instead), and `Module.sliccKernel.hostname`.
 - **What `uname` says:** for an Emscripten program built with homescoop's `__syscall_uname` import (wasm-coreutils 9.12.0-7 on), the kernel answers `uname(2)`: sysname `Linux`, nodename the node name, release `6.0.0-slicc` (as `/proc/sys/kernel/osrelease`), version `#1 SMP PREEMPT_DYNAMIC` (as `/proc/version`), machine `wasm32` and domainname `(none)`, so `uname -a` and musl's `gethostname()` see them. `uname -o` is coreutils' compiled-in `Emscripten`. Older Emscripten builds still report their C library's `Emscripten 4.0.23` and `emscripten`, and WASIX programs `wasmer.sh`; the kernel has nothing to answer there.
 - **Resolving it:** `/etc/hosts` maps the node name and both of those names to `127.0.1.1` (Debian's convention), and name resolution answers them, and `localhost.localdomain`, itself, as `127.0.1.1` and `::1`. So a program that looks up its own host name, as git does for every commit, never asks the [uplink](#uplink), and `127.0.1.1` is the kernel's loopback.
 - **The trade-off:** a raw connection to the real `wasmer.sh` resolves to loopback too. HTTP(S) to it still goes through the realm proxy and the transport, which resolve names themselves; `wasmer.sh` is deliberately not in `no_proxy`.
@@ -1235,7 +1235,7 @@ Releases are cut by semantic-release on every push to `main`, in two jobs, and o
 
 Every change is certified in its pull request, before it merges (`cert-review-pr.yml`, next section), and `cert-review` is a required check of the merge queue, so every commit on `main`, and every release built from it, was certified first. A release is then **verified on npm** (`release / verify on npm` in `release.yml`, `tools/cert-review/verify.mjs`), in code, for every tag the run made:
 
-- It waits up to an hour for npm to serve the version (an accepted publish can take a while to appear; 1.125.4 took 55 min). `release-recover` logs `npm publish`'s own output every time, and says PASS for a version it published only once npm serves it (the tarball answers) with `dist.integrity` equal to the tarball it packed; the reference is the `integrity` of `npm publish --json`'s own report, the bytes npm uploaded (a separate pack isn't byte-identical; 1.136.1 was served fine and still read as not served), and it publishes from the folder, never a tarball, so the packument keeps `gitHead`; an exit 0 without a report fails, and a version npm says is already published has no report, so it's only checked for being served; a version npm took but doesn't serve so after 25 min is `release-recover: INCOMPLETE`, and the publish job fails (#1228: 1.134.2 was taken, never served, and still read as PASS). A version semantic-release itself just published is handed to this job instead. A version npm still doesn't serve after the hour, and doesn't list, while a newer one of ours is its `latest`, ends with `verify: SKIPPED <name>@<version>: never served by npm; superseded by <latest>` (the gate takes SKIPPED like PASS); only after the whole wait, since a slow version can appear late and must not go unverified. SKIPPED writes no certified line, so nothing downstream reads it as certified; if npm serves a skipped version later, the coordinator's merge watchdog notes it within 10 min (any version that appears below npm's `latest`), and the coordinator re-runs `release / verify on npm` in that version's Release run for the normal verdict, the certified line or the supply-chain alert. One npm still doesn't serve, with nothing newer or a version list it can't read, is a "not served yet, re-run" failure, never a supply-chain alert. It then downloads the tarball and checks `dist.integrity` (sha512), the SLSA v1 provenance (the tarball's sha512 is its subject; `release.yml` on `refs/heads/main`, a GitHub-hosted builder; `gitCommit` = `gitHead` = the tag, on `main`), and `npm audit signatures`. npm serves a version's attestations a little after the version itself, so a 404 from the attestations, a missing `dist.attestations`, an `npm view` or network error while looking for them, or `npm audit signatures`' E404 on them, is retried within the same hour: it's a supply-chain alert only once the version has been served for 30 min, its packument has stopped changing for 10, and the attestations still answer 404, or the hour has run out. Any other status, or attestations that don't match, fail at once. A version that `release-recover.mjs` skipped because npm's `latest` is newer (#837) has nothing to verify.
+- It waits up to an hour for npm to serve the version (an accepted publish can take a while to appear; 1.125.4 took 55 min). `release-recover` publishes a version it has to recover with a plain `npm publish --provenance` from the folder (so the packument keeps `gitHead`) and logs npm's own exit code and output; it fails only on npm's own non-zero exit, and npm's "cannot publish over the previously published version" on a re-run counts as already done. Whether npm serves the version is this job's to check. A version npm still doesn't serve after the hour, and doesn't list, while a newer one of ours is its `latest`, ends with `verify: SKIPPED <name>@<version>: never served by npm; superseded by <latest>` (the gate takes SKIPPED like PASS); only after the whole wait, since a slow version can appear late and must not go unverified. SKIPPED writes no certified line, so nothing downstream reads it as certified; if npm serves a skipped version later, the coordinator's merge watchdog notes it within 10 min (any version that appears below npm's `latest`), and the coordinator re-runs `release / verify on npm` in that version's Release run for the normal verdict, the certified line or the supply-chain alert. One npm still doesn't serve, with nothing newer or a version list it can't read, is a "not served yet, re-run" failure, never a supply-chain alert. It then downloads the tarball and checks `dist.integrity` (sha512), the SLSA v1 provenance (the tarball's sha512 is its subject; `release.yml` on `refs/heads/main`, a GitHub-hosted builder; `gitCommit` = `gitHead` = the tag, on `main`), and `npm audit signatures`. npm serves a version's attestations a little after the version itself, so a 404 from the attestations, a missing `dist.attestations`, an `npm view` or network error while looking for them, or `npm audit signatures`' E404 on them, is retried within the same hour: it's a supply-chain alert only once the version has been served for 30 min, its packument has stopped changing for 10, and the attestations still answer 404, or the hour has run out. Any other status, or attestations that don't match, fail at once. A version that `release-recover.mjs` skipped because npm's `latest` is newer (#837) has nothing to verify.
 - It then writes `certified @ai-ecoverse/slicc-kernel@<v> sha256=<64 hex> (covers <first>–<v>; ci: <run>; pr-certified: <each merged pull request's cert-review at its merge>; known: <open known-issue issues>)` into the GitHub release's notes, between `<!-- cert-verify -->` markers. homescoop's ci reads exactly that prefix and re-hashes the npm tarball against it. `covers` starts after the last version npm serves, so a skipped version is covered by the next. Notes that already carry the identical line stay unchanged. A pull request's `cert-review` is the newest finished one (success, failure or error) on its head at or before its merge, or the newest pending one if none had finished. A re-review that a later `ready_for_review`, `reopened` or `cert-review-approved` event starts on the same head, still pending at the merge or ending after it, doesn't change what the merge queue saw, and a status posted after the merge can't change a release's line.
 - A mismatch writes no line. The job is red with a `supply-chain alert`, and so is a line already in the notes with another sha256.
 

package/dist/kernel-worker.js

@@ -178,13 +178,13 @@ var IndexedDbMeta = class {
     return [transaction, transaction.objectStore(META_STORE)];
   }
   async get(paths) {
-    const missing4 = paths.filter((path) => !this.cache.has(path));
-    if (missing4.length > 0) {
+    const missing5 = paths.filter((path) => !this.cache.has(path));
+    if (missing5.length > 0) {
       this.settleRemoves();
       const generation = this.generation;
       const [transaction, store] = this.transaction("readonly");
       const found = /* @__PURE__ */ new Map();
-      for (const path of missing4) {
+      for (const path of missing5) {
         const request3 = store.get(path);
         request3.onsuccess = () => void found.set(path, request3.result ?? null);
       }
@@ -7125,7 +7125,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.139.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.140.0" : "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
@@ -9805,6 +9805,70 @@ function devCreation(path, cred) {
   return cred && cred.euid !== 0 ? "EACCES" : "EPERM";
 }
 
+// src/fs/etc-files.ts
+var HOSTNAME_PATH = "/etc/hostname";
+var S_IFREG3 = 32768;
+function missing4(err) {
+  return err?.code === "ENOENT";
+}
+function statOf(path, bytes) {
+  const epoch = /* @__PURE__ */ new Date(0);
+  return {
+    isFile: true,
+    isDirectory: false,
+    isSymbolicLink: false,
+    size: bytes.length,
+    mode: S_IFREG3 | 420,
+    mtime: epoch,
+    atime: epoch,
+    ctime: epoch,
+    ino: inodeOf(path),
+    nlink: 1,
+    uid: 0,
+    gid: 0
+  };
+}
+function withEtcFiles(fs, files) {
+  const bytesOf2 = (path) => {
+    const text = files.get(path)?.();
+    return text === void 0 ? void 0 : new TextEncoder().encode(text);
+  };
+  const absent2 = (path) => fs.lstat(path).then(() => false, missing4);
+  const fallback = (path, make) => async (err) => {
+    const bytes = missing4(err) && files.has(path) && await absent2(path) ? bytesOf2(path) : void 0;
+    if (bytes === void 0) throw err;
+    return make(bytes);
+  };
+  const ranged2 = rangedOps(fs);
+  const own = {
+    stat: (path) => fs.stat(path).catch(fallback(path, (b) => statOf(path, b))),
+    lstat: (path) => fs.lstat(path).catch(fallback(path, (b) => statOf(path, b))),
+    exists: async (path) => await fs.exists(path) || files.has(path) && await absent2(path),
+    ...fs.createExclusive ? {
+      createExclusive: async (path, owner) => {
+        if (files.has(path) && await absent2(path)) throw fsError("EEXIST", path);
+        return fs.createExclusive.call(
+          fs,
+          path,
+          owner
+        );
+      }
+    } : {},
+    readFile: (path) => fs.readFile(path).catch(fallback(path, (b) => new TextDecoder().decode(b))),
+    readFileBuffer: (path) => fs.readFileBuffer(path).catch(fallback(path, (b) => b)),
+    ...ranged2 ? {
+      pread: (path, offset, length2, version) => ranged2.pread(path, offset, length2, version).catch(fallback(path, (b) => b.slice(offset, offset + length2)))
+    } : {}
+  };
+  return new Proxy(fs, {
+    get(target, key, receiver) {
+      if (Object.hasOwn(own, key)) return own[key];
+      const value2 = Reflect.get(target, key, receiver);
+      return typeof value2 === "function" ? value2.bind(target) : value2;
+    }
+  });
+}
+
 // src/fs/fresh-modules.ts
 var MAGIC = [0, 97, 115, 109];
 var MAX_FRESH = 65536;
@@ -11260,7 +11324,7 @@ function inodeless(mount, attr2) {
   if (mount.caps.links) mount.caps = { ...mount.caps, links: false };
   return true;
 }
-function statOf(attr2, path, mount) {
+function statOf2(attr2, path, mount) {
   const mtime = new Date(attr2.mtime);
   const fallback = attr2.kind === "directory" ? 16877 : attr2.kind === "symlink" ? 41471 : attr2.kind === "fifo" ? 4516 : 33188;
   return {
@@ -11732,7 +11796,7 @@ var MountFs = class _MountFs {
     const { mount, rel: rel2 } = found;
     if (!owner || !mount.owners || !mount.caps.owners) return void 0;
     const dir = parentOf7(real);
-    const above = statOf(await this.table.getattr(mount, dir, parentOf7(rel2)), dir, mount);
+    const above = statOf2(await this.table.getattr(mount, dir, parentOf7(rel2)), dir, mount);
     const setgid = (above.mode & S_ISGID4) !== 0;
     let mode = owner.mode;
     if (directory && setgid) mode = (mode ?? 493) | S_ISGID4;
@@ -12064,7 +12128,7 @@ var MountFs = class _MountFs {
   }
   statWriting(attr2, real, mount) {
     const ends = (this.table.writing(real)?.extents ?? []).map(([, end]) => end);
-    return statOf({ ...attr2, size: Math.max(attr2.size, ...ends) }, real, mount);
+    return statOf2({ ...attr2, size: Math.max(attr2.size, ...ends) }, real, mount);
   }
   async stat(path, redirects = 0) {
     const real = await this.follow(path);
@@ -15475,11 +15539,11 @@ function ipv6(host) {
   const back = halves.length === 2 ? groups(halves[1]) : [];
   if (![...head, ...back].every((g) => /^[0-9A-Fa-f]{1,4}$/.test(g))) return void 0;
   const words2 = [...head, ...back].map((g) => Number.parseInt(g, 16));
-  const missing4 = 8 - words2.length - tail2.length;
-  if (halves.length === 2 ? missing4 < 1 : missing4 !== 0) return void 0;
+  const missing5 = 8 - words2.length - tail2.length;
+  if (halves.length === 2 ? missing5 < 1 : missing5 !== 0) return void 0;
   const all = [
     ...head.map((g) => Number.parseInt(g, 16)),
-    ...new Array(halves.length === 2 ? missing4 : 0).fill(0),
+    ...new Array(halves.length === 2 ? missing5 : 0).fill(0),
     ...back.map((g) => Number.parseInt(g, 16)),
     ...tail2
   ];
@@ -27888,13 +27952,13 @@ function interpreter(head) {
 function expandDefaults(defaults2, env) {
   const out = {};
   for (const [key, value2] of Object.entries(defaults2 ?? {})) {
-    let missing4 = false;
+    let missing5 = false;
     const expanded = value2.replace(ENV_REFERENCE, (_, name2) => {
       const set3 = Object.hasOwn(env, name2) ? env[name2] : void 0;
-      if (set3 === void 0) missing4 = true;
+      if (set3 === void 0) missing5 = true;
       return set3 ?? "";
     });
-    if (!missing4) out[key] = expanded;
+    if (!missing5) out[key] = expanded;
   }
   return out;
 }
@@ -30065,7 +30129,8 @@ var Launcher = class {
   }
   commandFs(root) {
     return withCommandDirs(
-      root,
+      withEtcFiles(root, /* @__PURE__ */ new Map([[HOSTNAME_PATH, () => `${this.hostname}
+`]])),
       async () => this.commandNames(await this.commands()),
       (dir) => this.userCommandDir(dir),
       this.owners,