@stage-labs/metro 0.1.0-beta.30 → 0.1.0-beta.301

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

@@ -0,0 +1,48 @@
+import type { WASocket } from 'baileys';
+import { ChannelDirectory, DIRECTORY_LIMIT, type ChannelEntry, type ChannelList } from '@metro-labs/core/stations/channel-directory';
+import { lineOf } from './accounts.js';
+import { KnownChats, channelName } from './channel-chats.js';
+
+const REASON = `Participating groups come from WhatsApp. Direct chats are limited to at most ${DIRECTORY_LIMIT} chat metadata records observed or synced to this installation; WhatsApp has no all-direct-chats directory. Cleared chats are omitted, and WhatsApp channels are not enumerated.`;
+
+export class WhatsAppChannels {
+  private readonly chats: KnownChats;
+  private readonly directory = new ChannelDirectory();
+
+  constructor(private readonly accountId: string) {
+    this.chats = new KnownChats(accountId);
+  }
+
+  bind(sock: Pick<WASocket, 'ev'>, current: () => boolean): void {
+    sock.ev.on('chats.upsert', (chats) => {
+      if (current()) this.chats.note(chats, true);
+    });
+    sock.ev.on('chats.update', (chats) => {
+      if (current()) this.chats.note(chats, true);
+    });
+    sock.ev.on('messaging-history.set', ({ chats }) => {
+      if (current()) this.chats.note(chats);
+    });
+    sock.ev.on('chats.delete', (ids) => {
+      if (current()) this.chats.remove(ids);
+    });
+    sock.ev.on('chats.clear', ({ id }) => {
+      if (current()) this.chats.remove([id]);
+    });
+  }
+
+  list(ready: () => Promise<Pick<WASocket, 'groupFetchAllParticipating'>>, args: Record<string, unknown>): Promise<ChannelList> {
+    return this.directory.list(this.accountId, args, async () => {
+      const groups = await (await ready()).groupFetchAllParticipating();
+      const channels: ChannelEntry[] = [];
+      for (const group of Object.values(groups)) {
+        if (!/^\d+(?:-\d+)?@g\.us$/.test(group.id) || group.id.length > 128) continue;
+        const name = channelName(group.subject);
+        channels.push({ id: group.id, line: lineOf(this.accountId, group.id), kind: 'group', ...(name ? { name } : {}) });
+        if (channels.length > DIRECTORY_LIMIT) break;
+      }
+      channels.push(...this.chats.list());
+      return { channels, capability: { supported: true, complete: false, source: 'mixed', reason: REASON } };
+    });
+  }
+}

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

@@ -0,0 +1,31 @@
+import { log } from '@metro-labs/core/log';
+import { TrainError } from '@metro-labs/core/train-error';
+import { supportsHistoryDeletion } from './app-state.js';
+import { createHistory, type History } from './history.js';
+
+const UNAVAILABLE = 'WhatsApp local history is unavailable because this runtime lacks the deletion patch. Ask the owner to update and restart Metro to load the patched runtime. Prior history was invalidated to avoid stale deleted messages.';
+const ignore = (): void => undefined;
+
+export function createClientHistory(accountId: string, supported = supportsHistoryDeletion()): History {
+  const history = createHistory(accountId);
+  if (supported) return history;
+  try {
+    history.invalidate();
+  } finally {
+    history.close();
+  }
+  log.warn({ accountId }, UNAVAILABLE);
+  return {
+    read() { throw new TrainError('whatsapp_history_unavailable', UNAVAILABLE); },
+    ingest: ignore,
+    ingestSent: ignore,
+    alias: ignore,
+    clearRange: ignore,
+    invalidate: ignore,
+    update: ignore,
+    deleteMessages: ignore,
+    edit: ignore,
+    flush: ignore,
+    close: ignore,
+  };
+}

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

