@stage-labs/metro 0.1.0-beta.263 → 0.1.0-beta.264

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));
+  },
+};

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

@@ -0,0 +1,58 @@
+import { jidNormalizedUser, type WAMessageKey } from 'baileys';
+import { TrainError } from '@metro-labs/core/train-error';
+import { HISTORY_LIMITS } from './history-types.js';
+
+export const normalizedJid = (jid: string): string => jidNormalizedUser(jid);
+const phone = (jid: string): boolean => jid.endsWith('@s.whatsapp.net');
+const lid = (jid: string): boolean => jid.endsWith('@lid');
+const identity = (v: unknown): v is string => typeof v === 'string' && v.length <= 256 && (phone(v) || lid(v));
+const invalid = (): never => { throw new TrainError('whatsapp_history_invalid', 'WhatsApp history aliases are invalid; refusing to discard replay protection'); };
+
+export class HistoryIdentity {
+  private readonly groups = new Map<string, readonly string[]>();
+
+  constructor(value: unknown = []) {
+    if (!Array.isArray(value)) return invalid();
+    for (const group of value) this.restore(group);
+    if (this.groups.size > HISTORY_LIMITS.aliases) return invalid();
+  }
+
+  private restore(group: unknown): void {
+    if (!Array.isArray(group) || !group.every(identity)) return invalid();
+    const pn = group.find(phone);
+    const alternate = group.find(lid);
+    if (!pn || !alternate) return invalid();
+    for (const jid of group) this.alias(jid, phone(jid) ? alternate : pn);
+  }
+
+  get size(): number { return this.groups.size; }
+
+  known(jid: string): readonly string[] {
+    const normalized = normalizedJid(jid);
+    return this.groups.get(normalized) ?? [normalized];
+  }
+
+  canonical(jid: string): string { return this.known(jid)[0] ?? normalizedJid(jid); }
+
+  same(left: string, right: string): boolean { return this.canonical(left) === this.canonical(right); }
+
+  alias(left: string, right: string): boolean {
+    if (!identity(left) || !identity(right)) return false;
+    const a = normalizedJid(left);
+    const b = normalizedJid(right);
+    if (phone(a) === phone(b) || this.same(a, b)) return false;
+    const group = [...new Set([...this.known(a), ...this.known(b)])].sort();
+    for (const jid of group) this.groups.set(jid, group);
+    return true;
+  }
+
+  remember(key: WAMessageKey): boolean {
+    const chat = this.alias(key.remoteJid ?? '', key.remoteJidAlt ?? '');
+    const sender = this.alias(key.participant ?? '', key.participantAlt ?? '');
+    return chat || sender;
+  }
+
+  clear(): void { this.groups.clear(); }
+
+  serialize(): readonly (readonly string[])[] { return [...new Set(this.groups.values())]; }
+}

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

