@stage-labs/metro 0.1.0-beta.21 → 0.1.0-beta.211

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

@@ -11,7 +11,7 @@
     "test": "tsc --noEmit && bun test test/"
   },
   "dependencies": {
-    "@metro-labs/mcp": "workspace:*"
+    "@metro-labs/core": "workspace:*"
   },
   "devDependencies": {
     "@stage-labs/config": "0.1.0-beta.2",

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

@@ -1,11 +1,8 @@
 import { randomUUID } from 'node:crypto';
-import { Line, asLine } from '@metro-labs/mcp/lines';
-import { mintId, type MetroEvent } from '@metro-labs/mcp/events';
-import type { Endpoint } from '@metro-labs/mcp/endpoints';
-import type { Station, Verb } from '@metro-labs/mcp/stations/types';
-
-const sessionOwner = (sessionId: string): Line =>
-  asLine(`metro://session/${sessionId}`);
+import { Line } from '@metro-labs/core/lines';
+import { mintId, type MetroEvent } from '@metro-labs/core/events';
+import type { Endpoint } from '@metro-labs/core/endpoints';
+import type { Station, Verb } from '@metro-labs/core/stations/types';
 
 export const webhookStation: Station = {
   name: 'webhook',
@@ -31,7 +28,7 @@ export function webhookEntry(
     line,
     lineName: endpoint.label,
     from: line,
-    to: endpoint.session ? sessionOwner(endpoint.session) : line,
+    to: line,
     messageId:
       headers['x-github-delivery'] ?? headers['x-request-id'] ?? randomUUID(),
     text: `${headers['x-github-event'] ?? headers['x-intercom-topic'] ?? 'event'} ${method} ${url}`,

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

@@ -6,24 +6,21 @@
   "exports": {
     ".": "./src/station.ts",
     "./train": "./src/index.ts",
-    "./login": "./src/login.ts",
-    "./tokens": "./src/token-store.ts"
+    "./login": "./src/login.ts"
   },
   "scripts": {
     "build": "tsc",
     "test": "tsc --noEmit && bun test test/"
   },
   "dependencies": {
-    "@metro-labs/mcp": "workspace:*",
+    "@metro-labs/core": "workspace:*",
     "baileys": "7.0.0-rc14"
   },
   "devDependencies": {
     "@stage-labs/config": "0.1.0-beta.2",
-    "@types/qrcode-terminal": "^0.12.2",
     "eslint": "^10.3.0",
     "knip": "^6.15.0",
     "madge": "^8.0.0",
-    "qrcode-terminal": "^0.12.0",
     "typescript": "^5"
   }
 }

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

@@ -1,37 +1,21 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
 import {
   makeAccountStore,
   resolveAccountId,
   type Die,
-} from '@metro-labs/mcp/stations/account-store';
+} from '@metro-labs/core/stations/account-store';
 import type { WhatsAppAccount } from './types.js';
 
-const ACCOUNTS_FILE =
-  process.env.WHATSAPP_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'whatsapp-accounts.json');
-
 const isJid = (s: string): boolean => s.includes('@');
 
