@ai-ecoverse/slicc-kernel 1.179.0 → 1.181.0

package/dist/index.js

@@ -1958,7 +1958,7 @@ var RemoteTransport = class {
 };
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 14];
+var PROTOCOL = [1, 16];
 function locksOf(scope = globalThis) {
   const locks = scope.navigator?.locks;
   return typeof locks?.request === "function" ? locks : void 0;
@@ -2023,6 +2023,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();
@@ -2090,6 +2091,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;
@@ -2118,6 +2123,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, dropped) {
+    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 });
+    } 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) {
@@ -2180,6 +2202,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, done } = channel.request({
+    op: "trace",
+    tag,
+    ...options.limit !== void 0 ? { limit: options.limit } : {}
+  });
+  channel.tracing.set(id, onEvents);
+  try {
+    await done;
+  } catch (error) {
+    channel.tracing.delete(id);
+    throw error;
+  }
+  return {
+    close: () => {
+      if (!channel.tracing.delete(id)) return;
+      void channel.call({ op: "untrace", trace: id }).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)));
@@ -2193,6 +2238,8 @@ 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();
@@ -2217,6 +2264,19 @@ async function spawnOn(channel, argv, opts) {
     signal: async (name = "SIGTERM") => void await channel.call({ op: "kill", pid: -pgid, signal: name })
   };
 }
+async function sudoRunOn(channel, replay, { stdout, stderr, tag }) {
+  await since(channel, 16, "sudoRun", async () => {
+  });
+  const started = Promise.withResolvers();
+  let endedBy;
+  const { done } = channel.request(
+    { op: "sudo-run", replay, options: { stdout, stderr, tag } },
+    { started: started.resolve, ended: (signal) => endedBy = signal }
+  );
+  done.catch(started.reject);
+  const pid = await started.promise;
+  return { pid, pgid: pid, ended: endedOf(done, () => endedBy) };
+}
 function endedOf(done, signal) {
   return quiet(
     done.then((status) => {
@@ -2254,6 +2314,10 @@ 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;
@@ -2413,6 +2477,8 @@ async function attachKernel(port, options = {}) {
       channel.traitsListeners.add(listener);
       return () => channel.traitsListeners.delete(listener);
     },
+    trace: (tag, onEvents, options2 = {}) => traceOn(channel, tag, onEvents, options2),
+    sudoRun: (replay, options2 = {}) => sudoRunOn(channel, replay, options2),
     async close(o = {}) {
       if (channel.failure) return;
       await channel.call({ op: "detach", ...o.kill ? { kill: true } : {} }).catch(() => void 0);
@@ -2801,6 +2867,16 @@ function decodedRun(result) {
     stderr: decoder2.decode(result.stderr)
   };
 }
+async function sudoRunOn2(request, replay, { stdout, stderr, tag }) {
+  const started = Promise.withResolvers();
+  const { done } = request(
+    { op: "sudo-run", replay, options: { stdout, stderr, tag } },
+    { started: started.resolve }
+  );
+  done.catch(started.reject);
+  const pid = await started.promise;
+  return { pid, pgid: pid, ended: quiet(done.then(endedOf2)) };
+}
 function endedOf2(r) {
   if (typeof r === "number") return { status: r };
   const { status, signal } = r;
@@ -2966,6 +3042,7 @@ async function createKernel(options = {}) {
       return decodedRun(result);
     },
     openTerminal,
+    sudoRun: (replay, sudoOptions = {}) => sudoRunOn2(request, replay, sudoOptions),
     connect: connector(call, bound),
     ...accounts(call, options.users === void 0 ? DEFAULT_USERS : options.users),
     setRoutes: async (routes) => void await call({ op: "routes", routes }),