@volter/supercode-teams 0.3.90 → 0.3.91

package/connector/index.mjs

@@ -19,6 +19,8 @@ import { NativeEffects } from './native-effects.mjs';
 import { consumeAgentClosures } from './agent-closures.mjs';
 
 const SYNC_PROBLEM_LIMIT=20;
+// How many times a session's launch agent is asked of harness serve: when first seen, and after a change at most twice more.
+const LAUNCH_AGENT_ASKS=3;
 const CAPACITY_CODE='SUBSCRIPTION_OPEN_CAPACITY';
 // Whether a root covers a session's folder: the root's own, or (unless the root is exact-only) one under it, by real path.
 const realOr=path=>{try{return realpathSync(path);}catch{return path;}};
@@ -638,8 +640,12 @@ export class TeamsConnector {
     // the binding is written only while this work is still the session's (checked again after its awaits)
     const bindingRead=this.clock.nowMs();
     try{await this.nativeEffects.discover(descriptor,ruleId,()=>this.sessionLive(key,ruleId,epoch)&&!((this.runtimeEnded?.get(key)??-Infinity)>=bindingRead));}catch(error){this.lastError=error;}
-    // The agent this session's launch named, read when first seen here and whenever it changes, until queued for binding.
-    if(captured&&!this.state.agent_sessions?.[key]&&(changed||!this.launchChecked?.has(key))){(this.launchChecked??=new Set()).add(key);await this.noteLaunchAgent(locator,()=>this.sessionLive(key,ruleId,epoch));}
+    // The agent this session's launch named, read when first seen here, and after a change at most twice more (a launch
+    // record written just after its session appeared), until queued for binding. Never on every change: a launch's agent
+    // is fixed at the launch, and asking on every transcript write of every live session kept harness serve's loop
+    // busy with more than one call a second (yuerans: 1357 calls over a second each in ten minutes).
+    const asked=this.launchChecked?.get(key)??0;
+    if(captured&&!this.state.agent_sessions?.[key]&&asked<LAUNCH_AGENT_ASKS&&(asked===0||changed)){(this.launchChecked??=new Map()).set(key,asked+1);await this.noteLaunchAgent(locator,()=>this.sessionLive(key,ruleId,epoch));}
     // A session seen with its native bundle still owed (from before this start) waits for its file to go quiet; one
     // captured now has its wait armed by the commit that records it (flushOutbox).
     if(!changed)this.armNativeIdle(key);

package/live-sessions.mjs

@@ -62,11 +62,11 @@ function startedMs(pid) {
 
 /** Whether the runtime a receipt names answers at its address as that runtime (its own identity, with the receipt's
  *  token): the proof a start read off the wall clock cannot give, as the clock may have stepped since the receipt.
- *  true or false, or null when it did not answer within 2 s (the request is aborted then): not known either way. */
-async function answersAs(receipt) {
+ *  true or false, or null when it did not answer within `boundMs` (the request is aborted then): not known either way. */
+async function answersAs(receipt, boundMs = 2000) {
   try {
     const client = new FrontendClient({ baseUrl: receipt.base_url, token: receipt.token, clientId: `live-${receipt.receipt_id}`, permissions: ['observe'] });
-    return (await client.describe({ signal: AbortSignal.timeout(2000) }))?.session_id === receipt.runtime_session_id;
+    return (await client.describe({ signal: AbortSignal.timeout(boundMs) }))?.session_id === receipt.runtime_session_id;
   } catch (error) {
     if (error?.name === 'TimeoutError' || error?.name === 'AbortError') return null;
     return false;
@@ -467,6 +467,12 @@ export class LiveSessions extends EventEmitter {
    * file and checked as live_runtime.rs `resolve_live_runtime` checks it (its schema, a loopback address, its process
    * alive, the source it names): the bearer token a delivery uses is read here, at the delivery, never kept in the map.
    */
+  /** The live runtimes of `harness` whose workspace is `cwd`, each by the ids it may be closed by (in-memory, no read). */
+  runtimesIn(harness, cwd) {
+    return [...this.runtimes.values()].filter((runtime) => runtime.harness === harness && runtime.cwd === cwd && alive(runtime.pid))
+      .map((runtime) => [...new Set([runtime.sessionId, runtime.runtimeSessionId].filter((id) => typeof id === 'string' && id))]);
+  }
+
   runtimeReceipt(harness, id) {
     for (const [receiptId, runtime] of this.runtimes) {
       if (runtime.harness !== harness || (runtime.sessionId !== id && runtime.runtimeSessionId !== id) || !alive(runtime.pid)) continue;
@@ -544,10 +550,12 @@ export class LiveSessions extends EventEmitter {
     if (held.length !== 1) return null;
     // a caller's identity: checked again now, with no process (the runtime asked at its own address), as a runtime that
     // ended may have left its pid to another process before the sweep lets its receipt go
-    const answered = await answersAs(held[0].probe);
-    // one that did not answer in time is not known either way: refused, never taken for its parent's session or its
+    // a host stalled by load answers late, not never: one that did not answer in 2 s is asked once more, for 8 s
+    let answered = await answersAs(held[0].probe);
+    if (answered === null) answered = await answersAs(held[0].probe, 8000);
+    // one that did not answer then is not known either way: refused, never taken for its parent's session or its
     // environment's (which would name another caller)
-    if (answered === null) throw Object.assign(new CallerRefused(`process ${pid} is a runtime that did not answer within 2 s, so which session is calling was not confirmed; nothing was done`), { unconfirmed: true });
+    if (answered === null) throw Object.assign(new CallerRefused(`process ${pid} is a runtime that did not answer within 10 s, so which session is calling was not confirmed; nothing was done`), { unconfirmed: true });
     if (!answered) return null;
     return this.#address(held[0].harness, held[0].sessionId);
   }

package/machine.mjs

@@ -645,6 +645,7 @@ export class TeamsMachine extends MachineCore {
       recordedConfig: (locator) => this.#serveRequest('harness.v1.sessions.recorded_config', { locator }, 15_000) });
     this.relays = new Relays({ mailRoot, machine, supercodeBin: this.supercodeBin, serve: (method, params, timeoutMs) => this.#serveRequest(method, params, timeoutMs),
       runtimeOf: (harness, id) => live.runtimeReceipt(harness, id), runtimeNamed: (receiptId) => live.receiptNamed(receiptId),
+      runtimesIn: (harness, cwd) => live.runtimesIn(harness, cwd),
       log: (line) => this.emit('mail-log', line) });
     this.mailSend = new MailSend({ machine, mailRoot, live, store: this.mailStore, agents: this.agents, relays: this.relays,
       // a send waits on its receiver's door there (a relay's receipt takes up to 90 s), never past MAIL_SEND_MS

package/mail/relay.mjs

@@ -25,6 +25,8 @@ export const MAX_RELAYED_BYTES = 100_000;
 /** How many relays run at once, the most recently used (a relay runtime is some hundreds of MB; 10 held 2.1 GB on one
  *  machine): beyond them a relay's runtime is closed (its folder kept: it starts again when next needed). */
 export const RELAYS_RUNNING = 4;
+/** How long a relay whose runtime start lost its answer is looked at for a runtime that start left running. */
+const LOST_START_KEPT_MS = 5 * 60_000;
 
 const alive = (pid) => { if (!Number.isInteger(pid) || pid <= 0) return false; try { process.kill(pid, 0); return true; } catch (error) { return error.code === 'EPERM'; } };
 const readJson = (path) => { try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; } };
@@ -61,8 +63,9 @@ export class Relays {
    * id)` the live-runtime receipt the live-session map holds for a runtime id (its file read whole), or null;
    * `runtimeNamed(receiptId)` one receipt read by its own name.
    */
-  constructor({ mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed = () => null, log = () => {} }) {
-    Object.assign(this, { mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed, log });
+  constructor({ mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed = () => null, runtimesIn = () => [], log = () => {} }) {
+    Object.assign(this, { mailRoot, machine, supercodeBin, serve, runtimeOf, runtimeNamed, runtimesIn, log });
+    this.lost = new Map(); // relay folder → when a start of its runtime lost its answer (the runtime may run, unnamed)
     this.sending = new Map(); // relay folder → the send in progress through it (one at a time per relay)
     this.running = new Map(); // relay folder → { connection, runtime_id, usedAt }: the relays this daemon runs
   }
@@ -78,7 +81,25 @@ export class Relays {
       // closed under the relay's own lock: a send to it that arrives meanwhile waits for the close, then starts it
       // again, never handing its turn to a runtime that is closing
       void this.#locked(directory, () => this.serve('harness.v1.runtimes.close', { connection: relay.connection, runtime_id: relay.runtime_id }, 15_000))
-        .catch((error) => this.log(`relay ${directory.split(/[\\/]/).pop()} beyond the ${RELAYS_RUNNING} most recent was not closed: ${error.message}`));
+        .catch((error) => {
+          // still running, so still counted: the next cap closes it again (unless a send started it anew meanwhile)
+          if (!this.running.has(directory)) this.running.set(directory, relay);
+          this.log(`relay ${directory.split(/[\\/]/).pop()} beyond the ${RELAYS_RUNNING} most recent was not closed: ${error.message}`);
+        });
+    }
+    // a start whose answer was lost may have left a runtime running in its relay's folder that no record names: closed by
+    // its id once the live-session map holds it (looked for over five minutes: the start may finish after its answer)
+    for (const [directory, lostAt] of this.lost) {
+      if (Date.now() - lostAt > LOST_START_KEPT_MS) { this.lost.delete(directory); continue; }
+      if (this.sending.has(directory)) continue;
+      const named = readJson(join(directory, 'relay.json'))?.runtime_id;
+      for (const ids of this.runtimesIn('claude-code', directory)) {
+        if (ids.includes(named)) continue;
+        void this.#locked(directory, async () => {
+          for (const id of ids) { try { await this.serve('harness.v1.runtimes.close', { runtime_id: id }, 15_000); return; } catch { /* the other id */ } }
+          this.log(`relay ${directory.split(/[\\/]/).pop()}: a runtime its lost start left running was not closed`);
+        });
+      }
     }
   }
 
@@ -165,7 +186,7 @@ export class Relays {
       catch (error) { if (this.runtimeOf('claude-code', record.runtime_id)) throw new Error(`could not retire the old relay: ${error.message}`); }
     }
     const key = spec.directory.split(/[\\/]/).pop();
-    const started = await this.serve('harness.v1.runtimes.start', {
+    const started = await this.#start(spec, {
       harness: 'claude-code',
       launch: {
         program: 'claude',
@@ -270,6 +291,13 @@ export class Relays {
     }
   }
 
+  /** `runtimes.start` for a relay: a start that fails (its answer lost, or late past its bound) may still have left a
+   *  runtime running, so its folder is looked at by the next caps (#cap). */
+  async #start(spec, params, timeoutMs) {
+    try { return await this.serve('harness.v1.runtimes.start', params, timeoutMs); }
+    catch (error) { this.lost.set(spec.directory, Date.now()); throw error; }
+  }
+
   /** A relay this daemon runs, used now. */
   #used(spec, connection) {
     const runtimeId = readJson(spec.record)?.runtime_id;

package/package.json

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