@stage-labs/metro 0.1.0-beta.4 → 0.1.0-beta.41

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

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

@@ -0,0 +1,60 @@
+import type makeWASocket from 'baileys';
+
+type BaileysLogger = NonNullable<
+  NonNullable<Parameters<typeof makeWASocket>[0]>['logger']
+>;
+
+const MAX_DETAIL = 400;
+
+const LEVELS = ['trace', 'debug', 'info', 'warn', 'error'] as const;
+
+type Level = (typeof LEVELS)[number];
+
+const DEFAULT_LEVEL: Level = 'warn';
+
+const SILENT = 'silent';
+
+const oneLine = (s: string): string => s.replace(/\s+/g, ' ').trim();
+
+function logLevel(): Level | typeof SILENT {
+  const raw = process.env.METRO_WHATSAPP_LOG_LEVEL?.trim().toLowerCase();
+  if (raw === SILENT) return SILENT;
+  return LEVELS.find((l) => l === raw) ?? DEFAULT_LEVEL;
+}
+
+function detail(obj: unknown): string {
+  if (obj === undefined || obj === null) return '';
+  if (obj instanceof Error) return ` ${oneLine(obj.message)}`;
+  if (typeof obj === 'string') return ` ${oneLine(obj)}`;
+  try {
+    return ` ${oneLine(JSON.stringify(obj) ?? '').slice(0, MAX_DETAIL)}`;
+  } catch {
+    return '';
+  }
+}
+
+export function baileysLogger(accountId: string): BaileysLogger {
+  const level = logLevel();
+  const noop = (): void => undefined;
+  const write =
+    (at: Level) =>
+    (obj: unknown, msg?: string): void => {
+      process.stderr.write(
+        `whatsapp[${accountId}] baileys ${at}: ${oneLine(msg ?? '')}${detail(obj)}\n`,
+      );
+    };
+  const method = (at: Level): ((obj: unknown, msg?: string) => void) =>
+    level !== SILENT && LEVELS.indexOf(at) >= LEVELS.indexOf(level)
+      ? write(at)
+      : noop;
+  const logger: BaileysLogger = {
+    level,
+    child: () => logger,
+    trace: method('trace'),
+    debug: method('debug'),
+    info: method('info'),
+    warn: method('warn'),
+    error: method('error'),
+  };
+  return logger;
+}

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

@@ -0,0 +1,176 @@
+import makeWASocket, {
+  Browsers,
+  DisconnectReason,
+  fetchLatestWaWebVersion,
+  type WASocket,
+} from 'baileys';
+import { errMsg, log } from '@metro-labs/mcp/log';
+import { inMemoryAuthState } from './auth-state.js';
+
+export class WhatsappLoginError extends Error {}
+
+export interface WhatsappLoginEvents {
+  onQr: (qr: string) => void;
+  onPairingCode: (code: string) => void;
+  onPaired: (result: {
+    config: { phone: string; credentials: unknown };
+    identity: { phone: string };
+  }) => void;
+  onFailed: (message: string) => void;
+}
+
+const PHONE_RE = /^[0-9]{6,15}$/;
+const RESTART_REQUIRED = 515;
+const MAX_REOPENS = 6;
+
+export function normalizePhone(raw: unknown): string {
+  const phone = typeof raw === 'string' ? raw.replace(/[^0-9]/g, '') : '';
+  if (phone !== '' && !PHONE_RE.test(phone))
+    throw new WhatsappLoginError(
+      'phone must be an international number in digits, for example 447700900123',
+    );
+  return phone;
+}
+
+function closeReason(err: unknown): number | undefined {
+  return (err as { output?: { statusCode?: number } } | undefined)?.output
+    ?.statusCode;
+}
+
+export class WhatsappLogin {
+  private auth = inMemoryAuthState();
+  private sock: WASocket | null = null;
+  private pairingRequested = false;
+  private settled = false;
+  private reopens = 0;
+
+  constructor(
+    private phone: string,
+    private events: WhatsappLoginEvents,
+  ) {}
+
+  get mode(): 'pairing-code' | 'qr' {
+    return this.phone === '' ? 'qr' : 'pairing-code';
+  }
+
+  async start(): Promise<void> {
+    const { version, error } = await fetchLatestWaWebVersion({});
+    if (error)
+      throw new WhatsappLoginError(
+        'could not reach WhatsApp to start the pairing',
+      );
+    this.open(version);
+  }
+
+  private open(version: [number, number, number]): void {
+    if (this.settled) return;
+    const sock = makeWASocket({
+      version,
+      auth: this.auth.state,
+      browser: Browsers.macOS('Safari'),
+      markOnlineOnConnect: false,
+      syncFullHistory: false,
+      printQRInTerminal: false,
+    });
+    this.sock = sock;
+    sock.ev.on('connection.update', (update) => {
+      const { connection, qr, lastDisconnect } = update;
+      if (typeof qr === 'string') this.onQr(sock, qr);
+      if (connection === 'open') this.finish();
+      if (connection === 'close')
+        this.onClose(version, closeReason(lastDisconnect?.error));
+    });
+  }
+
+  private onQr(sock: WASocket, qr: string): void {
+    if (this.settled) return;
+    if (this.mode === 'qr') {
+      this.events.onQr(qr);
+      return;
+    }
+    if (this.pairingRequested || this.auth.state.creds.registered) return;
+    this.pairingRequested = true;
+    void sock
+      .requestPairingCode(this.phone)
+      .then((code) => {
+        if (!this.settled) this.events.onPairingCode(code);
+      })
+      .catch(() => {
+        this.fail('WhatsApp refused to issue a pairing code for that number');
+      });
+  }
+
+  private onClose(
+    version: [number, number, number],
+    statusCode: number | undefined,
+  ): void {
+    if (this.settled) return;
+    if (statusCode === DisconnectReason.loggedOut) {
+      this.fail('WhatsApp ended the pairing, start again');
+      return;
+    }
+    this.reopens += 1;
+    if (this.reopens > MAX_REOPENS && statusCode !== RESTART_REQUIRED) {
+      this.fail('WhatsApp kept dropping the pairing connection, start again');
+      return;
+    }
+    this.open(version);
+  }
+
+  private pairedPhone(): string {
+    const linked = this.auth.state.creds.me?.id.split(':')[0] ?? '';
+    return PHONE_RE.test(linked) ? linked : this.phone;
+  }
+
+  private finish(): void {
+    if (this.settled) return;
+    const phone = this.pairedPhone();
+    if (phone === '') {
+      this.fail(
+        'WhatsApp paired but did not say which number it linked, so Metro has nothing to store',
+      );
+      return;
+    }
+    const credentials = this.auth.serialize();
+    this.settled = true;
+    this.closeSocket()
+      .then(() => {
+        this.events.onPaired({
+          config: { phone, credentials },
+          identity: { phone },
+        });
+      })
+      .catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'whatsapp login: pairing report failed');
+      });
+  }
+
+  private fail(message: string): void {
+    if (this.settled) return;
+    this.settled = true;
+    this.closeSocket()
+      .then(() => {
+        this.events.onFailed(message);
+      })
+      .catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'whatsapp login: failure report failed');
+      });
+  }
+
+  private async closeSocket(): Promise<void> {
+    const sock = this.sock;
+    this.sock = null;
+    if (!sock) return;
+    try {
+      sock.ev.removeAllListeners('connection.update');
+      await sock.end(undefined);
+    } catch {
+      log.warn({}, 'whatsapp login: pairing socket did not close cleanly');
+    }
+  }
+
+  async cancel(): Promise<void> {
+    this.settled = true;
+    await this.closeSocket();
+  }
+}

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

