@volter/supercode-teams 0.2.57 → 0.2.59

package/connector/index.mjs

@@ -66,6 +66,9 @@ const NATIVE_IDLE_MS=60000,NATIVE_IDLE_BYTES=8*1024*1024;
 // 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,FAST_LOAD_MS=5000;
+// Each capture writes the session's whole transcript as a new version on the server, so a session is captured at
+// most this often (a later change is captured when the wait ends): a busy fleet filled the server's database.
+const CAPTURE_FLOOR_MS=5000,LARGE_CAPTURE_FLOOR_MS=20000;
 // 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():'';
@@ -135,7 +138,7 @@ export class TeamsConnector {
     const heartbeat = () => {
       const next = beating.then(async () => {
         this.state.sequence += 1;
-        await this.request('POST', `/machines/${this.machineId}/heartbeat`, {
+        const reply = await this.request('POST', `/machines/${this.machineId}/heartbeat`, {
           incarnation_id: this.state.incarnation_id, sequence: this.state.sequence,
           bindings: [...this.nativeEffects.published(), ...await bindings()],
           roots: this.localRoots.map(({id,machine_id,name,harnesses})=>({id,machine_id,name,harnesses})),
@@ -143,6 +146,8 @@ export class TeamsConnector {
           // What each synced session's harness is doing (its turn: working, idle, …), from the last discovery.
           ...(this.reportedActivity ? { activity: this.reportedActivity } : {}),
         });
+        // The sessions someone is following now (a viewer or channel open on them) skip the capture floors.
+        if (Array.isArray(reply?.watched)) this.watched = new Set(reply.watched.map(item => `${item.harness}:${item.native_id}`));
         this.save();
       });
       beating = next.catch(() => {});
@@ -409,6 +414,11 @@ export class TeamsConnector {
   async capture(options) {
     if(!options.preloaded&&this.largeSession(options))return this.captureLarge(options);
     if(!options.preloaded){
+      const key=`${options.harness}:${options.nativeSessionId}`,now=this.clock.nowMs();
+      this.lastCaptures??=new Map();this.captureRetry??=new Map();
+      const wait=this.watched?.has(key)?0:CAPTURE_FLOOR_MS-(now-(this.lastCaptures.get(key)??0));
+      if(wait>0){if(!this.captureRetry.has(key))this.captureRetry.set(key,setTimeout(()=>{this.captureRetry.delete(key);this.capture(options).catch(()=>{});},wait).unref?.());return null;}
+      this.lastCaptures.set(key,now);
       const {locator}=options,path=locator?.storage?.kind==='file'&&existsSync(locator.storage.path)?realpathSync(locator.storage.path):null;
       const artifactBefore=path?statSync(path):null;
       options={...options,preloaded:{loaded:await (options.live?this.liveCore:this.core).session(locator).load(),artifactBefore}};
@@ -465,8 +475,8 @@ export class TeamsConnector {
         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.
-        // 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;
+        // A change that arrives sooner is captured when its wait ends. A session someone is following has no wait.
+        this.largeCaptures??=new Map();const last=this.largeCaptures.get(key),wait=last&&!this.watched?.has(key)?Math.min(LARGE_CAPTURE_EVERY_MS,Math.max(LARGE_CAPTURE_FLOOR_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 lane.core.session(options.locator).load({timeoutMs:Math.max(30000,Math.ceil(artifactBefore.size/(1024*1024))*1000)});

package/package.json

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

package/server/event-routes.mjs

@@ -132,6 +132,10 @@ export async function handleSessionEvents({ api, req, res, auth, id, url, reques
     }
   });
   stream.cleanup(api.events.subscribe(`session:${auth.team_id}:${sessionId}`, enqueue));
+  // Who is watching this session live: its machine captures a watched session as fast as it changes (heartbeat).
+  const watchers = api.watchers ??= new Map(), watchKey = `${auth.team_id}:${sessionId}`;
+  watchers.set(watchKey, (watchers.get(watchKey) ?? 0) + 1);
+  stream.cleanup(() => { const left = (watchers.get(watchKey) ?? 1) - 1; if (left > 0) watchers.set(watchKey, left); else watchers.delete(watchKey); });
   stream.cleanup(api.events.subscribe(`team:${auth.team_id}`, event => { if (event.type === 'authorization_changed') enqueue(); }));
   // The snapshot pins its journal cursor atomically. Replay closes the snapshot/subscription gap.
   await enqueue();

package/worker/index.mjs

@@ -118,6 +118,8 @@ export class TeamsServer extends DurableObject {
   async alarm() {
     await this.ready;
     const done = this.api.serverId ? await maintain(this.api).catch(() => null) : null;
+    // The database's size on every full pass, where `wrangler tail` reads it.
+    if (!done?.backlog) console.log(`maintain: database ${(this.ctx.storage.sql.databaseSize / 1048576).toFixed(1)} MB`);
     // A backlog (versions or parts left over) is worked again in seconds, not a minute.
     await this.ctx.storage.setAlarm(Date.now() + (done?.backlog ? 3_000 : MAINTAIN_MS));
   }