@arcaelas/whatsapp 7.4.2 → 8.2.0

package/build/esm/lib/message/index.js

@@ -288,6 +288,51 @@ export default class Message {
         await this._init.engine.set(`/chat/${doc.cid}/message/${doc.id}`, serialize(doc), doc.created_at);
         return true;
     }
+    /**
+     * Supervisa qué le pasa a este mensaje: que lo lean, que reproduzcan su audio o que lo
+     * retiren. Vive en la clase base, así que todo tipo de mensaje lo hereda.
+     *
+     * Por dentro escucha las actualizaciones del mensaje y las traduce: `message:updated` no
+     * distingue leído de reproducido —los dos son un cambio de estado— y quien supervisa un
+     * mensaje quiere saber cuál de los dos ocurrió, no que «algo cambió».
+     * Watches what happens to this message: that it gets read, that its audio gets played, or
+     * that it is retired. It lives on the base class, so every message type inherits it.
+     *
+     * Under the hood it listens to the message's updates and translates them: `message:updated`
+     * does not tell read from played —both are a status change— and whoever watches a message
+     * wants to know which of the two happened, not that «something changed».
+     *
+     * @param handler - Recibe cada cambio / Receives every change
+     * @returns Función para dejar de supervisar / Function to stop watching
+     */
+    watch(handler) {
+        const { wa } = this._init;
+        let seen = this._raw.status;
+        const off_updated = wa.on('message:updated', (msg) => {
+            if (msg.id === this._raw.id) {
+                const status = msg._raw.status;
+                // Sólo los avances cuentan: un mismo estado repetido no es una noticia, y sin
+                // este corte cada acuse reenviado por WhatsApp se contaría como una lectura más.
+                // Only advances count: a repeated status is not news, and without this cut every
+                // acknowledgement WhatsApp resends would count as another read.
+                if (status > seen) {
+                    seen = status;
+                    if (status >= proto.WebMessageInfo.Status.PLAYED)
+                        handler({ name: 'played', payload: msg });
+                    else if (status >= proto.WebMessageInfo.Status.READ)
+                        handler({ name: 'read', payload: msg });
+                }
+            }
+        });
+        const off_deleted = wa.on('message:deleted', (msg) => {
+            if (msg.id === this._raw.id)
+                handler({ name: 'deleted', payload: msg });
+        });
+        return () => {
+            off_updated();
+            off_deleted();
+        };
+    }
     /** Marca el mensaje como leído. / Marks the message as read. */
     async seen() {
         const { cid, id, author } = this._raw;
@@ -467,6 +512,23 @@ export class Audio extends Media {
     get duration() { return this._media?.seconds ?? 0; }
     /** Forma de onda 0-100 lista para pintar. / Paint-ready 0-100 waveform. */
     get waveform() { return Array.from(to_buffer(this._media?.waveform) ?? []); }
+    /** true si ya fue reproducido: el micrófono azul que ve quien lo mandó. / true when already played: the blue mic its sender sees. */
+    get played() { return this._raw.status >= proto.WebMessageInfo.Status.PLAYED; }
+    /**
+     * Acusa el audio como reproducido. Es un aviso aparte del de leído —abrir el chat no
+     * reproduce nada—, y por eso viaja como recibo propio: quien lo mandó ve el micrófono
+     * azul sólo después de esto.
+     * Acknowledges the audio as played. It is separate from the read receipt —opening the chat
+     * plays nothing— and so travels as its own receipt: whoever sent it sees the blue mic only
+     * after this.
+     *
+     * @returns true cuando el acuse salió / true once the receipt left
+     */
+    async play() {
+        const { cid, id, author } = this._raw;
+        await this._init.socket.sendReceipt(cid, cid.endsWith('@g.us') ? author : undefined, [id], 'played');
+        return true;
+    }
 }
 /** Mensaje de sticker. / Sticker message. */
 export class Sticker extends Media {
@@ -598,6 +660,25 @@ export class VCard extends Message {
 export class Event extends Message {
     /** @internal Bloque del evento en el raw. / Raw event block. */
     get _event() { return this._raw.raw.message?.eventMessage; }
+    /** Asistentes confirmados, acompañantes incluidos. / Confirmed attendees, companions included. */
+    get going() {
+        return (this._raw.responses ?? []).filter((entry) => entry.response === 'going').reduce((sum, entry) => sum + 1 + entry.guests, 0);
+    }
+    /**
+     * Respuestas de asistencia al evento, con el nombre resuelto de cada contacto y en orden
+     * de llegada — la última es la más reciente.
+     * Attendance responses, with each contact's resolved name, in arrival order — the last one
+     * is the most recent.
+     */
+    async attendees() {
+        const rows = [];
+        for (const entry of this._raw.responses ?? []) {
+            const who = await this._init.wa.Contact.get(entry.author).catch(() => null);
+            const contact = (who?.phone ?? entry.author.split('@')[0].split(':')[0]);
+            rows.push({ name: who?.name ?? contact, contact, response: entry.response, guests: entry.guests });
+        }
+        return rows;
+    }
     /** Nombre del evento. / Event name. */
     get name() { return this._event?.name ?? ''; }
     /** Inicio en ISO UTC. / Start as ISO UTC. */

package/build/esm/lib/whatsapp/index.d.ts

@@ -3,6 +3,33 @@ import { Account, contact } from '../../lib/contact/index.js';
 import Message, { message } from '../../lib/message/index.js';
 import { Feed } from '../../lib/status/index.js';
 import { type Engine } from '../../lib/store/index.js';
+/**
+ * Lo que hace alguien al otro lado, en los términos en los que se mira: WhatsApp distingue
+ * «disponible» de «escribiendo» y de «grabando», y esa distinción es justo la que interesa
+ * vigilar. `paused` no se propaga: es dejar de escribir, no un estado en sí.
+ * What someone is doing on the other end, in the terms one watches it: WhatsApp tells «available»
+ * from «typing» and from «recording», and that distinction is exactly what is worth watching.
+ * `paused` is not propagated: it is stopping typing, not a state of its own.
+ */
+export type Presence = 'online' | 'offline' | 'typing' | 'recording';
+/**
+ * Lo que se supervisa con `watch()`, en un solo sobre: `name` dice qué pasó y `payload` trae la
+ * instancia a la que le pasó, ya resuelta. Quien escucha no tiene que volver a buscar de quién
+ * se trata ni filtrar lo que no le toca.
+ * What `watch()` supervises, in a single envelope: `name` says what happened and `payload` brings
+ * the already-resolved instance it happened to. Whoever listens does not have to look up who it
+ * was nor filter out what does not concern them.
+ */
+export interface WatchEvent<N extends string, P> {
+    name: N;
+    payload: P;
+}
+/** Cada acción de alguien al otro lado, incluido dejar de escribir o de grabar. / Every action from the other end, including stopping typing or recording. */
+export type ContactWatch = 'online' | 'offline' | 'typing' | 'recording' | 'stopped-typing' | 'stopped-recording';
+/** Lo que le puede pasar a un mensaje ya enviado. / What can happen to an already-sent message. */
+export type MessageWatch = 'read' | 'played' | 'deleted';
+/** Un chat mezcla lo que hace la persona con lo que llega a la conversación. / A chat mixes what the person does with what arrives in the conversation. */
+export type ChatWatch = ContactWatch | 'message';
 type ChatInstance = InstanceType<ReturnType<typeof chat>>;
 type ContactInstance = InstanceType<ReturnType<typeof contact>>;
 interface Options {
@@ -63,8 +90,14 @@ export interface Farewell {
 interface EventMap {
     connected: [WhatsApp];
     disconnected: [WhatsApp, Farewell];
+    /** Fallo que no tumba la conexión pero que quien la abrió necesita saber. / A failure that does not drop the connection but whoever opened it needs to know. */
+    error: [Error & {
+        code?: string;
+    }, WhatsApp];
     'contact:created': [ContactInstance, ChatInstance, WhatsApp];
     'contact:updated': [ContactInstance, ChatInstance, WhatsApp];
+    /** Alguien entró, salió, escribe o graba. Sólo llega de quien se esté vigilando con `Contact.watch()`. / Someone came in, left, is typing or recording. Only arrives for whoever is being watched with `Contact.watch()`. */
+    'contact:presence': [ContactInstance, ContactWatch, WhatsApp];
     'chat:created': [ChatInstance, WhatsApp];
     'chat:deleted': [ChatInstance, WhatsApp];
     'chat:pinned': [ChatInstance, WhatsApp];
@@ -76,7 +109,7 @@ interface EventMap {
     'message:created': [Message, ChatInstance, WhatsApp];
     'message:updated': [Message, ChatInstance, WhatsApp];
     'message:deleted': [Message, ChatInstance, WhatsApp];
-    'message:reacted': [Message, ChatInstance, string, WhatsApp];
+    'message:reacted': [Message, ChatInstance, string, ContactInstance, WhatsApp];
     'message:starred': [Message, ChatInstance, WhatsApp];
     'message:unstarred': [Message, ChatInstance, WhatsApp];
     'message:forwarded': [Message, ChatInstance, WhatsApp];

package/build/esm/lib/whatsapp/index.js

@@ -1,4 +1,4 @@
-import { Browsers, decryptPollVote, DisconnectReason, downloadMediaMessage, fetchLatestBaileysVersion, getContentType, initAuthCreds, jidNormalizedUser, makeWASocket, proto, updateMessageWithPollUpdate, } from 'baileys';
+import { Browsers, decryptEventResponse, decryptPollVote, DisconnectReason, downloadMediaMessage, fetchLatestBaileysVersion, getContentType, initAuthCreds, jidNormalizedUser, makeWASocket, proto, updateMessageWithPollUpdate, } from 'baileys';
 import { EventEmitter } from 'node:events';
 import pino from 'pino';
 import * as QRCode from 'qrcode';
@@ -34,7 +34,18 @@ const queued = (locks, path, work) => {
     locks.set(path, next.catch(() => { }));
     return next;
 };
+/** Traduce el vocabulario de baileys al que se vigila; lo que no está aquí no se propaga. / Translates baileys' vocabulary into the watched one; whatever is missing is not propagated. */
+const PRESENCE = { available: 'online', unavailable: 'offline', composing: 'typing', recording: 'recording', paused: 'paused' };
 const readable = (value) => (value && !/^\+?[\d\s·•∙⋅]+$/.test(value) ? value : null);
+/**
+ * Refrescos de QR que dura un PIN antes de darlo por caducado. WhatsApp no avisa de la
+ * expiración, así que se mide por los ciclos de refresco (~20 s cada uno): tres son el margen
+ * observado en el que un código sigue siendo aceptado.
+ * QR refreshes a PIN lasts before it is considered expired. WhatsApp gives no expiry notice, so
+ * it is measured in refresh cycles (~20s each): three is the observed window in which a code is
+ * still accepted.
+ */
+const OTP_CYCLES = 3;
 export default class WhatsApp {
     #event = new EventEmitter();
     #options;
@@ -77,9 +88,13 @@ export default class WhatsApp {
         let retries = 0;
         let intentional = false;
         let silent = false;
+        let paired = false;
+        let cycles = 0;
         let alive = null;
         let timer = null;
         let chain = Promise.resolve();
+        /** Qué estaba haciendo cada quien, para poder leer su `paused`. / What each one was doing, so their `paused` can be read. */
+        const doing = new Map();
         const locks = new Map();
         return new Promise((resolve, reject) => {
             const start = async () => {
@@ -258,9 +273,33 @@ export default class WhatsApp {
                 socket.ev.on('creds.update', () => queued(locks, '/session/creds', () => engine.set('/session/creds', serialize(creds))));
                 socket.ev.on('connection.update', async ({ connection, lastDisconnect, qr }) => {
                     if (qr && !creds.registered) {
-                        await callback(digits && (method ?? 'otp') === 'otp'
-                            ? await socket.requestPairingCode(digits)
-                            : await QRCode.toBuffer(qr, { type: 'png', margin: 2 }));
+                        if (digits && (method ?? 'otp') === 'otp') {
+                            // El QR se refresca cada ~20 s, pero el PIN vive más: pedir uno en
+                            // cada refresco invalida el anterior y el que la persona está
+                            // tecleando deja de servir a media escritura —el síntoma es un PIN
+                            // correcto que «no lo toma»—. Por eso se cuenta el ciclo y sólo se
+                            // renueva al caducar de verdad, gastando un reintento del presupuesto.
+                            // The QR refreshes every ~20s, but the PIN lives longer: asking for
+                            // one on each refresh invalidates the previous, and the one being
+                            // typed stops working mid-typing —the symptom is a correct PIN that
+                            // «is not accepted»—. So the cycle is counted and it is only renewed
+                            // once it truly expires, spending one retry from the budget.
+                            cycles = paired ? cycles + 1 : 0;
+                            if (!paired || cycles >= OTP_CYCLES) {
+                                if (paired && budget !== null && retries >= budget) {
+                                    this.emit('error', Object.assign(new Error('El código de vinculación expiró'), { code: 'ERR_OTP_EXPIRED' }), this);
+                                }
+                                else {
+                                    retries += paired ? 1 : 0;
+                                    cycles = 0;
+                                    paired = true;
+                                    await callback(await socket.requestPairingCode(digits));
+                                }
+                            }
+                        }
+                        else {
+                            await callback(await QRCode.toBuffer(qr, { type: 'png', margin: 2 }));
+                        }
                     }
                     if (connection === 'open') {
                         connected = true;
@@ -371,6 +410,31 @@ export default class WhatsApp {
                         }
                     }).catch(() => { });
                 });
+                socket.ev.on('presence.update', ({ id, presences }) => {
+                    chain = chain.then(async () => {
+                        const cid = await canonical(id);
+                        for (const [participant, data] of Object.entries(presences)) {
+                            const state = PRESENCE[data.lastKnownPresence];
+                            if (state) {
+                                const who = await canonical(participant || cid);
+                                // `paused` es «dejó de hacer lo que hacía», y sólo el estado
+                                // anterior dice qué era: sin recordarlo no se puede distinguir
+                                // dejar de escribir de dejar de grabar.
+                                // `paused` means «stopped doing what they were doing», and only
+                                // the previous state says which: without remembering it there is
+                                // no telling stopped-typing from stopped-recording.
+                                const last = doing.get(who);
+                                const name = state === 'paused' ? (last === 'recording' ? 'stopped-recording' : 'stopped-typing') : state;
+                                if (state === 'typing' || state === 'recording')
+                                    doing.set(who, state);
+                                else
+                                    doing.delete(who);
+                                const card = deserialize(await engine.get(`/contact/${who}`));
+                                this.emit('contact:presence', new this.Contact(card ?? { id: who, lid: null, name: null, notify: null, verified_name: null, img_url: null, status: null }), name, this);
+                            }
+                        }
+                    }).catch(() => { });
+                });
                 socket.ev.on('lid-mapping.update', ({ lid, pn }) => {
                     chain = chain.then(async () => {
                         await remember(lid, pn);
@@ -476,7 +540,15 @@ export default class WhatsApp {
                                     ];
                                     await engine.set(found.path, serialize(found.doc), found.doc.created_at);
                                     const instance = new Message(init, found.doc);
-                                    this.emit('message:reacted', instance, await instance.chat(), emoji, this);
+                                    // Quién reaccionó viaja en el evento: sin él, distinguir la
+                                    // reacción del usuario del eco de una propia obligaba a cada
+                                    // consumidor a llevar su propio registro de ecos con timeouts.
+                                    // Who reacted travels in the event: without it, telling the
+                                    // user's reaction from the echo of an own one forced every
+                                    // consumer to keep its own echo ledger with timeouts.
+                                    const who = await canonical(author);
+                                    const card = deserialize(await engine.get(`/contact/${who}`));
+                                    this.emit('message:reacted', instance, await instance.chat(), emoji, new this.Contact(card ?? { id: who, lid: null, name: null, notify: null, verified_name: null, img_url: null, status: null }), this);
                                 }
                                 continue;
                             }
@@ -493,7 +565,18 @@ export default class WhatsApp {
                                     continue;
                                 }
                                 const type = { conversation: 'text', extendedTextMessage: 'text', imageMessage: 'image', videoMessage: 'video', audioMessage: 'audio' }[kind ?? ''];
-                                const author = msg.key.participant ?? '';
+                                // El autor de un estado puede llegar por `participant` o por su
+                                // alterno según venga identificado por teléfono o por LID, y se
+                                // guarda canónico como todo lo demás: con el LID crudo el estado
+                                // queda a nombre de un número larguísimo que no case con ningún
+                                // contacto, y para quien mira es un estado que no llegó.
+                                // A status author can arrive via `participant` or its alternate
+                                // depending on whether it is identified by phone or by LID, and
+                                // is stored canonically like everything else: with the raw LID
+                                // the status ends up under a long meaningless number matching no
+                                // contact, and to whoever looks it is a status that never came.
+                                const claimed = msg.key.participant ?? msg.key.participantAlt ?? '';
+                                const author = claimed ? await canonical(claimed) : '';
                                 if (!type || !author) {
                                     continue;
                                 }
@@ -521,6 +604,45 @@ export default class WhatsApp {
                                 this.emit('feed:created', new Feed(init, doc), this);
                                 continue;
                             }
+                            if (kind === 'encEventResponseMessage') {
+                                const enc = msg.message?.encEventResponseMessage;
+                                const key = enc?.eventCreationMessageKey;
+                                const found = key?.id && key.remoteJid ? await locate(key.remoteJid, key.id) : null;
+                                const raw_secret = found?.doc.raw.message?.messageContextInfo?.messageSecret;
+                                const secret = typeof raw_secret === 'string' ? Buffer.from(raw_secret, 'base64') : raw_secret;
+                                if (found && secret && enc?.encPayload && enc.encIv) {
+                                    const mine = [socket.user?.lid, socket.user?.id];
+                                    const theirs = (from) => [from.remoteJid, from.participant, from.remoteJidAlt];
+                                    const responders = (msg.key.fromMe ? mine : theirs(msg.key)).filter((id) => Boolean(id));
+                                    const creators = (found.doc.raw.key?.fromMe ? mine : theirs(found.doc.raw.key ?? {})).filter((id) => Boolean(id));
+                                    for (const pair of responders.flatMap((who) => creators.map((creator) => [who, creator]))) {
+                                        try {
+                                            const parsed = decryptEventResponse({ encPayload: enc.encPayload, encIv: enc.encIv }, {
+                                                eventCreatorJid: jidNormalizedUser(pair[1]),
+                                                eventMsgId: found.doc.id,
+                                                eventEncKey: secret,
+                                                responderJid: jidNormalizedUser(pair[0]),
+                                            });
+                                            const response = { 1: 'going', 2: 'not_going', 3: 'maybe' }[parsed.response];
+                                            if (response) {
+                                                const author = await canonical(jidNormalizedUser((msg.key.fromMe ? socket.user?.id : msg.key.participant ?? cid) ?? cid));
+                                                found.doc.responses = [
+                                                    ...(found.doc.responses ?? []).filter((entry) => entry.author !== author),
+                                                    { author, response, guests: Number(parsed.extraGuestCount ?? 0), at: (Number(msg.messageTimestamp) || Math.floor(Date.now() / 1_000)) * 1_000 },
+                                                ];
+                                                await engine.set(found.path, serialize(found.doc), found.doc.created_at);
+                                                const instance = new Message(init, found.doc);
+                                                this.emit('message:updated', instance, await instance.chat(), this);
+                                            }
+                                            break;
+                                        }
+                                        catch {
+                                            /* identidad equivocada / wrong identity */
+                                        }
+                                    }
+                                }
+                                continue;
+                            }
                             if (kind === 'pollUpdateMessage') {
                                 const key = msg.message?.pollUpdateMessage?.pollCreationMessageKey;
                                 const vote = msg.message?.pollUpdateMessage?.vote;

package/package.json

@@ -72,7 +72,7 @@
     "release": "npm publish --access public"
   },
   "types": "./build/esm/index.d.ts",
-  "version": "7.4.2",
+  "version": "8.2.0",
   "engines": {
     "node": ">=20"
   },