@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

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

@@ -0,0 +1,344 @@
+import { readFileSync, rmSync, statSync } from 'node:fs';
+import { clearHistoryTemps, historyFiles } from './history-files.js';
+import { writeSecure } from '@metro-labs/core/secure-fs';
+import { isRecord } from '@metro-labs/core/is-record';
+import { TrainError } from '@metro-labs/core/train-error';
+import type { proto, WAMessageKey } from 'baileys';
+import { HistoryIdentity, normalizedJid } from './history-identity.js';
+import type { WAMediaRef } from './media.js';
+import { historyJid, historyKey, clipped, numberOf } from './history-message.js';
+import { HISTORY_AGE_MS, HISTORY_LIMITS, newestFirst, slotOf, type StoredRow } from './history-types.js';
+
+export { historyFiles } from './history-files.js';
+
+const validTime = (v: unknown): v is number => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0 && v < 8.64e15;
+const invalid = (): never => { throw new TrainError('whatsapp_history_invalid', 'WhatsApp local history is invalid; refusing to discard replay protection'); };
+
+function mediaKind(value: unknown): value is WAMediaRef['kind'] {
+  return value === 'image' || value === 'video' || value === 'audio' || value === 'voice' || value === 'document' || value === 'sticker';
+}
+
+function mediaFromDisk(value: unknown): WAMediaRef {
+  if (!isRecord(value)) return invalid();
+  const kind = value.kind;
+  if (!mediaKind(kind)) return invalid();
+  return {
+    kind,
+    ...(typeof value.mime === 'string' ? { mime: clipped(value.mime, 128) } : {}),
+    ...(typeof value.name === 'string' ? { name: clipped(value.name, 256) } : {}),
+    ...(validTime(value.bytes) ? { bytes: value.bytes } : {}),
+  };
+}
+
+function optionalTime(value: unknown): number | undefined {
+  if (value === undefined) return undefined;
+  return validTime(value) ? value : invalid();
+}
+
+function metadataFromDisk(value: Record<string, unknown>): Omit<StoredRow, 'key' | 'at' | 'text'> {
+  const expiresAt = optionalTime(value.expiresAt);
+  const editedAt = optionalTime(value.editedAt);
+  const media = value.attachments;
+  if (media !== undefined && (!Array.isArray(media) || media.length > 1)) return invalid();
+  return {
+    ...(typeof value.senderJid === 'string' && value.senderJid.length <= 256 ? { senderJid: value.senderJid } : {}),
+    ...(value.truncated === true ? { truncated: true } : {}),
+    ...(Array.isArray(media) ? { attachments: media.map(mediaFromDisk) } : {}),
+    ...(expiresAt === undefined ? {} : { expiresAt }),
+    ...(editedAt === undefined ? {} : { editedAt }),
+  };
+}
+
+function rowFromDisk(value: unknown): StoredRow {
+  if (!isRecord(value)) return invalid();
+  const key = historyKey(value.key);
+  if (!key || key.isViewOnce || !validTime(value.at) || typeof value.text !== 'string') return invalid();
+  return { key, at: value.at, text: clipped(value.text, HISTORY_LIMITS.textBytes), ...metadataFromDisk(value) };
+}
+
+function timesFromDisk(value: unknown): Map<string, number> {
+  if (!Array.isArray(value)) return invalid();
+  const result = new Map<string, number>();
+  for (const item of value) {
+    if (!Array.isArray(item) || item.length !== 2 || typeof item[0] !== 'string' || item[0].length > 4096 || !validTime(item[1])) return invalid();
+    result.set(item[0], item[1]);
+  }
+  return result;
+}
+
+function rangeKey(jid: string, key: WAMessageKey | null | undefined): WAMessageKey | undefined {
+  return historyKey({ ...key, remoteJid: key?.remoteJid ?? jid });
+}
+
+function flagFromDisk(value: unknown): boolean {
+  if (value === undefined) return false;
+  return typeof value === 'boolean' ? value : invalid();
+}
+
+function unavailableFromDisk(value: unknown = []): Set<string> {
+  if (!Array.isArray(value) || value.length > HISTORY_LIMITS.unavailableChats) return invalid();
+  const jids: string[] = [];
+  for (const jid of value) {
+    if (typeof jid !== 'string' || !historyJid(jid)) return invalid();
+    jids.push(normalizedJid(jid));
+  }
+  return new Set(jids);
+}
+
+function readState(path: string): unknown {
+  try {
+    if (statSync(path).size > HISTORY_LIMITS.bytes) return invalid();
+    return JSON.parse(readFileSync(path, 'utf8')) as unknown;
+  } catch (err) {
+    if (isRecord(err) && err.code === 'ENOENT') return undefined;
+    throw err;
+  }
+}
+
+export class HistoryState {
+  readonly rows = new Map<string, StoredRow>();
+  private tombstones = new Map<string, number>();
+  private chatFloors = new Map<string, number>();
+  private floor: number;
+  private written = '';
+  private invalidated = false;
+  private readonly path: string;
+  private identities = new HistoryIdentity();
+  private unavailableChats = new Set<string>();
+  private unavailableOverflow = false;
+
+  constructor(private readonly accountId: string) {
+    this.path = historyFiles.path(accountId);
+    clearHistoryTemps(this.path);
+    this.floor = Date.now() - HISTORY_AGE_MS;
+    const raw = readState(this.path);
+    if (raw === undefined) return;
+    if (!isRecord(raw) || raw.version !== 1 || raw.accountId !== accountId || !validTime(raw.floor) || !Array.isArray(raw.rows)) return invalid();
+    const invalidated = flagFromDisk(raw.invalidated);
+    this.floor = Math.max(this.floor, raw.floor, invalidated ? Date.now() : 0);
+    this.identities = new HistoryIdentity(raw.aliases);
+    for (const item of raw.rows) {
+      const row = rowFromDisk(item);
+      this.identities.remember(row.key);
+      this.put(row);
+    }
+    this.tombstones = timesFromDisk(raw.tombstones);
+    this.chatFloors = timesFromDisk(raw.chatFloors);
+    this.unavailableChats = unavailableFromDisk(raw.unavailableChats);
+    this.unavailableOverflow = flagFromDisk(raw.unavailableOverflow);
+    this.aliasesChanged(Date.now());
+    if (invalidated) this.flush();
+  }
+
+  invalidate(now: number): void {
+    this.invalidated = true;
+    this.floor = Math.max(this.floor, now);
+    this.rows.clear();
+    this.tombstones.clear();
+    this.chatFloors.clear();
+    this.unavailableChats.clear();
+    this.unavailableOverflow = false;
+    this.identities.clear();
+    this.flush();
+  }
+
+  alias(pn: string, lid: string, now: number): void {
+    if (this.identities.alias(pn, lid)) this.aliasesChanged(now);
+  }
+
+  observe(key: WAMessageKey, now: number): void {
+    if (this.identities.remember(key)) this.aliasesChanged(now);
+  }
+
+  same(left: string, right: string): boolean { return this.identities.same(left, right); }
+
+  assertReadable(jid: string): void {
+    if (this.unavailableOverflow || this.identities.known(jid).some((alias) => this.unavailableChats.has(alias)))
+      throw new TrainError('whatsapp_history_unavailable', 'WhatsApp local history is unavailable because a chat deletion had no safe message range');
+  }
+
+  private unavailable(jid: string): void {
+    if (this.unavailableOverflow) return;
+    this.unavailableChats.add(this.identities.canonical(jid));
+    if (this.unavailableChats.size > HISTORY_LIMITS.unavailableChats) {
+      this.unavailableOverflow = true;
+      this.unavailableChats.clear();
+    }
+  }
+
+  private forgetAliases(): void {
+    this.unavailableOverflow ||= this.unavailableChats.size > 0;
+    this.identities.clear();
+  }
+
+  private aliasesChanged(now: number): void {
+    if (this.identities.size > HISTORY_LIMITS.aliases) {
+      this.floor = Math.max(this.floor, now);
+      this.forgetAliases();
+    }
+    this.sweep(now);
+    const seen = new Map<string, StoredRow>();
+    for (const row of this.rows.values()) {
+      const id = slotOf({ ...row.key, remoteJid: this.identities.canonical(row.key.remoteJid ?? '') });
+      const old = seen.get(id);
+      if (!old) { seen.set(id, row); continue; }
+      seen.set(id, this.merge(row, old));
+    }
+  }
+
+  private merge(row: StoredRow, old: StoredRow): StoredRow {
+    const kept = (row.editedAt ?? 0) > (old.editedAt ?? 0) ? row : old;
+    const dropped = kept === row ? old : row;
+    if (dropped.expiresAt !== undefined) kept.expiresAt = Math.min(kept.expiresAt ?? Infinity, dropped.expiresAt);
+    this.rows.delete(this.slot(dropped.key));
+    return kept;
+  }
+
+  private slot(key: WAMessageKey): string {
+    return slotOf({ ...key, remoteJid: normalizedJid(key.remoteJid ?? '') });
+  }
+
+  private slots(key: WAMessageKey): string[] {
+    return this.identities.known(key.remoteJid ?? '').map((jid) => slotOf({ remoteJid: jid, id: key.id }));
+  }
+
+  get(key: WAMessageKey): StoredRow | undefined {
+    for (const slot of this.slots(key)) {
+      const row = this.rows.get(slot);
+      if (row) return row;
+    }
+    return undefined;
+  }
+
+  put(row: StoredRow): void { this.rows.set(this.slot(row.key), row); }
+
+  after(jid: string): number {
+    return Math.max(this.floor, ...this.identities.known(jid).map((alias) => this.chatFloors.get(alias) ?? 0));
+  }
+
+  outside(key: WAMessageKey, at: number, now: number): boolean {
+    return at <= Math.max(now - HISTORY_AGE_MS, this.after(key.remoteJid ?? ''), this.after(key.remoteJidAlt ?? ''));
+  }
+
+  blocked(key: WAMessageKey, at: number): boolean {
+    return this.slots(key).some((slot) => this.tombstones.has(slot)) || at <= this.after(key.remoteJid ?? '');
+  }
+
+  remove(key: WAMessageKey, now: number, at?: number): void {
+    const clean = historyKey(key);
+    if (!clean) return;
+    const originalAt = this.get(clean)?.at ?? at;
+    if (originalAt !== undefined && this.outside(clean, originalAt, now)) return;
+    this.observe(clean, now);
+    let horizon = now;
+    for (const slot of this.slots(clean)) {
+      horizon = Math.max(horizon, this.rows.get(slot)?.at ?? 0, this.tombstones.get(slot) ?? 0);
+      this.rows.delete(slot);
+      this.tombstones.delete(slot);
+    }
+    this.tombstones.set(this.slot(clean), horizon);
+  }
+
+  clear(jid: string, cutoff: number): void {
+    if (!historyJid(jid)) return;
+    this.chatFloors.set(this.identities.canonical(jid), Math.max(cutoff, this.after(jid)));
+    for (const [slot, row] of this.rows)
+      if (this.same(row.key.remoteJid ?? '', jid) && row.at <= cutoff) this.rows.delete(slot);
+  }
+
+  clearRange(jid: string, range: proto.SyncActionValue.ISyncActionMessageRange, now: number): void {
+    if (!historyJid(jid)) return;
+    const cutoff = (numberOf(range.lastMessageTimestamp) ?? 0) * 1000;
+    let usable = cutoff > 0 && cutoff <= now;
+    if (usable) this.clear(jid, cutoff);
+    for (const item of range.messages ?? []) {
+      const key = rangeKey(jid, item.key);
+      const cleared = this.clearKey(jid, key, numberOf(item.timestamp), now);
+      usable ||= cleared;
+    }
+    if (!usable) this.unavailable(jid);
+  }
+
+  private clearKey(jid: string, key: WAMessageKey | undefined, at: number | undefined, now: number): boolean {
+    if (!key || (at !== undefined && at * 1000 > now)) return false;
+    if (!this.same(key.remoteJid ?? '', jid) && !this.same(key.remoteJidAlt ?? '', jid)) return false;
+    this.observe(key, now);
+    this.remove(key, now, at === undefined ? undefined : at * 1000);
+    return true;
+  }
+
+  private sweep(now: number): void {
+    this.floor = Math.max(this.floor, now - HISTORY_AGE_MS);
+    for (const [slot, row] of this.rows) {
+      if (this.blocked(row.key, row.at)) this.rows.delete(slot);
+      else if (row.expiresAt !== undefined && row.expiresAt <= now) this.remove(row.key, now);
+    }
+    for (const map of [this.tombstones, this.chatFloors])
+      for (const [key, cutoff] of map) if (cutoff <= this.floor) map.delete(key);
+  }
+
+  private trimMarkers(map: Map<string, number>, max: number): void {
+    if (map.size <= max) return;
+    const sorted = [...map.entries()].sort((a, b) => a[1] - b[1]);
+    for (const [key, cutoff] of sorted.slice(0, map.size - max)) {
+      this.floor = Math.max(this.floor, cutoff);
+      map.delete(key);
+    }
+  }
+
+  prune(now: number): void {
+    this.sweep(now);
+    const sorted = [...this.rows.values()].sort(newestFirst);
+    const counts = new Map<string, number>();
+    for (const [index, row] of sorted.entries()) {
+      const jid = this.identities.canonical(row.key.remoteJid ?? '');
+      const count = (counts.get(jid) ?? 0) + 1;
+      counts.set(jid, count);
+      if (count > HISTORY_LIMITS.rowsPerChat) this.chatFloors.set(jid, Math.max(this.after(jid), row.at));
+      if (index >= HISTORY_LIMITS.rows) this.floor = Math.max(this.floor, row.at);
+    }
+    this.trimMarkers(this.chatFloors, HISTORY_LIMITS.chatFloors);
+    this.trimMarkers(this.tombstones, HISTORY_LIMITS.tombstones);
+    this.sweep(now);
+    this.trimBytes(now);
+  }
+
+  private serialize(): string {
+    return JSON.stringify({
+      version: 1, accountId: this.accountId, floor: this.floor,
+      rows: [...this.rows.values()], aliases: this.identities.serialize(),
+      ...(this.invalidated ? { invalidated: true } : {}),
+      unavailableChats: [...this.unavailableChats], unavailableOverflow: this.unavailableOverflow,
+      tombstones: [...this.tombstones], chatFloors: [...this.chatFloors],
+    });
+  }
+
+  private trimBytes(now: number): void {
+    let bytes = Buffer.byteLength(this.serialize());
+    if (bytes <= HISTORY_LIMITS.bytes) return;
+    for (const row of [...this.rows.values()].sort(newestFirst).reverse()) {
+      this.rows.delete(this.slot(row.key));
+      this.floor = Math.max(this.floor, row.at);
+      bytes -= Buffer.byteLength(JSON.stringify(row)) + 1;
+      if (bytes < HISTORY_LIMITS.bytes - 1024) break;
+    }
+    this.sweep(now);
+    if (Buffer.byteLength(this.serialize()) > HISTORY_LIMITS.bytes) {
+      this.floor = Math.max(now, this.floor, ...this.tombstones.values(), ...this.chatFloors.values());
+      this.forgetAliases();
+      this.sweep(now);
+    }
+  }
+
+  flush(): void {
+    this.prune(Date.now());
+    const body = this.serialize();
+    if (body === this.written) return;
+    try {
+      writeSecure(this.path, body);
+      this.written = body;
+    } finally {
+      rmSync(`${this.path}.tmp-${process.pid}`, { force: true });
+    }
+  }
+}

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

