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

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/mcp/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/mcp/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/normalize.ts

@@ -0,0 +1,22 @@
+import type { Normalized } from '@metro-labs/mcp/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,141 @@
+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 function toInbound(
+  accountId: string,
+  m: WAMessage,
+): 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 } : {}),
+  };
+}
+
+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/station.ts

@@ -0,0 +1,17 @@
+import type { Station, Verb } from '@metro-labs/mcp/stations/types';
+
+export const whatsappStation: Station = {
+  name: 'whatsapp',
+  hasAccounts: true,
+  hasTrain: true,
+  messageVerbs: new Set<Verb>([
+    'send',
+    'reply',
+    'react',
+    'unreact',
+    'edit',
+    'delete',
+  ]),
+  attachmentMode: 'canonical',
+  tools: [],
+};

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

@@ -0,0 +1,98 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readJson, writeSecure } from '@metro-labs/mcp/secure-fs';
+import { errMsg } from '@metro-labs/mcp/log';
+
+export const PERSISTED_KEY_TYPES = ['tctoken', 'lid-mapping'] as const;
+
+export type KeyTable = Record<string, Record<string, unknown>>;
+
+const PERSISTED = new Set<string>(PERSISTED_KEY_TYPES);
+
+const WRITE_DEBOUNCE_MS = 1000;
+
+export const isPersistedKeyType = (type: string): boolean =>
+  PERSISTED.has(type);
+
+const safeSegment = (s: string): string => s.replace(/[^A-Za-z0-9_-]/g, '_');
+
+export function tokenStorePath(accountId: string): string {
+  const dir = process.env.WHATSAPP_TOKEN_DIR ?? join(homedir(), '.metro');
+  return join(dir, `whatsapp-tokens-${safeSegment(accountId)}.json`);
+}
+
+export function persistedSubset(table: KeyTable): KeyTable {
+  const out: KeyTable = {};
+  for (const type of PERSISTED_KEY_TYPES) {
+    const bucket = table[type];
+    if (!bucket) continue;
+    const kept: Record<string, unknown> = {};
+    for (const id of Object.keys(bucket)) {
+      const value = bucket[id];
+      if (value === undefined || value === null) continue;
+      kept[id] = value;
+    }
+    if (Object.keys(kept).length) out[type] = kept;
+  }
+  return out;
+}
+
+export interface TokenStore {
+  path: string;
+  load(): KeyTable;
+  scheduleSave(table: KeyTable): void;
+  saveNow(table: KeyTable): void;
+}
+
+export function makeTokenStore(
+  accountId: string,
+  onError: (message: string) => void,
+): TokenStore {
+  const path = tokenStorePath(accountId);
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let pending: KeyTable | undefined;
+  let written = '';
+  const saveNow = (table: KeyTable): void => {
+    const body = JSON.stringify(persistedSubset(table));
+    if (body === written) return;
+    try {
+      writeSecure(path, body);
+      written = body;
+    } catch (err) {
+      onError(`could not write ${path}: ${errMsg(err)}`);
+    }
+  };
+  return {
+    path,
+    load() {
+      const table = persistedSubset(readJson<KeyTable>(path, {}));
+      written = JSON.stringify(table);
+      return table;
+    },
+    scheduleSave(table) {
+      pending = table;
+      if (timer) return;
+      timer = setTimeout(() => {
+        timer = undefined;
+        if (pending) saveNow(pending);
+        pending = undefined;
+      }, WRITE_DEBOUNCE_MS);
+      timer.unref?.();
+    },
+    saveNow,
+  };
+}
+
+const stores = new Map<string, TokenStore>();
+
+export function tokenStoreFor(
+  accountId: string,
+  onError: (message: string) => void,
+): TokenStore {
+  const path = tokenStorePath(accountId);
+  const existing = stores.get(path);
+  if (existing) return existing;
+  const store = makeTokenStore(accountId, onError);
+  stores.set(path, store);
+  return store;
+}

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

@@ -0,0 +1,6 @@
+export interface WhatsAppAccount {
+  id: string;
+  phone: string;
+  owner?: string;
+  credentials?: unknown;
+}

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

@@ -0,0 +1,5 @@
+export { emit, mintId } from '@metro-labs/mcp/stations/station-runtime';
+
+export const SELF_URI =
+  process.env.METRO_SELF_URI ??
+  'metro://claude/user/8a1857f3-4039-4da6-a4e1-611b432d2082';

package/runtime/node_modules/@metro-labs/xmtp/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@metro-labs/xmtp",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/station.ts",
+    "./train": "./src/index.ts",
+    "./verify": "./src/verify.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && DYLD_FALLBACK_LIBRARY_PATH=/usr/lib bun test test/"
+  },
+  "dependencies": {
+    "@metro-labs/mcp": "workspace:*",
+    "@xmtp/content-type-primitives": "^3.0.1",
+    "@xmtp/content-type-reaction": "^2.0.2",
+    "@xmtp/content-type-remote-attachment": "^2.0.4",
+    "@xmtp/content-type-reply": "^2.0.3",
+    "@xmtp/content-type-wallet-send-calls": "^2.0.0",
+    "@xmtp/node-bindings": "1.9.1",
+    "@xmtp/node-sdk": "^6.0.0",
+    "viem": "^2.52.2"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.2",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
+}