@stage-labs/metro 0.1.0-beta.249 → 0.1.0-beta.250

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.249",
+  "version": "0.1.0-beta.250",
   "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.249",
+  "version": "0.1.0-beta.250",
   "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/xmtp/src/actions-conv.ts

@@ -16,6 +16,7 @@ import {
 import { updateChannelMeta } from './actions-meta.js';
 import { deletedByRequests, isDeleteRequest, superAdminCheck } from './delete-requests.js';
 import { isCallSignal } from './codecs.js';
+import { syncConversation } from './network.js';
 
 type Args = Record<string, unknown>;
 type Handler = (id: string, args: Args) => Promise<void>;
@@ -61,7 +62,7 @@ async function read(id: string, args: Args): Promise<void> {
   if (!conv)
     throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
   const lim = Math.min(Math.max(1, limit ?? 20), 200);
-  await conv.sync().catch(() => undefined);
+  await syncConversation(acct.client, conv);
   const all = await conv.messages();
   const deleted = deletedByRequests(all, superAdminCheck(conv));
   const slice = upTo(all.filter((m) => !isDeleteRequest(m) && !isCallSignal(m)), before).slice(-lim);
@@ -89,10 +90,10 @@ async function groupInfo(id: string, args: Args): Promise<void> {
 
 async function listMembers(id: string, args: Args): Promise<void> {
   const { line } = args as { line: string };
-  const { acct, conv } = await convOf(line);
+  const { conv } = await convOf(line);
   if (!conv)
     throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
-  respond(id, { result: await buildMemberList(acct, conv) });
+  respond(id, { result: await buildMemberList(conv) });
 }
 
 export const convHandlers: Record<string, Handler> = {

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

@@ -3,6 +3,7 @@ import { respond } from '@metro-labs/core/stations/station-runtime';
 import { ethIdentifiers, warmGroupName } from './conv-helpers.js';
 import { mergeAppData, normalizeAssigned, readAppDataObject, type GroupLike } from './labels.js';
 import { TrainError } from '@metro-labs/core/train-error';
+import { syncConversation } from './network.js';
 
 type Args = Record<string, unknown>;
 
@@ -73,7 +74,7 @@ async function applyChannelMeta(
       `${verb} target is not a group (no updateAppData)`,
     );
   }
-  await conv.sync();
+  await syncConversation(acct.client, conv);
   if (appData) mergeAppData(group.appData, appData);
   else readAppDataObject(group.appData);
   if (appData && Object.hasOwn(appData, 'assigned')) {

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

@@ -16,6 +16,7 @@ import { emitOutbound } from './emit.js';
 import { CallSignalCodec, FrameCodec, PollCodec, buildPollContent, encodeDeleteMessage } from './codecs.js';
 import { buildFrameContent } from './frames.js';
 import { buildWalletContent } from './wallet.js';
+import { network } from './network.js';
 import { callLeftovers } from './call-leftovers.js';
 import { convHandlers } from './actions-conv.js';
 import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
@@ -253,6 +254,11 @@ const handlers: Record<string, (id: string, args: Args) => Promise<void>> = {
 export type { CallMsg };
 
 export const handleCall = makeStation({
-  handlers,
+  handlers: Object.fromEntries(Object.entries(handlers).map(([action, handler]) => [
+    action,
+    action === 'accounts' || action === 'callLeftovers'
+      ? handler
+      : (id: string, args: Args) => network.run(() => handler(id, args)),
+  ])),
   normalize: messagingAliases({ action: 'removed' }),
 });

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

@@ -4,6 +4,7 @@ import { inboxEthCache, cacheInboxEth } from './wire.js';
 import { TrainError } from '@metro-labs/core/train-error';
 import type { MemberList, MetroMember } from '@metro-labs/core/stations/types';
 import { readAppData, readAppDataObject, type GroupLike } from './labels.js';
+import { network, syncConversation } from './network.js';
 
 export { parseMemberArgs, resolveMembers } from './member-args.js';
 
@@ -67,7 +68,9 @@ export async function resolveAddresses(
         cacheInboxEth(key, eth.identifier);
       }
     }
-  } catch {
+  } catch (error) {
+    network.note(error);
+    if (network.remaining() > 0) throw error;
     return addresses;
   }
   return addresses;
@@ -78,11 +81,12 @@ export async function buildGroupInfo(
   acct: Account,
   conv: Conv,
 ): Promise<Record<string, unknown>> {
-  await conv.sync();
+  await syncConversation(acct.client, conv);
   const rawAppData = (conv as unknown as GroupLike).appData ?? '';
   const appData = readAppDataObject(rawAppData);
-  const inboxIds = (await conv.members()).map((m) => m.inboxId);
-  const addresses = await resolveAddresses(acct, inboxIds);
+  const members = await conv.members();
+  const inboxIds = members.map((m) => m.inboxId);
+  const addresses = memberAddresses(members);
   const isDm =
     typeof (conv as unknown as { peerInboxId?: unknown }).peerInboxId ===
     'function';
@@ -114,6 +118,16 @@ export async function buildGroupInfo(
 interface RawMember {
   inboxId: string;
   permissionLevel?: number;
+  accountIdentifiers?: EthId[];
+}
+
+function memberAddresses(members: RawMember[]): Record<string, string> {
+  const addresses: Record<string, string> = {};
+  for (const member of members) {
+    const eth = member.accountIdentifiers?.find((id) => id.identifierKind === IdentifierKind.Ethereum);
+    if (eth) addresses[member.inboxId] = eth.identifier;
+  }
+  return addresses;
 }
 
 function toMetroMember(
@@ -128,15 +142,9 @@ function toMetroMember(
   return member;
 }
 
-export async function buildMemberList(
-  acct: Account,
-  conv: Conv,
-): Promise<MemberList> {
-  const raw = (await conv.members()) as RawMember[];
-  const addresses = await resolveAddresses(
-    acct,
-    raw.map((m) => m.inboxId),
-  );
+export async function buildMemberList(conv: Conv): Promise<MemberList> {
+  const raw = await conv.members();
+  const addresses = memberAddresses(raw);
   return {
     members: raw.map((m) => toMetroMember(m, addresses)),
     capability: { supported: true, complete: true, total: raw.length },
@@ -199,7 +207,7 @@ export async function applyMemberOp(
       'INVALID_ARGS',
       `${verb} target is not a group (no ${verb})`,
     );
-  await group.sync?.().catch(() => undefined);
+  await group.sync?.();
   await applyByIdentifiers(group, byIdent, addrs, verb);
   await applyByInboxId(group, byId, inboxes, verb);
 }

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

@@ -1,5 +1,5 @@
 import { errMsg } from '@metro-labs/core/log';
-import { ConsentState, type DecodedMessage } from '@xmtp/node-sdk';
+import type { DecodedMessage } from '@xmtp/node-sdk';
 import {
   accounts,
   bootAccount,
@@ -13,10 +13,10 @@ import { groupNameFor } from './conv-helpers.js';
 import { senderFieldsNow } from './sender.js';
 import { readCalls } from '@metro-labs/core/trains/protocol';
 import { handleCall } from './actions.js';
+import { streamMessages } from './stream.js';
 
 readCalls('xmtp', handleCall);
 
-const SYNC_MS = Number(process.env.XMTP_SYNC_MS ?? '60000');
 const SILENT_TYPES = new Set([
   'readReceipt',
   'transactionReference',
@@ -26,35 +26,6 @@ const SILENT_TYPES = new Set([
   'deleteRequest',
 ]);
 
-async function bootSync(acct: Account): Promise<void> {
-  const { id } = acct.cfg;
-  try {
-    await acct.client.conversations.syncAll([
-      ConsentState.Allowed,
-      ConsentState.Unknown,
-    ]);
-    const initial = await acct.client.conversations.list();
-    process.stderr.write(
-      `xmtp[${id}]: synced ${initial.length} conversation(s) at boot\n`,
-    );
-  } catch (err) {
-    process.stderr.write(
-      `xmtp[${id}] boot sync error: ${errMsg(err)}\n`,
-    );
-  }
-}
-
-function startPeriodicSync(acct: Account): void {
-  const { id } = acct.cfg;
-  setInterval(() => {
-    acct.client.conversations
-      .syncAll([ConsentState.Allowed, ConsentState.Unknown])
-      .catch((err: unknown) => {
-        process.stderr.write(`xmtp[${id}] sync error: ${errMsg(err)}\n`);
-      });
-  }, SYNC_MS).unref();
-}
-
 async function handleStreamMessage(
   acct: Account,
   msg: DecodedMessage,
@@ -74,28 +45,12 @@ async function handleStreamMessage(
 }
 
 async function runAccount(acct: Account): Promise<void> {
-  const { id } = acct.cfg;
-  await bootSync(acct);
-  startPeriodicSync(acct);
-
-  for (;;) {
-    try {
-      const stream = await acct.client.conversations.streamAllMessages({
-        consentStates: [ConsentState.Allowed, ConsentState.Unknown],
-      });
-      for await (const msg of stream) {
-        if (!msg) continue;
-        await handleStreamMessage(acct, msg).catch((err: unknown) => {
-          process.stderr.write(`xmtp[${id}] one message failed and was skipped: ${errMsg(err)}\n`);
-        });
-      }
-    } catch (err) {
-      process.stderr.write(
-        `xmtp[${id}] stream error (retry 5s): ${errMsg(err)}\n`,
-      );
-    }
-    await new Promise((r) => setTimeout(r, 5000));
-  }
+  await streamMessages(acct.client.conversations, async (msg) => {
+    if (!msg) return;
+    await handleStreamMessage(acct, msg).catch((err: unknown) => {
+      process.stderr.write(`xmtp[${acct.cfg.id}] one message failed and was skipped: ${errMsg(err)}\n`);
+    });
+  });
 }
 
 const cfgs = loadAccounts();

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

@@ -0,0 +1,110 @@
+import { errMsg } from '@metro-labs/core/log';
+import { TrainError } from '@metro-labs/core/train-error';
+
+const RATE_DELAY_MS = 60_000;
+const MAX_DELAY_MS = 300_000;
+
+function recordOf(value: unknown): Record<string, unknown> {
+  return typeof value === 'object' && value !== null ? value as Record<string, unknown> : {};
+}
+
+function retryAfter(error: unknown, now: number): number {
+  const fields = recordOf(error);
+  if (typeof fields.retryAfterMs === 'number' && Number.isFinite(fields.retryAfterMs))
+    return Math.max(0, fields.retryAfterMs);
+  const headers = fields.headers ?? recordOf(fields.response).headers ?? fields.metadata;
+  const get = recordOf(headers).get;
+  const raw: unknown = typeof get === 'function' ? get.call(headers, 'retry-after') : recordOf(headers)['retry-after'];
+  return retryDelay(Array.isArray(raw) ? raw[0] : raw, now);
+}
+
+function retryDelay(value: unknown, now: number): number {
+  if (typeof value !== 'string' && typeof value !== 'number') return 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000);
+  const date = Date.parse(String(value));
+  return Number.isFinite(date) ? Math.max(0, date - now) : 0;
+}
+
+function rateLimited(error: unknown): boolean {
+  const fields = recordOf(error);
+  return fields.code === 8 || fields.code === 429 || fields.status === 429 ||
+    /resource.?exhausted|resource has been exhausted|exceeds rate limit|\b429\b/i.test(errMsg(error));
+}
+
+export class NetworkBackoff {
+  private until = 0;
+  private delay = RATE_DELAY_MS;
+  private reason = '';
+
+  constructor(private readonly now: () => number = Date.now) {}
+
+  remaining(): number {
+    return Math.max(0, this.until - this.now());
+  }
+
+  note(error: unknown): void {
+    if (!rateLimited(error)) return;
+    const now = this.now();
+    if (now < this.until) {
+      this.until = Math.max(this.until, now + retryAfter(error, now));
+      return;
+    }
+    if (now - this.until >= MAX_DELAY_MS) this.delay = RATE_DELAY_MS;
+    this.until = now + Math.max(this.delay, retryAfter(error, now));
+    this.delay = Math.min(this.delay * 2, MAX_DELAY_MS);
+    this.reason = errMsg(error);
+  }
+
+  async run<T>(task: () => Promise<T>): Promise<T> {
+    const remaining = this.remaining();
+    if (remaining > 0)
+      throw new TrainError('xmtp_rate_limited', `XMTP is rate limited; retry in ${Math.ceil(remaining / 1000)}s. ${this.reason}`, {
+        retryable: true, retryAfterMs: remaining,
+      });
+    try {
+      return await task();
+    } catch (error) {
+      this.note(error);
+      throw error;
+    }
+  }
+}
+
+export const network = new NetworkBackoff();
+
+export class SyncRequests {
+  private tail: Promise<unknown> = Promise.resolve();
+  private readonly pending = new WeakMap<object, Map<string, Promise<unknown>>>();
+
+  constructor(
+    private readonly backoff: NetworkBackoff = network,
+    private readonly now: () => number = Date.now,
+  ) {}
+
+  run(owner: object, id: string, task: () => Promise<unknown>): Promise<unknown> {
+    let requests = this.pending.get(owner);
+    if (!requests) {
+      requests = new Map();
+      this.pending.set(owner, requests);
+    }
+    const previous = requests.get(id);
+    if (previous) return previous;
+    const queuedAt = this.now();
+    const run = () => {
+      if (this.now() - queuedAt >= 30_000)
+        throw new TrainError('xmtp_sync_busy', 'XMTP sync waited 30s; retry the request.', { retryable: true });
+      return this.backoff.run(task);
+    };
+    const pending = this.tail.then(run, run).finally(() => { requests.delete(id); });
+    requests.set(id, pending);
+    this.tail = pending;
+    return pending;
+  }
+}
+
+const syncs = new SyncRequests();
+
+export function syncConversation(owner: object, conv: { id: string; sync: () => Promise<unknown> }): Promise<unknown> {
+  return syncs.run(owner, conv.id, () => conv.sync());
+}

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

@@ -0,0 +1,66 @@
+import { errMsg } from '@metro-labs/core/log';
+import { ConsentState } from '@xmtp/node-sdk';
+import { network, type NetworkBackoff } from './network.js';
+
+interface StreamOptions<T> {
+  consentStates: ConsentState[];
+  retryOnFail: false;
+  onError: (error: Error) => void;
+  onValue: (message: T) => void;
+}
+
+interface StreamSource<T> {
+  streamAllMessages: (options: StreamOptions<T>) => Promise<AsyncIterable<T>>;
+}
+
+interface StreamRuntime {
+  backoff: NetworkBackoff;
+  now: () => number;
+  wait: (ms: number) => Promise<void>;
+  report: (message: string) => void;
+}
+
+const defaultRuntime: StreamRuntime = {
+  backoff: network,
+  now: Date.now,
+  wait: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  report: (message) => { process.stderr.write(`xmtp: ${message}\n`); },
+};
+
+export async function streamMessages<T>(
+  source: StreamSource<T>,
+  handle: (message: T) => Promise<void>,
+  runtime: StreamRuntime = defaultRuntime,
+): Promise<never> {
+  let delay = 5000;
+  for (;;) {
+    const started = runtime.now();
+    let delivery = Promise.resolve();
+    try {
+      const stream = await runtime.backoff.run(() => source.streamAllMessages({
+        consentStates: [ConsentState.Allowed, ConsentState.Unknown],
+        retryOnFail: false,
+        onValue: (message) => {
+          delivery = delivery.then(() => handle(message)).catch((error: unknown) => {
+            runtime.report(`message handler failed: ${errMsg(error)}`);
+          });
+        },
+        onError: (error) => {
+          runtime.backoff.note(error);
+          runtime.report(`stream error: ${errMsg(error)}`);
+        },
+      }));
+      const iterator = stream[Symbol.asyncIterator]();
+      while (!(await iterator.next()).done) await delivery;
+    } catch (error) {
+      runtime.backoff.note(error);
+      runtime.report(`stream error: ${errMsg(error)}`);
+    }
+    await delivery;
+    if (runtime.now() - started >= 60_000) delay = 5000;
+    const wait = Math.max(delay, runtime.backoff.remaining());
+    runtime.report(`stream ended; retry in ${Math.ceil(wait / 1000)}s`);
+    await runtime.wait(wait);
+    delay = Math.min(delay * 2, 300_000);
+  }
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.249"
+  "version": "0.1.0-beta.250"
 }