@@ -0,0 +1,91 @@
+import type { proto, WAMessage, WAMessageKey, WAMessageUpdate } from 'baileys';
+import type { WAMediaRef } from './media.js';
+
+export const HISTORY_LIMITS = Object.freeze({
+  days: 30,
+  rows: 5000,
+  rowsPerChat: 500,
+  bytes: 8 * 1024 * 1024,
+  textBytes: 16 * 1024,
+  tombstones: 5000,
+  chatFloors: 1000,
+  unavailableChats: 1000,
+  aliases: 5000,
+  pageSize: 100,
+  pageBytes: 2 * 1024 * 1024,
+});
+
+export const HISTORY_SWEEP_MS = 60_000;
+export const HISTORY_SAVE_MS = 1000;
+export const HISTORY_AGE_MS = HISTORY_LIMITS.days * 86_400_000;
+
+export interface HistoryRow {
+  key: WAMessageKey;
+  messageId: string;
+  chatJid: string;
+  senderJid?: string;
+  fromMe: boolean;
+  timestamp: string;
+  text: string;
+  truncated?: boolean;
+  attachments?: WAMediaRef[];
+}
+
+export interface StoredRow {
+  key: WAMessageKey;
+  at: number;
+  senderJid?: string;
+  text: string;
+  truncated?: boolean;
+  attachments?: WAMediaRef[];
+  editedAt?: number;
+  expiresAt?: number;
+}
+
+export interface HistoryOptions {
+  limit?: number;
+  before?: string;
+  since?: string;
+}
+
+export interface HistoryPage {
+  messages: HistoryRow[];
+  count: number;
+  hasMore: boolean;
+  nextBefore?: string;
+  coverage: {
+    partial: true;
+    source: 'local';
+    description: string;
+    oldest: string | null;
+    newest: string | null;
+    retained: number;
+    retainedAfter: string;
+    limits: typeof HISTORY_LIMITS;
+  };
+}
+
+export type HistoryDelete = { keys: readonly WAMessageKey[] } | { jid: string; all: true };
+
+export interface History {
+  read(jid: string, options?: HistoryOptions): HistoryPage;
+  ingest(messages: readonly WAMessage[], selfJid?: string): void;
+  ingestSent(messages: readonly WAMessage[], selfJid?: string, ephemeralExpiration?: number): void;
+  alias(pn: string, lid: string): void;
+  clearRange(jid: string, range?: proto.SyncActionValue.ISyncActionMessageRange | null): void;
+  invalidate(): void;
+  update(updates: readonly WAMessageUpdate[], selfJid?: string): void;
+  deleteMessages(event: HistoryDelete): void;
+  edit(jid: string, messageId: string, text: string): void;
+  flush(): void;
+  close(): void;
+}
+
+export const slotOf = (key: WAMessageKey): string => JSON.stringify([key.remoteJid, key.id]);
+
+export function newestFirst(a: StoredRow, b: StoredRow): number {
+  if (a.at !== b.at) return b.at - a.at;
+  const left = slotOf(a.key);
+  const right = slotOf(b.key);
+  return left === right ? 0 : left < right ? 1 : -1;
+}

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

