@volter/supercode-teams 0.2.82 → 0.2.84

package/connector/index.mjs

@@ -262,7 +262,7 @@ export class TeamsConnector {
         // syncing. An error of the connection itself (the outbox, authentication, the server, a stop) still ends
         // 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 (this.sessionChanged(options) && !this.predatesWindow(options)) try { await this.capture(options); } catch (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`);
@@ -278,6 +278,17 @@ export class TeamsConnector {
     this.pruneNativeCache(discovered);
     this.rotateFollowers(followCandidates);
   }
+  // 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.
+  predatesWindow({locator,configuration,ruleId,ruleRevision,harness,nativeSessionId}){
+    if(this.state.origins[`${harness}:${nativeSessionId}`])return false;
+    const rule=configuration?.rules?.find(item=>item.id===ruleId&&item.revision===ruleRevision&&item.state==='active');if(!rule)return false;
+    const backfill=typeof rule.backfill==='string'?{mode:rule.backfill}:rule.backfill??{mode:'all'};
+    const keptBefore=backfill.mode==='since'?backfill.since:backfill.mode==='none'?rule.capture_after:null;
+    if(!Number.isSafeInteger(keptBefore)||locator?.storage?.kind!=='file')return false;
+    try{return statSync(realpathSync(locator.storage.path)).mtimeMs<keptBefore;}catch{return false;}
+  }
   // 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.2.82",
+  "version": "0.2.84",
   "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, readdirSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { randomBytes } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import { weztermConfigFile } from './terminal-look.mjs';
 
 const onPath = (name) => {
@@ -31,11 +31,12 @@ function selfDeletingScript(argv, extension) {
 // 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.
+// 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, or null. */
-function weztermSocket() {
+/** 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; }
@@ -44,15 +45,17 @@ function weztermSocket() {
     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 ${WEZTERM_CLASS}`)) return join(dir, name);
+    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). */
 function weztermLaunch(program, argv) {
-  const start = [program, '--config-file', weztermConfigFile(), 'start', '--always-new-process', '--class', WEZTERM_CLASS, '--', ...argv];
-  const socket = process.platform === 'win32' ? null : weztermSocket();
+  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(' ');