@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

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

@@ -1,40 +1,7 @@
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { errMsg } from '@metro-labs/mcp/log';
-import { readCalls } from '@metro-labs/mcp/trains/protocol';
-import { accounts, loadAccounts, accountFor, lineOf, targetOf } from './accounts.js';
-import { createClient, type WAClient } from './client.js';
+import { runClientTrain } from '@metro-labs/core/stations/train-boot';
+import { accounts, loadAccounts } from './accounts.js';
+import { createClient } from './client.js';
 import { startInbound } from './inbound.js';
 import { makeHandleCall } from './actions.js';
 
-const clients = new Map<string, WAClient>();
-
-function clientFor(accountId: string): WAClient {
-  let client = clients.get(accountId);
-  if (!client) {
-    const account = accounts.get(accountId);
-    if (!account)
-      throw new TrainError('not_implemented', `unknown account '${accountId}'`);
-    client = createClient(account);
-    clients.set(accountId, client);
-  }
-  return client;
-}
-
-const handleCall = makeHandleCall(clientFor);
-
-readCalls('whatsapp', handleCall);
-
-function boot(): void {
-  for (const cfg of loadAccounts()) accounts.set(cfg.id, cfg);
-  for (const id of accounts.keys())
-    startInbound(clientFor(id)).catch((err: unknown) => {
-      process.stderr.write(`whatsapp[${id}] inbound failed: ${errMsg(err)}\n`);
-    });
-  process.stderr.write(
-    `whatsapp train ready (inbound+outbound) — ${accounts.size} account(s): ${[...accounts.keys()].join(', ')}\n`,
-  );
-}
-
-boot();
-
-export { clients, accounts, clientFor, accountFor, lineOf, targetOf };
+runClientTrain({ station: 'whatsapp', accounts, loadAccounts, createClient, startInbound, makeHandleCall, disconnectClient: (client) => client.disconnect() });

package/runtime/node_modules/@metro-labs/whatsapp/src/keys.ts

@@ -1,4 +1,4 @@
-import { TrainError } from '@metro-labs/mcp/train-error';
+import { TrainError } from '@metro-labs/core/train-error';
 import type { WAMessageKey } from 'baileys';
 import { isGroupJid } from './parse.js';
 

package/runtime/node_modules/@metro-labs/whatsapp/src/login.ts

@@ -4,7 +4,7 @@ import makeWASocket, {
   fetchLatestWaWebVersion,
   type WASocket,
 } from 'baileys';
-import { errMsg, log } from '@metro-labs/mcp/log';
+import { errMsg, log } from '@metro-labs/core/log';
 import { inMemoryAuthState } from './auth-state.js';
 
 export class WhatsappLoginError extends Error {}

package/runtime/node_modules/@metro-labs/whatsapp/src/media.ts

@@ -1,5 +1,5 @@
 import type { proto } from 'baileys';
-import { extFromMime } from '@metro-labs/mcp/stations/attachments';
+import { extFromMime } from '@metro-labs/core/stations/attachments';
 
 export type WAMediaKind =
   | 'image'

package/runtime/node_modules/@metro-labs/whatsapp/src/members.ts

