@ai-ecoverse/slicc-kernel 1.139.1 → 1.140.1

package/README.md

@@ -330,7 +330,7 @@ On top of preview1 a WASI program gets:
   A kernel without the imports answers `ENOSYS`, and the libc reports `SI_USER` with pid and uid 0, as before. **SIGCHLD:** with `SIGCHLD` set to `SIG_IGN` (by the program, or inherited), or with `SA_NOCLDWAIT` in the flags `slicc.sigaction_set` gets for `SIGCHLD`, an exited child is reaped at once and never stays a zombie: `waitpid` for it is `ECHILD`, and `wait` blocks until every child has exited, then fails with `ECHILD`, as on Linux. `SIGCHLD` is still sent. An explicit `SIG_DFL` turns it back off. A child that a process waits on for `exec`, or that `kernel.run` and the run calls collect, is never reaped that way.
 - **Pipes** have no file type for WASI and WASIX programs' `fstat` (`st_mode` type 0), because WASI has no FIFO file type. A socket type, as kernels 1.47.3 to 1.48.1 gave them, made Ruby treat a `popen` pipe as a socket (`close_write` then never ends the child's input). The kernel's `slicc_fs.fd_mode` answers `S_IFIFO | 0600` (Linux numbering) for a pipe, and wasix-sysroot 2025.9.30-21 and later take the type from it, so programs built on it see a FIFO (`S_ISFIFO`); older libcs keep only the permission bits. Until then Python's asyncio refuses a pipe for a subprocess (`Pipe transport is only for pipes, sockets and character devices`). They are read and written as pipes; socket calls on them fail with `ENOTSOCK`, and `isatty()` is false. Emscripten programs, bash included, see a FIFO. The same holds for any kernel descriptor that is neither seekable nor a terminal or device, such as captured output.
 - **Sockets**: the WASIX socket calls (`sock_open`, `sock_pair` for an `AF_UNIX` stream or datagram pair, `bind`, `listen`, `connect`, `accept`, options, local and peer names) are the kernel's loopback sockets, and preview1's `sock_recv` / `sock_send` / `sock_shutdown` work on them and on inherited ones. Writing to a socket whose peer is gone fails with `EPIPE`, through `fd_write` as through `sock_send`, as if `MSG_NOSIGNAL` were set. A write to a pipe, FIFO or terminal whose reader is gone follows the program's `SIGPIPE` disposition, as the kernel knows it (#810): at the default it ends the program with status 141; ignored (also an ignore inherited across `exec` and spawn, as bash's `trap '' PIPE` passes on), the write fails with `EPIPE`; with a handler, the handler runs on the thread that wrote and then the write fails with `EPIPE` (#820); blocked, `SIGPIPE` stays pending and the write fails with `EPIPE`. An Emscripten program's write to a pipe, and its `send` without `MSG_NOSIGNAL`, follow the same rules, except that the kernel doesn't see an Emscripten program's signal mask, so a blocked `SIGPIPE` there still ends it. A WASIX program's libc reads an inherited ignore back through `slicc.sigaction_inherited` (wasix-sysroot -32 and later; see below). An Emscripten program's shim reads it from `Module.sliccKernel.sigInherited()` (#965, homescoop#973). That's a mask with bit n set for signal n (not bit n-1, as the WASIX import has it) holding only inherited `SIG_IGN`s, never `SIGKILL` or `SIGSTOP`. The shim seeds its `sigaction` table from it in a constructor that runs before any user constructor. The kernel puts the function on `Module.sliccKernel` before the glue runs constructors, ahead of the rest of `sliccKernel`. On a kernel without the function it is undefined, and the shim keeps the defaults. HTTP and HTTPS leave through the realm proxy that `https_proxy` names, as for any other program; `resolve` answers `/etc/hosts` names and literal addresses, and the [uplink](#uplink)'s names. `sock_open(SOCK_DGRAM)` on `AF_INET`/`AF_INET6` gives a [datagram socket](#datagram-sockets-udp); `sock_send_to` and `sock_recv_from` carry its addresses, and `RECV_DATA_TRUNCATED` is set in `ro_flags` when a datagram did not fit.
-- **Diagnostics**: a trap ends the program with 134 and its message on stderr; a program that crashes its worker otherwise (a JS stack overflow, `RangeError: Maximum call stack size exceeded`, or any other uncaught error) ends with 70, and its message goes to the process's own fd 2 too, so `2>` catches it (#1237), or to the session's stderr when it has no fd 2 to write; with `SLICC_WASM_BACKTRACE=1` the wasm frames follow, named from the module's name section, or from a sidecar for a module shipped without one (`<module>.names` beside it, or the same path in a `<package>-names` package). `SLICC_WASI_STATS=1` makes a program print its calls, counted and timed, as it ends.
+- **Diagnostics**: a trap ends the program with 134 and its message on stderr; a program that crashes its worker otherwise (a JS stack overflow, `RangeError: Maximum call stack size exceeded`, or any other uncaught error) ends with 70, and its message goes to the process's own fd 2 too, so `2>` catches it (#1237), or to the session's stderr when it has no fd 2 to write; with `SLICC_WASM_BACKTRACE=1` the wasm frames follow, named from the module's name section, or from a sidecar for a module shipped without one (`<module>.names` beside it, or the same path in a `<package>-names` package). A sidecar that doesn't fit the module, naming another number of functions than the module has (imported and defined), gets one warning line before the trap message, and the frames keep their raw indices instead of wrong names (#1239). `SLICC_WASI_STATS=1` makes a program print its calls, counted and timed, as it ends.
 
 ### Program imports
 
@@ -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`.

package/dist/kernel-worker.js

@@ -118,8 +118,9 @@ var MemoryMeta = class {
     this.entries.set(to, moved(root(carried.find((entry) => entry.path === from)), to));
     if (left) this.entries.set(from, left);
   }
-  async remove(paths) {
+  async remove(paths, left) {
     for (const path of paths) this.entries.deleteTree(path);
+    if (left) this.entries.set(left.path, left);
   }
   absent(path) {
     return !this.entries.has(path);
@@ -178,13 +179,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);
       }
@@ -265,9 +266,9 @@ var IndexedDbMeta = class {
   }
   removing = /* @__PURE__ */ new Map();
   removeTimer;
-  async remove(paths) {
+  async remove(paths, left) {
     this.settleRemoves();
-    return this.removeNow(paths);
+    return this.removeNow(paths, left);
   }
   async removeFile(path) {
     const known = this.cache.get(path);
@@ -281,14 +282,16 @@ var IndexedDbMeta = class {
       REMOVE_WAIT_MS
     );
   }
-  async removeNow(paths) {
+  async removeNow(paths, left) {
     const [transaction, store] = this.transaction("readwrite");
     for (const path of paths) {
       store.delete(path);
       store.delete(descendants(path));
     }
+    if (left) store.put(left);
     await settle(transaction, () => void 0);
     this.changed({ trees: paths });
+    if (left) this.cache.set(left.path, left);
   }
   settleRemoves() {
     if (this.removing.size > 0) void this.flushRemoves().catch(() => void 0);
@@ -2316,10 +2319,10 @@ var OpfsFs = class {
         return;
       }
     }
-    await this.meta.remove([found.path]);
-    if (found.handle?.kind === "directory") {
-      await this.meta.update(found.path, (entry) => entry ?? vacatedAt(found.path));
-    }
+    await this.meta.remove(
+      [found.path],
+      found.handle?.kind === "directory" ? vacatedAt(found.path) : void 0
+    );
     this.touch(Date.now(), parentOf3(found.path));
   }
   links() {
@@ -7125,7 +7128,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.139.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.140.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
@@ -9805,6 +9808,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 +11327,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 +11799,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 +12131,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 +15542,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 +27955,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 +30132,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,