@@ -0,0 +1,84 @@
+import type { proto } from 'baileys';
+import { extFromMime } from '@metro-labs/mcp/stations/attachments';
+
+export type WAMediaKind =
+  | 'image'
+  | 'video'
+  | 'voice'
+  | 'audio'
+  | 'document'
+  | 'sticker';
+
+export interface WAMediaRef {
+  kind: WAMediaKind;
+  mime?: string;
+  name?: string;
+  bytes?: number;
+}
+
+interface Long {
+  toNumber(): number;
+}
+
+interface MediaNode {
+  mimetype?: string | null;
+  fileName?: string | null;
+  fileLength?: number | Long | null;
+  ptt?: boolean | null;
+}
+
+const MEDIA_NODES: [keyof proto.IMessage, WAMediaKind][] = [
+  ['imageMessage', 'image'],
+  ['videoMessage', 'video'],
+  ['audioMessage', 'audio'],
+  ['documentMessage', 'document'],
+  ['stickerMessage', 'sticker'],
+];
+
+const EXT_BY_KIND: Record<WAMediaKind, string> = {
+  image: 'jpg',
+  video: 'mp4',
+  voice: 'ogg',
+  audio: 'mp3',
+  document: 'bin',
+  sticker: 'webp',
+};
+
+function toBytes(v: number | Long | null | undefined): number | undefined {
+  if (typeof v === 'number') return v;
+  if (v && typeof v.toNumber === 'function') return v.toNumber();
+  return undefined;
+}
+
+function baseMime(v: string | null | undefined): string | undefined {
+  const first = typeof v === 'string' ? (v.split(';')[0] ?? '').trim() : '';
+  return first || undefined;
+}
+
+function fallbackName(kind: WAMediaKind, mime: string | undefined): string {
+  const ext = extFromMime(mime) ?? EXT_BY_KIND[kind];
+  return kind === 'voice' ? `voice-message.${ext}` : `${kind}.${ext}`;
+}
+
+export function mediaRefIn(inner: proto.IMessage): WAMediaRef | undefined {
+  for (const [key, base] of MEDIA_NODES) {
+    const node = inner[key] as MediaNode | null | undefined;
+    if (!node) continue;
+    const kind = base === 'audio' && node.ptt === true ? 'voice' : base;
+    const mime = baseMime(node.mimetype);
+    const bytes = toBytes(node.fileLength);
+    return {
+      kind,
+      ...(mime ? { mime } : {}),
+      name: node.fileName ?? fallbackName(kind, mime),
+      ...(bytes === undefined ? {} : { bytes }),
+    };
+  }
+  return undefined;
+}
+
+export function mediaTag(ref: WAMediaRef | undefined): string | undefined {
+  if (!ref) return undefined;
+  if (ref.kind === 'document') return `[document: ${ref.name ?? 'document'}]`;
+  return `[${ref.kind}]`;
+}

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

@@ -0,0 +1,22 @@
+import type { Normalized } from '@metro-labs/mcp/stations/messaging-normalize';
+
+type Args = Record<string, unknown>;
+
+export function normalizeWhatsApp(action: string, env: Args): Normalized {
+  if (action === 'reply') {
+    return {
+      action: 'send',
+      args: {
+        line: env.line,
+        text: env.text,
+        replyTo: env.replyTo ?? env.messageId,
+        account: env.account,
+        attachments: env.attachments,
+      },
+    };
+  }
+  if (action === 'unreact') {
+    return { action: 'react', args: { ...env, emoji: '' } };
+  }
+  return { action, args: env };
+}