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

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

@@ -0,0 +1,178 @@
+import { TrainError } from '@metro-labs/mcp/train-error';
+import { errMsg } from '@metro-labs/mcp/log';
+import { kindOf } from '@metro-labs/mcp/stations/attachments';
+import {
+  makeStation,
+  respond,
+  type CallMsg,
+  type StationHandler,
+} from '@metro-labs/mcp/stations/station-runtime';
+import { accountFor, accounts, targetOf } from './accounts.js';
+import { normalizeWhatsApp } from './normalize.js';
+import type { WAClient } from './client.js';
+
+type Args = Record<string, unknown>;
+
+interface Resolved {
+  accountId: string;
+  client: WAClient;
+  jid: string;
+}
+
+type ClientFor = (accountId: string) => WAClient;
+
+function str(v: unknown): string | undefined {
+  return typeof v === 'string' ? v : undefined;
+}
+
+function resolve(args: Args, clientFor: ClientFor): Resolved {
+  const line = str(args.line);
+  if (!line) throw new TrainError('bad_request', 'missing line');
+  const target = targetOf(line);
+  if (!target) throw new TrainError('bad_request', `bad line '${line}'`);
+  const accountId = accountFor({ account: str(args.account), line });
+  return { accountId, client: clientFor(accountId), jid: target.jid };
+}
+
+async function guard<T>(run: () => Promise<T>): Promise<T> {
+  try {
+    return await run();
+  } catch (e) {
+    if (e instanceof TrainError) throw e;
+    const msg = errMsg(e);
+    if (/rate.?over.?limit|too many|429/i.test(msg))
+      throw new TrainError('rate_limited', msg);
+    throw new TrainError('whatsapp_call', msg);
+  }
+}
+
+interface WireAttachment {
+  kind?: string;
+  path?: string;
+  url?: string;
+  mime?: string;
+  name?: string;
+}
+
+function attachmentsOf(args: Args): WireAttachment[] {
+  const raw = args.attachments;
+  if (!Array.isArray(raw)) return [];
+  return (raw as WireAttachment[]).filter((a) => Boolean(a.path ?? a.url));
+}
+
+async function sendMediaSet(
+  client: WAClient,
+  jid: string,
+  atts: WireAttachment[],
+  text: string,
+  replyTo: string | undefined,
+): Promise<{ messageId: string; labels: string[] }> {
+  const labels: string[] = [];
+  let messageId = '';
+  for (let i = 0; i < atts.length; i++) {
+    const att = atts[i];
+    if (!att) continue;
+    const path = att.path ?? att.url ?? '';
+    const kind = att.kind ?? kindOf(att.mime ?? '', path);
+    messageId = await guard(() =>
+      client.sendMedia(
+        jid,
+        {
+          kind,
+          path,
+          mime: att.mime ?? 'application/octet-stream',
+          name: att.name ?? path.split('/').pop() ?? 'attachment',
+          ...(i === 0 && text ? { caption: text } : {}),
+        },
+        replyTo,
+      ),
+    );
+    labels.push(kind);
+  }
+  return { messageId, labels };
+}
+
+function makeSend(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, jid } = resolve(args, clientFor);
+    const text = str(args.text) ?? '';
+    const replyTo = str(args.replyTo);
+    const atts = attachmentsOf(args);
+    if (atts.length) {
+      const { messageId, labels } = await sendMediaSet(
+        client,
+        jid,
+        atts,
+        text,
+        replyTo,
+      );
+      respond(id, {
+        result: { messageId, account: accountId, attachments: labels },
+      });
+      return;
+    }
+    const messageId = await guard(() => client.sendText(jid, text, replyTo));
+    respond(id, { result: { messageId, account: accountId } });
+  };
+}
+
+function makeReact(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, jid } = resolve(args, clientFor);
+    const messageId = str(args.messageId) ?? '';
+    const emoji = str(args.emoji) ?? '';
+    await guard(() => client.sendReaction(jid, messageId, emoji));
+    respond(id, { result: { ok: true, account: accountId } });
+  };
+}
+
+function makeEdit(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, jid } = resolve(args, clientFor);
+    const messageId = str(args.messageId) ?? '';
+    const text = str(args.text) ?? '';
+    await guard(() => client.editMessage(jid, messageId, text));
+    respond(id, { result: { ok: true, account: accountId } });
+  };
+}
+
+function makeDelete(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, jid } = resolve(args, clientFor);
+    const messageId = str(args.messageId) ?? '';
+    await guard(() => client.deleteMessage(jid, messageId));
+    respond(id, { result: { ok: true, account: accountId } });
+  };
+}
+
+function makeAccounts(clientFor: ClientFor): StationHandler {
+  return (id) => {
+    const list = [...accounts.values()].map((a) => {
+      const phone = clientFor(a.id).self();
+      return {
+        id: a.id,
+        handle: phone === null ? null : `+${phone}`,
+        url: phone === null ? null : `https://wa.me/${phone}`,
+        connected: phone !== null,
+        owner: a.owner ?? null,
+      };
+    });
+    respond(id, { result: { accounts: list } });
+    return Promise.resolve();
+  };
+}
+
+export function makeHandleCall(
+  clientFor: ClientFor,
+): (msg: CallMsg) => Promise<void> {
+  return makeStation({
+    handlers: {
+      accounts: makeAccounts(clientFor),
+      send: makeSend(clientFor),
+      react: makeReact(clientFor),
+      edit: makeEdit(clientFor),
+      delete: makeDelete(clientFor),
+    },
+    normalize: normalizeWhatsApp,
+  });
+}

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

