@volter/supercode-teams 0.3.89 → 0.3.90

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. */
+ *  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) {
   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(2000) }))?.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. */
@@ -514,7 +516,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 +544,11 @@ 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;
+    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
+    // 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) return null;
     return this.#address(held[0].harness, held[0].sessionId);
   }
 

package/mail/relay.mjs

@@ -75,11 +75,28 @@ 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)
+      // 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}`));
     }
   }
 
+  /** `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);
+    }
+  }
+
   /** The relay that speaks for `represented`, known as `representedName`: its name and its files. */
   spec(represented, representedName) {
     const name = relayName(String(representedName).split('@')[0], String(represented).split(':')[1]);
@@ -127,8 +144,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,8 +155,11 @@ 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}`); }
@@ -148,7 +169,7 @@ export class Relays {
       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 +179,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 +229,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 +252,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,10 +267,6 @@ 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();
     }
   }
 

package/package.json

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