@ezychat/wa 0.1.49 → 0.1.51

package/dist/baileys/adapter.d.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'node:events';
 import { type BaileysEventMap, type MessageUpsertType, type MessageUserReceiptUpdate, type WAMessageUpdate, type WAMessage } from 'baileys';
 import type { WaStatus } from '@ezychat/shared';
-import { type SendResult, type WaAdapter, type WaAdapterEvents, type WaAdapterOptions, type WaContactAlias, type WaGroupInfo, type WaMessageStatusUpdate, type WaSendFile, type WaSendOptions } from '../types.js';
+import { type SendResult, type WaAdapter, type WaAdapterEvents, type WaAdapterOptions, type WaContactAlias, type WaGroupInfo, type WaMessageStatusUpdate, type WaReactionTarget, type WaSendFile, type WaSendOptions } from '../types.js';
 /** True when a send error means "the connection went away" (retry later) rather than a real rejection. */
 export declare function isConnectionError(err: unknown): boolean;
 /** Per-participant group receipt → our status (read wins over delivered). */
@@ -87,6 +87,7 @@ export declare class BaileysAdapter extends EventEmitter implements WaAdapter {
     private send;
     sendText(chatJid: string, text: string, opts?: WaSendOptions): Promise<SendResult>;
     sendMedia(chatJid: string, file: WaSendFile, opts?: WaSendOptions): Promise<SendResult>;
+    sendReaction(chatJid: string, target: WaReactionTarget, emoji: string): Promise<SendResult>;
     markRead(chatJid: string, messageIds: string[]): Promise<void>;
     sendPresence(chatJid: string, presence: 'composing' | 'paused'): Promise<void>;
     downloadMedia(messageId: string): Promise<Buffer | null>;

package/dist/baileys/adapter.js

@@ -5,7 +5,7 @@ import { WaUnavailableError, } from '../types.js';
 import { createAuthStore } from './auth-store.js';
 import { backoffMs, classifyDisconnect } from './disconnect.js';
 import { Lru } from './lru.js';
-import { jidType, mapWAMessage, toMs } from './mapping.js';
+import { jidType, mapStoredReactions, mapWAMessage, mapWAReaction, toMs } from './mapping.js';
 import { quotedForChat, quotedFromRef } from './quoted.js';
 import { contactAliasPair, normalizeContactJid } from './contact-aliases.js';
 import { checkedNumberJid } from './number-check.js';
@@ -429,8 +429,22 @@ export class BaileysAdapter extends EventEmitter {
         const id = m.key?.id;
         if (!id)
             return;
+        // A reaction arrives as its own message in messages.upsert (live) and in history batches.
+        // Baileys also emits messages.reaction for the same live reaction: that event is not
+        // subscribed, so a reaction is counted once.
+        const reaction = mapWAReaction(m);
+        if (reaction) {
+            if (source === 'history' && reaction.timestamp < this.historyCutoff())
+                return;
+            this.emitTyped('reaction', reaction, { source });
+            return;
+        }
         if (m.message)
             this.raw.set(id, m);
+        // History sync keeps earlier reactions on the reacted message itself.
+        if (source === 'history')
+            for (const r of mapStoredReactions(m))
+                this.emitTyped('reaction', r, { source });
         const mapped = mapWAMessage(m, (raw) => this.download(raw));
         if (!mapped)
             return;
@@ -585,7 +599,9 @@ export class BaileysAdapter extends EventEmitter {
             throw new WaUnavailableError();
         return this.sock;
     }
-    async send(chatJid, content, opts) {
+    async send(chatJid, content, opts, 
+    /** keep the sent message for quotes and media (not for reactions) */
+    cache = true) {
         const sock = this.requireOpen();
         // The live cache is small and cleared on reconnect; rebuild older quotes from the saved copy.
         // Either way the quote points at the chat the reply goes to (phone number or WhatsApp ID).
@@ -609,7 +625,8 @@ export class BaileysAdapter extends EventEmitter {
         const id = res?.key?.id;
         if (!res || !id)
             throw new Error('send returned no message id');
-        this.raw.set(id, res);
+        if (cache)
+            this.raw.set(id, res);
         return { id, timestamp: toMs(res.messageTimestamp) };
     }
     sendText(chatJid, text, opts) {
@@ -647,6 +664,17 @@ export class BaileysAdapter extends EventEmitter {
         }
         return this.send(chatJid, content, opts);
     }
+    sendReaction(chatJid, target, emoji) {
+        // The cached key carries the group author exactly as WhatsApp delivered it.
+        const participant = this.raw.get(target.id)?.key?.participant ?? target.participant;
+        const key = {
+            remoteJid: chatJid,
+            id: target.id,
+            fromMe: target.fromMe,
+            ...(participant && chatJid.endsWith('@g.us') ? { participant } : {}),
+        };
+        return this.send(chatJid, { react: { text: emoji, key } }, undefined, false);
+    }
     async markRead(chatJid, messageIds) {
         const sock = this.requireOpen();
         const keys = messageIds.map((id) => {

package/dist/baileys/mapping.d.ts

@@ -1,5 +1,5 @@
 import { type proto, type WAMessage } from 'baileys';
-import type { WaIncomingMessage } from '../types.js';
+import type { WaIncomingMessage, WaReaction } from '../types.js';
 export type JidKind = 'dm' | 'group' | 'other';
 export declare function jidType(jid: string): JidKind;
 type LongLike = {
@@ -10,12 +10,24 @@ type LongLike = {
 };
 /** Convert a protobuf timestamp (number | Long | null) in seconds to epoch ms. */
 export declare function toMs(ts: number | LongLike | null | undefined, fallback?: number): number;
+/**
+ * A live or history reaction message (`reactionMessage`): who reacted with which emoji to which
+ * message. Empty text = the reaction was removed. Null for anything else, for reactions without a
+ * target or reactor, and for status/broadcast/newsletter chats. Encrypted reactions
+ * (`encReactionMessage`, community announcements) are not read.
+ */
+export declare function mapWAReaction(msg: proto.IWebMessageInfo): WaReaction | null;
+/**
+ * Reactions WhatsApp attached to a stored message (history sync keeps them on the message itself,
+ * `WebMessageInfo.reactions`, instead of separate reaction messages). Removed ones are skipped.
+ */
+export declare function mapStoredReactions(msg: proto.IWebMessageInfo): WaReaction[];
 /** Optional hook for media downloads that need a live socket (reupload of expired media). */
 export type MediaDownloader = (msg: WAMessage) => Promise<Buffer>;
 /**
  * Map a raw Baileys message to our adapter shape. Returns null for messages
- * that should not appear in the inbox (reactions, protocol, key distribution,
- * status/newsletter/broadcast, empty).
+ * that should not appear in the inbox (reactions — read by mapWAReaction —, protocol, key
+ * distribution, status/newsletter/broadcast, empty).
  */
 export declare function mapWAMessage(msg: proto.IWebMessageInfo, download?: MediaDownloader): WaIncomingMessage | null;
 export {};

package/dist/baileys/mapping.js

@@ -20,11 +20,95 @@ export function toMs(ts, fallback = Date.now()) {
         return ((ts.high >>> 0) * 2 ** 32 + (ts.low >>> 0)) * 1000;
     return fallback;
 }
+/** A protobuf millisecond timestamp (number | Long | null) as epoch ms, or `fallback`. */
+function msToNumber(ts, fallback) {
+    if (ts == null)
+        return fallback;
+    if (typeof ts === 'number')
+        return ts;
+    if ('toNumber' in ts && typeof ts.toNumber === 'function')
+        return ts.toNumber();
+    if ('low' in ts)
+        return (ts.high >>> 0) * 2 ** 32 + (ts.low >>> 0);
+    return fallback;
+}
+/** Who reacted, from the reaction's own message key (group participant, DM partner or us). */
+function reactor(key, chatJid) {
+    const fromMe = !!key.fromMe;
+    if (fromMe)
+        return { senderJid: null, senderJidAlt: null, fromMe };
+    if (jidType(chatJid) !== 'group')
+        return { senderJid: normalizeContactJid(chatJid) ?? chatJid, senderJidAlt: null, fromMe };
+    return {
+        senderJid: normalizeContactJid(key.participant),
+        senderJidAlt: normalizeContactJid(key.participantAlt),
+        fromMe,
+    };
+}
+/**
+ * A live or history reaction message (`reactionMessage`): who reacted with which emoji to which
+ * message. Empty text = the reaction was removed. Null for anything else, for reactions without a
+ * target or reactor, and for status/broadcast/newsletter chats. Encrypted reactions
+ * (`encReactionMessage`, community announcements) are not read.
+ */
+export function mapWAReaction(msg) {
+    const key = msg.key;
+    const chatJid = key?.remoteJid;
+    if (!key || !chatJid || jidType(chatJid) === 'other')
+        return null;
+    const reaction = normalizeMessageContent(msg.message)?.reactionMessage;
+    const targetId = reaction?.key?.id;
+    if (!reaction || !targetId)
+        return null;
+    const who = reactor(key, chatJid);
+    if (!who.fromMe && !who.senderJid)
+        return null;
+    const isGroup = jidType(chatJid) === 'group';
+    const alt = isGroup ? null : normalizeContactJid(key.remoteJidAlt);
+    return {
+        targetId,
+        chatJid,
+        chatJidAlt: alt && alt.endsWith('@lid') !== chatJid.endsWith('@lid') ? alt : null,
+        ...who,
+        senderName: who.fromMe ? null : (msg.pushName ?? null),
+        emoji: reaction.text ?? '',
+        timestamp: msToNumber(reaction.senderTimestampMs, toMs(msg.messageTimestamp)),
+    };
+}
+/**
+ * Reactions WhatsApp attached to a stored message (history sync keeps them on the message itself,
+ * `WebMessageInfo.reactions`, instead of separate reaction messages). Removed ones are skipped.
+ */
+export function mapStoredReactions(msg) {
+    const chatJid = msg.key?.remoteJid;
+    const targetId = msg.key?.id;
+    if (!chatJid || !targetId || jidType(chatJid) === 'other' || !msg.reactions?.length)
+        return [];
+    const fallback = toMs(msg.messageTimestamp);
+    return msg.reactions.flatMap((r) => {
+        if (!r.key || !r.text)
+            return [];
+        const who = reactor(r.key, chatJid);
+        if (!who.fromMe && !who.senderJid)
+            return [];
+        return [
+            {
+                targetId,
+                chatJid,
+                chatJidAlt: null,
+                ...who,
+                senderName: null,
+                emoji: r.text,
+                timestamp: msToNumber(r.senderTimestampMs, fallback),
+            },
+        ];
+    });
+}
 const defaultDownloader = async (msg) => (await downloadMediaMessage(msg, 'buffer', {}));
 /**
  * Map a raw Baileys message to our adapter shape. Returns null for messages
- * that should not appear in the inbox (reactions, protocol, key distribution,
- * status/newsletter/broadcast, empty).
+ * that should not appear in the inbox (reactions — read by mapWAReaction —, protocol, key
+ * distribution, status/newsletter/broadcast, empty).
  */
 export function mapWAMessage(msg, download = defaultDownloader) {
     const key = msg.key;

package/dist/fake/fake-adapter.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
 import type { WaStatus } from '@ezychat/shared';
-import { type SendResult, type WaAdapter, type WaAdapterEvents, type WaContactAlias, type WaGroupInfo, type WaIncomingMessage, type WaSendFile, type WaSendOptions } from '../types.js';
+import { type SendResult, type WaAdapter, type WaAdapterEvents, type WaContactAlias, type WaGroupInfo, type WaIncomingMessage, type WaReaction, type WaReactionTarget, type WaSendFile, type WaSendOptions } from '../types.js';
 export interface FakeSentRecord {
     chatJid: string;
     text?: string;
@@ -31,6 +31,11 @@ export declare class FakeWaAdapter extends EventEmitter implements WaAdapter {
     readonly groupInfoCalls: string[];
     readonly aboutCalls: string[];
     readonly sent: FakeSentRecord[];
+    readonly reactions: Array<{
+        chatJid: string;
+        target: WaReactionTarget;
+        emoji: string;
+    }>;
     readonly reads: Array<{
         chatJid: string;
         messageIds: string[];
@@ -70,6 +75,8 @@ export declare class FakeWaAdapter extends EventEmitter implements WaAdapter {
     private afterSend;
     sendText(chatJid: string, text: string, opts?: WaSendOptions): Promise<SendResult>;
     sendMedia(chatJid: string, file: WaSendFile, opts?: WaSendOptions): Promise<SendResult>;
+    /** Like WhatsApp, the linked number's own reaction comes back as a `reaction` event first. */
+    sendReaction(chatJid: string, target: WaReactionTarget, emoji: string): Promise<SendResult>;
     markRead(chatJid: string, messageIds: string[]): Promise<void>;
     sendPresence(chatJid: string, presence: 'composing' | 'paused'): Promise<void>;
     downloadMedia(messageId: string): Promise<Buffer | null>;
@@ -97,6 +104,15 @@ export declare class FakeWaAdapter extends EventEmitter implements WaAdapter {
         chatJid: string;
         body: string;
     }): WaIncomingMessage;
+    /**
+     * Emit a reaction (live unless `source` says history): `emoji` '' removes the person's reaction.
+     * In a DM the reactor defaults to the chat partner; `fromMe` means the linked number reacted.
+     */
+    simulateReaction(p: Partial<WaReaction> & {
+        chatJid: string;
+        targetId: string;
+        emoji: string;
+    }, source?: 'live' | 'history'): WaReaction;
     simulateStatus(s: Partial<WaStatus>): void;
     failNextSend(err?: Error): void;
     setConnected(connected: boolean): void;

package/dist/fake/fake-adapter.js

@@ -23,6 +23,7 @@ export class FakeWaAdapter extends EventEmitter {
     groupInfoCalls = [];
     aboutCalls = [];
     sent = [];
+    reactions = [];
     reads = [];
     presences = [];
     /**
@@ -111,6 +112,15 @@ export class FakeWaAdapter extends EventEmitter {
         this.media.set(id, file.buffer);
         return this.afterSend(chatJid, id);
     }
+    /** Like WhatsApp, the linked number's own reaction comes back as a `reaction` event first. */
+    async sendReaction(chatJid, target, emoji) {
+        this.beforeSend();
+        const id = `${this.idPrefix}-REACT-${FAKE_RUN}-${++this.outCounter}`;
+        const timestamp = Date.now();
+        this.reactions.push({ chatJid, target: { ...target }, emoji });
+        this.simulateReaction({ chatJid, targetId: target.id, emoji, fromMe: true, timestamp });
+        return { id, timestamp };
+    }
     async markRead(chatJid, messageIds) {
         this.reads.push({ chatJid, messageIds: [...messageIds] });
     }
@@ -209,6 +219,33 @@ export class FakeWaAdapter extends EventEmitter {
         this.emitTyped('message', msg, { source: 'live' });
         return msg;
     }
+    /**
+     * Emit a reaction (live unless `source` says history): `emoji` '' removes the person's reaction.
+     * In a DM the reactor defaults to the chat partner; `fromMe` means the linked number reacted.
+     */
+    simulateReaction(p, source = 'live') {
+        const isGroup = p.chatJid.endsWith('@g.us');
+        const fromMe = p.fromMe ?? false;
+        const reaction = {
+            targetId: p.targetId,
+            chatJid: p.chatJid,
+            chatJidAlt: p.chatJidAlt ?? null,
+            senderJid: fromMe
+                ? null
+                : p.senderJid !== undefined
+                    ? p.senderJid
+                    : isGroup
+                        ? null
+                        : p.chatJid,
+            senderJidAlt: p.senderJidAlt ?? null,
+            senderName: p.senderName ?? null,
+            fromMe,
+            emoji: p.emoji,
+            timestamp: p.timestamp ?? Date.now(),
+        };
+        this.emitTyped('reaction', reaction, { source });
+        return reaction;
+    }
     simulateStatus(s) {
         this.setStatus(s);
     }

package/dist/types.d.ts

@@ -26,6 +26,30 @@ export interface WaIncomingMessage {
         download: () => Promise<Buffer>;
     };
 }
+/**
+ * One person's emoji reaction to a message. WhatsApp keeps one reaction per person and message: a
+ * new emoji replaces the previous one, an empty `emoji` removes it.
+ */
+export interface WaReaction {
+    /** WhatsApp id of the message that was reacted to. */
+    targetId: string;
+    /** The chat of both the reaction and the reacted message (as WhatsApp delivered it). */
+    chatJid: string;
+    /** DM only: the same person's other address (`key.remoteJidAlt`), as for messages. */
+    chatJidAlt?: string | null;
+    /** Who reacted: the group participant or the DM partner; null when `fromMe`. */
+    senderJid: string | null;
+    /** Group reactor's explicitly associated alternate phone/LID address. */
+    senderJidAlt?: string | null;
+    /** WhatsApp profile name delivered with the reaction (never inferred). */
+    senderName: string | null;
+    /** Reacted from the linked number (its phone or another linked device). */
+    fromMe: boolean;
+    /** The emoji; '' = the reaction was removed. */
+    emoji: string;
+    /** epoch ms */
+    timestamp: number;
+}
 export interface WaChatInfo {
     jid: string;
     type: 'dm' | 'group';
@@ -79,6 +103,10 @@ export interface WaAdapterEvents {
     message: [WaIncomingMessage, {
         source: 'live' | 'history';
     }];
+    /** Someone reacted to a message, changed their reaction or removed it (live or history). */
+    reaction: [WaReaction, {
+        source: 'live' | 'history';
+    }];
     messageStatus: [WaMessageStatusUpdate];
     chats: [WaChatInfo[]];
     contacts: [WaContactInfo[]];
@@ -107,6 +135,15 @@ export interface WaSendOptions {
     /** Used when the quoted message is no longer in the adapter's live cache. */
     quoted?: WaQuotedRef;
 }
+/** The message a reaction points at: WhatsApp matches it by chat, id, side and group author. */
+export interface WaReactionTarget {
+    /** WhatsApp id of the message. */
+    id: string;
+    /** The message was sent from the linked number. */
+    fromMe: boolean;
+    /** Group messages from someone else: who wrote it. */
+    participant?: string | null;
+}
 export interface SendResult {
     id: string;
     timestamp: number;
@@ -138,6 +175,11 @@ export interface WaAdapter {
     requestPairingCode(phone: string): Promise<string>;
     sendText(chatJid: string, text: string, opts?: WaSendOptions): Promise<SendResult>;
     sendMedia(chatJid: string, file: WaSendFile, opts?: WaSendOptions): Promise<SendResult>;
+    /**
+     * React to a message as the linked number (`emoji` '' removes the reaction). WhatsApp keeps one
+     * reaction per number, so this replaces one made on the phone. Throws WaUnavailableError offline.
+     */
+    sendReaction(chatJid: string, target: WaReactionTarget, emoji: string): Promise<SendResult>;
     markRead(chatJid: string, messageIds: string[]): Promise<void>;
     sendPresence(chatJid: string, presence: 'composing' | 'paused'): Promise<void>;
     /** re-download by id if still cached */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezychat/wa",
-  "version": "0.1.49",
+  "version": "0.1.51",
   "type": "module",
   "description": "EzyChat core: WhatsApp adapter interface, Baileys adapter and fake adapter.",
   "license": "MIT",
@@ -37,7 +37,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ezychat/shared": "0.1.49",
+    "@ezychat/shared": "0.1.51",
     "baileys": "^7.0.0-rc14",
     "pino": "^10.4.0",
     "qrcode": "^1.5.4"