@ai-ecoverse/slicc-kernel 1.28.0 → 1.29.1

package/README.md

@@ -140,7 +140,7 @@ A WASI preview1 or WASIX program (Zig, Rust, Go, wasi-libc or wasix-libc C) has
 { "slicc": { "abi": "wasi", "commands": { "rg": { "wasm": "bin/rg.wasm" }, "rustc": { "script": "bin/rustc" } } } }
 ```
 
-Entries may also set `argv0`, `args` and `env`, and a package can set `slicc.env` for all of its commands. In `env`, `${package}` is the package directory, `${cwd}` the process's working directory, and `${NAME}` the caller's `NAME` when the program starts (a default naming an unset variable is left out); a relative path that exists in the package (`lib/python3.14`, `./`) becomes that absolute path. The caller's environment wins over these defaults; a `null` value removes the variable for the command, after the caller's environment is applied (a host-networked program can drop the kernel's proxy settings that way), and a command entry can set a variable its package's `slicc.env` removes. The first package to define a name wins. `sh` runs bash as `sh` unless a package provides its own. The installed commands appear as executables in a virtual `/usr/bin` and `/bin`, so `PATH` lookups, `command -v` and `ls /usr/bin` work without writing anything to OPFS. A process can also run a program by the path of its glue when the `.wasm` sits next to it, a wasm module by its own path (as a WASI program), and a script through its `#!` line (including `#!/usr/bin/env name`). Executing any other file fails with `ENOEXEC`, so bash runs it as a shell script, as POSIX shells do. Commands also come from pnpm's global directory. Every process gets `PNPM_HOME=/home/.local/share/pnpm`, unless the embedder sets its own, and has `$PNPM_HOME/bin` on `PATH`. The kernel scans each of pnpm's global install groups (`$PNPM_HOME/global/*/<group>/node_modules`) after `/node_modules`, which wins when both provide a command. The catalog is re-read whenever anything under either changes, so `pnpm add -g @ai-ecoverse/wasi-ripgrep` makes `rg` work in the same shell, and `pnpm remove -g` removes it again.
+Entries may also set `argv0`, `args` and `env`, and a package can set `slicc.env` for all of its commands. An entry with `"argv0Path": true` gets the absolute path it was run by as `argv[0]` when that path is a link outside `/bin` and `/usr/bin` to the command, as a venv's `bin/python` is (the `#!` line of a script naming such a link included), so it can find what sits beside that link; other entries keep their `argv0`. In `env`, `${package}` is the package directory, `${cwd}` the process's working directory, and `${NAME}` the caller's `NAME` when the program starts (a default naming an unset variable is left out); a relative path that exists in the package (`lib/python3.14`, `./`) becomes that absolute path. The caller's environment wins over these defaults; a `null` value removes the variable for the command, after the caller's environment is applied (a host-networked program can drop the kernel's proxy settings that way), and a command entry can set a variable its package's `slicc.env` removes. The first package to define a name wins. `sh` runs bash as `sh` unless a package provides its own. The installed commands appear as executables in a virtual `/usr/bin` and `/bin`, so `PATH` lookups, `command -v` and `ls /usr/bin` work without writing anything to OPFS. A process can also run a program by the path of its glue when the `.wasm` sits next to it, a wasm module by its own path (as a WASI program), and a script through its `#!` line (including `#!/usr/bin/env name`). Executing any other file fails with `ENOEXEC`, so bash runs it as a shell script, as POSIX shells do. Commands also come from pnpm's global directory. Every process gets `PNPM_HOME=/home/.local/share/pnpm`, unless the embedder sets its own, and has `$PNPM_HOME/bin` on `PATH`. The kernel scans each of pnpm's global install groups (`$PNPM_HOME/global/*/<group>/node_modules`) after `/node_modules`, which wins when both provide a command. The catalog is re-read whenever anything under either changes, so `pnpm add -g @ai-ecoverse/wasi-ripgrep` makes `rg` work in the same shell, and `pnpm remove -g` removes it again.
 
 ### WASI programs
 
