@stage-labs/metro 0.1.0-beta.3 → 0.1.0-beta.300

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

@@ -0,0 +1,94 @@
+import { getBinaryNodeChild, type BinaryNode, type GroupParticipant } from 'baileys';
+import { extractGroupMetadata } from 'baileys/lib/Socket/groups.js';
+import { TrainError } from '@metro-labs/core/train-error';
+import { isRecord } from '@metro-labs/core/is-record';
+import type { MemberCapability, MemberList, MetroMember } from '@metro-labs/core/stations/types';
+import { isGroupJid } from './parse.js';
+import { phoneOf, type NameBook } from './names.js';
+
+interface WhatsAppMember extends MetroMember {
+  lid?: string;
+  phoneNumber?: string;
+}
+
+function memberName(p: GroupParticipant, names: NameBook): string | undefined {
+  return names.get(p.id) ?? p.name ?? p.notify
+    ?? (p.lid ? names.get(p.lid) : undefined)
+    ?? (p.phoneNumber ? names.get(p.phoneNumber) : undefined);
+}
+
+function memberRole(p: GroupParticipant): string | undefined {
+  return p.admin ?? (p.isSuperAdmin ? 'superadmin' : p.isAdmin ? 'admin' : undefined);
+}
+
+function memberOf(p: GroupParticipant, names: NameBook): WhatsAppMember {
+  const lid = p.id.endsWith('@lid') ? p.id : p.lid;
+  const phoneNumber = p.id.endsWith('@s.whatsapp.net') ? p.id : p.phoneNumber;
+  const displayName = memberName(p, names);
+  const address = phoneOf(phoneNumber);
+  const role = memberRole(p);
+  return {
+    id: p.id,
+    ...(displayName ? { display_name: displayName } : {}),
+    ...(lid ? { lid } : {}),
+    ...(phoneNumber ? { phoneNumber } : {}),
+    ...(address ? { address } : {}),
+    roles: role ? [role] : [],
+    is_admin: role === 'admin' || role === 'superadmin',
+  };
+}
+
+function memberLimit(limit: number | undefined): number {
+  if (limit === undefined) return 200;
+  if (!Number.isFinite(limit) || limit < 1 || !Number.isInteger(limit))
+    throw new TrainError('bad_request', 'limit must be a positive integer');
+  return Math.min(limit, 1000);
+}
+
+function binaryNode(value: unknown): value is BinaryNode {
+  if (!isRecord(value) || typeof value.tag !== 'string' || !isRecord(value.attrs)) return false;
+  if (!Object.values(value.attrs).every((attr) => typeof attr === 'string')) return false;
+  const content = value.content;
+  return content === undefined || typeof content === 'string' || content instanceof Uint8Array
+    || (Array.isArray(content) && content.every(binaryNode));
+}
+
+function memberTotal(response: BinaryNode): number | undefined {
+  const value = getBinaryNodeChild(response, 'group')?.attrs.size;
+  if (!value || !/^\d+$/.test(value)) return undefined;
+  const size = Number(value);
+  return Number.isSafeInteger(size) ? size : undefined;
+}
+
+function capability(total: number | undefined, fetched: number, returned: number): MemberCapability {
+  const complete = total !== undefined && total === fetched && returned === total;
+  const reason = returned < fetched ? 'Member list was limited; increase limit up to 1000'
+    : total === undefined ? 'WhatsApp did not report a total member count'
+      : total !== fetched ? 'WhatsApp returned a partial member list' : undefined;
+  return { supported: true, complete, ...(total === undefined ? {} : { total }), ...(reason ? { reason } : {}) };
+}
+
+export async function listMembers(
+  jid: string,
+  query: (node: BinaryNode) => Promise<unknown>,
+  names: NameBook,
+  limit?: number,
+): Promise<MemberList> {
+  const cap = memberLimit(limit);
+  if (!isGroupJid(jid)) return {
+    members: [],
+    capability: { supported: false, complete: false, reason: 'WhatsApp member lookup requires a group line (@g.us)' },
+  };
+  const response = await query({
+    tag: 'iq', attrs: { type: 'get', xmlns: 'w:g2', to: jid },
+    content: [{ tag: 'query', attrs: { request: 'interactive' } }],
+  });
+  if (!binaryNode(response)) throw new TrainError('whatsapp_call', 'WhatsApp returned invalid group metadata');
+  const group = extractGroupMetadata(response);
+  const participants = [...new Map(group.participants.map((p) => [p.id, p])).values()];
+  const members = participants.slice(0, cap).map((p) => memberOf(p, names));
+  return {
+    members,
+    capability: capability(memberTotal(response), participants.length, members.length),
+  };
+}

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

