@volter/supercode-teams 0.3.10 → 0.3.12

package/bin/teams.mjs

@@ -52,7 +52,7 @@ import { NODE_PROTOCOL } from '@volter/teams/channel';
 
 const MACHINE_VERBS = new Set(['machine', 'slow', 'describe', 'panes', 'input', 'suspend', 'resume', 'files', 'ports', 'port', 'browser', 'stream', 'jobs', 'workspace', 'title', 'attention', 'watch', 'rpc', 'launches', 'log', 'mail', 'health']);
 // Every flag a machine verb reads; any other is refused rather than silently ignored.
-const KNOWN_FLAGS = new Set(['home', 'since', 'machine', 'context', 'floor', 'supercode', 'tmux-socket', 'verbose', 'lines', 'input', 'name', 'for', 'urgency', 'reason', 'interrupt', 'query', 'out', 'in', 'interval', 'no-enter', 'when-composer-empty', 'key', 'listen', 'list', 'from', 'to', 'path', 'to-path', 'repo', 'branch', 'solo', 'card', 'create', 'presence-only', 'clear-draft', 'message-ids', 'json', 'all']);
+const KNOWN_FLAGS = new Set(['home', 'since', 'machine', 'context', 'floor', 'supercode', 'tmux-socket', 'verbose', 'lines', 'input', 'name', 'for', 'urgency', 'reason', 'interrupt', 'query', 'out', 'in', 'interval', 'no-enter', 'when-composer-empty', 'key', 'listen', 'list', 'from', 'to', 'path', 'to-path', 'repo', 'branch', 'solo', 'card', 'create', 'presence-only', 'processes', 'panes', 'clear-draft', 'message-ids', 'json', 'all']);
 
 const argv = process.argv.slice(2);
 const flags = {};
@@ -218,7 +218,11 @@ async function main() {
     case 'describe':
       return withNode(async (rpc) => out(await rpc.call('describe')));
     case 'panes': {
-      if (sub === 'ls') return withNode(async (rpc) => out(await rpc.call(flags['presence-only'] ? 'panes.present' : 'panes.list')));
+      // `--processes`: each pane and its root pid (no screens read); `--presence-only [--panes a,b]`: whether each pane's
+      // composer is idle, for the named panes only when named.
+      if (sub === 'ls') return withNode(async (rpc) => out(await rpc.call(
+        flags.processes ? 'panes.processes' : flags['presence-only'] ? 'panes.present' : 'panes.list',
+        flags['presence-only'] && typeof flags.panes === 'string' ? { panes: flags.panes.split(',').filter(Boolean) } : {})));
       if (sub === 'capture') return withNode(async (rpc) => out((await rpc.call('panes.capture', { pane: rest[0], lines: Number(flags.lines ?? 200) })).text));
       if (sub === 'close') return withNode(async (rpc) => out(await rpc.call('panes.close', { pane: rest[0] })));
       die('panes ls|capture|close');

package/machine.mjs

@@ -521,10 +521,12 @@ export class TeamsMachine extends MachineCore {
   async #checkEnds() {
     const pending = this.#pendingNotices();
     if (!pending.length) { clearInterval(this.endWatch); this.endWatch = null; return; }
+    // One pane listing for every pending notice, not one per notice.
+    const panes = await this.host.listSessions();
     for (const ask of pending) {
       // A pane has ended when it is gone, or when its program has exited and the host keeps it for its last screen
       // (a ConPTY pane whose program failed).
-      const session = await this.#paneByContext(ask.pane);
+      const session = panes.find((s) => s.contextKey === ask.pane) ?? null;
       if (session && !session.dead) continue;
       appendFileSync(this.#noticesPath(), JSON.stringify({ t: Date.now(), pane: ask.pane, told: true }) + '\n', { mode: 0o600 });
       const exit = session?.dead ? deadPaneExit(session) : paneExit(ask.pane);
@@ -1725,7 +1727,9 @@ export class TeamsMachine extends MachineCore {
         // No harness callback: discovery may be the harness's own caller.
         const whole = operator || holds(admitted, 'view', '*');
         if (!whole && !observesPanes(admitted)) need('view', '*');
-        const sessions = (await this.host.listSessions()).filter(s => s.contextKey && !s.dead && (whole || holds(admitted, 'observe', `pane:${s.contextKey}`)));
+        // `panes`: only these are read (a caller that needs some panes' composers does not pay a capture of every pane).
+        const asked = Array.isArray(params.panes) ? new Set(params.panes.map(String)) : null;
+        const sessions = (await this.host.listSessions()).filter(s => s.contextKey && !s.dead && (!asked || asked.has(s.contextKey)) && (whole || holds(admitted, 'observe', `pane:${s.contextKey}`)));
         return Promise.all(sessions.map(async session => {
           const screen = await Promise.resolve().then(() => this.host.capture(session.id, { lines: 100, preserveEscapes: true })).catch(() => null);
           const kind = this.#paneKind(session.contextKey, session);
@@ -1733,6 +1737,15 @@ export class TeamsMachine extends MachineCore {
           return { pane: session.contextKey, idleComposer: composer != null && !/\besc to (?:interrupt|cancel)\b/iu.test(screen) };
         }));
       }
+      case 'panes.processes': {
+        // Each pane and its root process, from the pane listing alone: what a caller that maps processes to panes
+        // needs, without panes.list's screen capture of every pane (message list asked for that, t_23e47b73).
+        const whole = operator || holds(admitted, 'view', '*');
+        if (!whole && !observesPanes(admitted)) need('view', '*');
+        return (await this.host.listSessions())
+          .filter(s => s.contextKey && !s.dead && (whole || holds(admitted, 'observe', `pane:${s.contextKey}`)))
+          .map(s => ({ pane: s.contextKey, pid: s.rootPid ?? null }));
+      }
       case 'harness.v1.panes.list':
       case 'panes.list': {
         // A participant lists the panes its grants let it observe; view on the whole
@@ -1876,9 +1889,15 @@ export class TeamsMachine extends MachineCore {
         // Everything this daemon launched, by key, with whether the pane still lives: how an
         // operator tells its own launches from a person's panes without reading labels.
         if (!operator) throw Object.assign(new Error('operators only'), { code: 403 });
+        // One pane listing for the whole journal: one per launch (thousands of them) ran past the door's 30 s bound,
+        // the slowest door the slow log named on yuerans-macbook-pro (t_23e47b73).
+        // The journal first, then the panes: a launch that becomes ready while the panes are listed is in a listing
+        // taken after it, so it never reads as not live.
         const rows = [];
-        for (const found of this.launches.all()) {
-          const session = found.pane ? await this.#paneByContext(found.pane) : null;
+        const launched = this.launches.all();
+        const panes = await this.host.listSessions();
+        for (const found of launched) {
+          const session = found.pane ? panes.find((s) => s.contextKey === found.pane) ?? null : null;
           rows.push({ key: found.key, pane: found.pane ?? null, kind: found.kind ?? null, by: found.by ?? null, status: found.status ?? null, at: found.t, live: Boolean(session && !session.dead), ...initialInputFacts(found) });
         }
         return rows;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",