@volter/supercode-teams 0.3.85 → 0.3.87

package/bin/workspace/calendar.mjs

@@ -12,6 +12,18 @@
 import { execFileSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { usage, requireArgs } from './args.mjs';
+import { openMachine } from '../../machine-door.mjs';
+import { nodeRpc } from '../../client.mjs';
+import { ownClaim } from '../../live-sessions.mjs';
+
+/** One mail sent by this machine's daemon, as this process's caller (its claim): throws when it was not sent. */
+async function mail(to, body, subject) {
+  const channel = await openMachine({ machine: null });
+  try {
+    const answer = await (await nodeRpc(channel)).call('harness.v1.mail.send', { to, body, subject, claim: ownClaim() }, { timeoutMs: 120_000 });
+    if (answer?.code !== 0) throw new Error(answer?.text ?? 'not sent');
+  } finally { channel.close(); }
+}
 
 async function pack() {
   try { return await import('@volter/supercode-calendar'); } catch { /* not installed */ }
@@ -116,7 +128,7 @@ export async function calendarCommand(sub, { flags, rest, output, client, contex
       const uid = `notice-${risk.id}-${risk.due}`;
       if (notices.has(uid)) continue;
       const body = `${risk.title} (${risk.id}) is at risk for ${new Date(risk.due).toISOString().slice(0, 16)}Z: ${calendar.sentence(risk.chance, risk.p85, risk.due)} (${risk.reason}). The calendar's base rate; your call is yours.`;
-      execFileSync(supercode(), ['message', 'send', String(flags.notify), body, '--subject', `At risk: ${risk.id}`], { stdio: ['ignore', 'pipe', 'pipe'] });
+      await mail(String(flags.notify), body, `At risk: ${risk.id}`);
       await put(client, path, 'notice', { '@type': 'Event', uid, title: `Mailed ${flags.notify} about ${risk.id}`, start: new Date().toISOString(), duration: 'PT0S', 'volter:kind': 'notice', 'volter:card': risk.id });
       sent.push(risk.id);
     }

package/bin/workspace.mjs

@@ -1132,6 +1132,11 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
     if (!context.machine_only) machineEvents.published = new PublishedEvents({ supercodeHome: home, context: contextName, machineId: saved.machine.id });
     const machine = new TeamsMachine({ home: daemonHome, supercode: binary, ...(flags.tmux_socket ? { tmuxSocket: String(flags.tmux_socket) } : {}), link: { server: context.origin, teamId: context.team_id, machineId: saved.machine.id, credential: saved.credential.token, incarnationId: connector.state.incarnation_id, configuration: () => connector.configuration() }, onTurn: (turn) => connector.noteTurn(turn), onTurnWithdrawn: (turn) => connector.withdrawTurn(turn) });
     machine.machineEvents = machineEvents;
+    // what ends the daemon's harness serve is said in the connector's log, as `machine start` says it
+    machine.on('serve-exit', (exit) => process.stderr.write(`supercode teams: harness serve exited: ${JSON.stringify(exit)}\n`));
+    machine.on('serve-stderr', (text) => process.stderr.write(`supercode teams: harness serve: ${String(text).trimEnd().slice(-2000)}\n`));
+    // its mail goes through the daemon's own send, in this process
+    machineEvents.send = (request) => machine.sendOwn(request);
     // the Claude worker homes the roots declare: their live sessions are this machine's too (the live-session map)
     connector.onClaudeHomes = (homes) => machine.live?.claudeHomes(homes);
     // The boards registered with this daemon are published by this connector, under the machine credential (D138 step 4).

package/connector/index.mjs

@@ -176,6 +176,9 @@ function atomic(path, text) {
 /** How long a held session's never-published observation is kept. */
 const PROFILE_FORGOTTEN_MS=7*86400000;
 
+/** How long the connector waits for the machine daemon's harness to come back before it gives up on its feeds. */
+const REOPEN_PATIENCE_MS=3*60_000;
+
 export class TeamsConnector {
   constructor({server,teamId,machineId,sourceId,credential,stateDir,daemon=null,core,largeCore=core,slowCore=largeCore,harnesses=[],hostKeyId=null,effectExecutor=null,clock={nowMs:()=>Date.now()},fetch:fetchImpl=globalThis.fetch,heartbeatMs=15000,nativeIdleMs=NATIVE_IDLE_MS}){Object.assign(this,{server:serverOrigin(server),teamId,machineId,sourceId,credential,stateDir,daemon,core,largeCore,slowCore,harnesses,hostKeyId,effectExecutor,clock,fetch:fetchImpl,heartbeatMs,nativeIdleMs});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};this.loadEntries();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.forgetNativeCache();this.state.native_failed??={};this.spillHolders();this.removeUnheldSpills();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();}
   // A capture burst saves after every step, and each save is a synchronous stringify, write and fsync of the whole
@@ -515,8 +518,23 @@ export class TeamsConnector {
     if(this.reopening||!this.feeds?.size)return;this.reopening=true;
     process.stderr.write(`supercode teams: ${reason}; the session index feeds are opened again\n`);
     for(const feed of this.feeds.values())feed.dead=true;
-    try{for(const [key,feed] of [...this.feeds])await this.openFeed(key,feed,{});this.activityFingerprint=null;this.queueActivityFollow();}
-    catch(error){this.feedsFailed(error);}
+    // The daemon starts its harness serve again after it ends (1 s doubling to 1 min): the feeds are opened again on a
+    // growing wait that outlasts it (1 s doubling to 30 s, for up to 3 minutes), and only a daemon that never brings
+    // one back ends this connector.
+    const started=Date.now();let wait=1000;
+    try{
+      for(;;){
+        try{for(const [key,feed] of [...this.feeds])if(feed.dead)await this.openFeed(key,feed,{});break;}
+        catch(error){
+          if(this.abort.signal.aborted)return;
+          if(Date.now()-started>REOPEN_PATIENCE_MS){this.feedsFailed(error);return;}
+          process.stderr.write(`supercode teams: the session index feeds are not open yet (${error?.message??error}); tried again in ${Math.round(wait/1000)} s\n`);
+          await new Promise(resolve=>{const timer=setTimeout(resolve,wait);timer.unref?.();});
+          wait=Math.min(30_000,wait*2);
+        }
+      }
+      this.activityFingerprint=null;this.queueActivityFollow();
+    }
     finally{this.reopening=false;}
   }
   /**

package/execution.mjs

@@ -109,7 +109,9 @@ export class JobOwner {
     writeFileSync(join(this.dir, `${id}.json`), JSON.stringify(record), { mode: 0o600 });
     this.live.set(id, record);
     child.stdout.on('data', (bytes) => { if (!stream.closed) stream.write(bytes.toString('base64')); });
-    stream.on('data', (chunk) => { if (!child.stdin.destroyed) child.stdin.write(Buffer.from(chunk, 'base64')); });
+    // a job that stopped reading its input (EPIPE) ends that job's stream, never the daemon
+    child.stdin.on('error', (error) => finish(`its input closed (${error.code ?? error.message})`));
+    stream.on('data', (chunk) => { if (!child.stdin.destroyed && child.stdin.writable) child.stdin.write(Buffer.from(chunk, 'base64')); });
     const finish = (reason) => {
       if (!this.live.has(id)) return;
       this.live.delete(id);

package/live-sessions.mjs

@@ -219,6 +219,8 @@ export class LiveSessions extends EventEmitter {
       return;
     }
     if (typeof record.sessionId !== 'string' || !record.sessionId) return;
+    // a parked session (its process kept for a job) is no live session (claude_peer.rs `read_registry`)
+    if (record.parkedJobId != null) { if (known?.dir === dir) { this.#dropClaude(pid); this.#changed(); } return; }
     const history = known ? known.history.filter((id) => id !== record.sessionId) : [];
     history.push(record.sessionId);
     while (history.length > HISTORY_KEPT) history.shift();
@@ -226,6 +228,7 @@ export class LiveSessions extends EventEmitter {
     this.claude.set(pid, {
       pid, dir, sessionId: record.sessionId, name: typeof record.name === 'string' ? record.name : '', status: typeof record.status === 'string' ? record.status : 'unknown',
       cwd: typeof record.cwd === 'string' ? record.cwd : null, tmux: typeof record.tmux === 'string' ? record.tmux : null, procStart, history,
+      socket: typeof record.messagingSocketPath === 'string' && record.messagingSocketPath ? record.messagingSocketPath : null,
       // a rewrite of the same process's file (its status, its name) keeps its start's check: no `ps` for each rewrite
       ...(known && known.procStart === procStart && known.startChecked ? { startChecked: known.startChecked } : {}),
     });
@@ -371,20 +374,20 @@ export class LiveSessions extends EventEmitter {
   sessions() {
     const out = []; const seen = new Set();
     const named = new Map([...this.claude.values()].map((entry) => [entry.sessionId, entry]));
-    for (const runtime of this.runtimes.values()) {
+    for (const [id, runtime] of this.runtimes) {
       if (!alive(runtime.pid)) continue;
       const registered = named.get(runtime.sessionId) ?? (runtime.runtimeSessionId ? named.get(runtime.runtimeSessionId) : null);
       if (registered?.name.startsWith(RELAY_PREFIX)) continue;
       const address = this.#address(runtime.harness, runtime.sessionId);
       if (seen.has(address)) continue; seen.add(address);
       const name = registered?.name || `${runtime.harness}-${runtime.sessionId.slice(0, 8)}`;
-      out.push({ address, name: `${name}@${this.machine}`, status: 'hosted', door: 'runtime', pid: runtime.pid, cwd: runtime.cwd, pane: null, tools: false });
+      out.push({ address, name: `${name}@${this.machine}`, status: 'hosted', door: 'runtime', pid: runtime.pid, cwd: runtime.cwd, pane: null, tools: false, receipt: id });
     }
     for (const entry of this.claude.values()) {
       if (entry.name.startsWith(RELAY_PREFIX) || !alive(entry.pid)) continue;
       const address = this.#address('claude-code', entry.sessionId);
       if (seen.has(address)) continue; seen.add(address);
-      out.push({ address, name: `${entry.name}@${this.machine}`, status: entry.status, door: 'native', pid: entry.pid, cwd: entry.cwd, pane: entry.tmux, tools: this.hasTools(entry.pid) });
+      out.push({ address, name: `${entry.name}@${this.machine}`, status: entry.status, door: 'native', pid: entry.pid, cwd: entry.cwd, pane: entry.tmux, tools: this.hasTools(entry.pid), socket: entry.socket ?? null });
     }
     const codex = new Set([...this.codexRunning.keys(), ...this.codexPaneOf.keys()]);
     for (const sessionId of codex) {
@@ -399,6 +402,36 @@ export class LiveSessions extends EventEmitter {
     return out;
   }
 
+  /**
+   * The live-runtime receipt of `harness`'s runtime `id` (its source session or its runtime session), read whole from its
+   * 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.
+   */
+  runtimeReceipt(harness, id) {
+    for (const [receiptId, runtime] of this.runtimes) {
+      if (runtime.harness !== harness || (runtime.sessionId !== id && runtime.runtimeSessionId !== id) || !alive(runtime.pid)) continue;
+      const receipt = readReceiptFile(join(this.receiptsDir, `${receiptId}.json`));
+      if (receipt?.receipt_id === receiptId && receipt.source?.harness === harness && receipt.source?.session_id === runtime.sessionId) return receipt;
+    }
+    return null;
+  }
+
+  /**
+   * The live-runtime receipt named `receiptId`, read from its own file (`<live-runtimes>/<receiptId>.json`) and taken
+   * into the map: a runtime whose receipt the watch has not delivered yet (its event late or lost) is read by name, never
+   * waited on or listed for.
+   */
+  receiptNamed(receiptId) {
+    if (typeof receiptId !== 'string' || !/^[0-9a-f]+$/i.test(receiptId)) return null;
+    const receipt = readReceiptFile(join(this.receiptsDir, `${receiptId}.json`));
+    if (!receipt || receipt.receipt_id !== receiptId || typeof receipt.source?.harness !== 'string' || typeof receipt.source?.session_id !== 'string') return null;
+    if (!this.runtimes.has(receiptId)) {
+      this.runtimes.set(receiptId, { pid: receipt.pid, harness: receipt.source.harness, sessionId: receipt.source.session_id, runtimeSessionId: typeof receipt.runtime_session_id === 'string' ? receipt.runtime_session_id : null, cwd: typeof receipt.source.workspace === 'string' ? receipt.source.workspace : null });
+      this.#changed();
+    }
+    return receipt;
+  }
+
   /** A session the index holds that is not live: mail to it is stored until it is next active, never refused. */
   isIndexedNotLive(address) {
     const [, machine, harness, sessionId] = String(address).split(':');
@@ -420,7 +453,7 @@ export class LiveSessions extends EventEmitter {
   }
 
   /** The session a client runs in, from its claim: its parent's current session, else its environment's id through the map. */
-  #sessionOfClaim({ ppid, session }) {
+  #sessionOfClaim({ pid, ppid, session }) {
     const parent = this.claude.get(Number(ppid));
     if (parent && alive(parent.pid)) return this.#address('claude-code', parent.sessionId);
     if (typeof session === 'string' && session) {
@@ -428,6 +461,15 @@ export class LiveSessions extends EventEmitter {
       if (!found) throw new CallerRefused(`the session this command runs in (${session}) is not one this machine's live sessions have held, so it cannot act for it; nothing was done`);
       return found;
     }
+    // a runtime supercode hosts, calling from its own process or a child of it (the native agent's mail tool): taken
+    // only when exactly one live runtime's receipt names that process. A process several receipts name (harness serve
+    // records its own pid on each runtime it hosts with no child of its own) is no one runtime, and is refused.
+    for (const candidate of [Number(pid), Number(ppid)]) {
+      if (!Number.isInteger(candidate) || candidate <= 0) continue;
+      const held = [...this.runtimes.values()].filter((runtime) => runtime.pid === candidate && alive(runtime.pid));
+      if (held.length === 1) return this.#address(held[0].harness, held[0].sessionId);
+      if (held.length > 1) throw new CallerRefused(`process ${candidate} hosts ${held.length} runtimes, so which one is calling is not known; nothing was done`);
+    }
     return null;
   }
 
@@ -458,6 +500,16 @@ export class LiveSessions extends EventEmitter {
   }
 }
 
+/** A live-runtime receipt file, when it is one a delivery may use: its schema, and a loopback HTTP address. */
+function readReceiptFile(path) {
+  let receipt = null;
+  try { receipt = JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
+  if (receipt?.schema !== 'supercode.live-runtime.v1' || typeof receipt.token !== 'string' || !receipt.token) return null;
+  let url = null; try { url = new URL(receipt.base_url); } catch { return null; }
+  if (url.protocol !== 'http:' || !['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname) || !alive(receipt.pid)) return null;
+  return receipt;
+}
+
 /** The environment variables a client's claim is read from: what names the session or board a process acts for. */
 export const ACTING_VARIABLES = ['CLAUDE_CODE_SESSION_ID', 'CODEX_THREAD_ID', 'SUPERCODE_CALLER', 'SUPERCODE_BOARD_OWNER_PID'];
 

package/machine-events.mjs

@@ -4,7 +4,6 @@
 // processes through the daemon's `events` door (PublishedEvents), never one stream per process.
 import { mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
-import { spawn } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
 import { fromContext } from '@volter/teams/context';
 import { retryAfterMs, spentClause } from '@volter/teams/http-client';
@@ -80,14 +79,13 @@ export class MachineEvents {
       }
     })().finally(()=>{this.flushing=null;});return this.flushing;
   }
-  deliver(item){return new Promise((resolve,reject)=>{
-    const child=spawn(this.binary,['message','remote-deliver'],{env:this.env,stdio:['pipe','pipe','pipe']});let detail='';
-    const timer=setTimeout(()=>{child.kill('SIGTERM');reject(new Error('mail delivery timed out; retained for retry'));},30000);
-    child.stdout.on('data',chunk=>{detail=(detail+chunk).slice(-1000);});child.stderr.on('data',chunk=>{detail=(detail+chunk).slice(-1000);});
-    child.once('error',error=>{clearTimeout(timer);reject(error);});child.once('close',code=>{clearTimeout(timer);let receipt;try{receipt=JSON.parse(detail.trim().split('\n').at(-1));}catch{}code===0&&receipt?.code===0?resolve():reject(new Error(receipt?.text||detail||`exit ${code}`));});
-    child.stdin.on('error',()=>{});
-    child.stdin.end(JSON.stringify({op:'send',from:`sc:${this.machine}:operator:teams-events`,from_name:'Teams machine events',to:item.to,id:item.id,queue:item.to.split(':')[2]==='board',notice:true,body:item.body}));
-  });}
+  /** One event's mail, through this machine's daemon's own send (`send`, set by the connector that runs both): retained
+   *  for retry when it is not delivered. */
+  async deliver(item){
+    if(typeof this.send!=='function')throw new Error('this machine\'s daemon has not started; retained for retry');
+    const receipt=await this.send({from:`sc:${this.machine}:operator:teams-events`,from_name:'Teams machine events',to:item.to,id:item.id,queue:item.to.split(':')[2]==='board',notice:true,body:item.body});
+    if(receipt?.code!==0)throw new Error(receipt?.text||'not delivered');
+  }
 }
 
 // What a local reader's cursor names: this connector's stream continuity (its epoch) and a server event sequence. A