@@ -0,0 +1,94 @@
+import { getBinaryNodeChild, type BinaryNode, type GroupParticipant } from 'baileys';
+import { extractGroupMetadata } from 'baileys/lib/Socket/groups.js';
+import { TrainError } from '@metro-labs/core/train-error';
+import { isRecord } from '@metro-labs/core/is-record';
+import type { MemberCapability, MemberList, MetroMember } from '@metro-labs/core/stations/types';
+import { isGroupJid } from './parse.js';
+import { phoneOf, type NameBook } from './names.js';
+
+interface WhatsAppMember extends MetroMember {
+  lid?: string;
+  phoneNumber?: string;
+}
+
+function memberName(p: GroupParticipant, names: NameBook): string | undefined {
+  return names.get(p.id) ?? p.name ?? p.notify
+    ?? (p.lid ? names.get(p.lid) : undefined)
+    ?? (p.phoneNumber ? names.get(p.phoneNumber) : undefined);
+}
+
+function memberRole(p: GroupParticipant): string | undefined {
+  return p.admin ?? (p.isSuperAdmin ? 'superadmin' : p.isAdmin ? 'admin' : undefined);
+}
+
+function memberOf(p: GroupParticipant, names: NameBook): WhatsAppMember {
+  const lid = p.id.endsWith('@lid') ? p.id : p.lid;
+  const phoneNumber = p.id.endsWith('@s.whatsapp.net') ? p.id : p.phoneNumber;
+  const displayName = memberName(p, names);
+  const address = phoneOf(phoneNumber);
+  const role = memberRole(p);
+  return {
+    id: p.id,
+    ...(displayName ? { display_name: displayName } : {}),
+    ...(lid ? { lid } : {}),
+    ...(phoneNumber ? { phoneNumber } : {}),
+    ...(address ? { address } : {}),
+    roles: role ? [role] : [],
+    is_admin: role === 'admin' || role === 'superadmin',
+  };
+}
+
+function memberLimit(limit: number | undefined): number {
+  if (limit === undefined) return 200;
+  if (!Number.isFinite(limit) || limit < 1 || !Number.isInteger(limit))
+    throw new TrainError('bad_request', 'limit must be a positive integer');
+  return Math.min(limit, 1000);
+}
+
+function binaryNode(value: unknown): value is BinaryNode {
+  if (!isRecord(value) || typeof value.tag !== 'string' || !isRecord(value.attrs)) return false;
+  if (!Object.values(value.attrs).every((attr) => typeof attr === 'string')) return false;
+  const content = value.content;
+  return content === undefined || typeof content === 'string' || content instanceof Uint8Array
+    || (Array.isArray(content) && content.every(binaryNode));
+}
+
+function memberTotal(response: BinaryNode): number | undefined {
+  const value = getBinaryNodeChild(response, 'group')?.attrs.size;
+  if (!value || !/^\d+$/.test(value)) return undefined;
+  const size = Number(value);
+  return Number.isSafeInteger(size) ? size : undefined;
+}
+
+function capability(total: number | undefined, fetched: number, returned: number): MemberCapability {
+  const complete = total !== undefined && total === fetched && returned === total;
+  const reason = returned < fetched ? 'Member list was limited; increase limit up to 1000'
+    : total === undefined ? 'WhatsApp did not report a total member count'
+      : total !== fetched ? 'WhatsApp returned a partial member list' : undefined;
+  return { supported: true, complete, ...(total === undefined ? {} : { total }), ...(reason ? { reason } : {}) };
+}
+
+export async function listMembers(
+  jid: string,
+  query: (node: BinaryNode) => Promise<unknown>,
+  names: NameBook,
+  limit?: number,
+): Promise<MemberList> {
+  const cap = memberLimit(limit);
+  if (!isGroupJid(jid)) return {
+    members: [],
+    capability: { supported: false, complete: false, reason: 'WhatsApp member lookup requires a group line (@g.us)' },
+  };
+  const response = await query({
+    tag: 'iq', attrs: { type: 'get', xmlns: 'w:g2', to: jid },
+    content: [{ tag: 'query', attrs: { request: 'interactive' } }],
+  });
+  if (!binaryNode(response)) throw new TrainError('whatsapp_call', 'WhatsApp returned invalid group metadata');
+  const group = extractGroupMetadata(response);
+  const participants = [...new Map(group.participants.map((p) => [p.id, p])).values()];
+  const members = participants.slice(0, cap).map((p) => memberOf(p, names));
+  return {
+    members,
+    capability: capability(memberTotal(response), participants.length, members.length),
+  };
+}

package/runtime/node_modules/@metro-labs/whatsapp/src/messages.ts

