@ai-ecoverse/slicc-kernel 1.75.1 → 1.77.0

package/dist/node.js

@@ -5312,7 +5312,8 @@ function commandOf(pkg, name2, raw, packageAbi, shared) {
     return { name: name2, abi: packageAbi, glue: script, wasm: script, argv0: name2, script, ...withEnv };
   }
   const abi = abiOf(raw.abi, packageAbi);
-  const argv0 = typeof raw.argv0 === "string" && raw.argv0 ? raw.argv0 : name2;
+  const fixed = typeof raw.argv0 === "string" && raw.argv0 !== "";
+  const argv0 = fixed ? raw.argv0 : name2;
   const args = argsOf(pkg, raw.args);
   if (abi === "js") {
     const module = inside(pkg, raw.module);
@@ -5323,6 +5324,7 @@ function commandOf(pkg, name2, raw, packageAbi, shared) {
       glue: module,
       wasm: module,
       argv0,
+      ...fixed ? { argv0Fixed: true } : {},
       ...raw.argv0Path === true ? { argv0Path: true } : {},
       ...args ? { args } : {},
       ...withEnv
@@ -5338,6 +5340,7 @@ function commandOf(pkg, name2, raw, packageAbi, shared) {
     glue,
     wasm,
     argv0,
+    ...fixed ? { argv0Fixed: true } : {},
     ...raw.argv0Path === true ? { argv0Path: true } : {},
     ...abi === "wasi" && raw.preopenRoot === true ? { preopenRoot: true } : {},
     ...args ? { args } : {},
@@ -7958,6 +7961,7 @@ var IDLE_OPS = /* @__PURE__ */ new Set([
 ]);
 var SYS_CAP_US = 2e4;
 var LOCAL = SAB_CLOCK_OFFSET;
+var BLOCKED = 0;
 var IDLE = 1;
 function epochMicros() {
   return Math.floor((performance.timeOrigin + performance.now()) * 1e3);
@@ -8032,6 +8036,7 @@ var CpuClock = class {
     const busy = this.kind === "sys" ? Math.min(spent, SYS_CAP_US) : 0;
     this.sys += busy;
     this.idle += spent - busy;
+    Atomics.store(slots(this.sab), BLOCKED, BigInt(this.idle));
   }
 };
 var ProcessClocks = class {
@@ -8403,8 +8408,8 @@ function pidStat(info, boot) {
     0,
     ticks(info.utime ?? 0),
     ticks(info.stime ?? 0),
-    0,
-    0,
+    ticks(info.cutime ?? 0),
+    ticks(info.cstime ?? 0),
     20,
     0,
     1,
@@ -8428,8 +8433,9 @@ function pidStat(info, boot) {
 `;
 }
 var sigMask = (mask = 0) => (mask >>> 1).toString(16).padStart(16, "0");
+var STATES = { S: "S (sleeping)", T: "T (stopped)", Z: "Z (zombie)" };
 function pidStatus(info) {
-  const state = info.state === "Z" ? "Z (zombie)" : "S (sleeping)";
+  const state = STATES[info.state];
   const c = info.cred ?? ROOT;
   const ids = (r, e, s) => `${r}	${e}	${s}	${e}`;
   return [
@@ -11163,6 +11169,7 @@ async function runChild(req, deps) {
       {
         file: req.file,
         argv: req.argv,
+        ...req.argv0 !== void 0 ? { argv0: req.argv0 } : {},
         env: req.env,
         cwd: req.cwd,
         ...req.pgid !== void 0 ? { pgid: req.pgid } : {},
@@ -12038,6 +12045,16 @@ function words(value) {
   }
   return [...value];
 }
+var ESCAPES = { "	": "\\t", "\n": "\\n", "\r": "\\r" };
+function clipboardLine(text) {
+  let out = "";
+  for (const c of text) {
+    const code = c.charCodeAt(0);
+    const control = code < 32 || code === 127;
+    out += control ? ESCAPES[c] ?? `\\x${code.toString(16).padStart(2, "0")}` : c;
+  }
+  return out.length > 200 ? `${out.slice(0, 200)}\u2026` : out;
+}
 var DYING = { ok: false, errno: "EINTR", message: "the process is being killed" };
 var HOSTS_ONLY = new Resolver({ routes: new Routes() });
 var WasmProcess = class {
@@ -12121,9 +12138,10 @@ var WasmProcess = class {
     return "deliver";
   }
   async spawn(req) {
-    const { file, argv, env, cwd, stdio, inherit: inherit2, exec, pgid, session } = req;
+    const { file, argv, argv0, env, cwd, stdio, inherit: inherit2, exec, pgid, session } = req;
     const group = { ...pgid !== void 0 ? { pgid } : {}, ...session ? { session } : {} };
-    const spawned = { file, argv, env, cwd, ...group, ...exec ? { exec } : {} };
+    const named = argv0 !== void 0 ? { argv0 } : {};
+    const spawned = { file, argv, ...named, env, cwd, ...group, ...exec ? { exec } : {} };
     const pid = await this.children.spawn(spawned, stdio, inherit2);
     if (!exec) return pid;
     if (this.killed) void Promise.allSettled([this.options.kill?.(pid, SIG.KILL)]);
@@ -12289,7 +12307,22 @@ var WasmProcess = class {
     if (req.max <= 0) return new Uint8Array(0);
     if (channel.unread) channel.stamp = await this.clipboardStamp();
     const signal = channel.settled ? this.interrupt.signal : this.blockingSignal(cancelled);
-    return channel.read(Math.min(req.max, MAX_READ), signal);
+    try {
+      return await channel.read(Math.min(req.max, MAX_READ), signal);
+    } catch (err) {
+      await this.clipboardComplaint(err);
+      throw err;
+    }
+  }
+  async clipboardComplaint(err) {
+    const name2 = this.options.clipboardName;
+    if (name2 === void 0 || !(err instanceof KernelError) || err.detail === void 0) return;
+    if (err.code !== "EACCES" && err.code !== "EIO") return;
+    const stderr = this.fds.has(2) ? this.fds.get(2).file : void 0;
+    if (!stderr?.write || stderr.clipboard) return;
+    const line = `${name2}: /dev/clipboard: ${clipboardLine(err.detail)}
+`;
+    await stderr.write(new TextEncoder().encode(line), AbortSignal.timeout(1e3)).catch(() => 0);
   }
   async write(fd, body, nonblock = false, cancelled) {
     const file = this.fds.get(fd).file;
@@ -12502,7 +12535,10 @@ var WasmProcess = class {
         this.options.locks?.closed(this.pid, req.fd);
         const channel = this.fds.get(req.fd).file.clipboard;
         if (channel) channel.stamp = await this.clipboardStamp();
-        await Promise.resolve(this.fds.close(req.fd));
+        await Promise.resolve(this.fds.close(req.fd)).catch(async (err) => {
+          if (channel) await this.clipboardComplaint(err);
+          throw err;
+        });
         return { ok: true, kind: "void" };
       }
       case "fd-pipe": {
@@ -13193,12 +13229,15 @@ function holdingToken(opts, holds, caller) {
     renamed: (from, to) => holds.renamed(from, to)
   });
 }
+function clipboardName(opts) {
+  return opts.program.abi === "js" ? {} : { clipboardName: opts.argv0 };
+}
 function processOptions(opts, header4, hooks, created3) {
   return {
     ...inherited(opts),
     ...opts.owners ? { owners: true } : {},
     ...opts.sealed ? { sealed: opts.sealed } : {},
-    ...opts.clipboard ? { clipboard: opts.clipboard } : {},
+    ...opts.clipboard ? { clipboard: opts.clipboard, ...clipboardName(opts) } : {},
     ...opts.readonlyAt ? { readonlyAt: opts.readonlyAt } : {},
     ...opts.dac ? { guard: { dac: opts.dac, fs: opts.fs, created: created3 } } : {},
     ...opts.identity ? { identity: opts.identity } : {},
@@ -16054,6 +16093,7 @@ function targetOf(command) {
     glue: command.glue,
     wasm: command.wasm,
     argv0: command.argv0,
+    ...command.argv0Fixed ? { fixed: true } : {},
     ...command.args ? { prefix: command.args } : {},
     ...command.env ? { env: command.env } : {},
     ...command.unset ? { unset: command.unset } : {},
@@ -16089,6 +16129,10 @@ function concat5(chunks2) {
   }
   return out;
 }
+function addTimes(into, pid, t) {
+  const at = into.get(pid) ?? { utime: 0, stime: 0 };
+  into.set(pid, { utime: at.utime + t.utime, stime: at.stime + t.stime });
+}
 var Launcher = class {
   fs;
   processFs;
@@ -16416,8 +16460,10 @@ var Launcher = class {
     const target = withScriptEnv(found, command);
     return { target, args: [...target.prefix ?? [], ...passed], via: [interp] };
   }
-  async plan(file, argv, cwd, scope) {
-    const direct = await this.resolve(file, argv[0] ?? file, cwd, scope);
+  async plan(file, argv, cwd, scope, argv0) {
+    const found = await this.resolve(file, argv[0] ?? file, cwd, scope);
+    const named = typeof argv0 === "string" && found && !found.fixed;
+    const direct = named ? { ...found, argv0 } : found;
     if (direct) return { target: direct, args: [...direct.prefix ?? [], ...argv.slice(1)] };
     const script = await this.interpreted(file, argv, cwd, scope);
     return script && { ...script, script: true };
@@ -16624,7 +16670,7 @@ var Launcher = class {
       http: new HttpHandles(this.transport, pid),
       locks: this.locks,
       resolver: this.resolver,
-      onReap: (child) => this.reaped(child),
+      onReap: (child) => this.reaped(child, pid),
       ...req.fork ? { fork: req.fork } : {},
       ...this.shownIds(req)
     });
@@ -16643,9 +16689,14 @@ var Launcher = class {
       tty: terminal?.name ?? null,
       started: Date.now()
     });
+    handle.onState(
+      (state) => state === "stopped" ? this.stopped.add(pid) : this.stopped.delete(pid)
+    );
     void handle.exited.then(() => {
       const spent = handle.times?.();
       if (spent) this.spent.set(pid, spent);
+      if (spent) addTimes(this.imageTimes, this.jobs.shown(pid), spent);
+      this.stopped.delete(pid);
       this.processes.delete(pid);
       if (this.processes.size === 0) {
         clearInterval(this.sampler);
@@ -16673,11 +16724,20 @@ var Launcher = class {
       this.reapedTimes.stime += spent.stime;
     }
     this.spent.delete(pid);
+    this.imageTimes.delete(pid);
+    this.childTimes.delete(pid);
     this.creds.delete(pid);
     this.tags.delete(pid);
     this.granted.delete(pid);
   }
-  reaped(pid) {
+  reaped(pid, parent) {
+    const own = this.imageTimes.get(pid);
+    const theirs = this.childTimes.get(pid);
+    const into = this.jobs.shown(parent);
+    if (own) addTimes(this.childTimes, into, own);
+    if (theirs) addTimes(this.childTimes, into, theirs);
+    this.imageTimes.delete(pid);
+    this.childTimes.delete(pid);
     if (this.zombies.delete(pid)) this.forget(pid);
     else this.orphans.add(pid);
   }
@@ -16729,6 +16789,17 @@ var Launcher = class {
     this.sampler.unref?.();
   }
   spent = /* @__PURE__ */ new Map();
+  imageTimes = /* @__PURE__ */ new Map();
+  childTimes = /* @__PURE__ */ new Map();
+  stopped = /* @__PURE__ */ new Set();
+  stateOf(pid) {
+    if (!this.processes.has(pid)) return "Z";
+    return this.stopped.has(pid) ? "T" : "S";
+  }
+  childrenOf(pid) {
+    const t = this.childTimes.get(pid);
+    return t ? { cutime: t.utime, cstime: t.stime } : {};
+  }
   timesAt(pid) {
     return this.processes.get(pid)?.times?.() ?? this.spent.get(pid);
   }
@@ -16774,9 +16845,10 @@ var Launcher = class {
         sid: member.sid,
         ...described2,
         started: (this.described.get(root.pid) ?? described2).started,
-        state: this.processes.has(member.pid) ? "S" : "Z",
+        state: this.stateOf(member.pid),
         memory: this.processes.get(member.pid)?.memory() ?? 0,
         ...this.timesOf(member, members),
+        ...this.childrenOf(root.pid),
         umask: this.umaskOf(member.pid),
         cred,
         ...this.signalMasksOf(member.pid)
@@ -16806,7 +16878,7 @@ var Launcher = class {
       }
       const cred = grant ? grant.cred : this.credOf(ppid);
       const scope = grant ? "" : await this.scopeOf(cred.euid);
-      const planned = await this.plan(req.file, req.argv, req.cwd, scope);
+      const planned = await this.plan(req.file, req.argv, req.cwd, scope, req.argv0);
       try {
         await this.mayExec(cred, { ...req, pid: ppid }, planned);
       } catch (err) {