@@ -0,0 +1,161 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import type { WAMessage, WAMessageKey, proto } from 'baileys';
+import { mediaRefIn, type WAMediaRef } from './media.js';
+import { extractText, isGroupJid, isPrivateJid } from './parse.js';
+import { HISTORY_LIMITS, type StoredRow } from './history-types.js';
+
+const KEY_STRINGS = [
+  'remoteJid', 'id', 'participant', 'remoteJidAlt', 'remoteJidUsername',
+  'participantAlt', 'participantUsername', 'server_id', 'addressingMode',
+] as const;
+const CONTEXT_NODES = [
+  'extendedTextMessage', 'imageMessage', 'videoMessage', 'audioMessage',
+  'documentMessage', 'stickerMessage',
+] as const;
+
+type Timestamp = number | { toNumber(): number } | null | undefined;
+
+export function numberOf(value: Timestamp): number | undefined {
+  const n = typeof value === 'number' ? value : typeof value?.toNumber === 'function' ? value.toNumber() : undefined;
+  return n !== undefined && Number.isSafeInteger(n) && n > 0 ? n : undefined;
+}
+
+export function clipped(text: string, bytes: number): string {
+  if (Buffer.byteLength(text) <= bytes) return text;
+  const buffer = Buffer.from(text);
+  let end = bytes;
+  while (end > 0 && ((buffer[end] ?? 0) & 0xc0) === 0x80) end--;
+  return buffer.subarray(0, end).toString('utf8');
+}
+
+function keyStrings(value: Record<string, unknown>): [string, string | boolean | null][] | undefined {
+  const fields: [string, string | boolean | null][] = [];
+  for (const field of KEY_STRINGS) {
+    const v = value[field];
+    if (v === undefined) continue;
+    if (v !== null && (typeof v !== 'string' || v.length > 256)) return undefined;
+    fields.push([field, v]);
+  }
+  return fields;
+}
+
+export const historyJid = (jid: string): boolean => jid.length <= 256 && (isPrivateJid(jid) || isGroupJid(jid));
+
+function identified(key: WAMessageKey): boolean {
+  return Boolean(key.id) && historyJid(key.remoteJid ?? '');
+}
+
+export function historyKey(value: unknown): WAMessageKey | undefined {
+  if (!isRecord(value)) return undefined;
+  const fields = keyStrings(value);
+  if (!fields) return undefined;
+  for (const field of ['fromMe', 'isViewOnce']) {
+    const v = value[field];
+    if (v === undefined) continue;
+    if (v !== null && typeof v !== 'boolean') return undefined;
+    fields.push([field, v]);
+  }
+  const key: WAMessageKey = Object.fromEntries(fields);
+  return identified(key) ? key : undefined;
+}
+
+interface Content {
+  message?: proto.IMessage;
+  ephemeral: boolean;
+  forbidden: boolean;
+}
+
+function privateContent(message: proto.IMessage): boolean {
+  return [message.viewOnceMessage, message.viewOnceMessageV2, message.viewOnceMessageV2Extension,
+    message.imageMessage?.viewOnce, message.videoMessage?.viewOnce, message.audioMessage?.viewOnce,
+    message.messageContextInfo?.messageAddOnExpiryType].some(Boolean);
+}
+
+function innerOf(message: proto.IMessage): proto.IMessage | undefined {
+  const wrappers = [message.ephemeralMessage, message.deviceSentMessage, message.documentWithCaptionMessage, message.editedMessage];
+  return wrappers.find((wrapper) => wrapper?.message)?.message ?? undefined;
+}
+
+export function historyContent(message: proto.IMessage | null | undefined): Content {
+  if (!message) return { ephemeral: false, forbidden: false };
+  let current = message;
+  let ephemeral = false;
+  for (let depth = 0; current && depth < 12; depth++) {
+    if (privateContent(current)) return { ephemeral, forbidden: true };
+    ephemeral ||= Boolean(current.ephemeralMessage);
+    const inner = innerOf(current);
+    if (!inner) return { message: current, ephemeral, forbidden: false };
+    current = inner;
+  }
+  return { ephemeral, forbidden: true };
+}
+
+function contextOf(message: proto.IMessage): proto.IContextInfo | undefined {
+  for (const field of CONTEXT_NODES) {
+    const context = message[field]?.contextInfo;
+    if (context) return context;
+  }
+  return undefined;
+}
+
+const durationGiven = (n: number | null | undefined): n is number => n !== undefined && n !== null && n !== 0;
+
+function expiry(message: WAMessage, content: Content, at: number, expiration?: number): number | false | undefined {
+  const ctx = content.message ? contextOf(content.message) : undefined;
+  const duration = [message.ephemeralDuration, ctx?.expiration, expiration].filter(durationGiven);
+  if (duration.some((n) => !Number.isFinite(n) || n < 0)) return false;
+  const ephemeral = [content.ephemeral, message.ephemeralStartTimestamp, ctx?.disappearingMode, ctx?.ephemeralSettingTimestamp].some(Boolean);
+  if (!duration.length) return ephemeral ? false : undefined;
+  const start = numberOf(message.ephemeralStartTimestamp);
+  const base = start === undefined ? at : Math.min(at, start * 1000);
+  const end = base + Math.min(...duration) * 1000;
+  return Number.isSafeInteger(end) ? end : false;
+}
+
+function attachment(message: proto.IMessage): WAMediaRef | undefined {
+  const media = mediaRefIn(message);
+  if (!media) return undefined;
+  return {
+    kind: media.kind,
+    ...(media.mime ? { mime: clipped(media.mime, 128) } : {}),
+    ...(media.name ? { name: clipped(media.name, 256) } : {}),
+    ...(Number.isSafeInteger(media.bytes) && (media.bytes ?? -1) >= 0 ? { bytes: media.bytes } : {}),
+  };
+}
+
+function senderOf(key: WAMessageKey, selfJid?: string): string | undefined {
+  const sender = key.fromMe ? selfJid : isGroupJid(key.remoteJid ?? '') ? key.participant : key.remoteJid;
+  return typeof sender === 'string' && sender.length <= 256 ? sender : undefined;
+}
+
+function retainedExpiry(value: number | false | undefined, now: number): value is number | undefined {
+  return value !== false && (value === undefined || value > now);
+}
+
+export function projectMessage(message: WAMessage, now: number, selfJid?: string, expiration?: number): StoredRow | 'omit' | undefined {
+  const key = historyKey(message.key);
+  if (!key) return undefined;
+  const content = historyContent(message.message);
+  if (key.isViewOnce || content.forbidden) return 'omit';
+  const at = (numberOf(message.messageTimestamp) ?? 0) * 1000;
+  if (!at || at > now) return undefined;
+  const expiresAt = expiry(message, content, at, expiration);
+  if (!retainedExpiry(expiresAt, now)) return 'omit';
+  if (!content.message) return undefined;
+  return projectBody(key, content.message, at, selfJid, expiresAt);
+}
+
+function projectBody(key: WAMessageKey, message: proto.IMessage, at: number, selfJid?: string, expiresAt?: number): StoredRow | undefined {
+  const source = extractText(message);
+  const media = attachment(message);
+  if (!source && !media) return undefined;
+  const text = clipped(source, HISTORY_LIMITS.textBytes);
+  const senderJid = senderOf(key, selfJid);
+  return {
+    key, at, text,
+    ...(senderJid ? { senderJid } : {}),
+    ...(text !== source ? { truncated: true } : {}),
+    ...(media ? { attachments: [media] } : {}),
+    ...(expiresAt === undefined ? {} : { expiresAt }),
+  };
+}