@ai-ecoverse/slicc-kernel 1.47.2 → 1.47.3

package/README.md

@@ -66,7 +66,7 @@ Starts `argv` as the session leader on a new terminal and resolves once it is ru
 | --- | --- |
 | `pid` | the session leader's pid |
 | `onData` | the output listener; output that arrives while it is `null` is kept and delivered when one is set |
-| `write(data)` | types a string or bytes into the terminal; with `ISIG` on, `^C`, `^Z` and `^\` signal the foreground process group. A key typed while a child of that group is still setting up is held until the child has finished, then sent to the group in the foreground at that point. Setting up means the child's calls before its first other one: `setpgid`, `tcsetpgrp`, signal masks, and starting the program it execs (which then sets itself up too). The hold ends 2 s after the child's first call at the latest. A key typed while the foreground group is busy, not reading the terminal (a shell between reading a command line and starting it), goes to that group and also to the job the group starts next, once that job has taken the terminal; the second copy is dropped when the group reads the terminal again. So `^C` or `^Z` right after a command line reaches the new job, as it does on Linux, where starting a job takes microseconds rather than a worker start. |
+| `write(data)` | types a string or bytes into the terminal; with `ISIG` on, `^C`, `^Z` and `^\` signal the foreground process group. A key typed while a child of that group is still setting up is held until the child has finished, then sent to the group in the foreground at that point. Setting up means the child's calls before its first other one: `setpgid`, `tcsetpgrp`, signal masks, and starting the program it execs (which then sets itself up too). The hold ends 2 s after the child's first call at the latest. A key typed while the foreground group is busy, not reading the terminal (a shell between reading a command line and starting it), goes to that group and also to the job the group starts next, once that job has taken the terminal; the second copy is dropped when the group reads the terminal again. So `^C` or `^Z` right after a command line reaches the new job, as it does on Linux, where starting a job takes microseconds rather than a worker start. For the same reason, a child that is still setting up cannot give the terminal to its own group once its parent has already given the terminal to that group and taken it back: on Linux the child's `tcsetpgrp` would have landed first, so the parent's later choice stands. Otherwise `tcsetpgrp` behaves as before. |
 | `resize(cols, rows)` | sets the window size (`TIOCGWINSZ`) and sends `SIGWINCH` to the foreground process group |
 | `signal(name)` | sends a signal (`'SIGINT'`, `'SIGTSTP'`, `'SIGQUIT'`, `'SIGHUP'`, …) to the foreground process group, regardless of termios |
 | `exited` | resolves with the session leader's exit status (`128 + n` if killed by signal `n`) |
@@ -188,6 +188,7 @@ On top of preview1 a WASI program gets:
 - **Threads**: `wasi.thread-spawn` (wasm32-wasip1-threads) and WASIX `thread_spawn_v2` start a worker per thread on the process's shared memory, sized from the module's own import (a 2 GiB maximum when the engine cannot reserve more). The threads share one descriptor table; `exit` or a trap in any thread ends the process. At most 64 threads per process; `SLICC_WASM_THREADS` sets another cap, up to 256.
 - **WASIX** (a module importing `wasix_32v1`): fork and setjmp/longjmp through Asyncify (the module is built with `wasm-opt --asyncify`), exec, `posix_spawn`, `waitpid`, pipes, `dup2`, signal handlers and interval timers, terminal modes, and dynamic linking: a position-independent main module loads side modules with `dlopen` from `LD_LIBRARY_PATH`, its runtime path, `/lib`, `/usr/lib` and `/usr/local/lib`.
 - **Job control:** `^Z`, `SIGTSTP`, `SIGTTIN` and `SIGTTOU` stop a WASIX program at once, unless it has a handler for them. A stopped program that is busy computing is stopped for job control (`jobs` shows it, `fg`, `bg` and `SIGCONT` work), but its worker keeps a core busy until its next system call, since a worker's running code cannot be frozen from outside. Agents should `kill` such a job rather than leave it stopped. For the same reason, a signal with a handler or a terminating default (`^C`, `SIGTERM`) reaches a program that is busy computing only at its next system call, so a CPU-bound loop may not end on `^C`; `kill -9` always ends it. A thread blocked in the kernel or waiting on a lock (`pthread_cond_wait`, a futex) is woken by a signal for it (a futex wait checks for signals every 50 ms, so each waiting thread wakes briefly that often), and `pthread_kill` runs the handler on the thread it names.
+- **Pipes** show to WASI and WASIX programs as stream sockets (`fstat` gives `S_IFSOCK`), because WASI has no FIFO file type and an unknown type made programs refuse them (Python's asyncio subprocess pipes). They are still read and written as pipes; socket calls on them fail with `ENOTSOCK`, and `isatty()` is false. In a WASIX shell, `[ -p ]` is therefore false for a pipe and `[ -S ]` true. Emscripten programs, bash included, still see a FIFO. The same holds for any kernel descriptor that is neither seekable nor a terminal or device, such as captured output: WASI and WASIX programs see it as a stream socket too.
 - **Sockets**: the WASIX socket calls (`sock_open`, `sock_pair` for an `AF_UNIX` stream 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, since a WASI program cannot ignore `SIGPIPE`; a pipe or terminal whose reader is gone still ends the program with status 141. 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.
 - **Diagnostics**: a trap ends the program with 134 and its message on stderr; 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.
 

package/dist/kernel-worker.js

@@ -8131,9 +8131,9 @@ var KernelTty = class {
       this.line = [];
     } else if (byte === 10) {
       this.line.push(byte);
-      if (echo) this.output(encoder2.encode("\n"));
       this.readable.push(Uint8Array.from(this.line));
       this.line = [];
+      if (echo) this.output(encoder2.encode("\n"));
     } else {
       this.line.push(byte);
       if (echo) this.echo(byte);
@@ -9874,7 +9874,7 @@ var WasmProcess = class {
       case "tty-pgrp-get":
         return { ok: true, kind: "json", json: jobs ? jobs.tcgetpgrp(tty, this.sid()) : this.pid };
       case "tty-pgrp-set":
-        if (jobs) jobs.tcsetpgrp(this.pid, tty, req.pgrp);
+        if (jobs) jobs.tcsetpgrp(this.pid, tty, req.pgrp, this.options.settling?.() ?? false);
         else if (req.pgrp !== this.pid) throw new KernelError("EPERM");
         return { ok: true, kind: "void" };
     }
@@ -10259,6 +10259,7 @@ function processOptions(opts, header2, hooks) {
     ...inherited(opts),
     ...opts.identity ? { identity: opts.identity } : {},
     ...opts.onSyscall ? { onSyscall: opts.onSyscall } : {},
+    ...opts.settling ? { settling: opts.settling } : {},
     spawner: opts.spawner,
     forker: opts.forker,
     fs: opts.fs,
@@ -10431,6 +10432,7 @@ function spawnWasmProcess(opts) {
 // src/kernel/jobs.ts
 var JobTable = class {
   members = /* @__PURE__ */ new Map();
+  handoffs = /* @__PURE__ */ new Map();
   foreground = /* @__PURE__ */ new Map();
   terminals = /* @__PURE__ */ new Map();
   add(pid, parentPid, signal, terminal) {
@@ -10450,7 +10452,12 @@ var JobTable = class {
     return [...this.members.values()];
   }
   remove(pid) {
+    const member = this.members.get(pid);
     this.members.delete(pid);
+    if (member) this.prune(member.pgid);
+  }
+  prune(pgid) {
+    if (![...this.members.values()].some((m) => m.pgid === pgid)) this.handoffs.delete(pgid);
   }
   exec(pid, child, adopt = false) {
     const member = this.members.get(child);
@@ -10514,7 +10521,12 @@ var JobTable = class {
     if (id2 === target.sid) throw new KernelError("EPERM");
     const exists = [...this.members.values()].some((m) => m.pgid === group && m.sid === target.sid);
     if (group !== id2 && !exists) throw new KernelError("EPERM");
+    const left = target.pgid;
     target.pgid = group;
+    this.prune(left);
+  }
+  get handoffCount() {
+    return this.handoffs.size;
   }
   getpgid(caller, pid) {
     return this.byId(pid || this.idOf(caller)).pgid;
@@ -10567,12 +10579,24 @@ var JobTable = class {
   tcgetpgrp(tty, fallback) {
     return this.foreground.get(tty) ?? fallback;
   }
-  tcsetpgrp(caller, tty, pgid) {
+  tcsetpgrp(caller, tty, pgid, settling = false) {
     const self = this.member(caller);
     const inSession = [...this.members.values()].some((m) => m.pgid === pgid && m.sid === self.sid);
     if (!inSession) throw new KernelError("EPERM");
+    const current = this.foreground.get(tty);
+    if (settling && pgid === self.pgid && current !== pgid && this.reclaimed(pgid, self.ppid))
+      return;
+    if (pgid !== self.pgid) this.handoffs.set(pgid, { by: caller, reclaimed: false });
+    else if (current !== void 0) {
+      const handoff = this.handoffs.get(current);
+      if (handoff?.by === caller) handoff.reclaimed = true;
+    }
     this.foreground.set(tty, pgid);
   }
+  reclaimed(pgid, parent) {
+    const handoff = this.handoffs.get(pgid);
+    return handoff?.reclaimed === true && handoff.by === parent;
+  }
   signalOwnedForeground(tty, sig) {
     const pgid = this.foreground.get(tty);
     if (pgid !== void 0) this.killGroup(pgid, sig);
@@ -10616,6 +10640,9 @@ var SettlingChildren = class {
     this.parked = this.parked.filter((p) => p.pgid !== pgid);
     this.held = this.held.filter((h) => !(h.copy && h.pgid === pgid));
   }
+  isSettling(pid) {
+    return this.children.has(pid);
+  }
   syscall(pid, op) {
     const child = this.children.get(pid);
     if (!child) return;
@@ -12222,6 +12249,7 @@ var Launcher = class {
         this.decide(pid);
         this.settling.syscall(pid, call.op);
       },
+      settling: () => this.settling.isSettling(pid),
       ...req.ignored ? { ignored: req.ignored } : {},
       ...req.umask !== void 0 ? { umask: req.umask } : {},
       cred: req.cred,