@volter/supercode-teams 0.3.89 → 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

@@ -61,14 +61,16 @@ 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. */
-async function answersAs(receipt) {
+ *  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 `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'] });
-    let timer;
-    const bound = new Promise((resolve) => { timer = setTimeout(() => resolve(null), 2000); });
-    try { return (await Promise.race([client.describe(), bound]))?.session_id === receipt.runtime_session_id; } finally { clearTimeout(timer); }
-  } catch { return false; }
+    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;
+  }
 }
 
 /** Why a claim names no caller. */
@@ -343,7 +345,7 @@ export class LiveSessions extends EventEmitter {
     if (!alive(entry.pid)) return false;
     const started = await startedMs(entry.pid);
     if (!Number.isFinite(started) || !Number.isFinite(entry.created) || started <= entry.created + 2000) return true;
-    return answersAs(entry.probe);
+    return (await answersAs(entry.probe)) !== false;
   }
 
   /** One messaging-tools marker: the session process named by its file, the server pid in it. */
@@ -465,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;
@@ -514,7 +522,7 @@ export class LiveSessions extends EventEmitter {
     if (runtime === true) {
       // a pid several receipts name is no one runtime: the rest of the claim names it, never a refusal here
       let own = null;
-      try { own = await this.#runtimeOfPid(Number(pid)); } catch (error) { if (!(error instanceof CallerRefused)) throw error; }
+      try { own = await this.#runtimeOfPid(Number(pid)); } catch (error) { if (!(error instanceof CallerRefused) || error.unconfirmed) throw error; }
       if (own) return own;
     }
     const parent = this.claude.get(Number(ppid));
@@ -542,7 +550,13 @@ 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
-    if (!(await answersAs(held[0].probe))) return null;
+    // 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 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
   }
@@ -75,8 +78,43 @@ export class Relays {
     for (const [directory, relay] of kept.slice(RELAYS_RUNNING)) {
       if (this.sending.has(directory)) continue;
       this.running.delete(directory);
-      void 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}`));
+      // 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) => {
+          // 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`);
+        });
+      }
+    }
+  }
+
+  /** `work` run under the relay folder's lock: one send, or one close, at a time per relay, in arrival order. */
+  async #locked(directory, work) {
+    const previous = this.sending.get(directory) ?? Promise.resolve();
+    let release;
+    const mine = new Promise((resolve) => { release = resolve; });
+    const turn = previous.then(() => mine);
+    this.sending.set(directory, turn);
+    await previous;
+    try { return await work(); }
+    finally {
+      release();
+      if (this.sending.get(directory) === turn) this.sending.delete(directory);
     }
   }
 
