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

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

@@ -0,0 +1,318 @@
+import makeWASocket, {
+  Browsers,
+  DisconnectReason,
+  fetchLatestWaWebVersion,
+  type proto,
+  type WAMessage,
+  type WAMessageKey,
+  type WASocket,
+} from 'baileys';
+import { TrainError } from '@metro-labs/mcp/train-error';
+import { errMsg } from '@metro-labs/mcp/log';
+import type { WhatsAppAccount } from './types.js';
+import type { InboundMessage, ReactionInput } from './format.js';
+import { toInbound, toReaction, type ReactionEvent } from './parse.js';
+import { baileysLogger } from './logger.js';
+import { useAccountAuthState } from './auth-state.js';
+import { knownKey, makeKeyCache, targetKey, type KeyCache } from './keys.js';
+import { makeOutbox, type Outbox } from './outbox.js';
+import { deliveryNotes, describeNote } from './delivery.js';
+import {
+  ACK_WAIT_MS,
+  bindAcks,
+  makeAckWatch,
+  rejection,
+  type AckWatch,
+} from './ack.js';
+
+export interface InboundHandlers {
+  onMessage(m: InboundMessage, raw: WAMessage): void;
+  onReaction(r: ReactionInput): void;
+}
+
+export interface WAMedia {
+  kind: string;
+  path: string;
+  mime: string;
+  name: string;
+  caption?: string;
+}
+
+export interface WAClient {
+  account: WhatsAppAccount;
+  self(): string | null;
+  start(handlers: InboundHandlers): Promise<void>;
+  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>;
+  editMessage(jid: string, messageId: string, text: string): Promise<void>;
+  deleteMessage(jid: string, messageId: string): Promise<void>;
+  reuploadMedia(m: WAMessage): Promise<WAMessage>;
+  disconnect(): Promise<void>;
+}
+
+interface State {
+  account: WhatsAppAccount;
+  handlers?: InboundHandlers;
+  sock?: WASocket;
+  closed: boolean;
+  openResolve?: () => void;
+  openPromise: Promise<void>;
+  keys: KeyCache;
+  outbox: Outbox;
+  acks: AckWatch;
+}
+
+type SendOpts = Parameters<WASocket['sendMessage']>[2];
+type SendContent = Parameters<WASocket['sendMessage']>[1];
+
+function resetGate(st: State): void {
+  st.openPromise = new Promise<void>((resolve) => {
+    st.openResolve = resolve;
+  });
+}
+
+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);
+      if (inbound) st.handlers.onMessage(inbound, m);
+    }
+  });
+  sock.ev.on('messages.reaction', (events: ReactionEvent[]) => {
+    if (!st.handlers) return;
+    for (const event of events) {
+      const reaction = toReaction(st.account.id, event);
+      if (reaction) st.handlers.onReaction(reaction);
+    }
+  });
+}
+
+function bindDelivery(st: State, sock: WASocket): void {
+  sock.ev.on('messages.update', (updates) => {
+    for (const note of deliveryNotes(updates))
+      process.stderr.write(
+        `whatsapp[${st.account.id}] send ${note.messageId} to ${note.jid}: ${describeNote(note)}\n`,
+      );
+  });
+  bindAcks(sock, st.acks, (ack) => {
+    process.stderr.write(
+      `whatsapp[${st.account.id}] send ${ack.messageId} to ${ack.jid} REFUSED by WhatsApp: ack error ${ack.error ?? '?'}\n`,
+    );
+  });
+}
+
+function servedFromOutbox(
+  st: State,
+  key: WAMessageKey,
+): proto.IMessage | undefined {
+  const message = st.outbox.lookup(key);
+  if (key.fromMe === true)
+    process.stderr.write(
+      message
+        ? `whatsapp[${st.account.id}] asked to send ${key.id} to ${key.remoteJid} again — served from the outbox\n`
+        : `whatsapp[${st.account.id}] asked to send ${key.id} to ${key.remoteJid} again — NOT in the outbox, so that message can never arrive\n`,
+    );
+  return message;
+}
+
+const TERMINAL: Record<number, string> = {
+  [DisconnectReason.loggedOut]: ' — re-pair required',
+  [DisconnectReason.connectionReplaced]:
+    ' — another metro took this device; not reconnecting (two sockets on one ' +
+    'identity evict each other and risk a 463 timelock)',
+};
+
+export function terminalReason(code: number | undefined): string | undefined {
+  return code === undefined ? undefined : TERMINAL[code];
+}
+
+function onClose(st: State, code: number | undefined): void {
+  const terminal = terminalReason(code);
+  if (st.closed || terminal !== undefined) {
+    process.stderr.write(
+      `whatsapp[${st.account.id}] disconnected (code=${code ?? '?'})${terminal ?? ''}\n`,
+    );
+    return;
+  }
+  resetGate(st);
+  process.stderr.write(`whatsapp[${st.account.id}] reconnecting\n`);
+  void connect(st).catch((e: unknown) => {
+    process.stderr.write(
+      `whatsapp[${st.account.id}] reconnect failed: ${errMsg(e)}\n`,
+    );
+  });
+}
+
+function bindConnection(st: State, sock: WASocket): void {
+  sock.ev.on('connection.update', (update) => {
+    const { connection, lastDisconnect } = update;
+    if (connection === 'open') {
+      process.stderr.write(`whatsapp[${st.account.id}] connected\n`);
+      st.openResolve?.();
+      return;
+    }
+    if (connection !== 'close') return;
+    const code = (
+      lastDisconnect?.error as { output?: { statusCode?: number } } | undefined
+    )?.output?.statusCode;
+    onClose(st, code);
+  });
+}
+
+async function connect(st: State): Promise<void> {
+  const { state, saveCreds } = useAccountAuthState(
+    st.account.credentials,
+    st.account.id,
+  );
+  const { version, error } = await fetchLatestWaWebVersion({});
+  if (error) {
+    throw new TrainError(
+      'whatsapp_connect',
+      `failed to fetch WhatsApp web version: ${errMsg(error)}`,
+    );
+  }
+  const sock = makeWASocket({
+    version,
+    auth: state,
+    browser: Browsers.macOS('Safari'),
+    markOnlineOnConnect: false,
+    syncFullHistory: false,
+    logger: baileysLogger(st.account.id),
+    getMessage: (key) => Promise.resolve(servedFromOutbox(st, key)),
+  });
+  st.sock = sock;
+  sock.ev.on('creds.update', () => void saveCreds());
+  bindConnection(st, sock);
+  bindInbound(st, sock);
+  bindDelivery(st, sock);
+}
+
+async function ready(st: State): Promise<WASocket> {
+  await st.openPromise;
+  if (!st.sock) throw new TrainError('whatsapp_call', 'socket not connected');
+  return st.sock;
+}
+
+async function send(
+  st: State,
+  jid: string,
+  content: SendContent,
+  opts?: SendOpts,
+): Promise<string> {
+  const sock = await ready(st);
+  const sent = await sock.sendMessage(jid, content, opts);
+  st.keys.remember(sent?.key);
+  st.outbox.remember(sent?.key, sent?.message);
+  const messageId = sent?.key.id;
+  if (!messageId)
+    throw new TrainError(
+      'whatsapp_call',
+      `WhatsApp accepted no message for ${jid}, so there is nothing that can have arrived`,
+    );
+  const ack = await st.acks.wait(messageId, ACK_WAIT_MS);
+  const refused = ack ? rejection(ack) : undefined;
+  if (refused) throw refused;
+  return messageId;
+}
+
+function quotedOpts(st: State, jid: string, quotedId: string): SendOpts {
+  return {
+    quoted: {
+      key: knownKey(st.keys, jid, quotedId, false),
+      message: { conversation: '' },
+    },
+  };
+}
+
+function mediaContent(m: WAMedia): SendContent {
+  const source = { url: m.path };
+  const caption = m.caption ? { caption: m.caption } : {};
+  if (m.kind === 'image') return { image: source, ...caption };
+  if (m.kind === 'video')
+    return { video: source, mimetype: m.mime, ...caption };
+  if (m.kind === 'audio')
+    return { audio: source, mimetype: m.mime, ptt: false };
+  return {
+    document: source,
+    mimetype: m.mime,
+    fileName: m.name,
+    ...caption,
+  };
+}
+
+export function createClient(account: WhatsAppAccount): WAClient {
+  const st: State = {
+    account,
+    closed: false,
+    openPromise: Promise.resolve(),
+    keys: makeKeyCache(),
+    outbox: makeOutbox(),
+    acks: makeAckWatch(),
+  };
+  resetGate(st);
+  return {
+    account,
+    self() {
+      const jid = st.sock?.user?.id;
+      if (jid === undefined) return null;
+      return jid.split(':')[0]?.split('@')[0] ?? null;
+    },
+    async start(handlers) {
+      st.handlers = handlers;
+      try {
+        await connect(st);
+      } catch (e) {
+        process.stderr.write(
+          `whatsapp[${account.id}] connect failed: ${errMsg(e)}\n`,
+        );
+      }
+    },
+    sendText(jid, text, quotedId) {
+      return send(
+        st,
+        jid,
+        { text },
+        quotedId ? quotedOpts(st, jid, quotedId) : undefined,
+      );
+    },
+    sendMedia(jid, media, quotedId) {
+      return send(
+        st,
+        jid,
+        mediaContent(media),
+        quotedId ? quotedOpts(st, jid, quotedId) : undefined,
+      );
+    },
+    async sendReaction(jid, messageId, emoji) {
+      const target = targetKey(st.keys, jid, messageId, 'react to');
+      await send(st, jid, { react: { text: emoji, key: target } });
+    },
+    async editMessage(jid, messageId, text) {
+      await send(st, jid, {
+        text,
+        edit: knownKey(st.keys, jid, messageId, true),
+      });
+    },
+    async deleteMessage(jid, messageId) {
+      await send(st, jid, {
+        delete: knownKey(st.keys, jid, messageId, true),
+      });
+    },
+    async reuploadMedia(m) {
+      const sock = await ready(st);
+      return sock.updateMediaMessage(m);
+    },
+    async disconnect() {
+      st.closed = true;
+      try {
+        await st.sock?.end(undefined);
+      } catch {
+        st.sock = undefined;
+      }
+    },
+  };
+}

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

