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

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

@@ -0,0 +1,129 @@
+import {
+  BufferJSON,
+  initAuthCreds,
+  proto,
+  type AuthenticationCreds,
+  type AuthenticationState,
+  type SignalDataSet,
+  type SignalDataTypeMap,
+  type SignalKeyStore,
+} from 'baileys';
+import { TrainError } from '@metro-labs/core/train-error';
+import {
+  isPersistedKeyType,
+  tokenStoreFor,
+  type KeyTable,
+} from './token-store.js';
+
+interface AuthBlob {
+  creds: AuthenticationCreds;
+  keys: KeyTable;
+}
+
+function encode(value: unknown): unknown {
+  return JSON.parse(JSON.stringify(value, BufferJSON.replacer));
+}
+
+function decode(value: unknown): unknown {
+  return JSON.parse(JSON.stringify(value), BufferJSON.reviver);
+}
+
+function loadBlob(raw: unknown): AuthBlob {
+  const obj = raw as { creds?: unknown; keys?: KeyTable } | null;
+  const creds = obj?.creds;
+  if (creds === undefined || creds === null)
+    throw new TrainError(
+      'whatsapp_auth',
+      'stored credentials blob has no creds',
+    );
+  return {
+    creds: decode(creds) as AuthenticationCreds,
+    keys: obj?.keys ?? {},
+  };
+}
+
+function makeKeyStore(
+  table: KeyTable,
+  onPersistedWrite?: (table: KeyTable) => void,
+): SignalKeyStore {
+  return {
+    get: <T extends keyof SignalDataTypeMap>(type: T, ids: string[]) => {
+      const bucket = table[type] ?? {};
+      const data: Record<string, SignalDataTypeMap[T]> = {};
+      for (const id of ids) {
+        const raw = bucket[id];
+        if (raw === undefined || raw === null) continue;
+        const revived = decode(raw);
+        data[id] = (
+          type === 'app-state-sync-key'
+            ? proto.Message.AppStateSyncKeyData.fromObject(
+                revived as Record<string, unknown>,
+              )
+            : revived
+        ) as SignalDataTypeMap[T];
+      }
+      return data;
+    },
+    set: (data: SignalDataSet) => {
+      let persisted = false;
+      for (const category of Object.keys(data) as (keyof SignalDataSet)[]) {
+        const items = data[category];
+        if (!items) continue;
+        if (isPersistedKeyType(category)) persisted = true;
+        const bucket = (table[category] ??= {});
+        for (const id of Object.keys(items)) {
+          const value = items[id];
+          bucket[id] = value ? encode(value) : undefined;
+        }
+      }
+      if (persisted) onPersistedWrite?.(table);
+    },
+  };
+}
+
+export function inMemoryAuthState(
+  raw?: unknown,
+  opts?: { seed?: KeyTable; onPersistedWrite?: (table: KeyTable) => void },
+): {
+  state: AuthenticationState;
+  serialize: () => unknown;
+} {
+  const blob: AuthBlob =
+    raw === undefined || raw === null
+      ? { creds: initAuthCreds(), keys: {} }
+      : loadBlob(raw);
+  for (const [type, bucket] of Object.entries(opts?.seed ?? {}))
+    blob.keys[type] = { ...blob.keys[type], ...bucket };
+  const state: AuthenticationState = {
+    creds: blob.creds,
+    keys: makeKeyStore(blob.keys, opts?.onPersistedWrite),
+  };
+  return {
+    state,
+    serialize: () => ({ creds: encode(blob.creds), keys: blob.keys }),
+  };
+}
+
+export function useAccountAuthState(
+  credentials: unknown,
+  accountId: string,
+): {
+  state: AuthenticationState;
+  saveCreds: () => Promise<void>;
+} {
+  if (credentials === undefined || credentials === null)
+    throw new TrainError(
+      'whatsapp_auth',
+      `no WhatsApp credentials in accounts for '${accountId}' — run scripts/login.ts to pair`,
+    );
+  const store = tokenStoreFor(accountId, (message) => {
+    process.stderr.write(`whatsapp[${accountId}] token store: ${message}\n`);
+  });
+  const { state } = inMemoryAuthState(credentials, {
+    seed: store.load(),
+    onPersistedWrite: (table) => {
+      store.scheduleSave(table);
+    },
+  });
+  return { state, saveCreds: () => Promise.resolve() };
+}

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

@@ -0,0 +1,347 @@
+import makeWASocket, {
+  jidNormalizedUser,
+  Browsers,
+  DisconnectReason,
+  fetchLatestWaWebVersion,
+  type proto,
+  type WAMessage,
+  type WAMessageKey,
+  type WASocket,
+} from 'baileys';
+import { TrainError } from '@metro-labs/core/train-error';
+import { errMsg } from '@metro-labs/core/log';
+import type { WhatsAppAccount } from './types.js';
+import type { InboundMessage, ReactionInput } from './format.js';
+import type { SenderFound } from './resolve.js';
+import { toInbound, toReaction, type ReactionEvent, type SelfRef } 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>;
+  lookupSender(number: string): Promise<SenderFound>;
+  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 selfRef(st: State, sock: WASocket): SelfRef {
+  const jids = new Set<string>();
+  const me = sock.user;
+  if (me?.id) jids.add(jidNormalizedUser(me.id));
+  if (me?.lid) jids.add(jidNormalizedUser(me.lid));
+  return { jids, sentByMe: (jid, id) => st.keys.lookup(jid, id)?.fromMe === true };
+}
+
+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, selfRef(st, sock));
+      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 lidFor(st: State, sock: WASocket, jid: string): Promise<string | null> {
+  try {
+    return await sock.signalRepository.lidMapping.getLIDForPN(jid);
+  } catch (e) {
+    process.stderr.write(
+      `whatsapp[${st.account.id}] no lid on file for ${jid}: ${errMsg(e)}\n`,
+    );
+    return null;
+  }
+}
+
+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 lookupSender(number) {
+      const sock = await ready(st);
+      const found = (await sock.onWhatsApp(number))?.[0];
+      if (found?.exists !== true) return { exists: false, jid: null, lid: null };
+      const jid = jidNormalizedUser(found.jid);
+      return { exists: true, jid, lid: await lidFor(st, sock, jid) };
+    },
+    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,138 @@
+import type { SavedAttachment } from '@metro-labs/core/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;
+  replyTo?: string;
+  mentionsSelf?: boolean;
+  replyToSelf?: boolean;
+}
+
+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,
+    ...(m.replyTo === undefined ? {} : { reply_to: m.replyTo, event: { type: 'reply', replyTo: m.replyTo } }),
+    ...(m.mentionsSelf === true ? { mentions_self: true } : {}),
+    ...(m.replyToSelf === true ? { reply_to_self: true } : {}),
+    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,
+    },
+  };
+}