@@ -127,8 +165,9 @@ export class Relays {
 
   /** The relay's runtime, started in this daemon's harness serve when it is not running (claude_relay.rs
    *  `ensure_relay_runtime`): `{ runtime (its receipt), connection }`. */
-  async #ensure(spec) {
+  async #ensure(spec, step = () => {}) {
     const endpoint = await this.endpoint();
+    step('relay endpoint');
     if (!endpoint) throw new Error('the relay endpoint is not answering; the machine daemon\'s `supercode message watch` serves it (see mail/machine-daemon.log)');
     // written on every send: Claude Code reloads a changed settings file, so a running relay takes the hooks this
     // supercode installs
@@ -137,18 +176,21 @@ export class Relays {
     if (record?.runtime_id) {
       const runtime = this.runtimeOf('claude-code', record.runtime_id);
       if (runtime && alive(this.#pid(spec, runtime)) && record.connection && (record.endpoint === endpoint || await answers(Number(String(record.endpoint ?? '').split(':').pop())))) {
+        step('runtime reused');
         return { runtime, connection: record.connection };
       }
+      // why it is not reused, said in the timing line: a relay that should have been warm and was not shows here
+      step(`runtime not reused (${!runtime ? 'no live receipt' : !alive(this.#pid(spec, runtime)) ? 'its process ended' : !record.connection ? 'no connection' : 'endpoint moved'})`);
       // closed through the owner's door even after its receipt went
       try { await this.serve('harness.v1.runtimes.close', { connection: record.connection, runtime_id: record.runtime_id }, 15_000); }
       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',
-        arguments: ['--print', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--permission-prompt-tool', 'stdio', '--model', RELAY_MODEL, '--name', spec.name, '--permission-mode', 'bypassPermissions', '--setting-sources', 'project', '--settings', spec.settings, '--tools', 'ListAgents,SendMessage', '--no-session-persistence'],
+        arguments: ['--print', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--permission-prompt-tool', 'stdio', '--model', RELAY_MODEL, '--name', spec.name, '--permission-mode', 'bypassPermissions', '--setting-sources', 'project', '--settings', spec.settings, '--tools', 'ListAgents,SendMessage', '--no-session-persistence', '--strict-mcp-config'],
         // its API is the relay endpoint, its key the relay's folder there (which also keeps account connectors out)
         env: { ANTHROPIC_API_KEY: key, ANTHROPIC_BASE_URL: endpoint, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1', SUPERCODE_CLAUDE_RELAY: '1' },
       },
@@ -158,18 +200,27 @@ export class Relays {
     if (typeof runtimeId !== 'string') throw new Error(`the machine daemon did not start the relay: ${JSON.stringify(started)}`);
     const connection = typeof started.connection === 'string' ? started.connection : '';
     const pid = Number.isInteger(started?.handle?.endpoint?.pid) ? started.handle.endpoint.pid : null;
+    step('runtime started (runtimes.start)');
     writeFileSync(spec.record, JSON.stringify({ runtime_id: runtimeId, pid, endpoint, connection }));
+    // the daemon's from its start: counted by the cap even when the rest of this start fails
+    this.running.set(spec.directory, { connection, runtime_id: runtimeId, usedAt: Date.now() });
     // harness serve writes its receipt before it answers the start; the map learns it from its watch a moment later, so
     // one it does not hold yet is read by its own name (the receipt the runtime's terminal launch opens), never waited on
     const known = this.runtimeOf('claude-code', runtimeId);
-    if (known) return { runtime: known, connection };
+    if (known) { step('its receipt held'); return { runtime: known, connection }; }
     let receiptId = null;
     try {
       const launch = (await this.serve('harness.v1.runtimes.terminal_instructions', { connection }, 5000))?.launch;
       receiptId = (Array.isArray(launch?.arguments) ? launch.arguments : []).find((arg) => typeof arg === 'string' && arg.startsWith('supercode-live://'))?.slice('supercode-live://'.length) ?? null;
     } catch { /* said below */ }
     const runtime = receiptId ? this.runtimeNamed(receiptId) : null;
-    if (!runtime) throw new Error('the relay started but registered no live runtime');
+    step('its receipt read');
+    if (!runtime) {
+      // a runtime no send can use is closed, never left running untracked
+      this.running.delete(spec.directory);
+      try { await this.serve('harness.v1.runtimes.close', { connection, runtime_id: runtimeId }, 15_000); } catch { /* said below */ }
+      throw new Error('the relay started but registered no live runtime; it was closed');
+    }
     return { runtime, connection };
   }
 
@@ -199,20 +250,19 @@ export class Relays {
   async send(sender, senderName, receiver, message, messageId) {
     const spec = this.spec(sender, senderName);
     mkdirSync(spec.directory, { recursive: true });
-    const previous = this.sending.get(spec.directory) ?? Promise.resolve();
-    let release;
-    const mine = new Promise((resolve) => { release = resolve; });
-    const turn = previous.then(() => mine);
-    this.sending.set(spec.directory, turn);
-    await previous;
+    const asked = performance.now();
+    try { return await this.#locked(spec.directory, () => this.#send(spec, receiver, message, messageId, asked)); }
+    finally { this.#cap(); }
+  }
+
+  async #send(spec, receiver, message, messageId, asked) {
     try {
       const queued = { to: receiver.socket ? `uds:${receiver.socket}` : receiver.name, message };
-      const steps = [], began = performance.now();
+      const steps = [], began = asked;
       let mark = began;
       const step = (name) => { const now = performance.now(); steps.push(`${name} ${Math.round(now - mark)} ms`); mark = now; };
       step('lock');
-      let { runtime, connection } = await this.#ensure(spec);
-      step('runtime (started or reused)');
+      let { runtime, connection } = await this.#ensure(spec, step);
       this.#used(spec, connection);
       rmSync(spec.receipt, { force: true });
       writeFileSync(spec.queue, JSON.stringify(queued));
@@ -223,7 +273,7 @@ export class Relays {
         const pid = this.#pid(spec, runtime);
         // only a relay proven dead is started again; one alive but slow may still deliver
         if (receipt.delivered || attempt === 1 || pid == null || alive(pid)) break;
-        try { ({ runtime, connection } = await this.#ensure(spec)); this.#used(spec, connection); } catch (error) { receipt = { delivered: false, detail: error.message }; break; }
+        try { ({ runtime, connection } = await this.#ensure(spec, step)); this.#used(spec, connection); } catch (error) { receipt = { delivered: false, detail: error.message }; break; }
         rmSync(spec.receipt, { force: true });
       }
       rmSync(spec.queue, { force: true });
@@ -238,13 +288,16 @@ export class Relays {
     } catch (error) {
       rmSync(spec.queue, { force: true });
       return { delivered: false, detail: error.message };
-    } finally {
-      release();
-      if (this.sending.get(spec.directory) === turn) this.sending.delete(spec.directory);
-      this.#cap();
     }
   }
 
+  /** `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.89",
+  "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",