@stage-labs/metro 0.1.0-beta.27 → 0.1.0-beta.271

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. Restart the Metro service parent to install the patched runtime; a page Restart is not enough. 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,46 @@
+import type makeWASocket from 'baileys';
+import type { fetchLatestWaWebVersion, WAMessage } from 'baileys';
+import type { MemberList } from '@metro-labs/core/stations/types';
+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>;
+  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,20 @@ 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 { 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,42 +34,21 @@ 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;
 }
 
 type SendOpts = Parameters<WASocket['sendMessage']>[2];
@@ -72,22 +60,23 @@ function resetGate(st: State): void {
   });
 }
 
+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 +157,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,12 +180,24 @@ async function connect(st: State): Promise<void> {
   sock.ev.on('creds.update', () => void saveCreds());
   bindConnection(st, sock);
   bindInbound(st, 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;
 }
 
@@ -204,10 +208,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 +223,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 +257,59 @@ 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)),
   };
   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 +327,14 @@ 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);
+    },
     sendText(jid, text, quotedId) {
       return send(
         st,
@@ -287,6 +351,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 +369,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',

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

@@ -0,0 +1,127 @@
+import { proto, WAMessageStubType, type WAMessage, type WAMessageKey, type WAMessageUpdate } from 'baileys';
+import { clipped, historyContent, historyKey, numberOf, projectMessage } from './history-message.js';
+import { isGroupJid } from './parse.js';
+import { HISTORY_LIMITS, type StoredRow } from './history-types.js';
+import type { HistoryState } from './history-state.js';
+
+const earlierExpiry = (a?: number, b?: number): number | undefined => a === undefined ? b : b === undefined ? a : Math.min(a, b);
+const timestamp = (message: WAMessage): number | undefined => {
+  const seconds = numberOf(message.messageTimestamp);
+  return seconds === undefined ? undefined : seconds * 1000;
+};
+
+function removed(event: WAMessageUpdate): boolean {
+  return event.key.isViewOnce === true || event.update.message === null || event.update.messageStubType === WAMessageStubType.REVOKE;
+}
+
+function acceptedSent(row: StoredRow, sent?: { expiration?: number }): boolean {
+  return !sent || (row.key.fromMe === true && (row.expiresAt !== undefined || sent.expiration === 0));
+}
+
+function editedRow(old: StoredRow, row: StoredRow, revision: number): StoredRow {
+  const expiresAt = earlierExpiry(old.expiresAt, row.expiresAt);
+  return { ...old, ...row, truncated: row.truncated ?? false, editedAt: revision, ...(expiresAt === undefined ? {} : { expiresAt }) };
+}
+
+export class HistoryEvents {
+  constructor(private readonly state: HistoryState) {}
+
+  private author(old: WAMessageKey, editor: WAMessageKey): boolean {
+    if ((old.fromMe === true) !== (editor.fromMe === true)) return false;
+    if (!isGroupJid(old.remoteJid ?? '')) return true;
+    if (old.participant && editor.participant) return this.state.same(old.participant, editor.participant);
+    return old.fromMe === true;
+  }
+
+  private edited(key: WAMessageKey, message: proto.IMessage, revision: number, now: number, selfJid?: string): void {
+    const old = this.state.get(key);
+    if (!old) {
+      this.state.remove(key, now);
+      return;
+    }
+    if (!this.author(old.key, key)) return;
+    const row = projectMessage({ key: old.key, message, messageTimestamp: old.at / 1000 }, now, selfJid);
+    if (row === 'omit') this.state.remove(old.key, now, old.at);
+    if (!row || row === 'omit' || revision > now || revision <= (old.editedAt ?? old.at)) return;
+    this.state.put(editedRow(old, row, revision));
+  }
+
+  private protocol(message: WAMessage, now: number, selfJid?: string): boolean {
+    const protocol = historyContent(message.message).message?.protocolMessage;
+    if (!protocol) return false;
+    if (!protocol.key?.id) return true;
+    if (protocol.key.remoteJid && !this.state.same(protocol.key.remoteJid, message.key.remoteJid ?? '')) return true;
+    const key = historyKey({ ...message.key, id: protocol.key.id });
+    if (key) this.applyProtocol(key, protocol, message, now, selfJid);
+    return true;
+  }
+
+  private applyProtocol(key: WAMessageKey, protocol: proto.Message.IProtocolMessage, message: WAMessage, now: number, selfJid?: string): void {
+    if (protocol.type === proto.Message.ProtocolMessage.Type.REVOKE) this.state.remove(key, now);
+    if (protocol.type === proto.Message.ProtocolMessage.Type.MESSAGE_EDIT && protocol.editedMessage) {
+      const revision = numberOf(protocol.timestampMs) ?? timestamp(message) ?? 0;
+      this.edited(key, protocol.editedMessage, revision, now, selfJid);
+    }
+  }
+
+  ingest(message: WAMessage, now: number, selfJid?: string, sent?: { expiration?: number }): void {
+    if (!historyKey(message.key)) return;
+    const at = timestamp(message);
+    if (at !== undefined && this.state.outside(message.key, at, now)) return;
+    this.state.observe(message.key, now);
+    if (message.messageStubType === WAMessageStubType.REVOKE) {
+      this.state.remove(message.key, now, at);
+      return;
+    }
+    if (!this.protocol(message, now, selfJid)) this.content(message, now, selfJid, sent);
+  }
+
+  private content(message: WAMessage, now: number, selfJid?: string, sent?: { expiration?: number }): void {
+    const row = projectMessage(message, now, selfJid, sent?.expiration);
+    if (row === 'omit') this.state.remove(message.key, now, timestamp(message));
+    if (!row || row === 'omit' || this.state.blocked(row.key, row.at) || !acceptedSent(row, sent)) return;
+    const old = this.state.get(row.key);
+    if (old) this.duplicate(old, row);
+    else this.state.put(row);
+  }
+
+  private duplicate(old: StoredRow, row: StoredRow): void {
+    const expiresAt = earlierExpiry(old.expiresAt, row.expiresAt);
+    if (expiresAt !== undefined) old.expiresAt = expiresAt;
+    if (old.key.fromMe === true && old.senderJid === undefined && row.key.fromMe === true && row.senderJid) old.senderJid = row.senderJid;
+  }
+
+  update(event: WAMessageUpdate, now: number, selfJid?: string): void {
+    const { key, update } = event;
+    if (!historyKey(key)) return;
+    const originalAt = this.state.get(key)?.at ?? timestamp({ ...update, key });
+    if (removed(event) || update.ephemeralDuration || update.ephemeralStartTimestamp) {
+      this.state.remove(key, now, originalAt);
+      return;
+    }
+    this.state.observe(key, now);
+    if (!update.message) return;
+    const full = { ...update, key };
+    if (this.protocol(full, now, selfJid)) return;
+    const revision = timestamp(full);
+    if (revision) this.edited(key, update.message, revision, now, selfJid);
+    else this.refresh(full, now, selfJid);
+  }
+
+  private refresh(message: WAMessage, now: number, selfJid?: string): void {
+    const old = this.state.get(message.key);
+    const row = projectMessage({ ...message, messageTimestamp: old ? old.at / 1000 : undefined }, now, selfJid);
+    if (row === 'omit') this.state.remove(message.key, now, old?.at);
+    else if (row && old) this.duplicate(old, row);
+  }
+
+  edit(jid: string, messageId: string, source: string, now: number): void {
+    const old = this.state.get({ remoteJid: jid, id: messageId });
+    if (!old) {
+      this.state.remove({ remoteJid: jid, id: messageId }, now);
+      return;
+    }
+    const text = clipped(source, HISTORY_LIMITS.textBytes);
+    this.state.put({ ...old, text, truncated: text !== source, editedAt: now });
+  }
+}

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

@@ -0,0 +1,39 @@
+import { readdirSync, rmSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { accountFiles, type AccountFiles } from '@metro-labs/core/stations/account-files';
+import { isRecord } from '@metro-labs/core/is-record';
+
+const files = accountFiles('WHATSAPP_TOKEN_DIR', 'whatsapp-history-');
+const TEMP_NAME = /^(whatsapp-history-[A-Za-z0-9_-]*\.json)\.tmp-[1-9]\d*$/;
+
+function cleanTemps(dir: string, remove: (name: string) => boolean): void {
+  let names: string[];
+  try {
+    names = readdirSync(dir);
+  } catch (err) {
+    if (isRecord(err) && err.code === 'ENOENT') return;
+    throw err;
+  }
+  for (const name of names) {
+    const original = TEMP_NAME.exec(name)?.[1];
+    if (original && remove(original)) rmSync(join(dir, name), { force: true });
+  }
+}
+
+export function clearHistoryTemps(path: string): void {
+  const name = basename(path);
+  cleanTemps(dirname(path), (original) => original === name);
+}
+
+export const historyFiles: AccountFiles = {
+  path: files.path,
+  forget(accountId) {
+    files.forget(accountId);
+    clearHistoryTemps(files.path(accountId));
+  },
+  forgetExcept(keptAccountIds) {
+    files.forgetExcept(keptAccountIds);
+    const kept = new Set(keptAccountIds.map((id) => basename(files.path(id))));
+    cleanTemps(dirname(files.path('')), (original) => !kept.has(original));
+  },
+};