@volter/supercode-teams 0.2.88 → 0.2.90

package/connector/index.mjs

@@ -91,6 +91,8 @@ const messageText=value=>typeof value?.content==='string'?value.content.trim():A
 const fileStamp=stat=>`${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`;
 const recordedAt=entry=>{if(Number.isSafeInteger(entry.recorded_at))return entry.recorded_at;if(Number.isSafeInteger(entry.timestamp))return entry.timestamp;const value=entry.metadata?.timestamp??entry.value?.metadata?.timestamp??entry.timestamp;if(typeof value!=='string')return null;const parsed=Date.parse(value);return Number.isSafeInteger(parsed)?parsed:null;};
 const serverOrigin=value=>{const url=new URL(value),loopback=url.hostname==='localhost'||url.hostname==='::1'||url.hostname==='[::1]'||/^127(?:\.\d{1,3}){3}$/.test(url.hostname);if(!['http:','https:'].includes(url.protocol)||url.username||url.password||url.search||url.hash||(url.pathname!==''&&url.pathname!=='/')||(url.protocol==='http:'&&!loopback))throw new TypeError('server must be an HTTPS origin (HTTP is loopback-only)');return url.origin;};
+const SAVE_COALESCE_MS = 2000;
+
 function atomic(path, value) {
   const temporary = `${path}.${process.pid}.${randomBytes(12).toString('hex')}.tmp`;
   const fd = openSync(temporary, 'wx', 0o600);
@@ -108,7 +110,12 @@ function atomic(path, value) {
 }
 export class TeamsConnector {
   constructor({server,teamId,machineId,sourceId,credential,stateDir,core,largeCore=core,slowCore=largeCore,liveCore=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,slowCore,liveCore,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);}
+  // A capture burst saves after every step, and each save is a synchronous stringify, write and fsync of the whole
+  // state (megabytes once many sessions are tracked) on the loop that also answers the machine's doors: a Room line
+  // typed during a burst on a loaded disk waited out the server's 15 s open bound behind them. A burst writes once per
+  // window instead; stop() writes what is pending, so a clean stop loses nothing.
+  save(){this.saveDirty=true;if(this.saveTimer)return;this.saveTimer=setTimeout(()=>{this.saveTimer=null;try{this.flushState();}catch(error){process.stderr.write(`supercode teams: could not save the connector's state: ${error.message}\n`);}},SAVE_COALESCE_MS);this.saveTimer.unref?.();}
+  flushState(){if(this.saveTimer){clearTimeout(this.saveTimer);this.saveTimer=null;}if(!this.saveDirty)return;this.saveDirty=false;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,
   // so another process reads them while this one runs; the error itself stays in memory as lastError.
@@ -720,5 +727,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(){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.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.88",
+  "version": "0.2.90",
   "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/popup-terminals.mjs

@@ -4,10 +4,10 @@
 // daemon's ConPTY host on Windows, holds it); the pane ending ends the client, and the terminal closes the window as
 // its command exits. Adapters are tried in rank order; SUPERCODE_POPUP_TERMINAL names one (or `none`).
 import { spawn, spawnSync } from 'node:child_process';
-import { chmodSync, existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
-import { homedir, tmpdir } from 'node:os';
+import { chmodSync, existsSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { createHash, randomBytes } from 'node:crypto';
+import { randomBytes } from 'node:crypto';
 import { weztermConfigFile } from './terminal-look.mjs';
 
 const onPath = (name) => {
@@ -27,39 +27,13 @@ function selfDeletingScript(argv, extension) {
   return path;
 }
 
-// Supercode's windows share one WezTerm process, as Terminal.app's windows share one app: a window opened into a
-// running process is on screen in about 0.3 s, where a process started per window took 0.7 to 2 s (measured on macOS
-// 26 with WezTerm 20240203). The process is known by its class; it listens on ~/.local/share/wezterm/gui-sock-<pid>.
-// A window goes into it with `wezterm cli spawn --new-window`, and when there is none, or the spawn fails, the window
-// starts it. The fallback runs in the launched shell, so the daemon never waits on WezTerm. The class carries the
-// config's content: WezTerm does not reload it (terminal-look.mjs), so a process holding an older look is never reused.
-const WEZTERM_CLASS = 'dev.volter.supercode';
-
-/** The socket of a running supercode WezTerm process of class `cls`, or null. */
-function weztermSocket(cls) {
-  const dir = join(homedir(), '.local', 'share', 'wezterm');
-  let names;
-  try { names = readdirSync(dir); } catch { return null; }
-  for (const name of names) {
-    const pid = Number(/^gui-sock-(\d+)$/.exec(name)?.[1]);
-    if (!pid) continue;
-    try { process.kill(pid, 0); } catch { continue; }
-    const command = spawnSync('ps', ['-p', String(pid), '-o', 'command='], { encoding: 'utf8', timeout: 2_000 }).stdout ?? '';
-    if (command.includes(`--class ${cls} `)) return join(dir, name);
-  }
-  return null;
-}
-
-/** WezTerm's launch: a window in supercode's running WezTerm, else a new one with supercode's look (terminal-look.mjs). */
+// Each window is a WezTerm process of its own, with supercode's look (terminal-look.mjs). Windows sharing one process
+// share its one main thread: on the owner's Mac, four Claude sessions' output kept that thread painting for whole
+// seconds at a time (97-98% of 3 s samples), and a drag in any other popup went unanswered meanwhile. A process of its
+// own opens in 0.7 to 2 s where a window in a running process opened in about 0.3 s; it is never frozen by another
+// window's output.
 function weztermLaunch(program, argv) {
-  const config = weztermConfigFile();
-  const cls = `${WEZTERM_CLASS}.${createHash('sha256').update(readFileSync(config)).digest('hex').slice(0, 12)}`;
-  const start = [program, '--config-file', config, 'start', '--always-new-process', '--class', cls, '--', ...argv];
-  const socket = process.platform === 'win32' ? null : weztermSocket(cls);
-  if (!socket) return [start[0], start.slice(1)];
-  const quote = (arg) => `'${String(arg).replaceAll("'", `'"'"'`)}'`;
-  const spawnWindow = [program, 'cli', '--no-auto-start', 'spawn', '--new-window', '--', ...argv].map(quote).join(' ');
-  return ['/bin/sh', ['-c', `WEZTERM_UNIX_SOCKET=${quote(socket)} ${spawnWindow} >/dev/null 2>&1 || exec ${start.map(quote).join(' ')}`]];
+  return [program, ['--config-file', weztermConfigFile(), 'start', '--always-new-process', '--', ...argv]];
 }
 
 /** Adapters by platform, in rank order: { name, find() → program or null, launch(program, argv) → [command, args] }. */