@@ -0,0 +1,49 @@
+import { proto, type WAMessageUpdate } from 'baileys';
+
+const STATUS_NAMES: Record<number, string> = {
+  [proto.WebMessageInfo.Status.ERROR]: 'error',
+  [proto.WebMessageInfo.Status.PENDING]: 'pending',
+  [proto.WebMessageInfo.Status.SERVER_ACK]: 'server-ack',
+  [proto.WebMessageInfo.Status.DELIVERY_ACK]: 'delivered',
+  [proto.WebMessageInfo.Status.READ]: 'read',
+  [proto.WebMessageInfo.Status.PLAYED]: 'played',
+};
+
+export interface DeliveryNote {
+  messageId: string;
+  jid: string;
+  status: string;
+  reachedRecipient: boolean;
+  reason?: string;
+}
+
+function reasonOf(params: unknown): string | undefined {
+  if (!Array.isArray(params)) return undefined;
+  const parts: string[] = [];
+  for (const part of params)
+    if (typeof part === 'string' && part.trim() !== '') parts.push(part.trim());
+  return parts.length ? parts.join(': ') : undefined;
+}
+
+export function deliveryNotes(updates: WAMessageUpdate[]): DeliveryNote[] {
+  const notes: DeliveryNote[] = [];
+  for (const { key, update } of updates) {
+    const status = update.status;
+    if (typeof status !== 'number' || key.fromMe !== true) continue;
+    const jid = key.remoteJid;
+    const messageId = key.id;
+    if (!jid || !messageId) continue;
+    const reason = reasonOf(update.messageStubParameters);
+    notes.push({
+      messageId,
+      jid,
+      status: STATUS_NAMES[status] ?? String(status),
+      reachedRecipient: status >= proto.WebMessageInfo.Status.DELIVERY_ACK,
+      ...(reason === undefined ? {} : { reason }),
+    });
+  }
+  return notes;
+}
+
+export const describeNote = (note: DeliveryNote): string =>
+  note.reason === undefined ? note.status : `${note.status} (${note.reason})`;

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

