@stage-labs/metro 0.1.0-beta.26 → 0.1.0-beta.261

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

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/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/station.ts

@@ -1,4 +1,7 @@
-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';
 
 export const whatsappStation: Station = {
   name: 'whatsapp',
@@ -11,7 +14,19 @@ export const whatsappStation: Station = {
     'unreact',
     'edit',
     'delete',
+    'typing',
   ]),
   attachmentMode: 'canonical',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
+  resolvesSenders: true,
+  forget: (accountId) => {
+    tokenFiles.forget(accountId);
+    nameFiles.forget(accountId);
+  },
+  forgetExcept: (kept) => {
+    tokenFiles.forgetExcept(kept);
+    nameFiles.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",