@stage-labs/metro 0.1.0-beta.3 → 0.1.0-beta.300

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/send-expiry.ts

@@ -0,0 +1,65 @@
+import type { ChatUpdate, WASocket } from 'baileys';
+import { errMsg, log } from '@metro-labs/core/log';
+import { isGroupJid, isPrivateJid } from './parse.js';
+
+const MAX_CHATS = 2000;
+type Content = Parameters<WASocket['sendMessage']>[1];
+interface Setting { duration: number; at: number }
+
+function duration(value: number | undefined): number | undefined {
+  return value !== undefined && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+
+function setting(chat: ChatUpdate): Setting | undefined {
+  if (!Object.hasOwn(chat, 'ephemeralExpiration')) return undefined;
+  const seconds = duration(chat.ephemeralExpiration === null ? 0 : chat.ephemeralExpiration);
+  const timestamp = chat.ephemeralSettingTimestamp;
+  const at = typeof timestamp === 'number' ? timestamp : timestamp?.toNumber();
+  if (seconds === undefined || at === undefined || !Number.isSafeInteger(at) || at <= 0) return undefined;
+  return { duration: seconds, at };
+}
+
+export class SendExpiry {
+  private readonly chats = new Map<string, Setting>();
+
+  constructor(private readonly accountId: string) {}
+
+  private note(chat: ChatUpdate): void {
+    if (!chat.id || !isPrivateJid(chat.id)) return;
+    const next = setting(chat);
+    if (!next) return;
+    const known = this.chats.get(chat.id);
+    if (known && known.at > next.at) return;
+    this.chats.delete(chat.id);
+    this.chats.set(chat.id, next);
+    if (this.chats.size > MAX_CHATS) {
+      const oldest = this.chats.keys().next().value;
+      if (oldest !== undefined) this.chats.delete(oldest);
+    }
+  }
+
+  bind(sock: WASocket, current: () => boolean): void {
+    this.chats.clear();
+    const note = (chats: readonly ChatUpdate[]): void => {
+      if (current()) for (const chat of chats) this.note(chat);
+    };
+    sock.ev.on('chats.upsert', note);
+    sock.ev.on('chats.update', note);
+    sock.ev.on('messaging-history.set', ({ chats }) => { note(chats); });
+    sock.ev.on('chats.delete', (jids) => {
+      if (current()) for (const jid of jids) this.chats.delete(jid);
+    });
+  }
+
+  async forSend(sock: WASocket, jid: string, content: Content): Promise<number | undefined> {
+    if ('edit' in content || 'delete' in content || 'react' in content) return undefined;
+    if (!isGroupJid(jid)) return this.chats.get(jid)?.duration;
+    try {
+      const group = await sock.groupMetadata(jid);
+      return duration(group.ephemeralDuration ?? 0);
+    } catch (err) {
+      log.warn({ accountId: this.accountId, err: errMsg(err) }, 'whatsapp: send expiry unknown; local history may omit the message');
+      return undefined;
+    }
+  }
+}

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

@@ -0,0 +1,40 @@
+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';
+import { nameFiles } from './names.js';
+import { historyFiles } from './history-files.js';
+import { channelFiles } from './channel-chats.js';
+
+export const whatsappStation: Station = {
+  name: 'whatsapp',
+  hasAccounts: true,
+  hasTrain: true,
+  messageVerbs: new Set<Verb>([
+    'read',
+    'send',
+    'reply',
+    'react',
+    'unreact',
+    'edit',
+    'delete',
+    'typing',
+  ]),
+  attachmentMode: 'canonical',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
+  resolvesSenders: true,
+  discoversChannels: true,
+  forget: (accountId) => {
+    tokenFiles.forget(accountId);
+    nameFiles.forget(accountId);
+    historyFiles.forget(accountId);
+    channelFiles.forget(accountId);
+  },
+  forgetExcept: (kept) => {
+    tokenFiles.forgetExcept(kept);
+    nameFiles.forgetExcept(kept);
+    historyFiles.forgetExcept(kept);
+    channelFiles.forgetExcept(kept);
+  },
+  tools: [],
+};

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

@@ -0,0 +1,94 @@
+import { readJson, writeSecure } from '@metro-labs/core/secure-fs';
+import { accountFiles } from '@metro-labs/core/stations/account-files';
+import { errMsg } from '@metro-labs/core/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);
+
+export const tokenFiles = accountFiles('WHATSAPP_TOKEN_DIR', 'whatsapp-tokens-');
+
+export const tokenStorePath = (accountId: string): string => tokenFiles.path(accountId);
+
+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,5 @@
+export interface WhatsAppAccount {
+  id: string;
+  phone: string;
+  credentials?: unknown;
+}

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

@@ -0,0 +1,34 @@
+{
+  "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/core": "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/node-bindings": "1.9.1",
+    "@xmtp/node-sdk": "^6.0.0",
+    "@zerodev/ecdsa-validator": "5.4.9",
+    "@zerodev/sdk": "5.5.10",
+    "viem": "^2.52.2"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.3",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
+}

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

@@ -0,0 +1,103 @@
+import {
+  Client,
+  type ClientOptions,
+  type Conversation,
+} from '@xmtp/node-sdk';
+import { homedir } from 'node:os';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { CODECS } from './codecs.js';
+import { expandHome, identityFor, XMTP_ENV } from './identity.js';
+import type { SmartAccount } from './smart.js';
+import {
+  makeAccountStore,
+  resolveAccountId,
+} from '@metro-labs/core/stations/account-store';
+import { Line } from '@metro-labs/core/lines';
+
+export interface AccountConfig {
+  id: string;
+  privateKey?: string;
+  dbPath?: string;
+  smart?: boolean;
+}
+
+export const { loadAccounts } = makeAccountStore<AccountConfig>({
+  prefix: 'xmtp',
+  validate(raw, die) {
+    for (const a of raw) if (!a.privateKey) die(`account '${a.id}' needs a privateKey`);
+  },
+});
+
+function resolvePrivateKey(cfg: AccountConfig): string {
+  const privateKey = cfg.privateKey?.trim();
+  if (!privateKey) throw new Error(`account '${cfg.id}' has no privateKey`);
+  return privateKey;
+}
+
+export interface Account {
+  cfg: AccountConfig;
+  client: Client<unknown>;
+  inboxId: string;
+  address: string;
+  smart: SmartAccount | null;
+}
+export const accounts = new Map<string, Account>();
+
+export async function bootAccount(cfg: AccountConfig): Promise<void> {
+  const { signer, address, smart } = await identityFor(resolvePrivateKey(cfg), cfg.smart === true);
+  const dbPath = expandHome(
+    cfg.dbPath ?? join(homedir(), '.metro', `xmtp-${XMTP_ENV}-${cfg.id}.db3`),
+  );
+  const fresh = !existsSync(dbPath);
+  const options: ClientOptions = { env: XMTP_ENV, codecs: CODECS(), dbPath };
+  const client: Client<unknown> = await Client.create(signer, options);
+  accounts.set(cfg.id, { cfg, client, inboxId: client.inboxId, address, smart });
+  if (fresh)
+    process.stderr.write(
+      `xmtp[${cfg.id}] registered a NEW installation for this machine — ` +
+        'an inbox allows 10, and each machine you run metro on spends one\n',
+    );
+  process.stderr.write(
+    `xmtp[${cfg.id}] ready — inbox ${client.inboxId} (${address})\n`,
+  );
+}
+
+export function lineOf(accountId: string, convId: string): string {
+  return `metro://xmtp/${accountId}/${convId}`;
+}
+
+export function parseLine(
+  line: string,
+): { accountId: string; convId: string } | null {
+  const p = Line.parseXmtp(line);
+  return p ? { accountId: p.accountId, convId: p.resource } : null;
+}
+
+export function accountForCall(args: {
+  account?: string;
+  line?: string;
+}): Account {
+  const id = resolveAccountId(
+    accounts,
+    args,
+    (line) => parseLine(line)?.accountId,
+  );
+  const acct = accounts.get(id);
+  if (!acct) throw new Error(`unknown account '${id}'`);
+  return acct;
+}
+
+export async function convOf(
+  line: string,
+): Promise<{ acct: Account; conv: Conversation | undefined }> {
+  const parsed = parseLine(line);
+  if (!parsed) throw new Error(`bad xmtp line: ${line}`);
+  const acct = accounts.get(parsed.accountId);
+  if (!acct)
+    throw new Error(`unknown account '${parsed.accountId}' in line ${line}`);
+  return {
+    acct,
+    conv: await acct.client.conversations.getConversationById(parsed.convId),
+  };
+}

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

@@ -0,0 +1,110 @@
+import { errMsg } from '@metro-labs/core/log';
+import { accountForCall, convOf, lineOf, type Account } from './accounts.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import type { GroupLike } from './labels.js';
+
+type Args = Record<string, unknown>;
+
+async function removeSelfFromGroup(
+  id: string,
+  group: GroupLike & { removeMembers: (ids: string[]) => Promise<void> },
+  acct: Account,
+  resolvedLine: string,
+  removed: string[],
+): Promise<boolean> {
+  try {
+    await group.removeMembers([acct.inboxId]);
+    return true;
+  } catch (e) {
+    respond(id, {
+      result: {
+        line: resolvedLine,
+        id: group.id,
+        account: acct.cfg.id,
+        removed,
+        leftSelf: false,
+        selfRemovalError: `self-removal not supported: ${errMsg(e)}`,
+      },
+    });
+    return false;
+  }
+}
+
+type ClosableGroup = GroupLike & {
+  removeMembers: (ids: string[]) => Promise<void>;
+};
+
+async function resolveCloseTarget(
+  id: string,
+  args: Args,
+  acct: Account,
+): Promise<{ group: ClosableGroup; resolvedLine: string } | null> {
+  const { line, groupId } = args as { line?: string; groupId?: string };
+  const resolvedLine =
+    line ?? (groupId ? lineOf(acct.cfg.id, groupId) : undefined);
+  if (!resolvedLine) {
+    respond(id, { error: 'closeGroup requires `line` or `groupId`' });
+    return null;
+  }
+  const { conv } = await convOf(resolvedLine);
+  if (!conv) {
+    respond(id, { error: `conversation not found for ${resolvedLine}` });
+    return null;
+  }
+  const group = conv as unknown as ClosableGroup;
+  if (typeof group.removeMembers !== 'function') {
+    respond(id, {
+      error: 'closeGroup target is not a group (no removeMembers)',
+    });
+    return null;
+  }
+  await group.sync?.().catch(() => undefined);
+  return { group, resolvedLine };
+}
+
+export async function closeGroup(id: string, args: Args): Promise<void> {
+  const { removeInboxIds, removeSelf } = args as {
+    removeInboxIds?: string[];
+    removeSelf?: boolean;
+  };
+  const acct = accountForCall(args);
+  const target = await resolveCloseTarget(id, args, acct);
+  if (!target) return;
+  const { group, resolvedLine } = target;
+  const removeMembers = group.removeMembers.bind(group);
+
+  const others = (removeInboxIds ?? []).filter(
+    (iid) => typeof iid === 'string' && iid && iid !== acct.inboxId,
+  );
+  const removed: string[] = [];
+  let leftSelf = false;
+  try {
+    if (others.length) {
+      await removeMembers(others);
+      removed.push(...others);
+    }
+    if (removeSelf) {
+      leftSelf = await removeSelfFromGroup(
+        id,
+        group,
+        acct,
+        resolvedLine,
+        removed,
+      );
+      if (!leftSelf) return;
+    }
+  } catch (err) {
+    respond(id, { error: errMsg(err) });
+    return;
+  }
+
+  respond(id, {
+    result: {
+      line: resolvedLine,
+      id: group.id,
+      account: acct.cfg.id,
+      removed,
+      leftSelf,
+    },
+  });
+}