@stage-labs/metro 0.1.0-beta.238 → 0.1.0-beta.239

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.238",
+  "version": "0.1.0-beta.239",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.238",
+  "version": "0.1.0-beta.239",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

package/runtime/node_modules/@metro-labs/daemon/src/boot/boot.ts

@@ -52,7 +52,7 @@ import type { StationName } from '@metro-labs/core/station-names';
 import { startUploadReaper } from '../files/upload-store.js';
 import { startAttachReaper } from '../files/attach-reaper.js';
 import { startCloudWatchPublisher } from '../server/cloudwatch.js';
-import { isCallEvent, onCallEvent } from '../voice/calls.js';
+import { isCallEvent, leaveCallsForShutdown, onCallEvent, sweepLeftoverCalls } from '../voice/calls.js';
 
 installCrashGuard();
 acquireLock(join(STATE_DIR, '.tail-lock'));
@@ -137,6 +137,7 @@ installBearerSessions(agentsDir(), localOwner);
   await materializeFrom(fileSource);
   forgetOrphans(knownAccounts());
   supervisor.start();
+  sweepLeftoverCalls();
   const metroMcp = await createMetroMcp({ liveEvents: liveEvents() });
   webhookServer = await startWebhookServer(
     emit,
@@ -196,6 +197,7 @@ async function shutdown(): Promise<void> {
   if (shuttingDown) return;
   shuttingDown = true;
   log.info('dispatcher shutting down');
+  const leaving = leaveCallsForShutdown();
   unwatchSession();
   tunnel?.stop();
   if (webhookServer) {
@@ -211,6 +213,7 @@ async function shutdown(): Promise<void> {
       }),
     ]);
   }
+  await leaving;
   await supervisor.stop();
   process.exit(exitCode);
 }

package/runtime/node_modules/@metro-labs/daemon/src/voice/call.ts

@@ -10,6 +10,7 @@ const OFFER_WAIT_MS = 45_000;
 const LONGEST_CALL_MS = 60 * 60_000;
 const CONTEXT_MESSAGES = 12;
 const CONTEXT_CHARS = 400;