@@ -0,0 +1,132 @@
+import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
+import { lineOf } from './accounts.js';
+import { mintId, SELF_URI } from './wire.js';
+import type { WAMediaRef } from './media.js';
+
+export interface InboundMessage {
+  accountId: string;
+  chatJid: string;
+  senderJid: string;
+  messageId: string;
+  text: string;
+  date: Date;
+  isPrivate: boolean;
+  pushName?: string;
+  media?: WAMediaRef;
+}
+
+export interface ReactionInput {
+  accountId: string;
+  chatJid: string;
+  senderJid: string;
+  messageId: string;
+  emoji: string;
+  date: Date;
+  isPrivate: boolean;
+  pushName?: string;
+  removed?: boolean;
+}
+
+function attachmentView(ref: WAMediaRef): Record<string, unknown> {
+  return {
+    kind: ref.kind,
+    ...(ref.name ? { name: ref.name } : {}),
+    ...(ref.mime ? { mime: ref.mime } : {}),
+    ...(ref.bytes === undefined ? {} : { size: ref.bytes }),
+  };
+}
+
+export function envelope(m: InboundMessage): Record<string, unknown> {
+  return {
+    kind: 'inbound',
+    id: mintId(),
+    ts: m.date.toISOString(),
+    station: 'whatsapp',
+    line: lineOf(m.accountId, m.chatJid),
+    from: `metro://whatsapp/${m.accountId}/user/${m.senderJid}`,
+    ...(m.pushName ? { from_name: m.pushName, from_display_name: m.pushName } : {}),
+    message_id: m.messageId,
+    text: m.text,
+    is_private: m.isPrivate,
+    payload: {
+      account: m.accountId,
+      message_id: m.messageId,
+      ...(m.media ? { attachments: [attachmentView(m.media)] } : {}),
+    },
+  };
+}
+
+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',
+    line: lineOf(r.accountId, r.chatJid),
+    from: `metro://whatsapp/${r.accountId}/user/${r.senderJid}`,
+    ...(r.pushName ? { from_name: r.pushName } : {}),
+    message_id: r.messageId,
+    emoji: r.emoji,
+    event: { type: 'react', emoji: r.emoji, targetId: r.messageId },
+    is_private: r.isPrivate,
+    payload: {
+      account: r.accountId,
+      message_id: r.messageId,
+      removed: r.removed === true,
+    },
+  };
+}

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

