@ai-ecoverse/slicc-kernel 1.178.4 → 1.180.0

package/dist/node-process-worker.cjs

@@ -7518,7 +7518,7 @@ var init_version = __esm({
   "src/version.ts"() {
     "use strict";
     init_captured_globals();
-    KERNEL_VERSION = true ? "1.178.4" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.180.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });

package/dist/node-process-worker.js

@@ -7517,7 +7517,7 @@ var init_version = __esm({
   "src/version.ts"() {
     "use strict";
     init_captured_globals();
-    KERNEL_VERSION = true ? "1.178.4" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.180.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });

package/dist/node.js

@@ -2751,6 +2751,82 @@ var KERNEL_SIGINFO = Object.freeze({
   status: 0
 });
 
+// src/kernel/trace.ts
+var TRACE_LIMIT = 4096;
+var TRACE_LIMIT_MAX = 65536;
+function traceLimit(value2) {
+  if (value2 === void 0) return TRACE_LIMIT;
+  if (!Number.isInteger(value2) || value2 < 1 || value2 > TRACE_LIMIT_MAX) {
+    throw Object.assign(new Error(`a trace limit is an integer from 1 to ${TRACE_LIMIT_MAX}`), {
+      code: "EINVAL"
+    });
+  }
+  return value2;
+}
+var TraceHub = class {
+  subs = /* @__PURE__ */ new Set();
+  seq = 0;
+  get idle() {
+    return this.subs.size === 0;
+  }
+  subscribe(tag, viewer, deliver, limit = TRACE_LIMIT) {
+    const sub = {
+      tag,
+      viewer: copyCred(viewer),
+      limit,
+      queue: [],
+      dropped: 0,
+      waiting: false,
+      scheduled: false,
+      deliver
+    };
+    this.subs.add(sub);
+    return {
+      ack: () => {
+        sub.waiting = false;
+        this.schedule(sub);
+      },
+      close: () => {
+        this.subs.delete(sub);
+        sub.queue = [];
+      }
+    };
+  }
+  wants(tags, cred) {
+    if (!tags?.length || this.subs.size === 0) return false;
+    for (const sub of this.subs) if (this.matches(sub, tags, cred)) return true;
+    return false;
+  }
+  publish(tags, cred, draft) {
+    if (!tags?.length) return;
+    let event;
+    for (const sub of this.subs) {
+      if (!this.matches(sub, tags, cred)) continue;
+      event ??= { ...draft, seq: ++this.seq };
+      if (sub.queue.length >= sub.limit) sub.dropped++;
+      else sub.queue.push(event);
+      this.schedule(sub);
+    }
+  }
+  matches(sub, tags, cred) {
+    return tags.includes(sub.tag) && maySee(sub.viewer, cred);
+  }
+  schedule(sub) {
+    if (sub.scheduled || sub.waiting) return;
+    if (sub.queue.length === 0 && sub.dropped === 0) return;
+    sub.scheduled = true;
+    queueMicrotask(() => {
+      sub.scheduled = false;
+      if (!this.subs.has(sub)) return;
+      const batch = { events: sub.queue, dropped: sub.dropped };
+      sub.queue = [];
+      sub.dropped = 0;
+      sub.waiting = true;
+      sub.deliver(batch);
+    });
+  }
+};
+
 // src/kernel/net/http1.ts
 var HttpError = class extends Error {
   status;
@@ -3711,7 +3787,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.178.4" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.180.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
@@ -25973,6 +26049,9 @@ var JobTable = class {
   idOf(pid) {
     return this.members.get(pid)?.shownAs ?? pid;
   }
+  execParentOf(pid) {
+    return this.members.get(pid)?.execParent;
+  }
   byId(id2) {
     for (const member of this.members.values()) if (member.shownAs === id2) return member;
     return this.member(id2);
@@ -32611,6 +32690,11 @@ function usersMode(mode = "off") {
 function tagOption(tag) {
   if (tag !== void 0 && typeof tag !== "string") throw new TypeError("a tag must be a string");
 }
+function cwdMissingOption(value2) {
+  if (value2 === void 0 || value2 === "create") return "create";
+  if (value2 === "error") return "error";
+  throw new TypeError("cwdMissing must be 'create' or 'error'");
+}
 function withTag(tags, tag) {
   if (tag === void 0 || tags?.includes(tag)) return tags;
   return [...tags ?? [], tag];
@@ -34175,10 +34259,12 @@ var Launcher = class {
       });
       const fit = await (handle.ready ?? true);
       if (fit) {
+        this.traceAdmitted(handle.pid, true);
         await fds.closeAll();
         return handle;
       }
       await handle.exited;
+      this.traceAdmitted(handle.pid, false);
       await this.memories.refused().catch(async (err) => {
         await fds.closeAll();
         throw err;
@@ -34309,10 +34395,12 @@ var Launcher = class {
     if (req.group === "lead") this.jobs.lead(pid);
     if (req.group === "session") this.jobs.setsid(pid);
     this.described.set(pid, describe(req, terminal?.name ?? null));
+    this.traceStarted(pid, req);
     handle.onState(
       (state) => state === "stopped" ? this.stopped.add(pid) : this.stopped.delete(pid)
     );
-    void handle.exited.then(() => {
+    void handle.exited.then((status) => {
+      this.traceEnded(pid, handle, status);
       this.cwds.release(this.cwdSlots.get(pid));
       this.cwdSlots.delete(pid);
       this.cwdPaths.delete(pid);
@@ -34427,6 +34515,71 @@ var Launcher = class {
   imageTimes = /* @__PURE__ */ new Map();
   childTimes = /* @__PURE__ */ new Map();
   stopped = /* @__PURE__ */ new Set();
+  traces = new TraceHub();
+  traceHeld = /* @__PURE__ */ new Map();
+  replacedImages = /* @__PURE__ */ new Set();
+  traceStarted(pid, req) {
+    const replaces = req.exec ? req.ppid : void 0;
+    if (req.quietOom) this.traceHeld.set(pid, { replaces, events: [] });
+    else if (replaces !== void 0) this.replacedImages.add(replaces);
+    this.traceEmit(pid, () => {
+      const { pid: shown2, ppid } = this.identityOf(pid);
+      const described2 = this.described.get(pid);
+      const { argv, started, tty: _tty, exeId: _exeId, ...exe } = described2;
+      return {
+        type: req.fork ? "fork" : "exec",
+        pid: shown2,
+        ppid,
+        pgid: this.jobs.pgidOf(pid),
+        argv: [...argv],
+        ...exe,
+        uid: this.credOf(pid).euid,
+        at: started,
+        ...req.exec ? { replaced: true } : {}
+      };
+    });
+  }
+  traceEnded(pid, handle, status) {
+    if (this.replacedImages.delete(pid)) return;
+    this.traceEmit(pid, () => ({
+      type: "exit",
+      pid: this.jobs.idOf(pid),
+      status,
+      ...signalField(handle.termsig()),
+      ...this.chainTimes(pid),
+      at: Date.now()
+    }));
+  }
+  traceEmit(pid, build) {
+    if (this.traces.idle) return;
+    const tags = this.tagsOf(pid);
+    const cred = this.credOf(pid);
+    if (!this.traces.wants(tags, cred)) return;
+    const held = this.traceHeld.get(pid);
+    if (held) held.events.push({ tags, cred: copyCred(cred), draft: build() });
+    else this.traces.publish(tags, cred, build());
+  }
+  traceAdmitted(pid, fit) {
+    const held = this.traceHeld.get(pid);
+    if (!held) return;
+    this.traceHeld.delete(pid);
+    if (!fit) return;
+    if (held.replaces !== void 0) this.replacedImages.add(held.replaces);
+    for (const { tags, cred, draft } of held.events) this.traces.publish(tags, cred, draft);
+  }
+  chainTimes(pid) {
+    let utime = 0;
+    let stime = 0;
+    let timed2 = false;
+    for (let at = pid; at !== void 0; at = this.jobs.execParentOf(at)) {
+      const t = this.timesAt(at);
+      if (!t) continue;
+      timed2 = true;
+      utime += t.utime;
+      stime += t.stime;
+    }
+    return timed2 ? { utime, stime } : {};
+  }
   stateOf(pid) {
     if (!this.processes.has(pid)) return "Z";
     return this.stopped.has(pid) ? "T" : "S";
@@ -35489,7 +35642,7 @@ var Launcher = class {
     const kept = keepingOpen(fs, nodes, (path) => this.changes.publish(path));
     return this.swaps.wrap(unlinked.wrap(kept));
   }
-  async starting(argv, dir, account, tags, base) {
+  async starting(argv, dir, account, tags, base, missing6 = "create") {
     const tag = tags?.[0];
     await this.swaps.settled();
     this.resetCatalogs();
@@ -35498,8 +35651,13 @@ var Launcher = class {
     const cwd = await physicalPathAsync(this.base, start2.startsWith("/") ? start2 : `/${start2}`);
     await this.enterable(this.execGuard(credOf(account), 0, tag), cwd);
     const file = await this.execFile(argv[0] ?? "", cwd, this.execGuard(credOf(account), 0, tag));
-    if (!await this.base.exists(cwd))
+    if (!await this.base.exists(cwd)) {
+      if (missing6 === "error")
+        throw Object.assign(new Error(`cannot change to ${cwd}: No such file or directory`), {
+          code: "ENOENT"
+        });
       await this.stackFor(tags, base).fs.mkdir(cwd, { recursive: true });
+    }
     const plan = async () => {
       const found = await this.plan(file, argv, cwd, scope);
       await this.mayExec(credOf(account), { file, cwd, pid: 0, tag }, found);
@@ -35510,6 +35668,7 @@ var Launcher = class {
   }
   async openTerminal(argv, options) {
     const tagged = tagsOption(options);
+    const missing6 = cwdMissingOption(options.cwdMissing);
     const { tags } = tagged;
     const { account, tty: ttyGroup } = await this.terminalAccount(options.user);
     const { cwd, file, planned } = await this.starting(
@@ -35517,7 +35676,8 @@ var Launcher = class {
       options.cwd,
       account,
       tags,
-      tagged.tagBase
+      tagged.tagBase,
+      missing6
     );
     if (!planned) throw new Error(`${file}: command not found`);
     let leader = 0;
@@ -35569,6 +35729,7 @@ var Launcher = class {
   }
   async run(argv, options = {}) {
     const tagged = tagsOption(options);
+    const missing6 = cwdMissingOption(options.cwdMissing);
     const { tags } = tagged;
     const account = await this.account(options.user);
     const { cwd, file, planned } = await this.starting(
@@ -35576,7 +35737,8 @@ var Launcher = class {
       options.cwd,
       account,
       tags,
-      tagged.tagBase
+      tagged.tagBase,
+      missing6
     );
     const env = this.environment(cwd, options.env, account, options.login);
     const out = [];
@@ -36098,7 +36260,7 @@ function serveTransport(peer, transport, {
 }
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 13];
+var PROTOCOL = [1, 15];
 var FS_METHODS = [
   "readFile",
   "writeFile",
@@ -36265,9 +36427,21 @@ async function runAs(l, self, requested) {
 function clientCred(self) {
   return self ? credOf(self) : copyCred(ROOT);
 }
+var MAX_SPAWN_TAGS = 8;
+function spawnTags(value2) {
+  if (!Array.isArray(value2)) {
+    tagOption(value2);
+    return value2 === void 0 ? [] : [value2];
+  }
+  if (value2.length > MAX_SPAWN_TAGS) {
+    throw new TypeError(`a spawn adds at most ${MAX_SPAWN_TAGS} tags`);
+  }
+  for (const each of value2) tagOption(each ?? 0);
+  return value2;
+}
 async function runTagged(l, self, options, tag, session = -1) {
-  tagOption(options.tag);
-  const tags = withTag(withTag(void 0, tag), options.tag);
+  let tags = withTag(void 0, tag);
+  for (const added of spawnTags(options.tag)) tags = withTag(tags, added);
   return {
     user: await runAs(l, self, options.user),
     tag,
@@ -36398,6 +36572,34 @@ async function watchOp(l, req, watches, send2, g) {
   watches.set(req.id, unwatch);
   return { result: req.id };
 }
+function traceRegistry(send2) {
+  const traces = /* @__PURE__ */ new Map();
+  return {
+    answer(l, self, req) {
+      if (req.op === "untrace") {
+        traces.get(req.trace)?.close();
+        return { result: traces.delete(req.trace) };
+      }
+      if (typeof req.tag !== "string" || req.tag === "") {
+        throw fsError("EINVAL", "trace: a tag is a non-empty string");
+      }
+      const limit = traceLimit(req.limit);
+      const id2 = req.id;
+      const deliver = ({ events, dropped: dropped2 }) => send2({ trace: id2, events, ...dropped2 > 0 ? { dropped: dropped2 } : {} });
+      traces.set(id2, l.traces.subscribe(req.tag, credOf(self), deliver, limit));
+      return { result: id2 };
+    },
+    ack(data) {
+      if (typeof data.traceAck !== "number") return false;
+      traces.get(data.traceAck)?.ack();
+      return true;
+    },
+    close() {
+      for (const trace of traces.values()) trace.close();
+      traces.clear();
+    }
+  };
+}
 var TRAITS_WATCH = -1;
 function traitsWatch(launcher, transport, send2) {
   return launcher.onTraits(() => send2({ traits: transport.traits }));
@@ -36424,6 +36626,21 @@ function requestBinding(send2, port) {
     close: () => unbind?.()
   };
 }
+function answered(pending, req, reply, detach) {
+  pending.then(
+    ({ result, signal, transfer }) => {
+      reply(req.id, { result, ...signal ? { signal } : {} }, transfer);
+      if (req.op === "detach") detach(req.kill === true);
+    },
+    (err) => {
+      const code = err?.code;
+      reply(req.id, {
+        error: err instanceof Error ? err.message : String(err),
+        ...typeof code === "string" ? { code } : {}
+      });
+    }
+  );
+}
 function serveClient(port, host) {
   let state = "new";
   let self;
@@ -36439,6 +36656,7 @@ function serveClient(port, host) {
   };
   const reply = (id2, body, transfer) => send2({ id: id2, ...body }, transfer);
   const hosts = hostRegistries(send2, ended.promise, port);
+  const traces = traceRegistry(send2);
   function detach(kill = false, bye = "the slicc-kernel detached this client") {
     if (state === "closed") return;
     send2({ bye });
@@ -36446,6 +36664,7 @@ function serveClient(port, host) {
     net?.close();
     for (const unwatch of watches.values()) unwatch();
     watches.clear();
+    traces.close();
     hosts.close();
     for (const session of terminals.values()) session.close();
     terminals.clear();
@@ -36553,6 +36772,9 @@ function serveClient(port, host) {
       case "serve-facade":
       case "unserve-facade":
         return { result: hosts.answer(l, req) };
+      case "trace":
+      case "untrace":
+        return traces.answer(l, self, req);
       case "detach":
         return { result: true };
       default:
@@ -36576,20 +36798,9 @@ function serveClient(port, host) {
       net?.answer(data);
       return;
     }
+    if (traces.ack(data)) return;
     const req = data;
-    handle(req).then(
-      ({ result, signal, transfer }) => {
-        reply(req.id, { result, ...signal ? { signal } : {} }, transfer);
-        if (req.op === "detach") detach(req.kill === true);
-      },
-      (err) => {
-        const code = err?.code;
-        reply(req.id, {
-          error: err instanceof Error ? err.message : String(err),
-          ...typeof code === "string" ? { code } : {}
-        });
-      }
-    );
+    answered(handle(req), req, reply, detach);
   });
   port.addEventListener("close", () => detach());
   port.start?.();
@@ -37518,6 +37729,7 @@ var Channel = class {
   failure;
   pending = /* @__PURE__ */ new Map();
   watching = /* @__PURE__ */ new Map();
+  tracing = /* @__PURE__ */ new Map();
   cdpHooks = /* @__PURE__ */ new Map();
   cdpOpen = /* @__PURE__ */ new Set();
   facadeHooks = /* @__PURE__ */ new Map();
@@ -37585,6 +37797,10 @@ var Channel = class {
       this.watching.get(data.watch)?.(data.change);
       return;
     }
+    if (data.trace !== void 0 && data.id === void 0) {
+      this.traced(data.trace, data.events ?? [], data.dropped ?? 0);
+      return;
+    }
     if (data.bye !== void 0) {
       this.end(new KernelGoneError(data.bye));
       return;
@@ -37613,6 +37829,23 @@ var Channel = class {
     if (reply.error !== void 0) call.reject(new KernelCallError(reply.error, reply.code));
     else call.resolve(reply.result);
   }
+  traced(trace, events, dropped2) {
+    const listener = this.tracing.get(trace);
+    if (!listener) return;
+    const ack = () => {
+      if (this.tracing.has(trace)) this.post({ traceAck: trace });
+    };
+    let consumed;
+    try {
+      consumed = listener({ events, dropped: dropped2 });
+    } finally {
+      if (typeof consumed?.then === "function") {
+        void Promise.resolve(consumed).then(ack, ack);
+      } else {
+        ack();
+      }
+    }
+  }
   openCdp({ cdpOpen: { registration, ...request }, port }) {
     const hook = registration === void 0 ? void 0 : this.cdpHooks.get(registration);
     if (!hook || this.failure) {
@@ -37675,6 +37908,29 @@ async function serveCdpOn(channel, hook, options) {
     }
   };
 }
+async function traceOn(channel, tag, onEvents, options) {
+  if (typeof onEvents !== "function") throw new TypeError("trace: onEvents must be a function");
+  await since(channel, 15, "trace", async () => {
+  });
+  const { id: id2, done: done4 } = channel.request({
+    op: "trace",
+    tag,
+    ...options.limit !== void 0 ? { limit: options.limit } : {}
+  });
+  channel.tracing.set(id2, onEvents);
+  try {
+    await done4;
+  } catch (error) {
+    channel.tracing.delete(id2);
+    throw error;
+  }
+  return {
+    close: () => {
+      if (!channel.tracing.delete(id2)) return;
+      void channel.call({ op: "untrace", trace: id2 }).catch(() => void 0);
+    }
+  };
+}
 async function dialOn(channel, { port, host }) {
   const req = { op: "dial", port, ...host ? { host } : {} };
   return dialStream(await since(channel, 4, "dial", () => channel.call(req)));
@@ -37688,6 +37944,10 @@ async function spawnOn(channel, argv, opts) {
   });
   if (opts.tag !== void 0) await since(channel, 12, "a tag per spawn", async () => {
   });
+  if (Array.isArray(opts.tag)) await since(channel, 15, "several tags per spawn", async () => {
+  });
+  if (opts.cwdMissing === "error") await since(channel, 14, "cwdMissing: 'error'", async () => {
+  });
   const started = Promise.withResolvers();
   let endedBy;
   const options = { ...rest2, ...stdin !== void 0 ? { stdin: bytesOf4(stdin) } : {} };
@@ -37747,6 +38007,12 @@ async function terminalOn(channel, argv, opts) {
   });
   if (opts.tag !== void 0) await since(channel, 12, "a tag per terminal", async () => {
   });
+  if (Array.isArray(opts.tag)) {
+    await since(channel, 15, "several tags per terminal", async () => {
+    });
+  }
+  if (opts.cwdMissing === "error") await since(channel, 14, "cwdMissing: 'error'", async () => {
+  });
   let listener = onData ?? null;
   const backlog = [];
   const started = Promise.withResolvers();
@@ -37904,6 +38170,7 @@ async function attachKernel(port, options = {}) {
       channel.traitsListeners.add(listener);
       return () => channel.traitsListeners.delete(listener);
     },
+    trace: (tag, onEvents, options2 = {}) => traceOn(channel, tag, onEvents, options2),
     async close(o = {}) {
       if (channel.failure) return;
       await channel.call({ op: "detach", ...o.kill ? { kill: true } : {} }).catch(() => void 0);