@volter/supercode-teams 0.2.48 → 0.2.49

package/bin/workspace.mjs

@@ -720,14 +720,15 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
     // callers the server admits; its host key id rides the connector's heartbeat.
     const daemonHome = teamsHome();
     const hostKeyId = publicKeyId(loadOrCreateKeyPair(paths(daemonHome).machineKey).publicKeyPem);
-    // Large transcripts load through a harness process of their own: one serve process answers one request at a
-    // time, and a long load would hold discovery and every small session's capture behind it.
+    // Large transcripts load through harness processes of their own (a fast lane and a slow one): one serve process
+    // answers one request at a time, and a long load would hold discovery and every other capture behind it.
     const largeCore = new SupercodeHarnessClient({ command: binary, args: ['harness', 'serve'] });
-    const connector = new TeamsConnector({ server: context.origin, teamId: context.team_id, machineId: saved.machine.id, sourceId: saved.source.id, credential: saved.credential.token, stateDir: state.directory, core, largeCore, hostKeyId });
+    const slowCore = new SupercodeHarnessClient({ command: binary, args: ['harness', 'serve'] });
+    const connector = new TeamsConnector({ server: context.origin, teamId: context.team_id, machineId: saved.machine.id, sourceId: saved.source.id, credential: saved.credential.token, stateDir: state.directory, core, largeCore, slowCore, hostKeyId });
     // A connected machine is a person's: each pane it launches opens a window on its screen (SUPERCODE_POPUPS=0: none).
     const machine = new TeamsMachine({ home: daemonHome, supercode: binary, popups: process.env.SUPERCODE_POPUPS !== '0', ...(flags.tmux_socket ? { tmuxSocket: String(flags.tmux_socket) } : {}), link: { server: context.origin, teamId: context.team_id, machineId: saved.machine.id, credential: saved.credential.token, incarnationId: connector.state.incarnation_id, configuration: () => connector.configuration() }, onTurn: (turn) => connector.noteTurn(turn) });
     machine.on('link', (event) => { if (event.event === 'replaced') process.stderr.write(`supercode teams: ${event.error}. Two connectors were running for this machine; stop one of them (\`supercode teams disconnect\` where it should not run).\n`); });
-    const stopAll = async () => { await machine.stop().catch(() => {}); await connector.stop(); await core.close(); await largeCore.close(); await lifecycle.close(); state.update(current => current ? ({ ...current, process: undefined }) : null); };
+    const stopAll = async () => { await machine.stop().catch(() => {}); await connector.stop(); await core.close(); await largeCore.close(); await slowCore.close(); await lifecycle.close(); state.update(current => current ? ({ ...current, process: undefined }) : null); };
     try { await connector.start({ roots: () => saved.roots }); await machine.start(); } catch (error) { await stopAll(); throw error; }
     output({ version: 1, context: scope(context), data: { machine: saved.machine, source: saved.source, roots: saved.roots.map(({ path: _path, ...item }) => item), socket: machine.socketPath, foreground: true } });
     await new Promise(resolveStop => { let stopped = false; stopConnector = async () => { if (stopped) return; stopped = true; await stopAll(); resolveStop(); }; for (const signal of ['SIGINT', 'SIGTERM', ...(process.platform === 'win32' ? ['SIGHUP', 'SIGBREAK'] : [])]) process.once(signal, stopConnector); });

package/connector/index.mjs

@@ -65,7 +65,7 @@ const NATIVE_IDLE_MS=60000,NATIVE_IDLE_BYTES=8*1024*1024;
 // other request queued behind. A file of LARGE_CAPTURE_BYTES or more is captured at most once per
 // LARGE_CAPTURE_EVERY_MS (tried or not), its load given a second per megabyte, and one past NATIVE_MAX_BYTES is
 // published without a native bundle, which could not be built in time.
-const LARGE_CAPTURE_BYTES=8*1024*1024,LARGE_CAPTURE_EVERY_MS=5*60000,NATIVE_MAX_BYTES=64*1024*1024;
+const LARGE_CAPTURE_BYTES=8*1024*1024,LARGE_CAPTURE_EVERY_MS=5*60000,NATIVE_MAX_BYTES=64*1024*1024,FAST_LOAD_MS=5000;
 // A turn a Room member typed here waits this long to be found in its session's transcript.
 const TURN_NOTE_MS=24*3600000;
 const messageText=value=>typeof value?.content==='string'?value.content.trim():Array.isArray(value?.content)?value.content.map(part=>typeof part==='string'?part:part?.type==='text'?part.text??'':'').join('').trim():'';