@@ -0,0 +1,70 @@
+import { jidNormalizedUser, type Contact, type WASocket } from 'baileys';
+import { bindAppState, noteHistoryContact } from './app-state.js';
+import type { InboundHandlers } from './client-types.js';
+import type { History } from './history.js';
+import type { KeyCache } from './keys.js';
+import { noteContact, type NameBook } from './names.js';
+import { toInbound, toReaction, type SelfRef } from './parse.js';
+
+interface MessageHooks {
+  accountId: string;
+  keys: KeyCache;
+  names: NameBook;
+  history: History;
+  current(): boolean;
+  handlers(): InboundHandlers | undefined;
+  self(): SelfRef;
+}
+
+export function bindMessages(sock: Pick<WASocket, 'ev' | 'user'>, hooks: MessageHooks): void {
+  const selfJid = (): string | undefined => sock.user?.id ? jidNormalizedUser(sock.user.id) : undefined;
+  const noteContacts = (contacts: Partial<Contact>[]): void => {
+    if (!hooks.current()) return;
+    for (const contact of contacts) {
+      noteContact(hooks.names, contact);
+      noteHistoryContact(hooks.history, contact);
+    }
+  };
+  bindAppState(sock.ev, hooks);
+  sock.ev.on('messages.upsert', ({ messages, type }) => {
+    if (!hooks.current()) return;
+    for (const m of messages) hooks.keys.remember(m.key);
+    hooks.history.ingest(messages, selfJid());
+    const handlers = hooks.handlers();
+    if (type !== 'notify' || !handlers) return;
+    for (const m of messages) {
+      if (m.key.fromMe) continue;
+      const inbound = toInbound(hooks.accountId, m, hooks.self());
+      if (!inbound) continue;
+      hooks.names.note(inbound.senderJid, inbound.pushName);
+      handlers.onMessage(inbound, m);
+    }
+  });
+  sock.ev.on('contacts.upsert', noteContacts);
+  sock.ev.on('contacts.update', noteContacts);
+  sock.ev.on('messaging-history.set', ({ contacts, messages, lidPnMappings }) => {
+    if (!hooks.current()) return;
+    noteContacts(contacts);
+    for (const { pn, lid } of lidPnMappings ?? []) hooks.history.alias(pn, lid);
+    for (const m of messages) {
+      hooks.keys.remember(m.key);
+      if (m.key.fromMe !== true) hooks.names.note(m.key.participant ?? m.key.remoteJid, m.pushName);
+    }
+    hooks.history.ingest(messages, selfJid());
+  });
+  sock.ev.on('messages.update', (updates) => {
+    if (hooks.current()) hooks.history.update(updates, selfJid());
+  });
+  sock.ev.on('messages.delete', (event) => {
+    if (hooks.current()) hooks.history.deleteMessages(event);
+  });
+  sock.ev.on('messages.reaction', (events) => {
+    if (!hooks.current()) return;
+    const handlers = hooks.handlers();
+    if (!handlers) return;
+    for (const event of events) {
+      const reaction = toReaction(hooks.accountId, event);
+      if (reaction) handlers.onReaction(reaction);
+    }
+  });
+}

package/runtime/node_modules/@metro-labs/whatsapp/src/names.ts

@@ -0,0 +1,75 @@
+import { readFileSync } from 'node:fs';
+import { accountFiles } from '@metro-labs/core/stations/account-files';
+import { writeSecure } from '@metro-labs/core/secure-fs';
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg } from '@metro-labs/core/log';
+
+const MAX_NAMES = 2000;
+const SAVE_DELAY_MS = 2000;
+
+export const nameFiles = accountFiles('WHATSAPP_TOKEN_DIR', 'whatsapp-names-');
+
+export interface NameBook {
+  note(jid: string | null | undefined, name: string | null | undefined): void;
+  get(jid: string): string | undefined;
+}
+
+function loaded(file: string | undefined): Map<string, string> {
+  if (file === undefined) return new Map();
+  try {
+    const raw: unknown = JSON.parse(readFileSync(file, 'utf8'));
+    if (!isRecord(raw)) return new Map();
+    return new Map(Object.entries(raw).filter((e): e is [string, string] => typeof e[1] === 'string' && e[1] !== ''));
+  } catch {
+    return new Map();
+  }
+}
+
+export function makeNameBook(file?: string): NameBook {
+  const names = loaded(file);
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  const save = (): void => {
+    timer = null;
+    if (file === undefined) return;
+    try {
+      writeSecure(file, JSON.stringify(Object.fromEntries(names)));
+    } catch (err) {
+      process.stderr.write(`whatsapp: could not save the names: ${errMsg(err)}\n`);
+    }
+  };
+  return {
+    note(jid, name) {
+      const clean = name?.trim() ?? '';
+      if (!jid || clean === '' || names.get(jid) === clean) return;
+      names.delete(jid);
+      names.set(jid, clean);
+      if (names.size > MAX_NAMES) {
+        const oldest = names.keys().next().value;
+        if (oldest !== undefined) names.delete(oldest);
+      }
+      if (file !== undefined && timer === null) {
+        timer = setTimeout(save, SAVE_DELAY_MS);
+        timer.unref();
+      }
+    },
+    get: (jid) => names.get(jid),
+  };
+}
+
+export interface ContactNames {
+  id?: string | null;
+  lid?: string | null;
+  phoneNumber?: string | null;
+  name?: string | null;
+  notify?: string | null;
+}
+
+export function noteContact(book: NameBook, c: ContactNames): void {
+  const name = c.name ?? c.notify;
+  for (const jid of [c.id, c.lid, c.phoneNumber]) book.note(jid, name);
+}
+
+export const phoneOf = (jid: string | null | undefined): string | undefined => {
+  const digits = /^(\d{6,})(?::\d+)?@s\.whatsapp\.net$/.exec(jid ?? '')?.[1];
+  return digits === undefined ? undefined : `+${digits}`;
+};