@@ -0,0 +1,195 @@
+import { errMsg, log } from '@metro-labs/core/log';
+import { TrainError } from '@metro-labs/core/train-error';
+import type { proto, WAMessage, WAMessageUpdate } from 'baileys';
+import { HistoryEvents } from './history-events.js';
+import { HistoryState } from './history-state.js';
+import {
+  HISTORY_LIMITS, HISTORY_SAVE_MS, HISTORY_SWEEP_MS, newestFirst,
+  type History, type HistoryDelete, type HistoryOptions, type HistoryPage, type HistoryRow, type StoredRow,
+} from './history-types.js';
+
+export { historyFiles } from './history-state.js';
+export type { History, HistoryOptions, HistoryPage, HistoryRow } from './history-types.js';
+
+function shown(row: StoredRow): HistoryRow {
+  return {
+    key: { ...row.key }, messageId: row.key.id ?? '', chatJid: row.key.remoteJid ?? '',
+    fromMe: row.key.fromMe === true, timestamp: new Date(row.at).toISOString(), text: row.text,
+    ...(row.senderJid ? { senderJid: row.senderJid } : {}),
+    ...(row.truncated ? { truncated: true } : {}),
+    ...(row.attachments ? { attachments: row.attachments.map((a) => ({ ...a })) } : {}),
+  };
+}
+
+function readBounds(options: HistoryOptions): { limit: number; since: number } {
+  const limit = options.limit ?? 50;
+  const since = options.since === undefined ? 0 : Date.parse(options.since);
+  if (!Number.isInteger(limit) || limit < 1 || !Number.isFinite(since))
+    throw new TrainError('bad_request', 'WhatsApp history needs a positive integer limit and a valid since timestamp');
+  return { limit: Math.min(limit, HISTORY_LIMITS.pageSize), since };
+}
+
+const rowTime = (row: StoredRow | undefined): string | null => row === undefined ? null : new Date(row.at).toISOString();
+
+function boundedPage(result: HistoryPage, rows: StoredRow[], limit: number): HistoryPage {
+  let bytes = Buffer.byteLength(JSON.stringify(result));
+  for (const row of rows.slice(0, limit)) {
+    const message = shown(row);
+    const added = Buffer.byteLength(JSON.stringify(message)) + 1;
+    const cursor = Buffer.byteLength(JSON.stringify({ count: result.messages.length + 1, hasMore: true, nextBefore: message.messageId }));
+    if (bytes + added + cursor > HISTORY_LIMITS.pageBytes - 128 * 1024) break;
+    result.messages.push(message);
+    bytes += added;
+  }
+  result.count = result.messages.length;
+  result.hasMore = rows.length > result.count;
+  if (result.hasMore) result.nextBefore = result.messages.at(-1)?.messageId;
+  return result;
+}
+
+function page(state: HistoryState, jid: string, options: HistoryOptions): HistoryPage {
+  const { limit, since } = readBounds(options);
+  const rows = [...state.rows.values()].filter((row) => state.same(row.key.remoteJid ?? '', jid)).sort(newestFirst);
+  const before = options.before === undefined ? -1 : rows.findIndex((row) => row.key.id === options.before);
+  if (options.before !== undefined && before < 0)
+    throw new TrainError('whatsapp_history_cursor', 'The before message is not retained in this chat. Read without before to restart local pagination.');
+  const matching = rows.slice(before + 1).filter((row) => row.at >= since);
+  return boundedPage({
+    messages: [], count: 0, hasMore: false,
+    coverage: {
+      partial: true, source: 'local',
+      description: 'Only locally observed or synced messages and successful sends with known expiry state. Own sends with unknown expiry are omitted until observed or synced. Gaps remain; no older backfill or media downloads. View-once and unknown-expiry content is omitted. before is exclusive; since is inclusive. Pages reserve output-formatting overhead within the serialized-byte limit. hasMore describes retained local matches only.',
+      oldest: rowTime(rows.at(-1)), newest: rowTime(rows[0]),
+      retained: rows.length, retainedAfter: new Date(state.after(jid)).toISOString(), limits: HISTORY_LIMITS,
+    },
+  }, matching, limit);
+}
+
+class LocalHistory implements History {
+  private readonly state: HistoryState;
+  private readonly events: HistoryEvents;
+  private readonly sweep: ReturnType<typeof setInterval>;
+  private timer?: ReturnType<typeof setTimeout>;
+  private closed = false;
+
+  constructor(private readonly accountId: string) {
+    this.state = new HistoryState(accountId);
+    this.events = new HistoryEvents(this.state);
+    this.state.prune(Date.now());
+    this.sweep = setInterval(() => { this.saveSafely(); }, HISTORY_SWEEP_MS);
+    this.sweep.unref();
+    this.schedule();
+  }
+
+  private assertOpen(): void {
+    if (this.closed) throw new TrainError('whatsapp_history_closed', 'WhatsApp local history is closed');
+  }
+
+  private saveSafely(): void {
+    try {
+      this.flush();
+    } catch (err) {
+      log.error({ accountId: this.accountId, err: errMsg(err) }, 'whatsapp: could not save local history');
+    }
+  }
+
+  private schedule(): void {
+    if (this.timer) return;
+    this.timer = setTimeout(() => { this.saveSafely(); }, HISTORY_SAVE_MS);
+    this.timer.unref();
+  }
+
+  private changed(now: number): void {
+    this.state.prune(now);
+    this.schedule();
+  }
+
+  read(jid: string, options: HistoryOptions = {}): HistoryPage {
+    this.assertOpen();
+    this.changed(Date.now());
+    this.state.assertReadable(jid);
+    return page(this.state, jid, options);
+  }
+
+  ingest(messages: readonly WAMessage[], selfJid?: string): void {
+    this.ingestAll(messages, selfJid);
+  }
+
+  ingestSent(messages: readonly WAMessage[], selfJid?: string, ephemeralExpiration?: number): void {
+    this.ingestAll(messages, selfJid, { expiration: ephemeralExpiration });
+  }
+
+  private ingestAll(messages: readonly WAMessage[], selfJid?: string, sent?: { expiration?: number }): void {
+    this.assertOpen();
+    const now = Date.now();
+    for (const [index, message] of messages.entries()) {
+      this.events.ingest(message, now, selfJid, sent);
+      if (index % 128 === 127) this.state.prune(now);
+    }
+    this.changed(now);
+  }
+
+  alias(pn: string, lid: string): void {
+    this.assertOpen();
+    const now = Date.now();
+    this.state.alias(pn, lid, now);
+    this.changed(now);
+  }
+
+  clearRange(jid: string, range?: proto.SyncActionValue.ISyncActionMessageRange | null): void {
+    this.assertOpen();
+    const now = Date.now();
+    this.state.clearRange(jid, range ?? {}, now);
+    this.changed(now);
+  }
+
+  invalidate(): void {
+    this.assertOpen();
+    this.state.invalidate(Date.now());
+  }
+
+  update(updates: readonly WAMessageUpdate[], selfJid?: string): void {
+    this.assertOpen();
+    const now = Date.now();
+    for (const [index, update] of updates.entries()) {
+      this.events.update(update, now, selfJid);
+      if (index % 128 === 127) this.state.prune(now);
+    }
+    this.changed(now);
+  }
+
+  deleteMessages(event: HistoryDelete): void {
+    this.assertOpen();
+    const now = Date.now();
+    if ('keys' in event) {
+      for (const [index, key] of event.keys.entries()) {
+        this.state.remove(key, now);
+        if (index % 128 === 127) this.state.prune(now);
+      }
+    } else this.state.clear(event.jid, now);
+    this.changed(now);
+  }
+
+  edit(jid: string, messageId: string, text: string): void {
+    this.assertOpen();
+    const now = Date.now();
+    this.state.prune(now);
+    this.events.edit(jid, messageId, text, now);
+    this.changed(now);
+  }
+
+  flush(): void {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = undefined;
+    this.state.flush();
+  }
+
+  close(): void {
+    if (this.closed) return;
+    clearInterval(this.sweep);
+    this.closed = true;
+    this.flush();
+  }
+}
+
+export const createHistory = (accountId: string): History => new LocalHistory(accountId);

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

