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

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

@@ -0,0 +1,66 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import {
+  makeAccountStore,
+  resolveAccountId,
+  type Die,
+} from '@metro-labs/core/stations/account-store';
+import type { WhatsAppAccount } from './types.js';
+
+const ACCOUNTS_FILE =
+  process.env.WHATSAPP_ACCOUNTS_FILE ??
+  join(homedir(), '.metro', 'whatsapp-accounts.json');
+
+const isJid = (s: string): boolean => s.includes('@');
+
+function validateAccount(
+  a: WhatsAppAccount,
+  seen: Set<string>,
+  die: Die,
+): void {
+  if (!a.id) die('account missing id');
+  if (!a.phone || typeof a.phone !== 'string')
+    die(`account '${a.id}' missing phone`);
+  if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
+  seen.add(a.id);
+}
+
+export const { loadAccounts } = makeAccountStore<WhatsAppAccount>({
+  prefix: 'whatsapp',
+  file: ACCOUNTS_FILE,
+  validate(raw, die) {
+    const seen = new Set<string>();
+    for (const a of raw) validateAccount(a, seen, die);
+  },
+});
+
+export const accounts = new Map<string, WhatsAppAccount>();
+
+export function accountFor(args: { account?: string; line?: string }): string {
+  return resolveAccountId(accounts, args, (line) => targetOf(line)?.accountId);
+}
+
+export function lineOf(accountId: string, jid: string): string {
+  return `metro://whatsapp/${accountId}/${jid}`;
+}
+
+interface Target {
+  accountId: string;
+  jid: string;
+}
+
+function splitScoped(path: string[]): { accountId: string; jid?: string } {
+  const first = path[0];
+  if (path.length >= 2 && first !== undefined && !isJid(first))
+    return { accountId: first, jid: path[1] };
+  return { accountId: 'default', jid: first };
+}
+
+export function targetOf(line: string): Target | undefined {
+  const prefix = 'metro://whatsapp/';
+  if (!line.startsWith(prefix)) return undefined;
+  const path = line.slice(prefix.length).split('/').filter(Boolean);
+  const { accountId, jid } = splitScoped(path);
+  if (jid === undefined || !isJid(jid)) return undefined;
+  return { accountId, jid };
+}

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