@@ -0,0 +1,72 @@
+import { downloadMediaMessage, type WAMessage } from 'baileys';
+import {
+  assertAttachmentSize,
+  saveStreamToCache,
+  type SavedAttachment,
+} from '@metro-labs/mcp/stations/attachments';
+import { TrainError } from '@metro-labs/mcp/train-error';
+import { baileysLogger } from './logger.js';
+import type { WAMediaRef } from './media.js';
+
+export type { SavedAttachment };
+
+const IDLE_TIMEOUT_MS = 60_000;
+
+export type ReuploadRequest = (m: WAMessage) => Promise<WAMessage>;
+
+export async function* withIdleTimeout(
+  chunks: AsyncIterable<Uint8Array>,
+  ms: number,
+): AsyncGenerator<Uint8Array> {
+  const iterator = chunks[Symbol.asyncIterator]();
+  for (;;) {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const idle = new Promise<never>((_resolve, reject) => {
+      timer = setTimeout(() => {
+        reject(
+          new TrainError(
+            'whatsapp_media_stalled',
+            `WhatsApp sent no media bytes for ${ms}ms, so the download was abandoned`,
+          ),
+        );
+      }, ms);
+    });
+    try {
+      const next = await Promise.race([iterator.next(), idle]);
+      if (next.done === true) return;
+      yield next.value;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}
+
+export async function saveWhatsAppMedia(
+  accountId: string,
+  raw: WAMessage,
+  ref: WAMediaRef,
+  messageId: string,
+  index = 0,
+  reupload?: ReuploadRequest,
+): Promise<SavedAttachment> {
+  if (ref.bytes !== undefined) assertAttachmentSize(ref.bytes);
+  const stream = await downloadMediaMessage(
+    raw,
+    'stream',
+    {},
+    reupload
+      ? { reuploadRequest: reupload, logger: baileysLogger(accountId) }
+      : undefined,
+  );
+  try {
+    return await saveStreamToCache(
+      withIdleTimeout(stream, IDLE_TIMEOUT_MS),
+      messageId,
+      index,
+      { mime: ref.mime, name: ref.name },
+    );
+  } catch (err) {
+    stream.destroy();
+    throw err;
+  }
+}

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/mcp/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,318 @@
+import makeWASocket, {
+  Browsers,
+  DisconnectReason,
+  fetchLatestWaWebVersion,
+  type proto,
+  type WAMessage,
+  type WAMessageKey,
+  type WASocket,
+} from 'baileys';
+import { TrainError } from '@metro-labs/mcp/train-error';
+import { errMsg } from '@metro-labs/mcp/log';
+import type { WhatsAppAccount } from './types.js';
+import type { InboundMessage, ReactionInput } from './format.js';
+import { toInbound, toReaction, type ReactionEvent } 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>;
+  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 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);
+      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 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 disconnect() {
+      st.closed = true;
+      try {
+        await st.sock?.end(undefined);
+      } catch {
+        st.sock = undefined;
+      }
+    },
+  };
+}