@@ -0,0 +1,48 @@
+import type makeWASocket from 'baileys';
+import type { fetchLatestWaWebVersion, WAMessage } from 'baileys';
+import type { MemberList } from '@metro-labs/core/stations/types';
+import type { ChannelList } from '@metro-labs/core/stations/channel-directory';
+import type { ProfileChange } from '@metro-labs/core/stations/profile';
+import type { SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import type { WhatsAppAccount } from './types.js';
+import type { InboundMessage, ReactionInput } from './format.js';
+import type { SenderFound } from './resolve.js';
+import type { HistoryOptions, HistoryPage } from './history.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>;
+  read(jid: string, options?: HistoryOptions): Promise<HistoryPage>;
+  listMembers(jid: string, limit?: number): Promise<MemberList>;
+  listChannels(args: Record<string, unknown>): Promise<ChannelList>;
+  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>;
+  showTyping(jid: 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>;
+  setProfile(change: ProfileChange): Promise<void>;
+  senderProfile(jid: string): Promise<SenderProfile | null>;
+  disconnect(): Promise<void>;
+}
+
+export interface ClientRuntime {
+  makeSocket: typeof makeWASocket;
+  fetchVersion: typeof fetchLatestWaWebVersion;
+}

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

@@ -1,4 +1,5 @@
 import makeWASocket, {
+  jidNormalizedUser,
   Browsers,
   DisconnectReason,
   fetchLatestWaWebVersion,
@@ -7,12 +8,21 @@ import makeWASocket, {
   type WAMessageKey,
   type WASocket,
 } from 'baileys';
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { errMsg } from '@metro-labs/mcp/log';
+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 { toInbound, toReaction, type ReactionEvent } from './parse.js';
+import type { InboundHandlers, WAClient, WAMedia, ClientRuntime } from './client-types.js';
+export type { InboundHandlers, WAClient, WAMedia } from './client-types.js';
+import { makeProfileCache, nonEmpty, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import type { SelfRef } from './parse.js';
+import type { History } from './history.js';
+import { createClientHistory } from './client-history.js';
+import { WhatsAppChannels } from './channels.js';
+import { bindMessages } from './messages.js';
+import { listMembers } from './members.js';
+import { SendExpiry } from './send-expiry.js';
 import { baileysLogger } from './logger.js';
+import { makeNameBook, nameFiles, phoneOf, type NameBook } from './names.js';
 import { useAccountAuthState } from './auth-state.js';
 import { knownKey, makeKeyCache, targetKey, type KeyCache } from './keys.js';
 import { makeOutbox, type Outbox } from './outbox.js';
@@ -25,69 +35,47 @@ import {
   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;
+  runtime: ClientRuntime;
+  history: History;
+  expiry: SendExpiry;
   handlers?: InboundHandlers;
   sock?: WASocket;
   closed: boolean;
+  closing?: Promise<void>;
   openResolve?: () => void;
   openPromise: Promise<void>;
   keys: KeyCache;
   outbox: Outbox;
   acks: AckWatch;
+  names: NameBook;
+  channels: WhatsAppChannels;
 }
-
 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);
-      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);
-    }
+  bindMessages(sock, {
+    accountId: st.account.id,
+    keys: st.keys,
+    names: st.names,
+    history: st.history,
+    current: () => !st.closed && st.sock === sock,
+    handlers: () => st.handlers,
+    self: () => selfRef(st, sock),
   });
 }
 
@@ -168,19 +156,22 @@ async function connect(st: State): Promise<void> {
     st.account.credentials,
     st.account.id,
   );
-  const { version, error } = await fetchLatestWaWebVersion({});
+  if (st.closed) return;
+  const { version, error } = await st.runtime.fetchVersion({});
+  if (st.closed) return;
   if (error) {
     throw new TrainError(
       'whatsapp_connect',
       `failed to fetch WhatsApp web version: ${errMsg(error)}`,
     );
   }