-function validateAccount(
-  a: WhatsAppAccount,
-  seen: Set<string>,
-  die: Die,
-): void {
-  if (!a.id) die('account missing id');
+function validateAccount(a: WhatsAppAccount, die: Die): void {
   if (!a.phone || typeof a.phone !== 'string')
     die(`account '${a.id}' missing phone`);
-  if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
-  seen.add(a.id);
 }
 
 export const { loadAccounts } = makeAccountStore<WhatsAppAccount>({
   prefix: 'whatsapp',
-  file: ACCOUNTS_FILE,
-  allowlistEnv: ['WHATSAPP_ONLY_ACCOUNTS', 'WHATSAPP_ACCOUNTS'],
   validate(raw, die) {
-    const seen = new Set<string>();
-    for (const a of raw) validateAccount(a, seen, die);
+    for (const a of raw) validateAccount(a, die);
   },
 });
 
@@ -50,18 +34,12 @@ interface Target {
   jid: string;
 }
 
-function splitScoped(path: string[]): { accountId: string; jid?: string } {
-  const first = path[0];
-  if (path.length >= 2 && first !== undefined && !isJid(first))
-    return { accountId: first, jid: path[1] };
-  return { accountId: 'default', jid: first };
-}
-
 export function targetOf(line: string): Target | undefined {
   const prefix = 'metro://whatsapp/';
   if (!line.startsWith(prefix)) return undefined;
   const path = line.slice(prefix.length).split('/').filter(Boolean);
-  const { accountId, jid } = splitScoped(path);
-  if (jid === undefined || !isJid(jid)) return undefined;
+  const [accountId, jid] = path;
+  if (path.length !== 2 || accountId === undefined || jid === undefined) return undefined;
+  if (!isJid(jid)) return undefined;
   return { accountId, jid };
 }

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

@@ -1,4 +1,4 @@
-import { TrainError } from '@metro-labs/mcp/train-error';
+import { TrainError } from '@metro-labs/core/train-error';
 import type { BinaryNode, WASocket } from 'baileys';
 
 const DEFAULT_ACK_WAIT_MS = 5000;

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

@@ -1,14 +1,16 @@
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { errMsg } from '@metro-labs/mcp/log';
-import { kindOf } from '@metro-labs/mcp/stations/attachments';
+import { TrainError } from '@metro-labs/core/train-error';
+import { errMsg } from '@metro-labs/core/log';
+import { kindOf } from '@metro-labs/core/stations/attachments';
 import {
   makeStation,
   respond,
   type CallMsg,
   type StationHandler,
-} from '@metro-labs/mcp/stations/station-runtime';
+} from '@metro-labs/core/stations/station-runtime';
+import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
 import { accountFor, accounts, targetOf } from './accounts.js';
-import { normalizeWhatsApp } from './normalize.js';
+import { phoneNumberOf, senderLookup } from './resolve.js';
+import { assertImage, fieldsOf, parseProfileChange, type ProfileApplied } from '@metro-labs/core/stations/profile';
 import type { WAClient } from './client.js';
 
 type Args = Record<string, unknown>;
@@ -48,8 +50,7 @@ async function guard<T>(run: () => Promise<T>): Promise<T> {
 
 interface WireAttachment {
   kind?: string;
-  path?: string;
-  url?: string;
+  path: string;
   mime?: string;
   name?: string;
 }
@@ -57,7 +58,7 @@ interface WireAttachment {
 function attachmentsOf(args: Args): WireAttachment[] {
   const raw = args.attachments;
   if (!Array.isArray(raw)) return [];
-  return (raw as WireAttachment[]).filter((a) => Boolean(a.path ?? a.url));
+  return (raw as Partial<WireAttachment>[]).filter((a): a is WireAttachment => Boolean(a.path));
 }
 
 async function sendMediaSet(
@@ -72,7 +73,7 @@ async function sendMediaSet(
   for (let i = 0; i < atts.length; i++) {
     const att = atts[i];
     if (!att) continue;
-    const path = att.path ?? att.url ?? '';
+    const path = att.path;
     const kind = att.kind ?? kindOf(att.mime ?? '', path);
     messageId = await guard(() =>
       client.sendMedia(
@@ -126,6 +127,14 @@ function makeReact(clientFor: ClientFor): StationHandler {
   };
 }
 
+function makeTyping(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, jid } = resolve(args, clientFor);
+    await guard(() => client.showTyping(jid));
+    respond(id, { result: { ok: true, account: accountId } });
+  };
+}
+
 function makeEdit(clientFor: ClientFor): StationHandler {
   return async (id, args) => {
     const { accountId, client, jid } = resolve(args, clientFor);
@@ -154,7 +163,6 @@ function makeAccounts(clientFor: ClientFor): StationHandler {
         handle: phone === null ? null : `+${phone}`,
         url: phone === null ? null : `https://wa.me/${phone}`,
         connected: phone !== null,
-        owner: a.owner ?? null,
       };
     });
     respond(id, { result: { accounts: list } });
@@ -162,6 +170,37 @@ function makeAccounts(clientFor: ClientFor): StationHandler {
   };
 }
 
+function makeResolveSender(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const query = str(args.query) ?? '';
+    const number = phoneNumberOf(query);
+    const found = await guard(() => clientFor(accountId).lookupSender(number));
+    respond(id, { result: { account: accountId, ...senderLookup(query, number, found) } });
+  };
+}
+
+function makeSetProfile(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const change = parseProfileChange(args);
+    if (change.avatar !== undefined) assertImage(change.avatar);
+    await guard(() => clientFor(accountId).setProfile(change));
+    const result: ProfileApplied = { account: accountId, applied: fieldsOf(change) };
+    respond(id, { result });
+  };
+}
+
+function makeProfile(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const user = str(args.user) ?? '';
+    if (user === '') throw new TrainError('whatsapp_user_required', 'profile needs the jid of the person', { retryable: false });
+    const profile = await guard(() => clientFor(accountId).senderProfile(user));
+    respond(id, { result: profile ?? { id: user } });
+  };
+}
+
 export function makeHandleCall(
   clientFor: ClientFor,
 ): (msg: CallMsg) => Promise<void> {
@@ -170,9 +209,13 @@ export function makeHandleCall(
       accounts: makeAccounts(clientFor),
       send: makeSend(clientFor),
       react: makeReact(clientFor),
+      typing: makeTyping(clientFor),
       edit: makeEdit(clientFor),
       delete: makeDelete(clientFor),
+      resolve_sender: makeResolveSender(clientFor),
+      set_profile: makeSetProfile(clientFor),
+      profile: makeProfile(clientFor),
     },
-    normalize: normalizeWhatsApp,
+    normalize: messagingAliases(),
   });
 }

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

