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

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

@@ -0,0 +1,28 @@
+const MAX_NAMES = 2000;
+
+export interface NameBook {
+  note(jid: string | null | undefined, name: string | null | undefined): void;
+  get(jid: string): string | undefined;
+}
+
+export function makeNameBook(): NameBook {
+  const names = new Map<string, string>();
+  return {
+    note(jid, name) {
+      const clean = name?.trim() ?? '';
+      if (!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);
+      }
+    },
+    get: (jid) => names.get(jid),
+  };
+}
+
+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/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));
+    },
+  };
+}

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

@@ -0,0 +1,185 @@
+import type { WAMessage, WAMessageKey, proto } from 'baileys';
+import { mediaRefIn, mediaTag, type WAMediaRef } from './media.js';
+import type { InboundMessage, ReactionInput } from './format.js';
+
+export const isGroupJid = (jid: string): boolean => jid.endsWith('@g.us');
+const isLidJid = (jid: string): boolean => jid.endsWith('@lid');
+export const isPrivateJid = (jid: string): boolean =>
+  jid.endsWith('@s.whatsapp.net') || isLidJid(jid);
+
+type Timestamp = number | { toNumber(): number } | null | undefined;
+
+export function tsToDate(ts: Timestamp): Date {
+  if (typeof ts === 'number') return new Date(ts * 1000);
+  if (ts && typeof ts.toNumber === 'function')
+    return new Date(ts.toNumber() * 1000);
+  return new Date();
+}
+
+type Content = proto.IMessage | null | undefined;
+
+const UNWRAPPERS: ((m: proto.IMessage) => Content)[] = [
+  (m) => m.ephemeralMessage?.message,
+  (m) => m.viewOnceMessage?.message,
+  (m) => m.viewOnceMessageV2?.message,
+  (m) => m.viewOnceMessageV2Extension?.message,
+  (m) => m.deviceSentMessage?.message,
+  (m) => m.documentWithCaptionMessage?.message,
+  (m) => m.editedMessage?.message,
+];
+
+function unwrapOnce(m: proto.IMessage): Content {
+  for (const pick of UNWRAPPERS) {
+    const inner = pick(m);
+    if (inner) return inner;
+  }
+  return undefined;
+}
+
+export function unwrap(message: Content): proto.IMessage | undefined {
+  let current: Content = message;
+  for (let depth = 0; current && depth < 8; depth += 1) {
+    const inner = unwrapOnce(current);
+    if (!inner) return current;
+    current = inner;
+  }
+  return current ?? undefined;
+}
+
+function captionOf(message: proto.IMessage): string {
+  const caption =
+    message.imageMessage?.caption ??
+    message.videoMessage?.caption ??
+    message.documentMessage?.caption;
+  return typeof caption === 'string' ? caption : '';
+}
+
+export function extractText(message: Content): string {
+  const inner = unwrap(message);
+  if (!inner) return '';
+  if (typeof inner.conversation === 'string') return inner.conversation;
+  const ext = inner.extendedTextMessage?.text;
+  if (typeof ext === 'string') return ext;
+  return captionOf(inner);
+}
+
+export function mediaRefOf(message: Content): WAMediaRef | undefined {
+  const inner = unwrap(message);
+  return inner ? mediaRefIn(inner) : undefined;
+}
+
+function projectText(
+  message: proto.IMessage | undefined,
+  ref: WAMediaRef | undefined,
+): string {
+  return [extractText(message), mediaTag(ref)].filter(Boolean).join(' ');
+}
+
+function senderJidOf(key: WAMessageKey, chatJid: string): string {
+  if (isGroupJid(chatJid)) return key.participant ?? chatJid;
+  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;
+  if (!chatJid || !messageId) return undefined;
+  const inner = unwrap(m.message);
+  if (!inner || inner.reactionMessage) return undefined;
+  const media = mediaRefOf(inner);
+  const text = projectText(inner, media);
+  if (!text && !media) return undefined;
+  return {
+    accountId,
+    chatJid,
+    senderJid: senderJidOf(m.key, chatJid),
+    messageId,
+    text,
+    date: tsToDate(m.messageTimestamp),
+    isPrivate: isPrivateJid(chatJid),
+    ...(m.pushName ? { pushName: m.pushName } : {}),
+    ...(media ? { media } : {}),
+    ...addressing(inner, chatJid, self),
+  };
+}
+
+export interface ReactionEvent {
+  key: WAMessageKey;
+  reaction: proto.IReaction;
+}
+
+function reactorJid(
+  reactorKey: WAMessageKey | undefined,
+  chatJid: string,
+): string {
+  return reactorKey?.participant ?? reactorKey?.remoteJid ?? chatJid;
+}
+
+export function toReaction(
+  accountId: string,
+  event: ReactionEvent,
+): ReactionInput | undefined {
+  const chatJid = event.key.remoteJid;
+  const messageId = event.key.id;
+  if (!chatJid || !messageId) return undefined;
+  const reactorKey = event.reaction.key ?? undefined;
+  if (reactorKey?.fromMe) return undefined;
+  const senderJid = reactorJid(reactorKey, chatJid);
+  const emoji = event.reaction.text ?? '';
+  return {
+    accountId,
+    chatJid,
+    senderJid,
+    messageId,
+    emoji,
+    date: new Date(),
+    isPrivate: isPrivateJid(chatJid),
+    removed: emoji === '',
+  };
+}

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

@@ -0,0 +1,24 @@
+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';
+
+export const whatsappStation: Station = {
+  name: 'whatsapp',
+  hasAccounts: true,
+  hasTrain: true,
+  messageVerbs: new Set<Verb>([
+    'send',
+    'reply',
+    'react',
+    'unreact',
+    'edit',
+    'delete',
+  ]),
+  attachmentMode: 'canonical',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
+  resolvesSenders: true,
+  forget: tokenFiles.forget,
+  forgetExcept: tokenFiles.forgetExcept,
+  tools: [],
+};