package/runtime/node_modules/@metro-labs/whatsapp/src/parse.ts

@@ -80,9 +80,52 @@ function senderJidOf(key: WAMessageKey, chatJid: string): string {
   return chatJid;
 }
 
+export interface SelfRef {
+  jids: ReadonlySet<string>;
+  sentByMe: (chatJid: string, id: string) => boolean;
+}
+
+const QUOTING_NODES = [
+  'extendedTextMessage',
+  'imageMessage',
+  'videoMessage',
+  'documentMessage',
+  'audioMessage',
+  'stickerMessage',
+] as const;
+
+function contextInfoOf(inner: proto.IMessage): proto.IContextInfo | undefined {
+  for (const node of QUOTING_NODES) {
+    const ctx = inner[node]?.contextInfo;
+    if (ctx) return ctx;
+  }
+  return undefined;
+}
+
+function quoteFacts(ctx: proto.IContextInfo, replyTo: string | undefined, chatJid: string, self: SelfRef): Addressing {
+  const quotedBy = typeof ctx.participant === 'string' ? ctx.participant : '';
+  const mentioned = (ctx.mentionedJid ?? []).some((jid) => self.jids.has(jid));
+  const replyToSelf = replyTo !== undefined && (self.jids.has(quotedBy) || self.sentByMe(chatJid, replyTo));
+  return {
+    ...(mentioned ? { mentionsSelf: true } : {}),
+    ...(replyToSelf ? { replyToSelf: true } : {}),
+  };
+}
+
+type Addressing = Pick<InboundMessage, 'replyTo' | 'mentionsSelf' | 'replyToSelf'>;
+
+function addressing(inner: proto.IMessage, chatJid: string, self: SelfRef | undefined): Addressing {
+  const ctx = contextInfoOf(inner);
+  if (ctx === undefined) return {};
+  const replyTo = typeof ctx.stanzaId === 'string' && ctx.stanzaId !== '' ? ctx.stanzaId : undefined;
+  const base: Addressing = replyTo === undefined ? {} : { replyTo };
+  return self === undefined ? base : { ...base, ...quoteFacts(ctx, replyTo, chatJid, self) };
+}
+
 export function toInbound(
   accountId: string,
   m: WAMessage,
+  self?: SelfRef,
 ): InboundMessage | undefined {
   const chatJid = m.key.remoteJid;
   const messageId = m.key.id;
@@ -102,6 +145,7 @@ export function toInbound(
     isPrivate: isPrivateJid(chatJid),
     ...(m.pushName ? { pushName: m.pushName } : {}),
     ...(media ? { media } : {}),
+    ...addressing(inner, chatJid, self),
   };
 }
 

package/runtime/node_modules/@metro-labs/whatsapp/src/resolve.ts