@@ -0,0 +1,70 @@
+import { jidNormalizedUser, type Contact, type WASocket } from 'baileys';
+import { bindAppState, noteHistoryContact } from './app-state.js';
+import type { InboundHandlers } from './client-types.js';
+import type { History } from './history.js';
+import type { KeyCache } from './keys.js';
+import { noteContact, type NameBook } from './names.js';
+import { toInbound, toReaction, type SelfRef } from './parse.js';
+
+interface MessageHooks {
+  accountId: string;
+  keys: KeyCache;
+  names: NameBook;
+  history: History;
+  current(): boolean;
+  handlers(): InboundHandlers | undefined;
+  self(): SelfRef;
+}
+
+export function bindMessages(sock: Pick<WASocket, 'ev' | 'user'>, hooks: MessageHooks): void {
+  const selfJid = (): string | undefined => sock.user?.id ? jidNormalizedUser(sock.user.id) : undefined;
+  const noteContacts = (contacts: Partial<Contact>[]): void => {
+    if (!hooks.current()) return;
+    for (const contact of contacts) {
+      noteContact(hooks.names, contact);
+      noteHistoryContact(hooks.history, contact);
+    }
+  };
+  bindAppState(sock.ev, hooks);
+  sock.ev.on('messages.upsert', ({ messages, type }) => {
+    if (!hooks.current()) return;
+    for (const m of messages) hooks.keys.remember(m.key);
+    hooks.history.ingest(messages, selfJid());
+    const handlers = hooks.handlers();
+    if (type !== 'notify' || !handlers) return;
+    for (const m of messages) {
+      if (m.key.fromMe) continue;
+      const inbound = toInbound(hooks.accountId, m, hooks.self());
+      if (!inbound) continue;
+      hooks.names.note(inbound.senderJid, inbound.pushName);
+      handlers.onMessage(inbound, m);
+    }
+  });
+  sock.ev.on('contacts.upsert', noteContacts);
+  sock.ev.on('contacts.update', noteContacts);
+  sock.ev.on('messaging-history.set', ({ contacts, messages, lidPnMappings }) => {
+    if (!hooks.current()) return;
+    noteContacts(contacts);
+    for (const { pn, lid } of lidPnMappings ?? []) hooks.history.alias(pn, lid);
+    for (const m of messages) {
+      hooks.keys.remember(m.key);
+      if (m.key.fromMe !== true) hooks.names.note(m.key.participant ?? m.key.remoteJid, m.pushName);
+    }
+    hooks.history.ingest(messages, selfJid());
+  });
+  sock.ev.on('messages.update', (updates) => {
+    if (hooks.current()) hooks.history.update(updates, selfJid());
+  });
+  sock.ev.on('messages.delete', (event) => {
+    if (hooks.current()) hooks.history.deleteMessages(event);
+  });
+  sock.ev.on('messages.reaction', (events) => {
+    if (!hooks.current()) return;
+    const handlers = hooks.handlers();
+    if (!handlers) return;
+    for (const event of events) {
+      const reaction = toReaction(hooks.accountId, event);
+      if (reaction) handlers.onReaction(reaction);
+    }
+  });
+}

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/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));
+    },
+  };
+}