@@ -0,0 +1,101 @@
+import { TrainError } from '@metro-labs/core/train-error';
+import type { BinaryNode, WASocket } from 'baileys';
+
+const DEFAULT_ACK_WAIT_MS = 5000;
+
+export function ackWaitMs(raw: string | undefined): number {
+  if (raw === undefined || raw.trim() === '') return DEFAULT_ACK_WAIT_MS;
+  const ms = Number(raw);
+  return Number.isFinite(ms) && ms >= 0 ? ms : DEFAULT_ACK_WAIT_MS;
+}
+
+export const ACK_WAIT_MS = ackWaitMs(process.env.METRO_WHATSAPP_ACK_WAIT_MS);
+
+const RECENT_MAX = 256;
+
+const RESTRICTION = '463';
+
+export interface SendAck {
+  messageId: string;
+  jid: string;
+  error?: string;
+}
+
+export function ackOf(node: BinaryNode): SendAck | undefined {
+  const { id, from, error } = node.attrs;
+  if (!id || !from) return undefined;
+  return { messageId: id, jid: from, ...(error ? { error } : {}) };
+}
+
+export function rejection(ack: SendAck): TrainError | undefined {
+  if (!ack.error) return undefined;
+  if (ack.error === RESTRICTION)
+    return new TrainError(
+      'whatsapp_account_restricted',
+      `WhatsApp refused the message to ${ack.jid} with ack error 463 (MessageAccountRestriction): the send carried no trusted-contact token, so WhatsApp counted it as reaching out to a stranger and this account is under a reach-out timelock. Nothing was delivered, and it must not be retried — every retry counts as another reach-out and deepens the lock.`,
+      { retryable: false },
+    );
+  return new TrainError(
+    'whatsapp_send_refused',
+    `WhatsApp refused the message to ${ack.jid} with ack error ${ack.error}, so it was not delivered`,
+    { retryable: false },
+  );
+}
+
+export interface AckWatch {
+  record(node: BinaryNode): SendAck | undefined;
+  wait(messageId: string, timeoutMs: number): Promise<SendAck | undefined>;
+}
+
+export function makeAckWatch(max: number = RECENT_MAX): AckWatch {
+  const recent = new Map<string, SendAck>();
+  const waiting = new Map<string, (ack: SendAck) => void>();
+  return {
+    record(node) {
+      const ack = ackOf(node);
+      if (!ack) return undefined;
+      const waiter = waiting.get(ack.messageId);
+      if (waiter) {
+        waiting.delete(ack.messageId);
+        waiter(ack);
+        return ack;
+      }
+      recent.delete(ack.messageId);
+      recent.set(ack.messageId, ack);
+      while (recent.size > max) {
+        const oldest = recent.keys().next().value;
+        if (oldest === undefined) break;
+        recent.delete(oldest);
+      }
+      return ack;
+    },
+    wait(messageId, timeoutMs) {
+      const seen = recent.get(messageId);
+      if (seen) {
+        recent.delete(messageId);
+        return Promise.resolve(seen);
+      }
+      return new Promise<SendAck | undefined>((resolve) => {
+        const timer = setTimeout(() => {
+          waiting.delete(messageId);
+          resolve(undefined);
+        }, timeoutMs);
+        waiting.set(messageId, (ack) => {
+          clearTimeout(timer);
+          resolve(ack);
+        });
+      });
+    },
+  };
+}
+
+export function bindAcks(
+  sock: WASocket,
+  watch: AckWatch,
+  onError: (ack: SendAck) => void,
+): void {
+  sock.ws.on('CB:ack,class:message', (node: BinaryNode) => {
+    const ack = watch.record(node);
+    if (ack?.error) onError(ack);
+  });
+}

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

@@ -0,0 +1,213 @@
+import { TrainError } from '@metro-labs/core/train-error';
+import { errMsg } from '@metro-labs/core/log';
+import { kindOf } from '@metro-labs/core/stations/attachments';
+import {
+  makeStation,
+  respond,
+  type CallMsg,
+  type StationHandler,
+} from '@metro-labs/core/stations/station-runtime';
+import { accountFor, accounts, targetOf } from './accounts.js';
+import { normalizeWhatsApp } from './normalize.js';
+import { phoneNumberOf, senderLookup } from './resolve.js';
+import { assertImage, fieldsOf, parseProfileChange, type ProfileApplied } from '@metro-labs/core/stations/profile';
+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,
+      };
+    });
+    respond(id, { result: { accounts: list } });
+    return Promise.resolve();
+  };
+}
+
+function makeResolveSender(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const query = str(args.query) ?? '';
+    const number = phoneNumberOf(query);
+    const found = await guard(() => clientFor(accountId).lookupSender(number));
+    respond(id, { result: { account: accountId, ...senderLookup(query, number, found) } });
+  };
+}
+
+function makeSetProfile(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const change = parseProfileChange(args);
+    if (change.avatar !== undefined) assertImage(change.avatar);
+    await guard(() => clientFor(accountId).setProfile(change));
+    const result: ProfileApplied = { account: accountId, applied: fieldsOf(change) };
+    respond(id, { result });
+  };
+}
+
+function makeProfile(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const user = str(args.user) ?? '';
+    if (user === '') throw new TrainError('whatsapp_user_required', 'profile needs the jid of the person', { retryable: false });
+    const profile = await guard(() => clientFor(accountId).senderProfile(user));
+    respond(id, { result: profile ?? { id: user } });
+  };
+}
+
+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),
+      resolve_sender: makeResolveSender(clientFor),
+      set_profile: makeSetProfile(clientFor),
+      profile: makeProfile(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/core/stations/attachments';
+import { TrainError } from '@metro-labs/core/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/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() };
+}