@ezychat/wa 0.0.0-stage → 0.1.39

package/dist/baileys/adapter.js

@@ -0,0 +1,710 @@
+import { EventEmitter } from 'node:events';
+import { Browsers, downloadMediaMessage, fetchLatestBaileysVersion, jidNormalizedUser, makeCacheableSignalKeyStore, makeWASocket, proto, } from 'baileys';
+import { pino } from 'pino';
+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 { quotedForChat, quotedFromRef } from './quoted.js';
+import { contactAliasPair, normalizeContactJid } from './contact-aliases.js';
+import { profilePhoto } from './photos.js';
+import { aboutFromStatusResult, mapGroupMetadata } from './groups.js';
+const RAW_CACHE_MAX = 2000;
+const DAY_MS = 86_400_000;
+/** Boom status codes Baileys uses when the socket is closed / lost / replaced / unavailable. */
+const CONNECTION_STATUS_CODES = new Set([408, 428, 440, 503]);
+/** True when a send error means "the connection went away" (retry later) rather than a real rejection. */
+export function isConnectionError(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const e = err;
+    const code = e.output?.statusCode;
+    if (code !== undefined && CONNECTION_STATUS_CODES.has(code))
+        return true;
+    return /connection (closed|lost|terminated)|socket (closed|hang up)|not open/i.test(String(e.message ?? ''));
+}
+/** Per-participant group receipt → our status (read wins over delivered). */
+export function receiptStatus(r) {
+    if (r.readTimestamp || r.playedTimestamp)
+        return 'read';
+    if (r.receiptTimestamp)
+        return 'delivered';
+    return null;
+}
+/** proto.WebMessageInfo.Status → our status. */
+function mapAck(status) {
+    switch (status) {
+        case proto.WebMessageInfo.Status.ERROR:
+            return 'failed';
+        case proto.WebMessageInfo.Status.SERVER_ACK:
+            return 'sent';
+        case proto.WebMessageInfo.Status.DELIVERY_ACK:
+            return 'delivered';
+        case proto.WebMessageInfo.Status.READ:
+        case proto.WebMessageInfo.Status.PLAYED:
+            return 'read';
+        default:
+            return null;
+    }
+}
+/**
+ * Real WhatsApp connection via Baileys (WhatsApp Web multi-device protocol).
+ * This is the only module in the repo allowed to import `baileys`.
+ */
+/**
+ * Browser identity sent at registration. WhatsApp terminates the registration (428 before any QR)
+ * for 'Desktop' identities such as Browsers.appropriate('Desktop'); a Chrome web client is accepted
+ * and is also required for phone-number pairing codes.
+ */
+export const WA_BROWSER = Browsers.ubuntu('Chrome');
+/** Digits only, with country code (8–15 digits, E.164 without '+'). */
+export function normalizePairingPhone(phone) {
+    const digits = phone.replace(/\D/g, '');
+    if (digits.length < 8 || digits.length > 15) {
+        throw new Error('Enter the phone number with country code, e.g. +60 12-345 6789');
+    }
+    return digits;
+}
+const PAIRING_READY_TIMEOUT_MS = 20_000;
+export class BaileysAdapter extends EventEmitter {
+    _status = { state: 'disconnected', me: null, qr: null, lastError: null };
+    sock = null;
+    auth;
+    logger;
+    historyDaysOpt;
+    raw = new Lru(RAW_CACHE_MAX);
+    attempt = 0;
+    reconnectTimer = null;
+    /** true when the socket was closed on purpose (disconnect/logout/replaced/blocked). */
+    stopped = true;
+    connecting = null;
+    signalKeys = null;
+    contactAliases = new Map();
+    /** Invalidates local-key reads when a socket closes or the linked account changes. */
+    aliasGeneration = 0;
+    constructor(opts) {
+        super();
+        this.auth = createAuthStore(opts.authDir);
+        this.historyDaysOpt = opts.historyDays;
+        this.logger = opts.logger ?? pino({ level: 'silent' });
+    }
+    /** current history_days (re-read each time so a settings change applies on the next relink) */
+    get historyDays() {
+        const v = typeof this.historyDaysOpt === 'function' ? this.historyDaysOpt() : this.historyDaysOpt;
+        return typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : 0;
+    }
+    get status() {
+        return this._status;
+    }
+    on(ev, fn) {
+        return super.on(ev, fn);
+    }
+    off(ev, fn) {
+        return super.off(ev, fn);
+    }
+    emitTyped(ev, ...args) {
+        try {
+            this.emit(ev, ...args);
+        }
+        catch (err) {
+            this.logger.error({ err, ev }, 'wa listener threw');
+        }
+    }
+    setStatus(patch) {
+        this._status = { ...this._status, ...patch };
+        this.emitTyped('status', this._status);
+    }
+    // ---------------------------------------------------------------- lifecycle
+    async connect() {
+        this.stopped = false;
+        if (this.sock || this.connecting)
+            return this.connecting ?? undefined;
+        this.clearReconnect();
+        this.connecting = this.open().finally(() => {
+            this.connecting = null;
+        });
+        return this.connecting;
+    }
+    async disconnect() {
+        this.stopped = true;
+        this.clearReconnect();
+        await this.closeSocket();
+        this.setStatus({ state: 'disconnected', qr: null });
+    }
+    async logout() {
+        this.stopped = true;
+        this.clearContactAliases();
+        this.clearReconnect();
+        const sock = this.sock;
+        if (sock) {
+            try {
+                await sock.logout();
+            }
+            catch (err) {
+                this.logger.warn({ err }, 'wa logout request failed; wiping auth anyway');
+            }
+        }
+        await this.closeSocket();
+        await this.auth.wipe();
+        this.setStatus({ state: 'logged_out', me: null, qr: null });
+    }
+    async takeover() {
+        this.attempt = 0;
+        await this.closeSocket();
+        await this.connect();
+    }
+    /**
+     * Link by phone number instead of QR: returns the 8-character code the user types in
+     * WhatsApp → Linked devices → Link with phone number instead.
+     */
+    async requestPairingCode(phone) {
+        const digits = normalizePairingPhone(phone);
+        if (this._status.state === 'open')
+            throw new Error('A WhatsApp number is already linked');
+        await this.connect();
+        await this.waitForPairingReady();
+        const sock = this.sock;
+        if (!sock)
+            throw new WaUnavailableError();
+        return sock.requestPairingCode(digits);
+    }
+    /** The socket can request a code once the server has offered a QR (i.e. registration started). */
+    waitForPairingReady() {
+        if (this.sock && this._status.state === 'qr')
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.off('status', onStatus);
+                reject(new WaUnavailableError());
+            }, PAIRING_READY_TIMEOUT_MS);
+            const onStatus = (s) => {
+                if (s.state === 'qr' && this.sock) {
+                    clearTimeout(timer);
+                    this.off('status', onStatus);
+                    resolve();
+                }
+            };
+            this.on('status', onStatus);
+        });
+    }
+    clearReconnect() {
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+    }
+    async closeSocket() {
+        this.signalKeys = null;
+        this.aliasGeneration++;
+        const sock = this.sock;
+        this.sock = null;
+        if (!sock)
+            return;
+        sock.ev.removeAllListeners('connection.update');
+        try {
+            await sock.end(undefined);
+        }
+        catch {
+            /* already closed */
+        }
+    }
+    scheduleReconnect(immediate = false) {
+        if (this.stopped)
+            return;
+        this.clearReconnect();
+        const delay = immediate ? 0 : backoffMs(this.attempt++);
+        this.logger.info({ delay, attempt: this.attempt }, 'wa reconnect scheduled');
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect().catch((err) => {
+                this.logger.error({ err }, 'wa reconnect failed');
+                this.setStatus({
+                    state: 'disconnected',
+                    lastError: String(err?.message ?? err),
+                });
+                this.scheduleReconnect();
+            });
+        }, delay);
+        this.reconnectTimer.unref?.();
+    }
+    async open() {
+        this.setStatus({ state: 'connecting', qr: null });
+        const { state, saveCreds } = await this.auth.load();
+        let version;
+        try {
+            const latest = await fetchLatestBaileysVersion();
+            version = latest.version;
+        }
+        catch (err) {
+            this.logger.warn({ err }, 'could not fetch latest WA version; using bundled default');
+        }
+        if (this.stopped)
+            return; // disconnect() was called while loading
+        const blog = this.logger.child({ module: 'baileys' });
+        const keys = makeCacheableSignalKeyStore(state.keys, blog);
+        const sock = makeWASocket({
+            ...(version ? { version } : {}),
+            auth: { creds: state.creds, keys },
+            logger: blog,
+            browser: WA_BROWSER,
+            syncFullHistory: this.historyDays > 0,
+            markOnlineOnConnect: false,
+            // Per-message filtering by historyDays happens in onHistory/ingest.
+            shouldSyncHistoryMessage: () => this.historyDays > 0,
+            getMessage: async (key) => key.id ? (this.raw.get(key.id)?.message ?? undefined) : undefined,
+        });
+        this.sock = sock;
+        this.signalKeys = keys;
+        this.aliasGeneration++;
+        const alive = () => !this.stopped && this.sock === sock;
+        sock.ev.on('creds.update', () => {
+            if (!alive())
+                return;
+            saveCreds().catch((err) => this.logger.error({ err }, 'saveCreds failed'));
+        });
+        sock.ev.on('connection.update', (u) => {
+            if (!alive())
+                return;
+            this.onConnectionUpdate(sock, u);
+        });
+        sock.ev.on('messages.upsert', ({ messages, type }) => {
+            if (!alive())
+                return;
+            this.handleUpsert(messages, type);
+        });
+        sock.ev.on('messaging-history.set', (h) => {
+            if (!alive())
+                return;
+            this.onHistory(h);
+        });
+        sock.ev.on('messages.update', (updates) => {
+            if (!alive())
+                return;
+            this.handleMessageUpdates(updates);
+        });
+        // Group chats: delivered/read arrive as per-participant receipts, not messages.update.
+        sock.ev.on('message-receipt.update', (updates) => {
+            if (!alive())
+                return;
+            this.handleReceipts(updates);
+        });
+        sock.ev.on('contacts.upsert', (cs) => alive() && this.emitContacts(cs));
+        sock.ev.on('contacts.update', (cs) => alive() && this.emitContacts(cs));
+        sock.ev.on('lid-mapping.update', ({ lid, pn }) => {
+            if (alive())
+                this.emitAliasPairs([[lid, pn]], 'lid-mapping');
+        });
+        sock.ev.on('chats.upsert', (cs) => alive() && this.emitChats(cs));
+        sock.ev.on('groups.upsert', (gs) => alive() && this.emitGroups(gs));
+        sock.ev.on('groups.update', (gs) => {
+            if (!alive())
+                return;
+            this.emitGroups(gs);
+            for (const g of gs)
+                if (g.id)
+                    this.emitTyped('groupChanged', { groupJid: g.id });
+        });
+        sock.ev.on('group-participants.update', ({ id }) => {
+            if (alive() && id)
+                this.emitTyped('groupChanged', { groupJid: id });
+        });
+    }
+    onConnectionUpdate(sock, u) {
+        if (u.qr) {
+            // The server is talking to us again; don't let earlier failures stretch the next retry.
+            this.attempt = 0;
+            this.setStatus({ state: 'qr', qr: u.qr });
+        }
+        if (u.connection === 'connecting' && this._status.state !== 'qr') {
+            this.setStatus({ state: 'connecting' });
+        }
+        if (u.connection === 'open') {
+            this.attempt = 0;
+            const user = sock.user;
+            this.setStatus({
+                state: 'open',
+                qr: null,
+                lastError: null,
+                me: user
+                    ? { jid: jidNormalizedUser(user.id), name: user.name ?? user.notify ?? null }
+                    : null,
+            });
+        }
+        if (u.connection === 'close') {
+            const err = u.lastDisconnect?.error;
+            const code = err?.output?.statusCode;
+            const message = err?.message ?? (code ? `closed (${code})` : 'connection closed');
+            this.sock = null;
+            this.signalKeys = null;
+            this.aliasGeneration++;
+            void this.handleClose(code, message);
+        }
+    }
+    async handleClose(code, message) {
+        if (this.stopped) {
+            this.setStatus({ state: 'disconnected', qr: null });
+            return;
+        }
+        const action = classifyDisconnect(code);
+        this.logger.warn({ code, action, message }, 'wa connection closed');
+        switch (action) {
+            case 'reconnect':
+                this.setStatus({ state: 'connecting', lastError: message });
+                // 515 restartRequired is expected right after pairing: reconnect at once.
+                this.scheduleReconnect(code === 515);
+                return;
+            case 'logged_out':
+                this.stopped = true;
+                this.clearContactAliases();
+                await this.auth.wipe().catch((e) => this.logger.error({ err: e }, 'auth wipe failed'));
+                this.setStatus({ state: 'logged_out', me: null, qr: null, lastError: message });
+                return;
+            case 'replaced':
+                this.stopped = true;
+                this.setStatus({ state: 'replaced', qr: null, lastError: message });
+                return;
+            case 'bad_session':
+                this.clearContactAliases();
+                try {
+                    const bak = await this.auth.backup();
+                    this.logger.warn({ bak }, 'bad session: auth backed up, wiping to request relink');
+                    await this.auth.wipe();
+                }
+                catch (e) {
+                    this.logger.error({ err: e }, 'bad session backup/wipe failed');
+                }
+                this.setStatus({ state: 'connecting', me: null, qr: null, lastError: message });
+                this.scheduleReconnect(true);
+                return;
+            case 'blocked':
+                this.stopped = true;
+                this.setStatus({ state: 'blocked', qr: null, lastError: message });
+                return;
+        }
+    }
+    // ---------------------------------------------------------------- inbound
+    historyCutoff() {
+        return this.historyDays > 0 ? Date.now() - this.historyDays * DAY_MS : Number.POSITIVE_INFINITY;
+    }
+    /**
+     * messages.upsert. 'notify' = live; 'append' = messages queued while we were offline (or our own
+     * sends / notifications) — also live: they are new to us, must bump unread / reopen / notify, and
+     * must never be dropped by the history cutoff. Only messaging-history.set is history.
+     * @internal exposed for tests
+     */
+    handleUpsert(messages, _type) {
+        for (const m of messages)
+            this.ingest(m, 'live');
+    }
+    /** @internal exposed for tests */
+    handleMessageUpdates(updates) {
+        for (const { key, update } of updates) {
+            if (!key.id || !key.remoteJid || !key.fromMe)
+                continue;
+            const status = mapAck(update.status);
+            if (status)
+                this.emitTyped('messageStatus', { id: key.id, chatJid: key.remoteJid, status });
+        }
+    }
+    /** @internal exposed for tests */
+    handleReceipts(updates) {
+        for (const { key, receipt } of updates) {
+            if (!key.id || !key.remoteJid || !key.fromMe)
+                continue;
+            const status = receiptStatus(receipt);
+            if (status)
+                this.emitTyped('messageStatus', { id: key.id, chatJid: key.remoteJid, status });
+        }
+    }
+    ingest(m, source) {
+        this.emitAliasPairs([
+            [m.key?.remoteJid, m.key?.remoteJidAlt],
+            [m.key?.participant, m.key?.participantAlt],
+        ], source === 'history' ? 'history' : 'message');
+        const id = m.key?.id;
+        if (!id)
+            return;
+        if (m.message)
+            this.raw.set(id, m);
+        const mapped = mapWAMessage(m, (raw) => this.download(raw));
+        if (!mapped)
+            return;
+        if (source === 'history' && mapped.timestamp < this.historyCutoff())
+            return;
+        this.emitTyped('message', mapped, { source });
+    }
+    /** @internal exposed for tests */
+    onHistory(h) {
+        this.emitAliasPairs((h.lidPnMappings ?? []).map(({ lid, pn }) => [lid, pn]), 'history');
+        if (h.contacts?.length)
+            this.emitContacts(h.contacts);
+        if (h.chats?.length)
+            this.emitChats(h.chats);
+        const cutoff = this.historyCutoff();
+        for (const m of h.messages ?? []) {
+            if (toMs(m.messageTimestamp, 0) < cutoff)
+                continue;
+            this.ingest(m, 'history');
+        }
+    }
+    emitContacts(cs) {
+        this.emitAliasPairs(cs.flatMap((c) => [
+            [c.id, c.lid],
+            [c.id, c.phoneNumber],
+            [c.lid, c.phoneNumber],
+        ]), 'contacts');
+        const out = [];
+        for (const c of cs) {
+            const jid = normalizeContactJid(c.id);
+            if (!jid)
+                continue;
+            const alias = this.contactAliases.get(jid);
+            out.push({
+                jid,
+                pushName: c.notify?.trim() || c.verifiedName?.trim() || null,
+                savedName: c.name?.trim() || null,
+                ...(alias ? { aliases: [alias] } : {}),
+            });
+        }
+        if (out.length)
+            this.emitTyped('contacts', out);
+        // The synchronous name event is stored first; late local mappings then connect it to the chat.
+        const generation = this.aliasGeneration;
+        void this.getContactAliases(out.map((c) => c.jid))
+            .then((aliases) => {
+            if (generation === this.aliasGeneration && aliases.length)
+                this.emitTyped('contactAliases', aliases);
+        })
+            .catch(() => {
+            this.logger.warn({ contactCount: out.length }, 'local contact alias lookup failed');
+        });
+    }
+    clearContactAliases() {
+        this.contactAliases.clear();
+        this.raw = new Lru(RAW_CACHE_MAX);
+        this.signalKeys = null;
+        this.aliasGeneration++;
+    }
+    /** Cache and emit only explicit PN/LID associations; reject contradictory associations. */
+    emitAliasPairs(pairs, source) {
+        const out = [];
+        for (const [first, second] of pairs) {
+            const pair = contactAliasPair(first, second);
+            if (pair && this.rememberAlias(pair))
+                out.push({ ...pair, source });
+        }
+        if (out.length) {
+            this.logger.debug({ mappingCount: out.length, source }, 'contact aliases received');
+            this.emitTyped('contactAliases', out);
+        }
+    }
+    rememberAlias({ jid, alias }) {
+        const oldAlias = this.contactAliases.get(jid);
+        const oldJid = this.contactAliases.get(alias);
+        if ((oldAlias && oldAlias !== alias) || (oldJid && oldJid !== jid))
+            return false;
+        if (oldAlias === alias && oldJid === jid)
+            return false;
+        this.contactAliases.set(jid, alias);
+        this.contactAliases.set(alias, jid);
+        return true;
+    }
+    async getContactAliases(jids) {
+        const normalized = [
+            ...new Set(jids.map(normalizeContactJid).filter((jid) => !!jid)),
+        ];
+        const keys = this.signalKeys;
+        const generation = this.aliasGeneration;
+        const pending = normalized.filter((jid) => !this.contactAliases.has(jid));
+        // keys.get reads files concurrently: bound each batch for large imported address books.
+        if (keys) {
+            for (let start = 0; start < pending.length; start += 256) {
+                const batch = pending.slice(start, start + 256);
+                const ids = batch.map((jid) => jid.endsWith('@lid') ? `${jid.split('@')[0]}_reverse` : jid.split('@')[0]);
+                const stored = await keys.get('lid-mapping', ids);
+                if (generation !== this.aliasGeneration || keys !== this.signalKeys)
+                    return [];
+                for (let i = 0; i < batch.length; i++) {
+                    const jid = batch[i];
+                    const user = stored[ids[i]];
+                    if (typeof user !== 'string' || !/^\d+$/.test(user))
+                        continue;
+                    const pair = contactAliasPair(jid, `${user}@${jid.endsWith('@lid') ? 's.whatsapp.net' : 'lid'}`);
+                    if (pair)
+                        this.rememberAlias(pair);
+                }
+            }
+        }
+        const out = new Map();
+        for (const jid of normalized) {
+            const alias = this.contactAliases.get(jid);
+            const pair = contactAliasPair(jid, alias);
+            if (pair)
+                out.set(pair.jid, { ...pair, source: 'keystore' });
+        }
+        return [...out.values()];
+    }
+    emitChats(cs) {
+        const out = [];
+        for (const c of cs) {
+            if (!c.id)
+                continue;
+            const t = jidType(c.id);
+            if (t === 'other')
+                continue;
+            out.push({ jid: c.id, type: t, name: c.name ?? null });
+        }
+        if (out.length)
+            this.emitTyped('chats', out);
+    }
+    emitGroups(gs) {
+        const out = [];
+        for (const g of gs) {
+            if (!g.id || jidType(g.id) !== 'group')
+                continue;
+            out.push({ jid: g.id, type: 'group', name: g.subject ?? null });
+        }
+        if (out.length)
+            this.emitTyped('chats', out);
+    }
+    async download(raw) {
+        const sock = this.sock;
+        const buf = await downloadMediaMessage(raw, 'buffer', {}, sock
+            ? { reuploadRequest: sock.updateMediaMessage, logger: this.logger }
+            : undefined);
+        return buf;
+    }
+    // ---------------------------------------------------------------- outbound
+    requireOpen() {
+        if (!this.sock || this._status.state !== 'open')
+            throw new WaUnavailableError();
+        return this.sock;
+    }
+    async send(chatJid, content, opts) {
+        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).
+        const cached = opts?.quotedId ? this.raw.get(opts.quotedId) : undefined;
+        const quoted = cached
+            ? quotedForChat(cached, chatJid)
+            : opts?.quotedId && opts.quoted
+                ? quotedFromRef(opts.quoted, chatJid)
+                : undefined;
+        let res;
+        try {
+            res = await sock.sendMessage(chatJid, content, quoted ? { quoted } : undefined);
+        }
+        catch (err) {
+            // connection dropped mid-send: report as unavailable so the queue keeps the job pending
+            if (isConnectionError(err) || this.sock !== sock || this._status.state !== 'open') {
+                throw new WaUnavailableError(`WhatsApp connection lost: ${String(err?.message ?? err)}`);
+            }
+            throw err;
+        }
+        const id = res?.key?.id;
+        if (!res || !id)
+            throw new Error('send returned no message id');
+        this.raw.set(id, res);
+        return { id, timestamp: toMs(res.messageTimestamp) };
+    }
+    sendText(chatJid, text, opts) {
+        return this.send(chatJid, { text }, opts);
+    }
+    sendMedia(chatJid, file, opts) {
+        const { buffer, mime, fileName, caption } = file;
+        let content;
+        if (mime.startsWith('image/') && mime !== 'image/webp') {
+            content = { image: buffer, mimetype: mime, ...(caption ? { caption } : {}) };
+        }
+        else if (mime === 'image/webp') {
+            content = { sticker: buffer, mimetype: mime };
+        }
+        else if (mime.startsWith('video/')) {
+            content = { video: buffer, mimetype: mime, ...(caption ? { caption } : {}) };
+        }
+        else if (file.voiceNote) {
+            // Seconds and waveform are given, so Baileys needs neither music-metadata nor audio-decode.
+            // Baileys copies `waveform` into the audio message but leaves it out of its content type.
+            const voice = {
+                audio: buffer,
+                mimetype: 'audio/ogg; codecs=opus',
+                ptt: true,
+                seconds: file.voiceNote.seconds,
+                waveform: file.voiceNote.waveform,
+            };
+            content = voice;
+        }
+        else if (mime.startsWith('audio/')) {
+            content = { audio: buffer, mimetype: mime };
+        }
+        else {
+            content = { document: buffer, mimetype: mime, fileName, ...(caption ? { caption } : {}) };
+        }
+        return this.send(chatJid, content, opts);
+    }
+    async markRead(chatJid, messageIds) {
+        const sock = this.requireOpen();
+        const keys = messageIds.map((id) => {
+            const raw = this.raw.get(id);
+            return raw?.key
+                ? { remoteJid: chatJid, id, fromMe: false, participant: raw.key.participant ?? undefined }
+                : { remoteJid: chatJid, id, fromMe: false };
+        });
+        if (keys.length)
+            await sock.readMessages(keys);
+    }
+    async sendPresence(chatJid, presence) {
+        const sock = this.requireOpen();
+        await sock.sendPresenceUpdate(presence, chatJid);
+    }
+    async downloadMedia(messageId) {
+        const raw = this.raw.get(messageId);
+        if (!raw)
+            return null;
+        try {
+            return await this.download(raw);
+        }
+        catch (err) {
+            this.logger.warn({ err, messageId }, 'media download failed');
+            return null;
+        }
+    }
+    async getGroupInfo(groupJid) {
+        const sock = this.requireOpen();
+        return mapGroupMetadata(await sock.groupMetadata(groupJid));
+    }
+    async getAbout(jid) {
+        if (!this.sock || this._status.state !== 'open')
+            throw new WaUnavailableError();
+        const kind = jid.endsWith('@lid') ? 'lid' : 'pn';
+        try {
+            const list = await this.sock.fetchStatus(jid);
+            const about = aboutFromStatusResult(list);
+            // Shape only, never the text: tells "WhatsApp returned nothing" apart from a parsing problem.
+            const first = Array.isArray(list)
+                ? list[0]
+                : undefined;
+            const inner = first?.status?.status;
+            this.logger.info({
+                kind,
+                entries: Array.isArray(list) ? list.length : null,
+                // '' = hidden by the person's privacy settings (code 401), null = none set
+                status: inner === '' ? 'private' : inner === null ? 'none' : typeof inner,
+                found: about !== null,
+            }, 'about read');
+            return about;
+        }
+        catch (err) {
+            // Thrown, not null: a failed lookup must never be remembered as "no About".
+            this.logger.warn({ err, kind }, 'about unavailable');
+            throw err;
+        }
+    }
+    async getProfilePicture(jid) {
+        // Offline is a failed lookup, never "no photo".
+        if (!this.sock || this._status.state !== 'open')
+            throw new WaUnavailableError();
+        const sock = this.sock;
+        return profilePhoto(() => sock.profilePictureUrl(jid, 'preview'));
+    }
+}