@@ -3,8 +3,8 @@ import {
   assertAttachmentSize,
   saveStreamToCache,
   type SavedAttachment,
-} from '@metro-labs/mcp/stations/attachments';
-import { TrainError } from '@metro-labs/mcp/train-error';
+} from '@metro-labs/core/stations/attachments';
+import { TrainError } from '@metro-labs/core/train-error';
 import { baileysLogger } from './logger.js';
 import type { WAMediaRef } from './media.js';
 

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

@@ -8,7 +8,7 @@ import {
   type SignalDataTypeMap,
   type SignalKeyStore,
 } from 'baileys';
-import { TrainError } from '@metro-labs/mcp/train-error';
+import { TrainError } from '@metro-labs/core/train-error';
 import {
   isPersistedKeyType,
   tokenStoreFor,

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

@@ -1,4 +1,5 @@
 import makeWASocket, {
+  jidNormalizedUser,
   Browsers,
   DisconnectReason,
   fetchLatestWaWebVersion,
@@ -7,12 +8,16 @@ import makeWASocket, {
   type WAMessageKey,
   type WASocket,
 } from 'baileys';
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { errMsg } from '@metro-labs/mcp/log';
+import { TrainError } from '@metro-labs/core/train-error';
+import { errMsg } from '@metro-labs/core/log';
 import type { WhatsAppAccount } from './types.js';
 import type { InboundMessage, ReactionInput } from './format.js';
-import { toInbound, toReaction, type ReactionEvent } from './parse.js';
+import type { SenderFound } from './resolve.js';
+import type { ProfileChange } from '@metro-labs/core/stations/profile';
+import { makeProfileCache, nonEmpty, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import { toInbound, toReaction, type ReactionEvent, type SelfRef } from './parse.js';
 import { baileysLogger } from './logger.js';
+import { makeNameBook, nameFiles, noteContact, phoneOf, type NameBook } from './names.js';
 import { useAccountAuthState } from './auth-state.js';
 import { knownKey, makeKeyCache, targetKey, type KeyCache } from './keys.js';
 import { makeOutbox, type Outbox } from './outbox.js';
@@ -45,9 +50,13 @@ export interface WAClient {
   sendText(jid: string, text: string, quotedId?: string): Promise<string>;
   sendMedia(jid: string, media: WAMedia, quotedId?: string): Promise<string>;
   sendReaction(jid: string, messageId: string, emoji: string): Promise<void>;
+  showTyping(jid: string): Promise<void>;
   editMessage(jid: string, messageId: string, text: string): Promise<void>;
   deleteMessage(jid: string, messageId: string): Promise<void>;
   reuploadMedia(m: WAMessage): Promise<WAMessage>;
+  lookupSender(number: string): Promise<SenderFound>;
+  setProfile(change: ProfileChange): Promise<void>;
+  senderProfile(jid: string): Promise<SenderProfile | null>;
   disconnect(): Promise<void>;
 }
 
@@ -61,6 +70,7 @@ interface State {
   keys: KeyCache;
   outbox: Outbox;
   acks: AckWatch;
+  names: NameBook;
 }
 
 type SendOpts = Parameters<WASocket['sendMessage']>[2];
@@ -72,16 +82,35 @@ function resetGate(st: State): void {
   });
 }
 
+function selfRef(st: State, sock: WASocket): SelfRef {
+  const jids = new Set<string>();
+  const me = sock.user;
+  if (me?.id) jids.add(jidNormalizedUser(me.id));
+  if (me?.lid) jids.add(jidNormalizedUser(me.lid));
+  return { jids, sentByMe: (jid, id) => st.keys.lookup(jid, id)?.fromMe === true };
+}
+
 function bindInbound(st: State, sock: WASocket): void {
   sock.ev.on('messages.upsert', ({ messages, type }) => {
     for (const m of messages) st.keys.remember(m.key);
     if (type !== 'notify' || !st.handlers) return;
     for (const m of messages) {
       if (m.key.fromMe) continue;
-      const inbound = toInbound(st.account.id, m);
+      const inbound = toInbound(st.account.id, m, selfRef(st, sock));
+      if (inbound) st.names.note(inbound.senderJid, inbound.pushName);
       if (inbound) st.handlers.onMessage(inbound, m);
     }
   });
+  sock.ev.on('contacts.upsert', (contacts) => {
+    for (const c of contacts) noteContact(st.names, c);
+  });
+  sock.ev.on('contacts.update', (contacts) => {
+    for (const c of contacts) noteContact(st.names, c);
+  });
+  sock.ev.on('messaging-history.set', ({ contacts, messages }) => {
+    for (const c of contacts) noteContact(st.names, c);
+    for (const m of messages) if (m.key.fromMe !== true) st.names.note(m.key.participant ?? m.key.remoteJid, m.pushName);
+  });
   sock.ev.on('messages.reaction', (events: ReactionEvent[]) => {
     if (!st.handlers) return;
     for (const event of events) {
@@ -191,6 +220,17 @@ async function connect(st: State): Promise<void> {
   bindDelivery(st, sock);
 }
 
+async function lidFor(st: State, sock: WASocket, jid: string): Promise<string | null> {
+  try {
+    return await sock.signalRepository.lidMapping.getLIDForPN(jid);
+  } catch (e) {
+    process.stderr.write(
+      `whatsapp[${st.account.id}] no lid on file for ${jid}: ${errMsg(e)}\n`,
+    );
+    return null;
+  }
+}
+
 async function ready(st: State): Promise<WASocket> {
   await st.openPromise;
   if (!st.sock) throw new TrainError('whatsapp_call', 'socket not connected');
@@ -244,6 +284,22 @@ function mediaContent(m: WAMedia): SendContent {
   };
 }
 
+async function readProfile(st: State, jid: string): Promise<SenderProfile> {
+  const sock = await ready(st);
+  const [statuses, avatar] = await Promise.all([sock.fetchStatus(jid).catch(() => undefined), sock.profilePictureUrl(jid, 'image').catch(() => undefined)]);
+  const about = nonEmpty((statuses?.[0]?.status as { status?: unknown } | undefined)?.status);
+  const picture = nonEmpty(avatar);
+  const phone = phoneOf(jid.endsWith('@lid') ? await sock.signalRepository.lidMapping.getPNForLID(jid).catch(() => null) : jid);
+  const name = st.names.get(jid);
+  return {
+    id: jid,
+    ...(name === undefined ? {} : { display_name: name }),
+    ...(phone === undefined ? {} : { name: phone, address: phone }),
+    ...(about === undefined ? {} : { about }),
+    ...(picture === undefined ? {} : { avatar: picture }),
+  };
+}
+
 export function createClient(account: WhatsAppAccount): WAClient {
   const st: State = {
     account,
@@ -252,8 +308,12 @@ export function createClient(account: WhatsAppAccount): WAClient {
     keys: makeKeyCache(),
     outbox: makeOutbox(),
     acks: makeAckWatch(),
+    names: makeNameBook(nameFiles.path(account.id)),
   };
   resetGate(st);
+  const senders = makeProfileCache<SenderProfile>((jid) => readProfile(st, jid), {
+    onError: (jid, err) => process.stderr.write(`whatsapp[${st.account.id}] could not read the profile of ${jid}: ${errMsg(err)}\n`),
+  });
   return {
     account,
     self() {
@@ -287,6 +347,10 @@ export function createClient(account: WhatsAppAccount): WAClient {
         quotedId ? quotedOpts(st, jid, quotedId) : undefined,
       );
     },
+    async showTyping(jid) {
+      const sock = await ready(st);
+      await sock.sendPresenceUpdate('composing', jid);
+    },
     async sendReaction(jid, messageId, emoji) {
       const target = targetKey(st.keys, jid, messageId, 'react to');
       await send(st, jid, { react: { text: emoji, key: target } });
@@ -306,6 +370,24 @@ export function createClient(account: WhatsAppAccount): WAClient {
       const sock = await ready(st);
       return sock.updateMediaMessage(m);
     },
+    async lookupSender(number) {
+      const sock = await ready(st);
+      const found = (await sock.onWhatsApp(number))?.[0];
+      if (found?.exists !== true) return { exists: false, jid: null, lid: null };
+      const jid = jidNormalizedUser(found.jid);
+      return { exists: true, jid, lid: await lidFor(st, sock, jid) };
+    },
+    async setProfile(change) {
+      const sock = await ready(st);
+      if (change.name !== undefined) await sock.updateProfileName(change.name);
+      if (change.bio !== undefined) await sock.updateProfileStatus(change.bio);
+      if (change.avatar !== undefined) {
+        const me = sock.user?.id;
+        if (me === undefined) throw new TrainError('whatsapp_call', 'own jid unknown');
+        await sock.updateProfilePicture(me, { url: change.avatar.path });
+      }
+    },
+    senderProfile: (jid) => senders.get(jid),
     async disconnect() {
       st.closed = true;
       try {

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

@@ -1,6 +1,5 @@
-import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
 import { lineOf } from './accounts.js';
-import { mintId, SELF_URI } from './wire.js';
+import { mintId } from '@metro-labs/core/stations/station-runtime';
 import type { WAMediaRef } from './media.js';
 
 export interface InboundMessage {
@@ -13,6 +12,9 @@ export interface InboundMessage {
   isPrivate: boolean;
   pushName?: string;
   media?: WAMediaRef;
+  replyTo?: string;
+  mentionsSelf?: boolean;
+  replyToSelf?: boolean;
 }
 
 export interface ReactionInput {
@@ -38,7 +40,6 @@ function attachmentView(ref: WAMediaRef): Record<string, unknown> {
 
 export function envelope(m: InboundMessage): Record<string, unknown> {
   return {
-    kind: 'inbound',
     id: mintId(),
     ts: m.date.toISOString(),
     station: 'whatsapp',
@@ -48,6 +49,9 @@ export function envelope(m: InboundMessage): Record<string, unknown> {
     message_id: m.messageId,
     text: m.text,
     is_private: m.isPrivate,
+    ...(m.replyTo === undefined ? {} : { reply_to: m.replyTo, event: { type: 'reply', replyTo: m.replyTo } }),
+    ...(m.mentionsSelf === true ? { mentions_self: true } : {}),
+    ...(m.replyToSelf === true ? { reply_to_self: true } : {}),
     payload: {
       account: m.accountId,
       message_id: m.messageId,
@@ -56,63 +60,8 @@ export function envelope(m: InboundMessage): Record<string, unknown> {
   };
 }
 
-function mediaEvent(
-  m: InboundMessage,
-  text: string,
-  payload: Record<string, unknown>,
-): Record<string, unknown> {
-  return {
-    kind: 'inbound',
-    id: mintId(),
-    ts: new Date().toISOString(),
-    station: 'whatsapp',
-    line: lineOf(m.accountId, m.chatJid),
-    from: SELF_URI,
-    text,
-    payload: { account: m.accountId, ...payload },
-  };
-}
-
-export function attachmentSavedEnvelope(
-  m: InboundMessage,
-  sourceId: string,
-  ref: WAMediaRef,
-  saved: SavedAttachment,
-  index: number,
-): Record<string, unknown> {
-  return mediaEvent(m, `📎 saved: ${saved.path}`, {
-    contentType: 'attachmentSaved',
-    attachmentFor: sourceId,
-    index,
-    kind: ref.kind,
-    attachmentPath: saved.path,
-    localPath: saved.path,
-    mime: saved.mime,
-    name: saved.name,
-  });
-}
-
-export function attachmentFailedEnvelope(
-  m: InboundMessage,
-  sourceId: string,
-  ref: WAMediaRef,
-  index: number,
-  reason: string,
-): Record<string, unknown> {
-  return mediaEvent(m, `📎 not fetched: ${reason}`, {
-    contentType: 'attachmentFailed',
-    attachmentFor: sourceId,
-    index,
-    kind: ref.kind,
-    name: ref.name,
-    mime: ref.mime,
-    reason,
-  });
-}
-
 export function reactionEnvelope(r: ReactionInput): Record<string, unknown> {
   return {
-    kind: 'react',
     id: mintId(),
     ts: r.date.toISOString(),
     station: 'whatsapp',

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

@@ -1,9 +1,8 @@
 import type { WAMessage } from 'baileys';
-import { errMsg } from '@metro-labs/mcp/log';
-import { emit } from './wire.js';
+import { emit } from '@metro-labs/core/stations/station-runtime';
+import { reportAttachment } from '@metro-labs/core/stations/train-events';
+import { lineOf } from './accounts.js';
 import {
-  attachmentFailedEnvelope,
-  attachmentSavedEnvelope,
   envelope,
   reactionEnvelope,
   type InboundMessage,
@@ -11,31 +10,19 @@ import {
 import { saveWhatsAppMedia } from './attachments.js';
 import type { WAClient } from './client.js';
 
-async function saveMedia(
+function saveMedia(
   client: WAClient,
   m: InboundMessage,
   raw: WAMessage,
   sourceId: string,
-): Promise<void> {
+): void {
   const ref = m.media;
   if (!ref) return;
-  try {
-    const saved = await saveWhatsAppMedia(
-      m.accountId,
-      raw,
-      ref,
-      m.messageId,
-      0,
-      (msg) => client.reuploadMedia(msg),
-    );
-    emit(attachmentSavedEnvelope(m, sourceId, ref, saved, 0));
-  } catch (err) {
-    const reason = errMsg(err);
-    process.stderr.write(
-      `whatsapp[${m.accountId}] ${ref.kind} download failed for ${m.messageId}: ${reason}\n`,
-    );
-    emit(attachmentFailedEnvelope(m, sourceId, ref, 0, reason));
-  }
+  reportAttachment(
+    saveWhatsAppMedia(m.accountId, raw, ref, m.messageId, 0, (msg) => client.reuploadMedia(msg)),
+    { station: 'whatsapp', account: m.accountId, line: lineOf(m.accountId, m.chatJid), forId: sourceId, index: 0 },
+    { saved: { kind: ref.kind }, failed: { kind: ref.kind, name: ref.name, mime: ref.mime } },
+  );
 }
 
 export async function startInbound(client: WAClient): Promise<void> {
@@ -44,11 +31,7 @@ export async function startInbound(client: WAClient): Promise<void> {
       const env = envelope(m);
       emit(env);
       if (!m.media) return;
-      saveMedia(client, m, raw, String(env.id)).catch((err: unknown) => {
-        process.stderr.write(
-          `whatsapp[${m.accountId}] media event not emitted: ${errMsg(err)}\n`,
-        );
-      });
+      saveMedia(client, m, raw, String(env.id));
     },
     onReaction: (r) => {
       emit(reactionEnvelope(r));

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 });

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 {}