+const LEAVE_RETRY_MS = 3_000;
 
 interface CallStart {
   line: string;
@@ -21,7 +22,7 @@ interface CallStart {
 
 const str = (value: unknown): string => (typeof value === 'string' ? value : '');
 
-async function trainCall(action: string, args: Record<string, unknown>): Promise<unknown> {
+export async function trainCall(action: string, args: Record<string, unknown>): Promise<unknown> {
   const answer = await forwardTrainCall('xmtp', action, args);
   if (answer.error !== undefined) throw new Error(answer.error);
   return answer.result;
@@ -57,6 +58,7 @@ export class Call {
   private timer: ReturnType<typeof setTimeout> | null = null;
   private longest: ReturnType<typeof setTimeout>;
   private over = false;
+  private left: Promise<void> = Promise.resolve();
 
   constructor(
     readonly start: CallStart,
@@ -93,11 +95,16 @@ export class Call {
       this.answer(this.start.callerPeer, raw.sdp).catch((err: unknown) => {
         this.hangUp(`answering failed: ${errMsg(err)}`);
       });
-    else if (raw.kind === 'leave' && fromCaller) this.end('the caller hung up', false);
+    else if (raw.kind === 'leave' && fromCaller) this.hangUp('the caller hung up');
   }
 
   hangUp(reason: string): void {
-    this.end(reason, true);
+    this.end(reason);
+  }
+
+  leave(reason: string): Promise<void> {
+    this.end(reason);
+    return this.left;
   }
 
   private async answer(to: string, offer: string): Promise<void> {
@@ -125,13 +132,15 @@ export class Call {
     return trainCall('callSignal', { line: this.start.line, signal });
   }
 
-  private end(reason: string, sendLeave: boolean): void {
+  private end(reason: string): void {
     if (this.over) return;
     this.over = true;
     if (this.timer !== null) clearTimeout(this.timer);
     clearTimeout(this.longest);
     log.info({ reason, seconds: Math.round((Date.now() - this.startedAt) / 1000) }, 'voice: call over');
-    this.wrapUp(reason, sendLeave)
+    this.left = this.sendLeave();
+    this.left
+      .then(() => this.wrapUp(reason))
       .catch((err: unknown) => {
         log.warn({ err: errMsg(err) }, 'voice: wrapping up the call failed');
       })
@@ -140,11 +149,20 @@ export class Call {
       });
   }
 
-  private async wrapUp(reason: string, sendLeave: boolean): Promise<void> {
-    if (sendLeave)
-      await this.signal({ kind: 'leave', callId: this.start.callId, from: this.selfPeer }).catch((err: unknown) => {
-        log.warn({ err: errMsg(err) }, 'voice: could not send the hang-up');
+  private async sendLeave(): Promise<void> {
+    const leave = { kind: 'leave', callId: this.start.callId, from: this.selfPeer };
+    try {
+      await this.signal(leave);
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'voice: could not send the hang-up, trying once more');
+      await new Promise((r) => setTimeout(r, LEAVE_RETRY_MS));
+      await this.signal(leave).catch((again: unknown) => {
+        log.warn({ err: errMsg(again) }, 'voice: could not send the hang-up; the next start sends it');
       });
+    }
+  }
+
+  private async wrapUp(reason: string): Promise<void> {
     this.peer?.close();
     const notes = await this.talk.finish();
     const minutes = Math.max(1, Math.round((Date.now() - this.startedAt) / 60_000));

package/runtime/node_modules/@metro-labs/daemon/src/voice/calls.ts

@@ -2,11 +2,15 @@ import { errMsg, log } from '@metro-labs/core/log';
 import { isRecord } from '@metro-labs/core/is-record';
 import type { TrainEvent } from '@metro-labs/core/trains/protocol';
 import { lineReceives, mayApprove } from '../agents/map.js';
-import { Call } from './call.js';
+import { Call, trainCall } from './call.js';
 import { readVoice, voiceReady } from './store.js';
 
-const INVITE_FRESH_MS = 60_000;
+const RING_MS = 40_000;
 const CALL_TYPES = new Set(['callInvite', 'callSignal']);
+const SHUTDOWN_LEAVE_MS = 2_000;
+const SWEEP_FIRST_MS = 5_000;
+const SWEEP_EVERY_MS = 10_000;
+const SWEEP_TRIES = 12;
 
 let current: Call | null = null;
 
@@ -17,26 +21,43 @@ const contentTypeOf = (env: TrainEvent): string => str(record(env.payload).conte
 
 export const isCallEvent = (env: TrainEvent): boolean => CALL_TYPES.has(contentTypeOf(env));
 
-function refusal(env: TrainEvent, line: string, from: string): string | null {
-  if (current !== null) return 'already in a call';
-  const sent = Date.parse(str(env.ts));
-  if (Number.isNaN(sent) || Date.now() - sent > INVITE_FRESH_MS) return 'the invite is too old';
+const sameCaller = (call: Call, line: string, from: string): boolean => call.start.line === line && call.start.from === from;
+
+function refusal(line: string, from: string): string | null {
+  if (current !== null && !sameCaller(current, line, from)) return 'already in a call';
   if (!voiceReady(readVoice())) return 'voice is off or has no API key on the Voice page';
   if (!lineReceives(line) || !mayApprove(line, from)) return 'the caller is not someone who can approve for this channel';
   return null;
 }
 
+function decline(line: string, callId: string): void {
+  trainCall('callSignal', { line, signal: { kind: 'decline', callId } }).catch((err: unknown) => {
+    log.warn({ line, err: errMsg(err) }, 'voice: could not decline a call');
+  });
+}
+
+function ringing(env: TrainEvent): boolean {
+  const sent = Date.parse(str(env.ts));
+  return !Number.isNaN(sent) && Date.now() - sent < RING_MS;
+}
+
 function invite(env: TrainEvent, body: Record<string, unknown>): void {
   const line = str(env.line);
   const from = str(env.from);
   const callId = str(body.callId);
   const callerPeer = str(body.from);
-  if (callId === '' || callerPeer === '') return;
-  const refused = refusal(env, line, from);
+  if (callId === '' || callerPeer === '' || current?.start.callId === callId) return;
+  if (!ringing(env)) {
+    log.info({ line }, 'voice: an invite came in after the caller stopped ringing, not answered');
+    return;
+  }
+  const refused = refusal(line, from);
   if (refused !== null) {
-    log.info({ line, reason: refused }, 'voice: a call came in and is not answered');
+    log.info({ line, reason: refused }, 'voice: a call came in and is declined');
+    decline(line, callId);
     return;
   }
+  current?.hangUp('the caller started a new call');
   const callerName = str(env.from_display_name) || str(env.from_name) || 'the caller';
   const call = new Call({ line, from, callerName, callId, callerPeer }, readVoice(), () => {
     if (current === call) current = null;
@@ -52,3 +73,57 @@ export function onCallEvent(env: TrainEvent): void {
   if (contentTypeOf(env) === 'callInvite') invite(env, body);
   else if (current !== null && env.line === current.start.line) current.signalled(body);
 }
+
+export function leaveCallsForShutdown(): Promise<void> {
+  if (current === null) return Promise.resolve();
+  const leaving = current.leave('Metro stopped or restarted');
+  const capped = new Promise<void>((resolve) => {
+    setTimeout(resolve, SHUTDOWN_LEAVE_MS).unref();
+  });
+  return Promise.race([leaving, capped]);
+}
+
+interface Leftover {
+  line: string;
+  callId: string;
+  peer: string;
+}
+
+function leftoversOf(result: unknown): Leftover[] {
+  const rows = isRecord(result) && Array.isArray(result.calls) ? result.calls : [];
+  return rows
+    .map((row) => record(row))
+    .map((row) => ({ line: str(row.line), callId: str(row.callId), peer: str(row.peer) }))
+    .filter((row) => row.line !== '' && row.callId !== '' && row.peer !== '');
+}
+
+export async function leaveLeftoverCalls(): Promise<number> {
+  const leftovers = leftoversOf(await trainCall('callLeftovers', {}));
+  let left = 0;
+  for (const { line, callId, peer } of leftovers) {
+    if (current?.start.callId === callId) continue;
+    try {
+      await trainCall('callSignal', { line, signal: { kind: 'leave', callId, from: peer } });
+      log.info({ line, callId }, 'voice: left a call this box was still in');
+      left += 1;
+    } catch (err) {
+      log.warn({ line, err: errMsg(err) }, 'voice: could not leave a call this box was still in');
+    }
+  }
+  return left;
+}
+
+function sweep(tries: number, delayMs: number): void {
+  setTimeout(() => {
+    leaveLeftoverCalls().catch((err: unknown) => {
+      const reason = errMsg(err);
+      if (reason.startsWith('no train named')) return;
+      if (tries > 1) sweep(tries - 1, SWEEP_EVERY_MS);
+      else log.warn({ err: reason }, 'voice: could not check for calls left open');
+    });
+  }, delayMs).unref();
+}
+
+export function sweepLeftoverCalls(): void {
+  sweep(SWEEP_TRIES, SWEEP_FIRST_MS);
+}

package/runtime/node_modules/@metro-labs/xmtp/src/actions.ts

@@ -14,6 +14,7 @@ import { resolveMsgId } from './wire.js';
 import { emitOutbound } from './emit.js';
 import { CallSignalCodec, FrameCodec, PollCodec, buildPollContent, encodeDeleteMessage } from './codecs.js';
 import { buildFrameContent } from './frames.js';
+import { callLeftovers } from './call-leftovers.js';
 import { convHandlers } from './actions-conv.js';
 import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
 import { TrainError } from '@metro-labs/core/train-error';
@@ -233,6 +234,7 @@ const handlers: Record<string, (id: string, args: Args) => Promise<void>> = {
   reply,
   delete: remove,
   callSignal,
+  callLeftovers: (id) => callLeftovers(id),
   sendAttachment,
   sendImage,
   ...convHandlers,

package/runtime/node_modules/@metro-labs/xmtp/src/call-leftovers.ts

@@ -0,0 +1,47 @@
+import type { DecodedMessage } from '@xmtp/node-sdk';
+import { isRecord } from '@metro-labs/core/is-record';
+import { TrainError } from '@metro-labs/core/train-error';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { accounts, lineOf, type Account } from './accounts.js';
+import { isCallSignal } from './codecs.js';
+
+const CALL_WINDOW_MS = 2 * 60 * 60_000;
+
+interface Leftover {
+  line: string;
+  callId: string;
+  peer: string;
+}
+
+function ownSignal(acct: Account, m: DecodedMessage): Record<string, unknown> | null {
+  if (m.senderInboxId !== acct.inboxId || !isCallSignal(m)) return null;
+  return isRecord(m.content) ? m.content : null;
+}
+
+function openJoins(acct: Account, line: string, messages: DecodedMessage[]): Leftover[] {
+  const open = new Map<string, string>();
+  for (const m of messages) {
+    const signal = ownSignal(acct, m);
+    if (signal === null || typeof signal.from !== 'string' || typeof signal.callId !== 'string') continue;
+    if (signal.kind === 'join') open.set(signal.from, signal.callId);
+    else if (signal.kind === 'leave') open.delete(signal.from);
+  }
+  return [...open].map(([peer, callId]) => ({ line, callId, peer }));
+}
+
+async function leftoversOf(acct: Account, sinceNs: bigint): Promise<Leftover[]> {
+  const found: Leftover[] = [];
+  for (const conv of await acct.client.conversations.list()) {
+    const messages = await conv.messages({ sentAfterNs: sinceNs, direction: 0 });
+    found.push(...openJoins(acct, lineOf(acct.cfg.id, conv.id), messages));
+  }
+  return found;
+}
+
+export async function callLeftovers(id: string): Promise<void> {
+  if (accounts.size === 0) throw new TrainError('UNAVAILABLE', 'no XMTP account is ready yet');
+  const sinceNs = BigInt(Date.now() - CALL_WINDOW_MS) * 1_000_000n;
+  const calls: Leftover[] = [];
+  for (const acct of accounts.values()) calls.push(...(await leftoversOf(acct, sinceNs)));
+  respond(id, { result: { calls } });
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.238"
+  "version": "0.1.0-beta.239"
 }