@volter/supercode-teams 0.2.117 → 0.2.119

package/bin/teams.mjs

@@ -19,6 +19,7 @@
 //   title set <pane> <text> | title ls
 //   attention ls | rank | request <pane> [--urgency now|soon|whenever] [--reason text] | clear <pane>
 //   watch [--interval ms] [--for ms]
+//   launches get <key> | list                 operators: keyed node launch receipts
 //   rpc <harness.v1 method> [json-params]   operators: one harness.v1 request
 //   log verify
 //
@@ -44,7 +45,7 @@ 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', 'log', 'mail']);
+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']);
 // 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']);
 
@@ -64,7 +65,7 @@ for (let i = 0; i < argv.length; i += 1) {
 }
 const [verb, sub, ...rest] = positional;
 
-const MACHINE_HELP = 'machine verbs: machine start|status, describe, panes, input, suspend, resume, files, ports, port, stream, jobs, workspace, title, attention, watch, rpc, log, browser (add --machine NAME for an enrolled machine)';
+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, browser (add --machine NAME for an enrolled machine)';
 
 if (verb === undefined || verb === 'help') {
   process.stdout.write(`supercode teams: ${MACHINE_HELP}\n`);
@@ -312,6 +313,12 @@ async function main() {
     case 'jobs':
       // `jobs [--machine NAME]`: the execution jobs the machine's daemon owns now.
       return withNode(async (rpc) => out(await rpc.call('jobs.list', {})));
+    case 'launches': {
+      if (sub === 'get' && rest[0]) return withNode(async (rpc) => out(await rpc.call('launches.get', { key: rest[0] })));
+      if (sub === 'list') return withNode(async (rpc) => out(await rpc.call('launches.list', {})));
+      die('launches get <key> | launches list [--machine NAME]');
+      return;
+    }
     case 'rpc': {
       const channel = await machineChannel();
       const client = new SupercodeHarnessClient({ transport: harnessTransport(channel) });

package/connector/index.mjs

@@ -207,6 +207,9 @@ export class TeamsConnector {
     /** The first sync pass, for a caller that waits on it; the connector keeps running if it fails. */
     this.firstPass = syncPass();
     this.timer = setInterval(syncPass, 15000);
+    // Viewed file-backed sessions should not wait for catalog discovery. Poll
+    // only their cheap file stamps; full reads remain coalesced in capture lanes.
+    this.liveCaptureTimer = setInterval(() => this.captureViewedFiles(), 750);
     this.heartbeatTimer = setInterval(() => {
       if (this.abort.signal.aborted) return;
       void heartbeat().catch(error => { this.lastError = error; });
@@ -243,6 +246,7 @@ export class TeamsConnector {
     // reads any session's tail, so a beat costs one bounded scan per root, not one over every session on the
     // machine; rules over the same root and harnesses share the scan.
     const discoveries=new Map(),followCandidates=[],discovered=new Set(),activity=[];
+    this.liveFiles??=new Map();
     this.turnStates??=new Map();
     for(const rule of activeRules.values()){
       const root=roots.find(item=>item.id===rule.selector.root_id);
@@ -268,6 +272,7 @@ export class TeamsConnector {
         const turn=descriptor.activity?.turn;
         if(typeof turn==='string'&&turn&&activity.length<4096){const key=`${harness}:${nativeSessionId}`,held=this.turnStates.get(key),since=held?.turn===turn?held.since:this.clock.nowMs();this.turnStates.set(key,{turn,since});activity.push({harness,native_id:nativeSessionId,turn,since});}
         const options={locator,descriptor,harness,nativeSessionId,ruleId:rule.id,ruleRevision:rule.revision,backfill:rule.backfill,rootPath:workspace,configuration};
+        if(locator.storage?.kind==='file')this.liveFiles.set(`${harness}:${nativeSessionId}`,options);
         // A session whose native store has not changed since this rule last captured it is not reloaded.
         // One session that cannot be captured (a transcript that rewrote its history needs an explicit resync)
         // is recorded, logged and skipped; it must not stop every other session, or the connector itself, from
@@ -289,12 +294,29 @@ export class TeamsConnector {
         followCandidates.push({key:`${rule.id}:${harness}:${nativeSessionId}`,activity:this.sessionActivity(options),options});
       }
     }
+    for(const [key,options] of this.liveFiles)if(!discovered.has(key)||!activeRules.has(options.ruleId))this.liveFiles.delete(key);
     this.nativeEffects.endDiscovery();
     for(const key of this.turnStates.keys())if(!discovered.has(key))this.turnStates.delete(key);
     this.reportedActivity=activity;
     this.pruneNativeCache(discovered);
     this.rotateFollowers(followCandidates);
   }
+  captureViewedFiles(){
+    if(this.abort.signal.aborted)return;
+    this.liveFileCaptures??=new Set();this.liveFileStamps??=new Map();
+    for(const key of [...(this.watched??[])].slice(0,FOLLOW_LIMIT)){
+      const known=this.liveFiles?.get(key);
+      if(!known||this.liveFileCaptures.has(key))continue;
+      const options={...known};
+      if(!this.sessionChanged(options)||this.liveFileStamps.get(key)===options.stamp)continue;
+      this.liveFileStamps.set(key,options.stamp);this.liveFileCaptures.add(key);
+      // Re-read authorization when a live file changes; never keep a stale rule
+      // alive merely because somebody still has the transcript open.
+      void this.capture({...options,configuration:null,live:true}).catch(error=>{
+        this.liveFileStamps.delete(key);if(!this.abort.signal.aborted)this.noteSessionProblem(options,error);
+      }).finally(()=>this.liveFileCaptures.delete(key));
+    }
+  }
   // A session never published under a rule that keeps back history recorded before a time (a `since` window, or a
   // `none` rule's capture_after), whose native file was last written before that time, holds only history the rule
   // keeps back: loading it (a 228 MB transcript is gigabytes in the harness process and here) would publish nothing.
@@ -538,6 +560,8 @@ export class TeamsConnector {
       const [key,options]=[...lane.queue.entries()].reduce((best,entry)=>written(entry)>written(best)?entry:best);lane.queue.delete(key);
       let started=null;
       try{
+        const seen=this.state.origins[key]?.capture_stamps?.[options.ruleId];
+        if(options.live&&seen?.rule_revision===options.ruleRevision&&seen.stamp===this.sessionStamp(options))continue;
         const artifactBefore=statSync(realpathSync(options.locator.storage.path));
         // A session is loaded again no sooner than ten times its last load took (a 0.5 s load: every 5 s; a load
         // that takes minutes: every LARGE_CAPTURE_EVERY_MS), so a live session streams while the lanes stay light.
@@ -740,5 +764,5 @@ export class TeamsConnector {
   }
   async flushOutbox(){let latest=null;while(this.state.outbox.length){const item=this.state.outbox[0];let receipt;this.dropLostArtifacts(item);this.refitParts(item);try{receipt=await this.sendCapture(item);}catch(error){if(error.status===409&&error.code==='carry_mismatch'){const key=`${item.begin.harness}:${item.begin.native_session_id}`;this.lastError=error;process.stderr.write(`supercode teams: the server does not hold what a capture of ${item.begin.harness} session ${item.begin.native_session_id} carried; it goes whole next time\n`);this.state.outbox.shift();if(this.state.origins[key])this.state.origins[key]={...this.state.origins[key],observed_keys:[],observed_digests:[],carry_refused:true};this.save();continue;}if(error.status===400&&error.code==='invalid_request'||error.status===413){this.lastError=error;this.noteSessionProblem({harness:item.begin.harness,nativeSessionId:item.begin.native_session_id,ruleId:item.begin.rule_id??null},error);(this.droppedCaptures??=new Set()).add(`${item.begin.harness}:${item.begin.native_session_id}`);process.stderr.write(`supercode teams: dropped a queued capture of ${item.begin.harness} session ${item.begin.native_session_id} the server refused${error.status===413?' (one message is larger than a request may be)':' as malformed'}: ${error.message}\n`);this.state.outbox.shift();this.save();continue;}if(!await this.ruleRejected(item,error))throw error;this.lastError=error;process.stderr.write(`supercode teams: dropped a queued capture of ${item.begin.harness} session ${item.begin.native_session_id}; its sync rule changed or was removed: ${error.message}\n`);this.state.outbox.shift();this.save();continue;}const key=`${item.begin.harness}:${item.begin.native_session_id}`,prior=this.state.origins[key]??{},next={...prior,generation:item.begin.generation,sequence:item.begin.sequence,digest:item.commit.digest,observed_keys:item.observed?.keys??prior.observed_keys,observed_digests:item.observed?.digests??prior.observed_digests,last_rule_revision:item.begin.rule_revision,backfill_mode:item.backfillMode};if(item.clearBaseline){delete next.baseline;delete next.baseline_digests;delete next.baseline_tool_tail;}if(item.nativeDeferred)next.native_deferred=true;else delete next.native_deferred;if(!item.begin.carry)delete next.carry_refused;if(item.stamp&&item.begin.rule_id)next.capture_stamps={...prior.capture_stamps,[item.begin.rule_id]:{stamp:item.stamp,rule_revision:item.begin.rule_revision,backfill_mode:item.backfillMode}};this.state.origins[key]=next;this.state.outbox.shift();this.save();// A queued capture is often flushed by another session's capture: its own session's problem ends with it.
 this.clearSessionProblem(item.begin.harness,item.begin.native_session_id);if(item.artifacts?.length)this.pruneSpill();latest=receipt;}return latest;}
-  stop(){try{this.flushState();}catch{}if(this.timer)clearInterval(this.timer);if(this.heartbeatTimer)clearInterval(this.heartbeatTimer);this.abort.abort();for(const follower of this.followers?.values()??[])follower.controller.abort();return this.nativeEffects.close();}
+  stop(){try{this.flushState();}catch{}if(this.timer)clearInterval(this.timer);if(this.liveCaptureTimer)clearInterval(this.liveCaptureTimer);if(this.heartbeatTimer)clearInterval(this.heartbeatTimer);this.abort.abort();for(const follower of this.followers?.values()??[])follower.controller.abort();return this.nativeEffects.close();}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.2.117",
+  "version": "0.2.119",
   "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",