@volter/supercode-teams 0.3.9 → 0.3.10

package/bin/teams.mjs

@@ -33,6 +33,7 @@ import { appendFileSync, createWriteStream, readFileSync, writeFileSync } from '
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { SupercodeHarnessClient } from '@volter/supercode-harness-sdk';
+import { noteStep, slowLogPath, timeCommand } from '@volter/supercode-harness-sdk/slow-log';
 
 // A Windows scheduled task keeps no output (launchd and systemd name log files), so its unit names one here.
 if (process.env.SUPERCODE_TEAMS_LOG) {
@@ -49,9 +50,9 @@ import { moveWorkspace } from '../workspace-move.mjs';
 import { teamsHome, paths, readJson, AccountLog, parseHostPort } from '@volter/teams/home';
 import { NODE_PROTOCOL } from '@volter/teams/channel';
 
-const MACHINE_VERBS = new Set(['machine', 'describe', 'panes', 'input', 'suspend', 'resume', 'files', 'ports', 'port', 'browser', 'stream', 'jobs', 'workspace', 'title', 'attention', 'watch', 'rpc', 'launches', 'log', 'mail', 'health']);
+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', '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', 'clear-draft', 'message-ids', 'json', 'all']);
 
 const argv = process.argv.slice(2);
 const flags = {};
@@ -68,8 +69,12 @@ for (let i = 0; i < argv.length; i += 1) {
   } else positional.push(a);
 }
 const [verb, sub, ...rest] = positional;
+// Each command is timed (the slow log, @volter/supercode-harness-sdk/slow-log); a service, a watch or a forward runs
+// until stopped and is timed one door at a time instead.
+const LONG_RUNNING = new Set(['connect', 'watch', 'port', 'stream', 'attach', 'serve']);
+if (!LONG_RUNNING.has(verb) && !(verb === 'machine' && sub === 'start') && !(verb === 'message' && sub === 'watch')) timeCommand(`teams ${[verb, sub].filter(Boolean).join(' ')}`, argv);
 