-  const sock = makeWASocket({
+  const sock = st.runtime.makeSocket({
     version,
     auth: state,
     browser: Browsers.macOS('Safari'),
     markOnlineOnConnect: false,
     syncFullHistory: false,
+    emitOwnEvents: false,
     logger: baileysLogger(st.account.id),
     getMessage: (key) => Promise.resolve(servedFromOutbox(st, key)),
   });
@@ -188,15 +179,25 @@ async function connect(st: State): Promise<void> {
   sock.ev.on('creds.update', () => void saveCreds());
   bindConnection(st, sock);
   bindInbound(st, sock);
+  st.channels.bind(sock, () => !st.closed && st.sock === sock);
+  st.expiry.bind(sock, () => !st.closed && st.sock === 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');
+  if (st.closed || !st.sock) throw new TrainError('whatsapp_call', 'socket not connected');
   return st.sock;
 }
-
 async function send(
   st: State,
   jid: string,
@@ -204,10 +205,13 @@ async function send(
   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;
+  const expiration = await st.expiry.forSend(sock, jid, content);
+  if (st.closed || st.sock !== sock) throw new TrainError('whatsapp_call', 'socket not connected');
+  const sent = await sock.sendMessage(jid, content, expiration === undefined ? opts : { ...opts, ephemeralExpiration: expiration });
+  const key = sent?.key;
+  st.keys.remember(key);
+  st.outbox.remember(key, sent?.message);
+  const messageId = key?.id;
   if (!messageId)
     throw new TrainError(
       'whatsapp_call',
@@ -216,9 +220,15 @@ async function send(
   const ack = await st.acks.wait(messageId, ACK_WAIT_MS);
   const refused = ack ? rejection(ack) : undefined;
   if (refused) throw refused;
+  recordSent(st, sock, sent, expiration);
   return messageId;
 }
 
+function recordSent(st: State, sock: WASocket, sent: WAMessage | undefined, expiration?: number): void {
+  if (!sent || st.closed) return;
+  st.history.ingestSent([sent], sock.user?.id ? jidNormalizedUser(sock.user.id) : undefined, expiration);
+}
+
 function quotedOpts(st: State, jid: string, quotedId: string): SendOpts {
   return {
     quoted: {
@@ -244,16 +254,60 @@ function mediaContent(m: WAMedia): SendContent {
   };
 }
 
-export function createClient(account: WhatsAppAccount): WAClient {
+async function readProfile(st: State, jid: string): Promise<SenderProfile> {
+  const sock = await ready(st);
+  const [statuses, avatar] = await Promise.all([sock.fetchStatus(jid).catch(() => undefined), sock.profilePictureUrl(jid, 'image').catch(() => undefined)]);
+  const about = nonEmpty((statuses?.[0]?.status as { status?: unknown } | undefined)?.status);
+  const picture = nonEmpty(avatar);
+  const phone = phoneOf(jid.endsWith('@lid') ? await sock.signalRepository.lidMapping.getPNForLID(jid).catch(() => null) : jid);
+  const name = st.names.get(jid);
+  return {
+    id: jid,
+    ...(name === undefined ? {} : { display_name: name }),
+    ...(phone === undefined ? {} : { name: phone, address: phone }),
+    ...(about === undefined ? {} : { about }),
+    ...(picture === undefined ? {} : { avatar: picture }),
+  };
+}
+
+async function disconnect(st: State): Promise<void> {
+  st.closed = true;
+  st.openResolve?.();
+  try {
+    st.history.close();
+  } finally {
+    const sock = st.sock;
+    st.sock = undefined;
+    await sock?.end(undefined);
+  }
+}
+
+function initialState(account: WhatsAppAccount, runtime: ClientRuntime): State {
   const st: State = {
     account,
+    runtime,
+    history: createClientHistory(account.id),
+    expiry: new SendExpiry(account.id),
     closed: false,
     openPromise: Promise.resolve(),
     keys: makeKeyCache(),
     outbox: makeOutbox(),
     acks: makeAckWatch(),
+    names: makeNameBook(nameFiles.path(account.id)),
+    channels: new WhatsAppChannels(account.id),
   };
   resetGate(st);
+  return st;
+}
+
+export function createClient(
+  account: WhatsAppAccount,
+  runtime: ClientRuntime = { makeSocket: makeWASocket, fetchVersion: fetchLatestWaWebVersion },
+): WAClient {
+  const st = initialState(account, runtime);
+  const senders = makeProfileCache<SenderProfile>((jid) => readProfile(st, jid), {
+    onError: (jid, err) => process.stderr.write(`whatsapp[${st.account.id}] could not read the profile of ${jid}: ${errMsg(err)}\n`),
+  });
   return {
     account,
     self() {
@@ -271,6 +325,18 @@ export function createClient(account: WhatsAppAccount): WAClient {
         );
       }
     },
+    read(jid, options) {
+      const page = st.history.read(jid, options);
+      for (const message of page.messages) st.keys.remember(message.key);
+      return Promise.resolve(page);
+    },
+    listMembers(jid, limit) {
+      return listMembers(jid, async (node): Promise<unknown> => await (await ready(st)).query(node), st.names, limit);
+    },
+    listChannels(args) {
+      if (st.closed) return Promise.reject(new TrainError('whatsapp_call', 'socket not connected'));
+      return st.channels.list(() => ready(st), args);
+    },
     sendText(jid, text, quotedId) {
       return send(
         st,
@@ -287,6 +353,10 @@ export function createClient(account: WhatsAppAccount): WAClient {
         quotedId ? quotedOpts(st, jid, quotedId) : undefined,
       );
     },
+    async showTyping(jid) {
+      const sock = await ready(st);
+      await sock.sendPresenceUpdate('composing', jid);
+    },
     async sendReaction(jid, messageId, emoji) {
       const target = targetKey(st.keys, jid, messageId, 'react to');
       await send(st, jid, { react: { text: emoji, key: target } });
@@ -301,18 +371,30 @@ export function createClient(account: WhatsAppAccount): WAClient {
       await send(st, jid, {
         delete: knownKey(st.keys, jid, messageId, true),
       });
+      if (!st.closed) st.history.deleteMessages({ keys: [{ remoteJid: jid, id: messageId }] });
     },
     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;
+    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 setProfile(change) {
+      const sock = await ready(st);
+      if (change.name !== undefined) await sock.updateProfileName(change.name);
+      if (change.bio !== undefined) await sock.updateProfileStatus(change.bio);
+      if (change.avatar !== undefined) {
+        const me = sock.user?.id;
+        if (me === undefined) throw new TrainError('whatsapp_call', 'own jid unknown');
+        await sock.updateProfilePicture(me, { url: change.avatar.path });
       }
     },
+    senderProfile: (jid) => senders.get(jid),
+    disconnect: () => st.closing ??= disconnect(st),
   };
 }

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

@@ -1,6 +1,5 @@
-import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
 import { lineOf } from './accounts.js';
-import { mintId, SELF_URI } from './wire.js';
+import { mintId } from '@metro-labs/core/stations/station-runtime';
 import type { WAMediaRef } from './media.js';
 
 export interface InboundMessage {
@@ -13,6 +12,9 @@ export interface InboundMessage {
   isPrivate: boolean;
   pushName?: string;
   media?: WAMediaRef;
+  replyTo?: string;
+  mentionsSelf?: boolean;
+  replyToSelf?: boolean;
 }
 
 export interface ReactionInput {
@@ -38,7 +40,6 @@ function attachmentView(ref: WAMediaRef): Record<string, unknown> {
 
 export function envelope(m: InboundMessage): Record<string, unknown> {
   return {
-    kind: 'inbound',
     id: mintId(),
     ts: m.date.toISOString(),
     station: 'whatsapp',
@@ -48,6 +49,9 @@ export function envelope(m: InboundMessage): Record<string, unknown> {
     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,
@@ -56,63 +60,8 @@ export function envelope(m: InboundMessage): Record<string, unknown> {
   };
 }
 
-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',