@@ -0,0 +1,52 @@
+import { TrainError } from '@metro-labs/core/train-error';
+
+const INTERNATIONAL = /^[1-9]\d{5,17}$/;
+
+export interface SenderFound {
+  exists: boolean;
+  jid: string | null;
+  lid: string | null;
+}
+
+export interface SenderLookup extends SenderFound {
+  query: string;
+  number: string;
+  id: string | null;
+}
+
+function refuse(query: string, why: string): never {
+  throw new TrainError('bad_request', `'${query}' ${why}`);
+}
+
+function international(query: string, digits: string): string {
+  if (digits.startsWith('00')) return digits.slice(2);
+  if (digits.startsWith('0'))
+    refuse(
+      query,
+      'is a national number, so metro cannot tell which country it is in; write it in full international form, as in 41791234567 for a Swiss 079 123 45 67',
+    );
+  return digits;
+}
+
+export function phoneNumberOf(raw: string): string {
+  const query = raw.trim();
+  if (query.toLowerCase().endsWith('@lid'))
+    refuse(query, 'is already a sender id, so add it directly instead of looking it up');
+  const local = query.split('@')[0] ?? '';
+  const digits = local.replace(/\D/g, '');
+  const number = local.startsWith('+') ? digits : international(query, digits);
+  if (!INTERNATIONAL.test(number))
+    refuse(query, 'is not a phone number metro can look up; write it in full international form, as in 41791234567');
+  return number;
+}
+
+export function senderLookup(query: string, number: string, found: SenderFound): SenderLookup {
+  return {
+    query: query.trim(),
+    number,
+    exists: found.exists,
+    jid: found.jid,
+    lid: found.lid,
+    id: found.lid ?? found.jid,
+  };
+}

package/runtime/node_modules/@metro-labs/whatsapp/src/send-expiry.ts

