@volter/supercode-teams 0.3.8 → 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-events.mjs

@@ -35,13 +35,17 @@ export class MachineEvents {
         if(!response.ok||!response.headers.get('content-type')?.includes('text/event-stream'))throw new Error(`machine events returned HTTP ${response.status}, expected event stream`);
         const reader=response.body.getReader();const decoder=new TextDecoder();let buffer='';
         try{for(;;){const {value,done}=await reader.read();if(done)break;clearTimeout(deadline);deadline=setTimeout(()=>streamAbort.abort(new Error('machine event stream timed out')),45000);buffer+=decoder.decode(value,{stream:true});if(buffer.length>2*1024*1024)throw new Error('machine event exceeded stream bound');let boundary;while((boundary=buffer.indexOf('\n\n'))>=0){const frame=buffer.slice(0,boundary);buffer=buffer.slice(boundary+2);const data=frame.split('\n').filter(line=>line.startsWith('data:')).map(line=>line.slice(5).trimStart()).join('\n');if(data)await this.receive(JSON.parse(data));}}}finally{await reader.cancel().catch(()=>{});}
-      }catch(error){if(!this.abort.signal.aborted){if(this.error!==error.message)process.stderr.write(`supercode teams machine events: ${error.message}\n`);this.error=error.message;}}
+      }catch(error){if(!this.abort.signal.aborted){this.failingSince??=Date.now();if(this.error!==error.message)process.stderr.write(`${new Date().toISOString()} supercode teams machine events: ${error.message} (cursor ${this.state.cursor})\n`);this.error=error.message;}}
       clearTimeout(deadline);this.connected=false;
       if(!this.abort.signal.aborted)await new Promise(resolve=>{const done=()=>{clearTimeout(timer);this.abort.signal.removeEventListener('abort',done);resolve();};const timer=setTimeout(done,5000);this.abort.signal.addEventListener('abort',done,{once:true});});
     }
   }
   async receive(event){
-    if(event.type==='machine_ready'){this.connected=true;this.error=null;return;}
+    if(event.type==='machine_ready'){
+      // A stream back after a failure says so, with how long it was down: a notice that arrives late is then traceable.
+      if(this.failingSince)process.stderr.write(`${new Date().toISOString()} supercode teams machine events: stream back at cursor ${event.cursor} after ${Math.round((Date.now()-this.failingSince)/1000)} s of: ${this.error}\n`);
+      this.connected=true;this.error=null;this.failingSince=null;return;
+    }
     if(event.type==='access_revoked')throw new Error('machine event subscription authorization revoked');
     if(!['machine_snapshot','machine_linked','machine_unlinked'].includes(event.type))return;
     if(!/^\d+$/.test(event.cursor??''))throw new Error('invalid machine event cursor');
@@ -74,6 +78,6 @@ export class MachineEvents {
     child.stdout.on('data',chunk=>{detail=(detail+chunk).slice(-1000);});child.stderr.on('data',chunk=>{detail=(detail+chunk).slice(-1000);});
     child.once('error',error=>{clearTimeout(timer);reject(error);});child.once('close',code=>{clearTimeout(timer);let receipt;try{receipt=JSON.parse(detail.trim().split('\n').at(-1));}catch{}code===0&&receipt?.code===0?resolve():reject(new Error(receipt?.text||detail||`exit ${code}`));});
     child.stdin.on('error',()=>{});
-    child.stdin.end(JSON.stringify({op:'send',from:`sc:${this.machine}:operator:teams-events`,from_name:'Teams machine events',to:item.to,id:item.id,queue:item.to.split(':')[2]==='board',body:item.to.split(':')[2]==='board'?JSON.stringify({machine_event:item.event,text:item.body}):item.body}));
+    child.stdin.end(JSON.stringify({op:'send',from:`sc:${this.machine}:operator:teams-events`,from_name:'Teams machine events',to:item.to,id:item.id,queue:item.to.split(':')[2]==='board',notice:true,body:item.body}));
   });}
 }

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.8",
+  "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.5",
+    "@volter/teams": "0.2.7",
     "@xterm/addon-serialize": "^0.14.0",
     "@xterm/headless": "^6.0.0",
     "protobufjs": "8.8.0",

package/server/node-upgrade.mjs

@@ -22,11 +22,14 @@ export function createMachineUpgradeHandler(api, { authenticate }) {
     socket.end(`HTTP/1.1 ${status} ${code}\r\nContent-Type: application/json\r\nContent-Length: ${Buffer.byteLength(body)}\r\nConnection: close\r\n\r\n${body}`);
   };
   const handler = async (req, socket, head) => {
+    // A caller that drops its connection mid-handshake (or later) ends only its own socket: an unheard socket error
+    // would end the whole server (measured: a client's ECONNRESET during authorization stopped the Node host).
+    socket.on('error', () => socket.destroy());
     try {
       const decision = await authorizeMachineUpgrade(api, { authenticate, url: req.url, headers: req.headers });
       if (decision.status) return refuse(socket, decision.status, decision.code, decision.message);
       return wss.handleUpgrade(req, socket, head, (ws) => {
-        ws.alive = true; ws.on('pong', () => { ws.alive = true; });
+        ws.alive = true; ws.on('pong', () => { ws.alive = true; }); ws.on('error', () => ws.terminate());
         void acceptMachineSocket(api, decision, createWebSocketStream(ws), (reason) => ws.close(1000, String(reason ?? 'closed').slice(0, 100)));
       });
     } catch (error) {

package/workspaces.mjs

@@ -20,7 +20,9 @@ export function repositoryId(value) {
 export function inspectCheckout(path) {
   const raw = git(path, ['rev-parse', '--path-format=absolute', '--show-toplevel', '--git-dir', '--git-common-dir']);
   const [root, dir, common] = raw.split('\n').map(p => realpathSync(resolve(path, p)));
-  const remote = git(root, ['remote', 'get-url', 'origin'], true);
+  // The repository the checkout declares (remote.origin.url), not where a URL rewrite (insteadOf: a mirror, a proxy, a
+  // World's twin) sends its transport.
+  const remote = git(root, ['config', '--get', 'remote.origin.url'], true);
   return { path: realpathSync(path), root, linked: dir !== common, repository: remote ? repositoryId(remote) : null, branch: git(root, ['branch', '--show-current']) || null };
 }
 export class Workspaces {