@@ -88,7 +88,7 @@ function atomic(path, value) {
   }
 }
 export class TeamsConnector {
-  constructor({server,teamId,machineId,sourceId,credential,stateDir,core,largeCore=core,hostKeyId=null,effectExecutor=null,clock={nowMs:()=>Date.now()},fetch:fetchImpl=globalThis.fetch,heartbeatMs=15000,nativeIdleMs=NATIVE_IDLE_MS,nativeIdleBytes=NATIVE_IDLE_BYTES}){Object.assign(this,{server:serverOrigin(server),teamId,machineId,sourceId,credential,stateDir,core,largeCore,hostKeyId,effectExecutor,clock,fetch:fetchImpl,heartbeatMs,nativeIdleMs,nativeIdleBytes});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.native_cache??={};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,largeCore=core,slowCore=largeCore,hostKeyId=null,effectExecutor=null,clock={nowMs:()=>Date.now()},fetch:fetchImpl=globalThis.fetch,heartbeatMs=15000,nativeIdleMs=NATIVE_IDLE_MS,nativeIdleBytes=NATIVE_IDLE_BYTES}){Object.assign(this,{server:serverOrigin(server),teamId,machineId,sourceId,credential,stateDir,core,largeCore,slowCore,hostKeyId,effectExecutor,clock,fetch:fetchImpl,heartbeatMs,nativeIdleMs,nativeIdleBytes});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.native_cache??={};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,
@@ -434,33 +434,39 @@ export class TeamsConnector {
   largeSession({locator}){
     try{return locator?.storage?.kind==='file'&&statSync(realpathSync(locator.storage.path)).size>=LARGE_CAPTURE_BYTES;}catch{return false;}
   }
-  // A large transcript's load takes seconds to minutes. It runs in a lane of its own, outside the serial capture
-  // queue, so no small session's capture waits behind it; only the capture of what it loaded joins the queue.
+  // A large transcript's load takes seconds to minutes. It runs outside the serial capture queue, so no small
+  // session's capture waits behind it; only the capture of what it loaded joins the queue. Two lanes, each with a
+  // harness process of its own: a session whose last load was quick (FAST_LOAD_MS) goes to the fast lane, one never
+  // loaded or slow to the slow one, so a live session never waits behind a giant old transcript.
   captureLarge(options){
-    (this.largeQueue??=new Map()).set(`${options.harness}:${options.nativeSessionId}`,options);
-    if(!this.largeLane)this.largeLane=this.runLargeLane().finally(()=>{this.largeLane=null;});
+    const key=`${options.harness}:${options.nativeSessionId}`,last=this.largeCaptures?.get(key);
+    const lane=last&&last.ms<FAST_LOAD_MS?'fast':'slow';
+    this.lanes??={fast:{queue:new Map(),running:null,core:this.largeCore},slow:{queue:new Map(),running:null,core:this.slowCore}};
+    for(const other of Object.values(this.lanes))other.queue.delete(key);
+    const target=this.lanes[lane];target.queue.set(key,options);
+    if(!target.running)target.running=this.runLargeLane(target).finally(()=>{target.running=null;});
     return null;
   }
-  async runLargeLane(){
-    while(this.largeQueue.size&&!this.abort.signal.aborted){
-      // The session written most recently goes first: a watched live session never waits behind a slow old one.
+  async runLargeLane(lane){
+    while(lane.queue.size&&!this.abort.signal.aborted){
+      // The session written most recently goes first.
       const written=([,item])=>{try{return statSync(realpathSync(item.locator.storage.path)).mtimeMs;}catch{return 0;}};
-      const [key,options]=[...this.largeQueue.entries()].reduce((best,entry)=>written(entry)>written(best)?entry:best);this.largeQueue.delete(key);
+      const [key,options]=[...lane.queue.entries()].reduce((best,entry)=>written(entry)>written(best)?entry:best);lane.queue.delete(key);
       let started=null;
       try{
         const artifactBefore=statSync(realpathSync(options.locator.storage.path));
-        // A session is loaded again no sooner than ten times its last load took (a 0.7 s load: every 7 s; a load
-        // that takes minutes: every LARGE_CAPTURE_EVERY_MS), so a live session streams while the lane stays light.
+        // 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.
         // A change that arrives sooner is captured when its wait ends.
         this.largeCaptures??=new Map();const last=this.largeCaptures.get(key),wait=last?Math.min(LARGE_CAPTURE_EVERY_MS,last.ms*10)-(this.clock.nowMs()-last.at):0;
         if(wait>0){this.largeRetry??=new Map();if(!this.largeRetry.has(key))this.largeRetry.set(key,setTimeout(()=>{this.largeRetry.delete(key);this.captureLarge(options);},wait).unref?.());continue;}
         started=this.clock.nowMs();
-        const loaded=await this.largeCore.session(options.locator).load({timeoutMs:Math.max(30000,Math.ceil(artifactBefore.size/(1024*1024))*1000)});
+        const loaded=await lane.core.session(options.locator).load({timeoutMs:Math.max(30000,Math.ceil(artifactBefore.size/(1024*1024))*1000)});
         this.largeCaptures.set(key,{at:started,ms:this.clock.nowMs()-started});
         await this.capture({...options,preloaded:{loaded,artifactBefore}});
       }catch(error){
         if(this.abort.signal.aborted)return;
-        // A load that failed or timed out waits like a slow one, so it does not hold the lane on every pass.
+        // A load that failed or timed out waits like a slow one, so it does not hold its lane on every pass.
         if(started!==null)this.largeCaptures.set(key,{at:started,ms:this.clock.nowMs()-started});
         this.noteSessionProblem(options,error);
         process.stderr.write(`supercode teams: ${options.harness} session ${options.nativeSessionId} not synced: ${error.message}\n`);

package/package.json

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