@volter/supercode-teams 0.2.23 → 0.2.24

package/connector/index.mjs

@@ -6,6 +6,16 @@ import { EffectConsumer } from './effects.mjs';
 import { NativeEffects } from './native-effects.mjs';
 
 const SYNC_PROBLEM_LIMIT=20;
+// Live follows are bounded. The harness SDK lets at most 64 subscription opens await replies at once (sdk/typescript
+// core.mjs MAX_PENDING_RUNTIME_OPENS; more reject with SUBSCRIPTION_OPEN_CAPACITY) and every live follow is a follower
+// the service polls, while a subtree rule can cover hundreds of sessions. Only the most recently active sessions (at
+// most FOLLOW_LIMIT, half the SDK's limit for headroom, active within FOLLOW_ACTIVE_WINDOW_MS) are followed live; the
+// rest are covered by each beat's stamp-based capture. Followers rotate as activity changes.
+const FOLLOW_LIMIT=32,FOLLOW_ACTIVE_WINDOW_MS=30*60*1000,FOLLOW_RETRY_MS=60*1000;
+const CAPACITY_CODE='SUBSCRIPTION_OPEN_CAPACITY';
+const capacityError=error=>error?.code===CAPACITY_CODE||/Too many unresolved subscriptions/.test(String(error?.message??''));
+// An error of the connection itself (the outbox, authentication, the server), not of one session.
+const connectionError=error=>Boolean(error?.outbox||error?.status===401||error?.status===403||error?.status>=500);
 const errorSummary=(error,at)=>error==null?null:{code:typeof error.code==='string'?error.code:null,message:String(error.message??error).slice(0,500),at};
 /** The sync status a connector keeps in its state directory (see TeamsConnector#syncStatus); null when it has none. */
 export function readSyncStatus(stateDir){
@@ -57,7 +67,7 @@ function atomic(path, value) {
   }
 }
 export class TeamsConnector {
-  constructor({server,teamId,machineId,sourceId,credential,stateDir,core,hostKeyId=null,effectExecutor=null,clock={nowMs:()=>Date.now()},fetch:fetchImpl=globalThis.fetch}){Object.assign(this,{server:serverOrigin(server),teamId,machineId,sourceId,credential,stateDir,core,hostKeyId,effectExecutor,clock,fetch:fetchImpl});mkdirSync(stateDir,{recursive:true,mode:0o700});chmodSync(stateDir,0o700);this.statePath=join(stateDir,'connector.json');this.state=existsSync(this.statePath)?JSON.parse(readFileSync(this.statePath,'utf8')):{version:1,sequence:0,origins:{},outbox:[]};this.state.effects??={};this.state.incarnation_id=`inc_${randomBytes(16).toString('hex')}`;this.abort=new AbortController();this.work=Promise.resolve();this.nativeEffects=new NativeEffects(this);this.effects=new EffectConsumer(this,effectExecutor?{prepare:async effect=>({execute:()=>effectExecutor(effect,{core:this.core,signal:this.abort.signal})})}:this.nativeEffects);this.save();}
+  constructor({server,teamId,machineId,sourceId,credential,stateDir,core,hostKeyId=null,effectExecutor=null,clock={nowMs:()=>Date.now()},fetch:fetchImpl=globalThis.fetch}){Object.assign(this,{server:serverOrigin(server),teamId,machineId,sourceId,credential,stateDir,core,hostKeyId,effectExecutor,clock,fetch:fetchImpl});mkdirSync(stateDir,{recursive:true,mode:0o700});chmodSync(stateDir,0o700);this.statePath=join(stateDir,'connector.json');this.state=existsSync(this.statePath)?JSON.parse(readFileSync(this.statePath,'utf8')):{version:1,sequence:0,origins:{},outbox:[]};this.state.effects??={};if(Array.isArray(this.state.sync_status?.problems))this.state.sync_status.problems=this.state.sync_status.problems.filter(item=>item?.code!==CAPACITY_CODE);this.state.incarnation_id=`inc_${randomBytes(16).toString('hex')}`;this.abort=new AbortController();this.work=Promise.resolve();this.nativeEffects=new NativeEffects(this);this.effects=new EffectConsumer(this,effectExecutor?{prepare:async effect=>({execute:()=>effectExecutor(effect,{core:this.core,signal:this.abort.signal})})}:this.nativeEffects);this.save();}
   save(){atomic(this.statePath,this.state);}
   // What `supercode teams status` shows about this connector: its last error, and the sessions it could not capture
   // (most recent first, bounded; an entry clears when that session next captures). They are kept in connector.json,
@@ -158,14 +168,14 @@ export class TeamsConnector {
   pollEffects() { return this.effects.poll(); }
   async syncConfiguredSessions(configuration,roots){
     if(typeof this.core.discover!=='function')return;
-    this.followers??=new Map();
+    this.followers??=new Map();this.followRetry??=new Map();this.stoppingFollowers??=new Set();
     this.nativeEffects.beginDiscovery();
     const activeRules=new Map(configuration.rules.filter(item=>item.state==='active').map(rule=>[rule.id,rule]));
-    for(const [key,follower] of this.followers){const rule=activeRules.get(follower.ruleId);if(!rule||rule.revision!==follower.ruleRevision){follower.controller.abort();this.followers.delete(key);}}
+    for(const [key,follower] of this.followers){const rule=activeRules.get(follower.ruleId);if(!rule||rule.revision!==follower.ruleRevision){this.stopFollower(key);}}
     // A rule covers its root folder and every folder under it. Core discovery filters that subtree before it
     // 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();
+    const discoveries=new Map(),followCandidates=[];
     for(const rule of activeRules.values()){
       const root=roots.find(item=>item.id===rule.selector.root_id);
       if(!root)continue;
@@ -193,22 +203,65 @@ export class TeamsConnector {
         // the pass. The session keeps its native binding either way, so it can still be attached to.
         let captured = true;
         if (this.sessionChanged(options)) try { await this.capture(options); } catch (error) {
-          if (error.outbox || error.status === 401 || error.status === 403 || error.status >= 500 || this.abort.signal.aborted) throw error;
+          if (connectionError(error) || this.abort.signal.aborted) throw error;
           captured = false; this.noteSessionProblem(options, error);
           process.stderr.write(`supercode teams: ${harness} session ${nativeSessionId} not synced: ${error.message}\n`);
         }
         try { await this.nativeEffects.discover(descriptor, rule.id); } catch (error) { this.lastError = error; }
         if (!captured) continue;
-        const key=`${rule.id}:${harness}:${nativeSessionId}`;
-        if(this.followers.has(key)||typeof this.core.session(locator).follow!=='function')continue;
-        const controller=new AbortController(),stop=()=>controller.abort(this.abort.signal.reason);this.abort.signal.addEventListener('abort',stop,{once:true});
-        // A follow event may land between beats, after the rule changed: it reads the configuration afresh.
-        const followed={...options,configuration:null,stamp:undefined};
-        const task=(async()=>{for await(const _event of this.core.session(locator).follow({signal:controller.signal})){if(controller.signal.aborted)break;await this.capture(followed);}})().catch(error=>{if(!controller.signal.aborted)this.noteSessionProblem(followed,error);}).finally(()=>{this.abort.signal.removeEventListener('abort',stop);this.followers.delete(key);});
-        this.followers.set(key,{ruleId:rule.id,ruleRevision:rule.revision,controller,task});
+        followCandidates.push({key:`${rule.id}:${harness}:${nativeSessionId}`,activity:this.sessionActivity(options),options});
       }
     }
     this.nativeEffects.endDiscovery();
+    this.rotateFollowers(followCandidates);
+  }
+  // When a session was last active: its descriptor's updated_at_ms, else its native file's modification time.
+  sessionActivity({locator,descriptor}){
+    let activity=Number.isSafeInteger(descriptor?.updated_at_ms)?descriptor.updated_at_ms:null;
+    const path=locator?.storage?.kind==='file'&&typeof locator.storage.path==='string'?locator.storage.path:null;
+    if(path)try{activity=Math.max(activity??0,statSync(path).mtimeMs);}catch{}
+    return activity;
+  }
+  // Follows the FOLLOW_LIMIT most recently active candidates (active within the window) and stops every other
+  // follower. A capacity refusal is not a session's failure: the connector backs off opening follows for a while.
+  rotateFollowers(candidates){
+    const now=this.clock.nowMs(),seen=new Set(),wanted=[];
+    for(const candidate of candidates.filter(item=>item.activity!==null&&now-item.activity<=FOLLOW_ACTIVE_WINDOW_MS).sort((a,b)=>b.activity-a.activity)){
+      if(seen.has(candidate.key)||typeof this.core.session(candidate.options.locator).follow!=='function')continue;
+      seen.add(candidate.key);wanted.push(candidate);if(wanted.length>=FOLLOW_LIMIT)break;
+    }
+    for(const key of this.followers.keys())if(!seen.has(key))this.stopFollower(key);
+    for(const [key,until] of this.followRetry)if(until<=now)this.followRetry.delete(key);
+    for(const {key,options} of wanted){
+      if(this.followers.has(key)||this.followRetry.has(key))continue;
+      // A stopped follower holds its slot until it has closed, so live follows never exceed the bound.
+      if((this.followBackoffUntil??0)>now||this.followers.size+this.stoppingFollowers.size>=FOLLOW_LIMIT)break;
+      this.follow(key,options);
+    }
+  }
+  stopFollower(key){
+    const follower=this.followers.get(key);if(!follower)return;
+    follower.controller.abort();this.followers.delete(key);
+    this.stoppingFollowers.add(follower.task);void follower.task.finally(()=>this.stoppingFollowers.delete(follower.task));
+  }
+  follow(key,options){
+    const {locator}=options,controller=new AbortController(),stop=()=>controller.abort(this.abort.signal.reason);this.abort.signal.addEventListener('abort',stop,{once:true});
+    // A follow event may land between beats, after the rule changed: it reads the configuration afresh.
+    const followed={...options,configuration:null,stamp:undefined};
+    const task=(async()=>{
+      for await(const _event of this.core.session(locator).follow({signal:controller.signal})){
+        if(controller.signal.aborted)break;
+        // A capture that fails is that session's problem, as on a beat; the follow goes on.
+        try{await this.capture(followed);}catch(error){if(controller.signal.aborted)break;if(connectionError(error))this.lastError=error;else this.noteSessionProblem(followed,error);}
+      }
+    })().catch(error=>{
+      if(controller.signal.aborted)return;
+      // The follow itself failed: the beat's capture still covers the session, so it is not listed as not syncing.
+      // A capacity refusal pauses every new follow for a while; any other failure retries this one after a while.
+      if(capacityError(error))this.followBackoffUntil=this.clock.nowMs()+FOLLOW_RETRY_MS;
+      else{this.followRetry.set(key,this.clock.nowMs()+FOLLOW_RETRY_MS);this.lastError=error;}
+    }).finally(()=>{this.abort.signal.removeEventListener('abort',stop);if(this.followers.get(key)?.controller===controller)this.followers.delete(key);});
+    this.followers.set(key,{ruleId:options.ruleId,ruleRevision:options.ruleRevision,controller,task});
   }
   // What a session's native store looked like when discovery listed it: its file's size and modification
   // time (read before any load, so a write after it reads as a change), those of the file's SQLite write-ahead

package/package.json

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