@@ -360,12 +360,12 @@ Programs mount and unmount with `mount(2)` and `umount2(2)`, so a `mount`/`umoun
 
 An exec'd program takes over the pid of the process it replaces, as on Linux: `getpid()` and `$$` in the new image, `/proc`, `ps`, `kill` and the parent's `waitpid` all agree on that pid, and the image's parent pid is the replaced process's. Its own children see that pid as their parent. A file removed or renamed over while programs hold it open keeps its bytes for them, as on Linux: the kernel keeps one copy for all holders, shared by their descriptors (writes through one are seen through the others), and frees it when the last one closes. Signals a program ignores stay ignored in the image it execs and in the children it spawns or forks, as POSIX has it, so `nohup cmd` and `trap '' TERM; exec cmd` keep `cmd` safe from them; caught signals go back to their default. The kernel holds what was handed down, so a new image that sets one of those signals back to the default with `signal(SIG_DFL)` still ignores it, until it installs a handler.
 
-- **Emscripten:** `Module.sliccKernel.execve(file, argv, env, cwd)` runs `file` as this process's new image on its fds 0, 1 and 2, waits for it, and returns its wait status, or a negative errno when it cannot start. `env` and `cwd` may be `null` for this process's own. An exec shim detects it with `typeof Module.sliccKernel.execve === 'function'` and exits with the status it returns, as `execve` never returns on success. Older shims spawn the program and then call `Module.sliccKernel.execWait(pid)`; that still works, but the image then reports a pid of its own from `getpid()`.
+- **Emscripten:** `Module.sliccKernel.execve(file, argv, env, cwd)` runs `file` as this process's new image on its fds 0, 1 and 2, waits for it, and returns its wait status, or a negative errno when it cannot start. `env` and `cwd` may be `null` for this process's own. An exec shim detects it with `typeof Module.sliccKernel.execve === 'function'` and exits with the status it returns, as `execve` never returns on success. Older shims spawn the program and then call `Module.sliccKernel.execWait(pid)`; that works the same way: a new program asks the kernel for its pid before `main`, and the kernel answers once its parent has made its next call, so an image an older shim execs also reports the pid it replaced (the wait starts once the program is loaded; should the parent make no call within 100 ms after that, the kernel answers anyway, and the image may then report its own pid; `launcher.identities` counts the programs that asked and those answered by that timeout).
 - **WASIX:** `proc_exec` does this by itself.
 
 ### `/proc`
 
-Every process of the kernel has `/proc/<pid>/` with `cmdline`, `comm`, `stat`, `statm` and `status`, in the formats procps reads, and `/proc/self` is a link to the `/proc/<pid>` of the process that reads it, as on Linux (`readlink /proc/self` is its pid, the one it was exec'd under included). They come from the kernel's process table when they are opened, so a terminal sees the processes of every client; an exec'd program shows under the pid its parent knows. `/proc/uptime`, `/proc/loadavg`, `/proc/stat` and `/proc/meminfo` are there too, and `/proc/mounts`. A process with no parent in the kernel (one a page, a client or the Node entry started) has parent 1, as children of init do, in `getppid()`, `/proc/<pid>/stat` and `ps` alike. Pids, parents, process groups, sessions, command lines, terminals, start and boot times are real, and so is each process's memory: the size of its wasm memory (`VSZ` and `RSS` alike, as wasm has no paging), which `/proc/meminfo` counts as used. CPU times, load and `MemTotal` (from `navigator.deviceMemory`, else 4 GiB) are placeholders. Only Emscripten processes see this `/proc`.
+Every process of the kernel has `/proc/<pid>/` with `cmdline`, `comm`, `stat`, `statm` and `status`, in the formats procps reads, and `/proc/self` is a link to the `/proc/<pid>` of the process that reads it, as on Linux (`readlink /proc/self` is its pid, the one it was exec'd under included). They come from the kernel's process table when they are opened, so a terminal sees the processes of every client; an exec'd program shows under the pid its parent knows. `/proc/uptime`, `/proc/loadavg`, `/proc/stat` and `/proc/meminfo` are there too, and `/proc/mounts`. A process with no parent in the kernel (one a page, a client or the Node entry started) has parent 1, as children of init do, in `getppid()`, `/proc/<pid>/stat` and `ps` alike, and so does a process whose parent has ended, waited for or not (`getppid()` asks the kernel each time; a shell's `$PPID` keeps the value it started with, as on Linux). Pids, parents, process groups, sessions, command lines, terminals, start and boot times are real, and so is each process's memory: the size of its wasm memory (`VSZ` and `RSS` alike, as wasm has no paging), which `/proc/meminfo` counts as used. CPU times, load and `MemTotal` (from `navigator.deviceMemory`, else 4 GiB) are placeholders. Only Emscripten processes see this `/proc`.
 
 While OPFS has no `/etc/passwd`, `/etc/group` or `/etc/mtab`, reading them gets per-process ones: root is uid 0 and the realm user, uid 1000, is named after `USER`, or `web_user` (Emscripten's default) without one, so it matches `$USER`, with `HOME` as its home, so `id`, `whoami`, `ls -l` and `ps` show names. Nothing is written to OPFS, and a real file there wins.
 

package/dist/kernel-worker.js

@@ -4527,6 +4527,7 @@ function commandOf(pkg, name2, raw, packageAbi, shared) {
     glue,
     wasm,
     argv0,
+    ...raw.argv0Path === true ? { argv0Path: true } : {},
     ...args ? { args } : {},
     ...withEnv,
     ...imports ? { imports } : {}
@@ -7731,6 +7732,7 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "mount",
   "umount",
   "proc-exec",
+  "proc-identity",
   "proc-setpgid",
   "proc-getpgid",
   "proc-getsid",
@@ -7830,6 +7832,7 @@ var WasmProcess = class {
     for (const listener of this.stateListeners) listener("continued", SIG.CONT);
   }
   async syscall(req) {
+    this.options.onSyscall?.();
     for (; ; ) {
       await this.resumed;
       const stops = this.stops;
@@ -8175,6 +8178,8 @@ var WasmProcess = class {
         const waited = await this.children.wait(req.pid, req.nohang, signal, flags);
         return { ok: true, kind: "json", json: waited };
       }
+      case "proc-identity":
+        return { ok: true, kind: "json", json: await this.options.identity?.() ?? null };
       case "proc-exec": {
         this.execChild = req.pid;
         this.options.jobs?.exec(this.pid, req.pid);
@@ -8325,6 +8330,8 @@ function spawnWasmProcess(opts) {
   const header2 = new Int32Array(sab, 0, SAB_HEADER_I32);
   const process = new WasmProcess(opts.pid, opts.fds, {
     ...opts.ignored ? { ignored: opts.ignored } : {},
+    ...opts.identity ? { identity: opts.identity } : {},
+    ...opts.onSyscall ? { onSyscall: opts.onSyscall } : {},
     spawner: opts.spawner,
     forker: opts.forker,
     fs: opts.fs,
@@ -9797,6 +9804,7 @@ var ENV_REFERENCE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 var WASM_MAGIC = [0, 97, 115, 109];
 var SHEBANG_MAX = 256;
 var NOT_FOUND = 127;
+var DECIDE_MS = 100;
 var INIT_PID = 1;
 var SHARED_DIRS = ["/tmp", "/home"];
 var encoder3 = new TextEncoder();
@@ -9895,6 +9903,8 @@ var Launcher = class {
   fstabRetries;
   inserted = /* @__PURE__ */ new Map();
   openFiles = /* @__PURE__ */ new Set();
+  deciding = /* @__PURE__ */ new Map();
+  identities = { asked: 0, timedOut: 0 };
   nodes;
   held = /* @__PURE__ */ new Set();
   processMounts;
@@ -9958,9 +9968,14 @@ var Launcher = class {
       const command = (await this.commands()).get(name2);
       return command && !command.script ? targetOf(command) : void 0;
     }
-    const glue = await followLinks(this.base, this.fs.resolvePath(cwd, file));
+    const path = this.fs.resolvePath(cwd, file);
+    const glue = await followLinks(this.base, path);
     const linked = COMMAND2.exec(glue)?.[1];
-    if (linked !== void 0) return this.resolve(`/bin/${linked}`, argv0, cwd);
+    if (linked !== void 0) {
+      const target = await this.resolve(`/bin/${linked}`, argv0, cwd);
+      const byPath = !COMMAND2.test(path) && (await this.commands()).get(linked)?.argv0Path === true;
+      return target && byPath ? { ...target, argv0: path } : target;
+    }
     const head = await this.head(glue);
     if (!head) return void 0;
     if (isWasm(head)) {
@@ -10096,8 +10111,19 @@ var Launcher = class {
     }
     const pid = this.nextPid++;
     const terminal = req.fds.stdioTerminal();
+    const decided = req.decided ?? Promise.resolve(true);
+    const count = (byParent) => {
+      this.identities.asked++;
+      if (!byParent) this.identities.timedOut++;
+    };
+    let asked;
     const handle = spawnWasmProcess({
       pid,
+      identity: async () => {
+        await (asked ??= decided.then(count));
+        return this.identityOf(pid);
+      },
+      onSyscall: () => this.decide(pid),
       ...req.ignored ? { ignored: req.ignored } : {},
       program: req.program,
       argv0: req.argv0,
@@ -10170,7 +10196,8 @@ var Launcher = class {
     };
     const shown = (pid) => {
       const member = pid === void 0 ? void 0 : members.get(pid);
-      return member ? rootOf(member).pid : INIT_PID;
+      const root = member && rootOf(member).pid;
+      return root !== void 0 && this.running(root) ? root : INIT_PID;
     };
     const listed = [];
     for (const member of members.values()) {
@@ -10199,7 +10226,9 @@ var Launcher = class {
         throw new SpawnError(await this.unrunnable(req.file, req.cwd));
       }
       const exec = req.exec ? { exec: true } : {};
+      const deciding = req.exec ? void 0 : this.undecided(ppid);
       const handle = await this.launch(planned, {
+        ...deciding ? { decided: deciding.promise } : {},
         env: req.env,
         cwd: req.cwd,
         fds,
@@ -10208,9 +10237,39 @@ var Launcher = class {
         ignored: this.ignoredBy(ppid),
         ...exec
       });
+      deciding?.attach();
       return childHandle(handle);
     };
   }
+  undecided(ppid) {
+    const decided = Promise.withResolvers();
+    return {
+      promise: decided.promise,
+      attach: () => {
+        const timer = setTimeout(() => decided.resolve(false), DECIDE_MS);
+        void decided.promise.then(() => clearTimeout(timer));
+        const waiting = this.deciding.get(ppid) ?? /* @__PURE__ */ new Set();
+        waiting.add(decided.resolve);
+        this.deciding.set(ppid, waiting);
+      }
+    };
+  }
+  identityOf(pid) {
+    const parent = this.jobs.shownParent(pid);
+    const alive = parent !== void 0 && this.running(parent);
+    return { pid: this.jobs.shown(pid), ppid: alive ? parent : INIT_PID };
+  }
+  running(shown) {
+    return this.jobs.list().some((member) => !this.zombies.has(member.pid) && this.jobs.shown(member.pid) === shown);
+  }
+  decide(ppid) {
+    const waiting = this.deciding.get(ppid);
+    if (!waiting) return;
+    this.deciding.delete(ppid);
+    setTimeout(() => {
+      for (const resolve of waiting) resolve(true);
+    }, 0);
+  }
   forker(ppid, parent) {
     const { exec: _exec, ...image } = parent;
     return async (state, fds) => childHandle(