@@ -0,0 +1,57 @@
+import type { WAMessage } from 'baileys';
+import { errMsg } from '@metro-labs/mcp/log';
+import { emit } from './wire.js';
+import {
+  attachmentFailedEnvelope,
+  attachmentSavedEnvelope,
+  envelope,
+  reactionEnvelope,
+  type InboundMessage,
+} from './format.js';
+import { saveWhatsAppMedia } from './attachments.js';
+import type { WAClient } from './client.js';
+
+async function saveMedia(
+  client: WAClient,
+  m: InboundMessage,
+  raw: WAMessage,
+  sourceId: string,
+): Promise<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));
+  }
+}
+
+export async function startInbound(client: WAClient): Promise<void> {
+  await client.start({
+    onMessage: (m, raw) => {
+      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`,
+        );
+      });
+    },
+    onReaction: (r) => {
+      emit(reactionEnvelope(r));
+    },
+  });
+}

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

@@ -0,0 +1,40 @@
+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 { 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 };

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

@@ -0,0 +1,59 @@
+import { TrainError } from '@metro-labs/mcp/train-error';
+import type { WAMessageKey } from 'baileys';
+import { isGroupJid } from './parse.js';
+
+const MAX_TRACKED_KEYS = 4000;
+
+export interface KeyCache {
+  remember(key: WAMessageKey | null | undefined): void;
+  lookup(jid: string, id: string): WAMessageKey | undefined;
+}
+
+const slotOf = (jid: string, id: string): string => `${jid}|${id}`;
+
+export function makeKeyCache(max: number = MAX_TRACKED_KEYS): KeyCache {
+  const seen = new Map<string, WAMessageKey>();
+  return {
+    remember(key) {
+      const id = key?.id;
+      const jid = key?.remoteJid;
+      if (!key || !id || !jid) return;
+      const slot = slotOf(jid, id);
+      seen.delete(slot);
+      seen.set(slot, key);
+      while (seen.size > max) {
+        const oldest = seen.keys().next().value;
+        if (oldest === undefined) break;
+        seen.delete(oldest);
+      }
+    },
+    lookup(jid, id) {
+      return seen.get(slotOf(jid, id));
+    },
+  };
+}
+
+export function knownKey(
+  cache: KeyCache,
+  jid: string,
+  id: string,
+  fromMe: boolean,
+): WAMessageKey {
+  return cache.lookup(jid, id) ?? { remoteJid: jid, id, fromMe };
+}
+
+export function targetKey(
+  cache: KeyCache,
+  jid: string,
+  id: string,
+  verb: string,
+): WAMessageKey {
+  const known = cache.lookup(jid, id);
+  if (known) return known;
+  if (isGroupJid(jid))
+    throw new TrainError(
+      'whatsapp_unknown_message',
+      `cannot ${verb} message '${id}' in group ${jid}: this connection never saw that message, so the group key naming its original sender cannot be built — WhatsApp would accept the send and display nothing`,
+    );
+  return { remoteJid: jid, id, fromMe: false };
+}