@@ -0,0 +1,65 @@
+import type { ChatUpdate, WASocket } from 'baileys';
+import { errMsg, log } from '@metro-labs/core/log';
+import { isGroupJid, isPrivateJid } from './parse.js';
+
+const MAX_CHATS = 2000;
+type Content = Parameters<WASocket['sendMessage']>[1];
+interface Setting { duration: number; at: number }
+
+function duration(value: number | undefined): number | undefined {
+  return value !== undefined && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+
+function setting(chat: ChatUpdate): Setting | undefined {
+  if (!Object.hasOwn(chat, 'ephemeralExpiration')) return undefined;
+  const seconds = duration(chat.ephemeralExpiration === null ? 0 : chat.ephemeralExpiration);
+  const timestamp = chat.ephemeralSettingTimestamp;
+  const at = typeof timestamp === 'number' ? timestamp : timestamp?.toNumber();
+  if (seconds === undefined || at === undefined || !Number.isSafeInteger(at) || at <= 0) return undefined;
+  return { duration: seconds, at };
+}
+
+export class SendExpiry {
+  private readonly chats = new Map<string, Setting>();
+
+  constructor(private readonly accountId: string) {}
+
+  private note(chat: ChatUpdate): void {
+    if (!chat.id || !isPrivateJid(chat.id)) return;
+    const next = setting(chat);
+    if (!next) return;
+    const known = this.chats.get(chat.id);
+    if (known && known.at > next.at) return;
+    this.chats.delete(chat.id);
+    this.chats.set(chat.id, next);
+    if (this.chats.size > MAX_CHATS) {
+      const oldest = this.chats.keys().next().value;
+      if (oldest !== undefined) this.chats.delete(oldest);
+    }
+  }
+
+  bind(sock: WASocket, current: () => boolean): void {
+    this.chats.clear();
+    const note = (chats: readonly ChatUpdate[]): void => {
+      if (current()) for (const chat of chats) this.note(chat);
+    };
+    sock.ev.on('chats.upsert', note);
+    sock.ev.on('chats.update', note);
+    sock.ev.on('messaging-history.set', ({ chats }) => { note(chats); });
+    sock.ev.on('chats.delete', (jids) => {
+      if (current()) for (const jid of jids) this.chats.delete(jid);
+    });
+  }
+
+  async forSend(sock: WASocket, jid: string, content: Content): Promise<number | undefined> {
+    if ('edit' in content || 'delete' in content || 'react' in content) return undefined;
+    if (!isGroupJid(jid)) return this.chats.get(jid)?.duration;
+    try {
+      const group = await sock.groupMetadata(jid);
+      return duration(group.ephemeralDuration ?? 0);
+    } catch (err) {
+      log.warn({ accountId: this.accountId, err: errMsg(err) }, 'whatsapp: send expiry unknown; local history may omit the message');
+      return undefined;
+    }
+  }
+}

package/runtime/node_modules/@metro-labs/whatsapp/src/station.ts

@@ -1,17 +1,40 @@
-import type { Station, Verb } from '@metro-labs/mcp/stations/types';
+import type { Station, Verb } from '@metro-labs/core/stations/types';
+import { PROFILE_FIELDS, type ProfileField } from '@metro-labs/core/stations/profile';
+import { tokenFiles } from './token-store.js';
+import { nameFiles } from './names.js';
+import { historyFiles } from './history-files.js';
+import { channelFiles } from './channel-chats.js';
 
 export const whatsappStation: Station = {
   name: 'whatsapp',
   hasAccounts: true,
   hasTrain: true,
   messageVerbs: new Set<Verb>([
+    'read',
     'send',
     'reply',
     'react',
     'unreact',
     'edit',
     'delete',
+    'typing',
   ]),
   attachmentMode: 'canonical',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
+  resolvesSenders: true,
+  discoversChannels: true,
+  forget: (accountId) => {
+    tokenFiles.forget(accountId);
+    nameFiles.forget(accountId);
+    historyFiles.forget(accountId);
+    channelFiles.forget(accountId);
+  },
+  forgetExcept: (kept) => {
+    tokenFiles.forgetExcept(kept);
+    nameFiles.forgetExcept(kept);
+    historyFiles.forgetExcept(kept);
+    channelFiles.forgetExcept(kept);
+  },
   tools: [],
 };

package/runtime/node_modules/@metro-labs/whatsapp/src/token-store.ts

@@ -1,7 +1,6 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { readJson, writeSecure } from '@metro-labs/mcp/secure-fs';
-import { errMsg } from '@metro-labs/mcp/log';
+import { readJson, writeSecure } from '@metro-labs/core/secure-fs';
+import { accountFiles } from '@metro-labs/core/stations/account-files';
+import { errMsg } from '@metro-labs/core/log';
 
 export const PERSISTED_KEY_TYPES = ['tctoken', 'lid-mapping'] as const;
 
@@ -14,12 +13,9 @@ const WRITE_DEBOUNCE_MS = 1000;
 export const isPersistedKeyType = (type: string): boolean =>
   PERSISTED.has(type);
 
-const safeSegment = (s: string): string => s.replace(/[^A-Za-z0-9_-]/g, '_');
+export const tokenFiles = accountFiles('WHATSAPP_TOKEN_DIR', 'whatsapp-tokens-');
 
-export function tokenStorePath(accountId: string): string {
-  const dir = process.env.WHATSAPP_TOKEN_DIR ?? join(homedir(), '.metro');
-  return join(dir, `whatsapp-tokens-${safeSegment(accountId)}.json`);
-}
+export const tokenStorePath = (accountId: string): string => tokenFiles.path(accountId);
 
 export function persistedSubset(table: KeyTable): KeyTable {
   const out: KeyTable = {};

package/runtime/node_modules/@metro-labs/whatsapp/src/types.ts

@@ -1,6 +1,5 @@
 export interface WhatsAppAccount {
   id: string;
   phone: string;
-  owner?: string;
   credentials?: unknown;
 }

package/runtime/node_modules/@metro-labs/xmtp/package.json

@@ -13,18 +13,19 @@
     "test": "tsc --noEmit && DYLD_FALLBACK_LIBRARY_PATH=/usr/lib bun test test/"
   },
   "dependencies": {
-    "@metro-labs/mcp": "workspace:*",
+    "@metro-labs/core": "workspace:*",
     "@xmtp/content-type-primitives": "^3.0.1",
     "@xmtp/content-type-reaction": "^2.0.2",
     "@xmtp/content-type-remote-attachment": "^2.0.4",
     "@xmtp/content-type-reply": "^2.0.3",
-    "@xmtp/content-type-wallet-send-calls": "^2.0.0",
     "@xmtp/node-bindings": "1.9.1",
     "@xmtp/node-sdk": "^6.0.0",
+    "@zerodev/ecdsa-validator": "5.4.9",
+    "@zerodev/sdk": "5.5.10",
     "viem": "^2.52.2"
   },
   "devDependencies": {
-    "@stage-labs/config": "0.1.0-beta.2",
+    "@stage-labs/config": "0.1.0-beta.3",
     "eslint": "^10.3.0",
     "knip": "^6.15.0",
     "madge": "^8.0.0",

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

@@ -7,36 +7,25 @@ import { homedir } from 'node:os';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { CODECS } from './codecs.js';
-import { expandHome, signerFor, XMTP_ENV } from './identity.js';
+import { expandHome, identityFor, XMTP_ENV } from './identity.js';
+import type { SmartAccount } from './smart.js';
 import {
   makeAccountStore,
   resolveAccountId,
-} from '@metro-labs/mcp/stations/account-store';
-import { Line } from '@metro-labs/mcp/lines';
-
-const ACCOUNTS_FILE =
-  process.env.XMTP_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'xmtp-accounts.json');
+} from '@metro-labs/core/stations/account-store';
+import { Line } from '@metro-labs/core/lines';
 
 export interface AccountConfig {
   id: string;
   privateKey?: string;
-  owner?: string;
   dbPath?: string;
+  smart?: boolean;
 }
 
 export const { loadAccounts } = makeAccountStore<AccountConfig>({
   prefix: 'xmtp',
-  file: ACCOUNTS_FILE,
-  allowlistEnv: ['XMTP_ONLY_ACCOUNTS', 'XMTP_ACCOUNTS'],
   validate(raw, die) {
-    const seen = new Set<string>();
-    for (const a of raw) {
-      if (!a.id) die('account missing id');
-      if (!a.privateKey) die(`account '${a.id}' needs a privateKey`);
-      if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
-      seen.add(a.id);
-    }
+    for (const a of raw) if (!a.privateKey) die(`account '${a.id}' needs a privateKey`);
   },
 });
 
