@stage-labs/metro 0.1.0-beta.13 → 0.1.0-beta.131

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

@@ -0,0 +1,57 @@
+import type { WAMessage } from 'baileys';
+import { errMsg } from '@metro-labs/core/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/core/train-error';
+import { errMsg } from '@metro-labs/core/log';
+import { readCalls } from '@metro-labs/core/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/core/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/core/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/core/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/core/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 };
+}

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

@@ -0,0 +1,38 @@
+import type { WAMessageKey, proto } from 'baileys';
+
+const MAX_TRACKED_SENDS = 256;
+
+export interface Outbox {
+  remember(
+    key: WAMessageKey | null | undefined,
+    message: proto.IMessage | null | undefined,
+  ): void;
+  lookup(key: WAMessageKey): proto.IMessage | undefined;
+}
+
+const slotOf = (jid: string, id: string): string => `${jid}|${id}`;
+
+export function makeOutbox(max: number = MAX_TRACKED_SENDS): Outbox {
+  const sent = new Map<string, proto.IMessage>();
+  return {
+    remember(key, message) {
+      const id = key?.id;
+      const jid = key?.remoteJid;
+      if (!id || !jid || !message || key?.fromMe !== true) return;
+      const slot = slotOf(jid, id);
+      sent.delete(slot);
+      sent.set(slot, message);
+      while (sent.size > max) {
+        const oldest = sent.keys().next().value;
+        if (oldest === undefined) break;
+        sent.delete(oldest);
+      }
+    },
+    lookup(key) {
+      const id = key.id;
+      const jid = key.remoteJid;
+      if (!id || !jid) return undefined;
+      return sent.get(slotOf(jid, id));
+    },
+  };
+}