-const MACHINE_HELP = 'machine verbs: machine start|status, describe, panes, input, suspend, resume, files, ports, port, stream, jobs, workspace, title, attention, watch, rpc, launches, log, health, browser (add --machine NAME for an enrolled machine)';
+const MACHINE_HELP = 'machine verbs: machine start|status|restart, slow [--since 1h], describe, panes, input, suspend, resume, files, ports, port, stream, jobs, workspace, title, attention, watch, rpc, launches, log, health, browser (add --machine NAME for an enrolled machine)';
 
 if (verb === undefined || verb === 'help') {
   process.stdout.write(`supercode teams: ${MACHINE_HELP}\n`);
@@ -109,7 +114,9 @@ function keyBytes(names) {
 }
 
 async function machineChannel() {
-  return openMachine({ machine: flags.machine ? String(flags.machine) : null, context: flags.context ? String(flags.context) : null, home });
+  const started = performance.now();
+  try { return await openMachine({ machine: flags.machine ? String(flags.machine) : null, context: flags.context ? String(flags.context) : null, home }); }
+  finally { noteStep(flags.machine ? `open machine ${flags.machine}` : 'open the local machine', performance.now() - started); }
 }
 
 // The session (or board) this command acts for: the pane doors refuse a session acting on a pane it did not start.
@@ -176,6 +183,38 @@ async function main() {
       if (sub === 'restart') return withNode(async (rpc) => out(await rpc.call('machine.restart', { reason: flags.reason ? String(flags.reason) : null })));
       die('machine start|status|restart');
     }
+    case 'slow': {
+      // `slow [--since 1h|30m|<iso>]`: the slow log on this machine, grouped by what was slow (kind and name), the
+      // slowest first, each with its count, median and longest time and its usual slowest step. The audit reads this.
+      const since = (() => {
+        const value = String(flags.since ?? '24h');
+        const relative = /^(\d+)([smhd])$/.exec(value);
+        if (relative) return Date.now() - Number(relative[1]) * { s: 1e3, m: 6e4, h: 36e5, d: 864e5 }[relative[2]];
+        const at = Date.parse(value);
+        if (Number.isNaN(at)) die('slow --since takes 30m, 2h, 1d or a date');
+        return at;
+      })();
+      let text = '';
+      for (const file of [`${slowLogPath()}.1`, slowLogPath()]) {
+        try { text += readFileSync(file, 'utf8'); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+      }
+      const groups = new Map();
+      for (const line of text.split('\n')) {
+        let row; try { row = JSON.parse(line); } catch { continue; }
+        if (!(Date.parse(row.at) >= since)) continue;
+        const key = `${row.kind} ${row.name}`;
+        const group = groups.get(key) ?? { kind: row.kind, name: row.name, count: 0, ms: [], steps: new Map(), last: null };
+        group.count += 1; group.ms.push(row.ms); group.last = row.at;
+        if (row.slowest?.step) group.steps.set(row.slowest.step, (group.steps.get(row.slowest.step) ?? 0) + 1);
+        groups.set(key, group);
+      }
+      out([...groups.values()].map((group) => {
+        const sorted = group.ms.sort((a, b) => a - b);
+        const step = [...group.steps].sort((a, b) => b[1] - a[1])[0];
+        return { kind: group.kind, name: group.name, count: group.count, median_ms: sorted[Math.floor(sorted.length / 2)], max_ms: sorted.at(-1), usual_slowest_step: step ? step[0] : null, last: group.last };
+      }).sort((a, b) => b.max_ms * b.count - a.max_ms * a.count));
+      return;
+    }
     case 'describe':
       return withNode(async (rpc) => out(await rpc.call('describe')));
     case 'panes': {

package/client.mjs

@@ -8,6 +8,7 @@ import { EventEmitter } from 'node:events';
 import { Channel } from '@volter/teams/channel';
 import { openLocalMachine, openRemoteMachine, StreamRpc, fromWebPage, harnessTransport } from '@volter/teams/client';
 import { lineSplitter } from '@volter/teams/lines';
+import { noteStep } from '@volter/supercode-harness-sdk/slow-log';
 
 export { openLocalMachine, openRemoteMachine, StreamRpc, fromWebPage, harnessTransport };
 
@@ -50,8 +51,17 @@ export async function execServerBridge(channel, harness, { host = '127.0.0.1' }
 
 /** The node's own doors (describe, grants, launch, files, ports, attention, titles) over the `node` stream. */
 export async function nodeRpc(channel) {
+  const opened = performance.now();
   const stream = await channel.open('node');
-  return new StreamRpc(stream);
+  noteStep('open the node stream', performance.now() - opened);
+  const rpc = new StreamRpc(stream);
+  // Each door call is a step of the running command (the slow log names the slowest).
+  const call = rpc.call.bind(rpc);
+  rpc.call = async (method, ...rest) => {
+    const started = performance.now();
+    try { return await call(method, ...rest); } finally { noteStep(`machine door ${method}`, performance.now() - started); }
+  };
+  return rpc;
 }
 
 /**

package/machine.mjs

@@ -44,6 +44,7 @@ import { TmuxTerminalHost, classifyAttentionSignal, composerHoldsDraft, composer
 // than failing the load: a POSIX daemon never needs it. Windows needs a supercode-terminal with PtyTerminalHost.
 import * as terminal from '@volter/supercode-terminal';
 import { findLiveReceipt, mintFrontendCredential } from '@volter/supercode-harness-sdk/live-runtime';
+import { recordSlow } from '@volter/supercode-harness-sdk/slow-log';
 import { lineSplitter } from '@volter/teams/lines';
 import { NODE_PROTOCOL } from '@volter/teams/channel';
 import { holds, observesPanes } from '@volter/teams/admission';
@@ -235,7 +236,8 @@ export class TeamsMachine extends MachineCore {
     }, 1000);
     this.terminalMailTimer.unref?.();
     // What actually runs under each hosted pane, for the trace pack (process-tree.mjs): one read every five seconds.
-    this.processTree = new ProcessTree({ root: join(this.home, 'processes'), panes: async () => (await this.attentionEvidence()).map(({ session }) => ({ pane: session.contextKey, rootPid: session.rootPid })) });
+    // It needs each pane's root pid only: the pane listing, not attention's screen capture of every pane.
+    this.processTree = new ProcessTree({ root: join(this.home, 'processes'), panes: async () => (await this.host.listSessions()).map((session) => ({ pane: session.contextKey, rootPid: session.rootPid })) });
     this.processTimer = setInterval(() => {
       if (this.processWork) return;
       this.processWork = this.processTree.sample().catch(error => this.emit('mail-watch-stderr', `process tree: ${error.message}`)).finally(() => { this.processWork = null; });
@@ -959,7 +961,9 @@ export class TeamsMachine extends MachineCore {
       const evidence = {
         liveness: own?.liveness ?? livenessOf(session.activeCommand),
         signal: classifyAttentionSignal(capture) ?? own?.signal ?? null,
-        idleSeconds: this.#idleSeconds(session.id, capture, now),
+        // tmux keeps when each pane last printed, so idle time advances between queries; a host that does not say
+        // (the Windows pane server) falls back to the screen's own plateau since this daemon last looked.
+        idleSeconds: Number.isFinite(session.lastOutputAt) ? Math.max(0, Math.round((now - session.lastOutputAt) / 1000)) : this.#idleSeconds(session.id, capture, now),
         requested,
         ...(own ? { livenessSource: 'cooperative' } : {}),
       };
@@ -1044,9 +1048,15 @@ export class TeamsMachine extends MachineCore {
   }
 
   async #drainTerminalMail() {
-    for (const saved of retainedTerminalMail(this.terminalMailRoot)) {
+    // One pane listing per tick, shared by every mailbox: a listing per mailbox each second was most of this
+    // daemon's tmux spawns (8 retained mailboxes, about 70 tmux processes a second, t_23e47b73).
+    const retained = retainedTerminalMail(this.terminalMailRoot);
+    if (!retained.length && !this.terminalMailboxes.size) return;
+    const panes = await this.host.listSessions();
+    const paneByContext = (contextKey) => panes.find((s) => s.contextKey === contextKey) ?? null;
+    for (const saved of retained) {
       if (this.terminalMailboxes.has(saved.recipient) || !saved.binding) continue;
-      const session = await this.#paneByContext(saved.binding.context);
+      const session = paneByContext(saved.binding.context);
       if (!session || session.id !== saved.binding.terminal || session.rootPid !== saved.binding.pid) continue;
       const queue = new TerminalMailbox(this.terminalMailRoot, saved.recipient, receipt => this.log.append({ principal: null, cap: 'control',
         target: `pane:${saved.binding.context}`, outcome: receipt.delivered ? 'input-delivered' : 'input-pending', detail: JSON.stringify(receipt) }), (locator, options) => this.#serveRequest('harness.v1.sessions.load', { locator, options: { ...options, include_subagents: false } }, 10000));
@@ -1057,7 +1067,7 @@ export class TeamsMachine extends MachineCore {
     // exists. Its mail stays retained: the session's next pane takes it up.
     for (const [recipient, queue] of this.terminalMailboxes) {
       const binding = queue.state.binding;
-      const live = binding ? await this.#paneByContext(binding.context) : null;
+      const live = binding ? paneByContext(binding.context) : null;
       if (!live || live.id !== binding.terminal) this.terminalMailboxes.delete(recipient);
     }
     await Promise.all([...this.terminalMailboxes.values()].filter(queue => !this.inputRepairs[queue.state.binding?.context] && !this.inputInFlight.has(queue.session?.id)).map(queue => queue.kick()));
@@ -1497,8 +1507,10 @@ export class TeamsMachine extends MachineCore {
           const result = await withTimeout(this.#dispatch(entry, request.method, request.params ?? {}), bound, request.method);
           reply({ id: request.id, result });
           this.emit('door', { method: request.method, ms: Date.now() - startedAt, outcome: 'ok' });
+          recordSlow({ kind: 'door', name: request.method, ms: Date.now() - startedAt, slowest: null, extra: { principal: entry.principal ?? null } });
         } catch (error) {
           this.emit('door', { method: request.method, ms: Date.now() - startedAt, outcome: error.code ?? 'error', detail: error.message });
+          recordSlow({ kind: 'door', name: request.method, ms: Date.now() - startedAt, outcome: String(error.code ?? 'error'), slowest: null, extra: { principal: entry.principal ?? null } });
           reply({ id: request.id, error: { code: error.code ?? -1, message: error.message } });
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.9",
+  "version": "0.3.10",
   "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",
@@ -66,7 +66,7 @@
     "@volter/supercode-health": "^0.1.0",
     "@volter/supercode-terminal": "^0.2.54",
     "@volter/supercode-trace": "^0.1.0",
-    "@volter/teams": "0.2.6",
+    "@volter/teams": "0.2.7",
     "@xterm/addon-serialize": "^0.14.0",
     "@xterm/headless": "^6.0.0",
     "protobufjs": "8.8.0",