@@ -51,25 +40,26 @@ export interface Account {
   client: Client<unknown>;
   inboxId: string;
   address: string;
+  smart: SmartAccount | null;
 }
 export const accounts = new Map<string, Account>();
 
 export async function bootAccount(cfg: AccountConfig): Promise<void> {
-  const { signer, address } = signerFor(resolvePrivateKey(cfg));
+  const { signer, address, smart } = await identityFor(resolvePrivateKey(cfg), cfg.smart === true);
   const dbPath = expandHome(
     cfg.dbPath ?? join(homedir(), '.metro', `xmtp-${XMTP_ENV}-${cfg.id}.db3`),
   );
   const fresh = !existsSync(dbPath);
   const options: ClientOptions = { env: XMTP_ENV, codecs: CODECS(), dbPath };
   const client: Client<unknown> = await Client.create(signer, options);
-  accounts.set(cfg.id, { cfg, client, inboxId: client.inboxId, address });
+  accounts.set(cfg.id, { cfg, client, inboxId: client.inboxId, address, smart });
   if (fresh)
     process.stderr.write(
       `xmtp[${cfg.id}] registered a NEW installation for this machine — ` +
         'an inbox allows 10, and each machine you run metro on spends one\n',
     );
   process.stderr.write(
-    `xmtp[${cfg.id}] ready — inbox ${client.inboxId} (${address}, owner=${cfg.owner ?? '(broadcast)'})\n`,
+    `xmtp[${cfg.id}] ready — inbox ${client.inboxId} (${address})\n`,
   );
 }
 

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

@@ -1,6 +1,6 @@
-import { errMsg } from '@metro-labs/mcp/log';
+import { errMsg } from '@metro-labs/core/log';
 import { accountForCall, convOf, lineOf, type Account } from './accounts.js';
-import { respond } from './wire.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
 import type { GroupLike } from './labels.js';
 
 type Args = Record<string, unknown>;