@@ -1,9 +1,8 @@
 import type { WAMessage } from 'baileys';
-import { errMsg } from '@metro-labs/mcp/log';
-import { emit } from './wire.js';
+import { emit } from '@metro-labs/core/stations/station-runtime';
+import { reportAttachment } from '@metro-labs/core/stations/train-events';
+import { lineOf } from './accounts.js';
 import {
-  attachmentFailedEnvelope,
-  attachmentSavedEnvelope,
   envelope,
   reactionEnvelope,
   type InboundMessage,
@@ -11,31 +10,19 @@ import {
 import { saveWhatsAppMedia } from './attachments.js';
 import type { WAClient } from './client.js';
 
-async function saveMedia(
+function saveMedia(
   client: WAClient,
   m: InboundMessage,
   raw: WAMessage,
   sourceId: string,
-): Promise<void> {
+): void {
   const ref = m.media;
   if (!ref) return;
-  try {
-    const saved = await saveWhatsAppMedia(
-      m.accountId,
-      raw,
-      ref,
-      m.messageId,
-      0,
-      (msg) => client.reuploadMedia(msg),
-    );
-    emit(attachmentSavedEnvelope(m, sourceId, ref, saved, 0));
-  } catch (err) {
-    const reason = errMsg(err);
-    process.stderr.write(
-      `whatsapp[${m.accountId}] ${ref.kind} download failed for ${m.messageId}: ${reason}\n`,
-    );
-    emit(attachmentFailedEnvelope(m, sourceId, ref, 0, reason));
-  }
+  reportAttachment(
+    saveWhatsAppMedia(m.accountId, raw, ref, m.messageId, 0, (msg) => client.reuploadMedia(msg)),
+    { station: 'whatsapp', account: m.accountId, line: lineOf(m.accountId, m.chatJid), forId: sourceId, index: 0 },
+    { saved: { kind: ref.kind }, failed: { kind: ref.kind, name: ref.name, mime: ref.mime } },
+  );
 }
 
 export async function startInbound(client: WAClient): Promise<void> {
@@ -44,11 +31,7 @@ export async function startInbound(client: WAClient): Promise<void> {
       const env = envelope(m);
       emit(env);
       if (!m.media) return;
-      saveMedia(client, m, raw, String(env.id)).catch((err: unknown) => {
-        process.stderr.write(
-          `whatsapp[${m.accountId}] media event not emitted: ${errMsg(err)}\n`,
-        );
-      });
+      saveMedia(client, m, raw, String(env.id));
     },
     onReaction: (r) => {
       emit(reactionEnvelope(r));