@manybot/manybot 5.5.4 → 5.6.1

package/dist/drivers/baileys/adapter.js

@@ -0,0 +1,629 @@
+/**
+ * drivers/baileys/adapter.ts
+ *
+ * Adapter that wraps a Baileys `WASocket` (the raw, driver-specific socket)
+ * and the in-memory store behind the driver-neutral `WaContract` declared
+ * in src/kernel/waContract.ts.
+ *
+ * This is the ONLY file outside `drivers/baileys/sdk/baileysSock.ts` that
+ * imports from `@whiskeysockets/baileys`. Every other module in the
+ * codebase (kernel, pluginApi, pluginLoader, sendGuard, contactAutoSave,
+ * messageHandler, api/index.ts) talks to the driver through this contract
+ * — never imports Baileys directly.
+ *
+ * Responsibilities:
+ *   - Convert Baileys event payloads (WAMessage, Chat, Contact) into the
+ *     neutral event payloads the contract declares.
+ *   - Convert BotQuotedRef / BotGroupMetadata / etc. back into the
+ *     Baileys-shaped arguments each Baileys method expects.
+ *   - Implement every method WaContract mandates, by delegating to the
+ *     matching Baileys WASocket method.
+ *
+ * Returns/dispatches are pure adapters — error semantics, retries, fallbacks
+ * all live elsewhere (sendFallbackGuard, sendGuard, pluginGuard).
+ */
+import { normalizeMessageContent, downloadMediaMessage, jidNormalizedUser, } from "@whiskeysockets/baileys";
+import { createHash } from "node:crypto";
+import { logger } from "#logger";
+/**
+ * Classify a Baileys message-content payload (`WAMessageContent`) into
+ * the neutral `(type, body, mimetype)` triple used by `BotMessage`. Pure
+ * function — no side effects, no closures — so it's safe to call for
+ * both real incoming messages and the embedded `quotedMessage` content
+ * carried in `contextInfo` (which can be an `ephemeralMessage`/
+ * `viewOnceMessage` wrapper, hence the `normalizeMessageContent` call).
+ *
+ * Exported so `api/index.ts` can decode the quoted payload when
+ * synthesizing the `BotMessage` returned by `getReply()`.
+ */
+export function decodeContent(content) {
+    const m = normalizeMessageContent(content) ?? undefined;
+    let type = "other";
+    let body = "";
+    let mimetype;
+    if (m?.conversation) {
+        type = "text";
+        body = m.conversation;
+    }
+    else if (m?.extendedTextMessage?.text) {
+        type = "text";
+        body = m.extendedTextMessage.text ?? "";
+    }
+    else if (m?.imageMessage) {
+        type = "image";
+        body = m.imageMessage.caption ?? "";
+        mimetype = m.imageMessage.mimetype ?? undefined;
+    }
+    else if (m?.videoMessage) {
+        type = "video";
+        body = m.videoMessage.caption ?? "";
+        mimetype = m.videoMessage.mimetype ?? undefined;
+    }
+    else if (m?.audioMessage) {
+        type = "audio";
+        mimetype = m.audioMessage.mimetype ?? undefined;
+    }
+    else if (m?.documentMessage) {
+        type = "document";
+        body = m.documentMessage.caption ?? "";
+        mimetype = m.documentMessage.mimetype ?? undefined;
+    }
+    else if (m?.stickerMessage) {
+        type = "sticker";
+        mimetype = m.stickerMessage.mimetype ?? undefined;
+    }
+    return { type, body, mimetype };
+}
+export function createBaileysAdapter(initial) {
+    // mutable so rebind() can swap it; closure-scoped so the contract below
+    // always sees the latest sock.
+    let sock = initial.sock;
+    const store = initial.store;
+    // ── Adapter-local helpers ────────────────────────────────────────────────
+    /**
+     * Build the `quoted` option for `sock.sendMessage(jid, content, opts)`.
+     *
+     * Baileys expects the `quoted` field to be a full message-shaped object —
+     * `{ key: {...}, message: {...} }` — so it can extract both the attribution
+     * (stanzaId/participant/fromMe from `key`) and the preview content (from
+     * `message`) when generating contextInfo. Passing only `key` makes
+     * `generateWAMessageFromContent` call `normalizeMessageContent(undefined)`
+     * → `getContentType(undefined)` → `undefined`, then index it with `[]`
+     * and throw `Cannot read properties of undefined (reading 'undefined')`.
+     *
+     * We resolve the full envelope from the in-memory store, indexed by the
+     * (remoteJid, id) pair carried in the neutral `BotQuotedRef`. If the
+     * envelope is no longer present (evicted past MAX_MSGS_PER_CHAT, lost on
+     * restart, etc.) we return `undefined` rather than emit a half-formed
+     * `quoted` — degrading to a plain unquoted reply is safer than crashing
+     * the calling plugin.
+     */
+    function buildQuotedOpts(quoted) {
+        if (!quoted?.id || !quoted?.remoteJid)
+            return undefined;
+        const raw = store.messages.get(quoted.remoteJid)?.get(quoted.id);
+        const inner = raw?.message;
+        if (!inner)
+            return undefined; // safe fallback: no quoted at all
+        // `quoted` (used by sendMessage for reply-citation) is a
+        // message-shaped object: `{ key: {...}, message: {...} }`. Baileys
+        // reads `quoted.key.*` to populate contextInfo (stanzaId, participant,
+        // fromMe) — passing the fields flat used to misattribute the reply to
+        // the bot itself. `quoted.message` is also required: Baileys' internal
+        // `generateWAMessageFromContent` calls `normalizeMessageContent(
+        // quoted.message)` and indexes the result with `getContentType(...)`,
+        // which throws if `.message` is missing.
+        return { quoted: { key: toFlatKey(quoted), message: inner } };
+    }
+    /**
+     * Translate a neutral `BotQuotedRef` into the FLAT key shape Baileys
+     * expects for `react`/`delete`/`edit`/`readMessages` (proto.IMessageKey
+     * — `{ id, remoteJid, fromMe, participant }` directly, NOT nested under
+     * a `.key` field). The nested `{key, message}` form is reserved for the
+     * `quoted` field on sendMessage — see `buildQuotedOpts` above.
+     */
+    function toFlatKey(ref) {
+        return {
+            id: ref.id ?? null,
+            remoteJid: ref.remoteJid ?? "",
+            fromMe: !!ref.fromMe,
+            participant: ref.participant ?? undefined,
+        };
+    }
+    /** Compute sha1-hex of a normalized buffer or string. */
+    function sha1(input) {
+        const hash = createHash("sha1");
+        if (typeof input === "string") {
+            hash.update(input, "utf8");
+        }
+        else {
+            hash.update(input);
+        }
+        return hash.digest("hex");
+    }
+    /** Translate a Baileys WAMessage into the neutral BotMessage envelope. */
+    function toBotMessage(msg) {
+        const m = normalizeMessageContent(msg.message) ?? undefined;
+        const { type, body, mimetype } = decodeContent(msg.message);
+        const key = msg.key;
+        const contextInfo = m?.extendedTextMessage?.contextInfo ??
+            m?.imageMessage?.contextInfo ??
+            m?.videoMessage?.contextInfo ??
+            m?.audioMessage?.contextInfo ??
+            m?.documentMessage?.contextInfo ??
+            undefined;
+        const ciTyped = contextInfo;
+        return {
+            id: msg.key.id ?? "",
+            chatId: msg.key.remoteJid ?? "",
+            fromMe: !!msg.key.fromMe,
+            type,
+            contentHash: sha1(body.trim()),
+            timestamp: Number(msg.messageTimestamp ?? 0) * 1000,
+            body,
+            mimetype: mimetype ?? undefined,
+            pushName: msg.pushName,
+            mentionedJid: ciTyped?.mentionedJid ?? undefined,
+            quotedKey: ciTyped?.stanzaId ? {
+                id: ciTyped.stanzaId,
+                remoteJid: msg.key.remoteJid ?? undefined,
+                fromMe: false,
+                participant: ciTyped.participant ?? undefined,
+            } : undefined,
+            fromLid: key.participantAlt,
+            fromPn: key.participant,
+            participantAlt: key.participantAlt,
+            remoteJidAlt: key.remoteJidAlt,
+            // Driver-specific escape hatches:
+            //   - pollEncKeyRaw: poll-decryption key for vote decryption
+            //   - contextInfo:   full IContextInfo (incl. embedded quotedMessage)
+            //                    so quoted-message consumers (api/index.ts
+            //                    buildMessageContext / downloadMedia fallback)
+            //                    can decode the quoted payload without going
+            //                    back through the store.
+            _raw: {
+                pollEncKeyRaw: m?.messageContextInfo?.messageSecret ?? undefined,
+                contextInfo: ciTyped ?? undefined,
+            },
+        };
+    }
+    /** Plain summary of a Baileys Chat. */
+    function chatSummary(c) {
+        return { id: c.id, name: c.name };
+    }
+    /** Plain summary of a Baileys Contact. */
+    function contactSummary(c) {
+        return {
+            id: c.id,
+            name: c.name,
+            notify: c.notify,
+            verifiedName: c.verifiedName,
+            lid: c.lid,
+        };
+    }
+    const subscribers = new Map();
+    // Tracks the handlers each socket has registered so we can remove them on a
+    // fresh socket after reconnect. Declared up here because the rebind helpers
+    // below close over it and the first `bindSockEventsExternal(sock)` call
+    // happens before the later declaration site would have executed — accessing
+    // it there would hit the temporal dead zone.
+    const boundHandlers = new WeakMap();
+    function emit(event, payload) {
+        const set = subscribers.get(event);
+        if (!set)
+            return;
+        for (const h of set) {
+            try {
+                h(payload);
+            }
+            catch (e) {
+                logger.debug(`[waContract] handler for "${event}" threw: ${e.message}`);
+            }
+        }
+    }
+    bindSockEventsExternal(sock);
+    // ── The contract ────────────────────────────────────────────────────────
+    const contract = {
+        name: "baileys",
+        // ── lifecycle ─────────────────────────────────────────────────────────
+        async connect() { },
+        async disconnect() { },
+        isReady() { return false; /* drivers/baileys/index.ts overrides this via the WaContract lifecycle */ },
+        async resolveLid(lid) {
+            try {
+                const repo = sock.signalRepository;
+                const fn = repo?.lidMapping?.getPNForLID;
+                if (typeof fn === "function") {
+                    const pn = await fn(lid);
+                    return pn ?? null;
+                }
+            }
+            catch (err) {
+                logger.debug(`[waContract] resolveLid cross-check failed for "${lid}": ${err.message}`);
+            }
+            return null;
+        },
+        // ── event subscription ────────────────────────────────────────────────
+        on(event, handler) {
+            let set = subscribers.get(event);
+            if (!set) {
+                set = new Set();
+                subscribers.set(event, set);
+            }
+            set.add(handler);
+            return () => set.delete(handler);
+        },
+        // ── send ───────────────────────────────────────────────────────────────
+        async sendText(jid, text, opts) {
+            const content = { text };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const sendOpts = buildQuotedOpts(opts?.quoted);
+            if (opts?.mentions?.length)
+                content.mentions = opts.mentions;
+            const ref = await sock.sendMessage(jid, content, sendOpts);
+            return toSentRef(ref, jid);
+        },
+        async sendImage(jid, buffer, opts) {
+            const content = { image: buffer };
+            if (opts?.caption)
+                content.caption = opts.caption;
+            if (opts?.viewOnce)
+                content.viewOnce = true;
+            if (opts?.mentions?.length)
+                content.mentions = opts.mentions;
+            const ref = await sock.sendMessage(jid, content, buildQuotedOpts(opts?.quoted));
+            return toSentRef(ref, jid);
+        },
+        async sendVideo(jid, buffer, opts) {
+            const content = { video: buffer };
+            if (opts?.caption)
+                content.caption = opts.caption;
+            if (opts?.viewOnce)
+                content.viewOnce = true;
+            if (opts?.gifPlayback)
+                content.gifPlayback = true;
+            if (opts?.mentions?.length)
+                content.mentions = opts.mentions;
+            const ref = await sock.sendMessage(jid, content, buildQuotedOpts(opts?.quoted));
+            return toSentRef(ref, jid);
+        },
+        async sendAudio(jid, buffer, opts) {
+            const content = { audio: buffer };
+            content.mimetype = opts?.mimetype ?? "audio/mp4";
+            if (opts?.ptt)
+                content.ptt = true;
+            if (opts?.viewOnce)
+                content.viewOnce = true;
+            const ref = await sock.sendMessage(jid, content, buildQuotedOpts(opts?.quoted));
+            return toSentRef(ref, jid);
+        },
+        async sendSticker(jid, buffer, opts) {
+            const ref = await sock.sendMessage(jid, { sticker: buffer }, buildQuotedOpts(opts?.quoted));
+            return toSentRef(ref, jid);
+        },
+        async sendDocument(jid, buffer, filename, mimetype, opts) {
+            const ref = await sock.sendMessage(jid, { document: buffer, mimetype, fileName: filename }, buildQuotedOpts(opts?.quoted));
+            return toSentRef(ref, jid);
+        },
+        async sendPoll(jid, opts) {
+            const poll = { name: opts.name, values: opts.values, selectableCount: opts.selectableCount ?? 1 };
+            const ref = await sock.sendMessage(jid, { poll }, buildQuotedOpts(opts.quoted));
+            return toSentRef(ref, jid);
+        },
+        async react(jid, target, emoji) {
+            const key = toFlatKey(target);
+            await sock.sendMessage(jid, { react: { text: emoji, key } });
+        },
+        async deleteMessage(jid, target, forEveryone) {
+            if (!forEveryone)
+                return;
+            const key = toFlatKey(target);
+            await sock.sendMessage(jid, { delete: key });
+        },
+        async editMessage(jid, target, text) {
+            const key = toFlatKey(target);
+            await sock.sendMessage(jid, { text, edit: key });
+        },
+        // ── presence + read ───────────────────────────────────────────────────
+        async sendPresenceUpdate(state, jid) {
+            const baileyState = state === "composing" ? "composing"
+                : state === "recording" ? "recording"
+                    : "paused";
+            await sock.sendPresenceUpdate(baileyState, jid);
+        },
+        async readMessages(keys) {
+            const baileyKeys = keys.map((k) => toFlatKey(k));
+            await sock.readMessages(baileyKeys);
+        },
+        // ── contacts ──────────────────────────────────────────────────────────
+        async onWhatsApp(jid) {
+            const fn = sock.onWhatsApp?.bind(sock);
+            if (!fn)
+                return null;
+            return await fn(jid);
+        },
+        async getBusinessProfile(jid) {
+            try {
+                const fn = sock.getBusinessProfile;
+                return await fn(jid);
+            }
+            catch {
+                return null;
+            }
+        },
+        async profilePictureUrl(jid) {
+            try {
+                const url = await sock.profilePictureUrl(jid, "image");
+                return url ?? null;
+            }
+            catch {
+                return null;
+            }
+        },
+        async fetchStatus(jid) {
+            const fn = sock.fetchStatus?.bind(sock);
+            if (!fn)
+                return null;
+            try {
+                const res = await fn(jid);
+                if (Array.isArray(res)) {
+                    const entry = res.find((r) => jidNormalizedUser(r.id) === jidNormalizedUser(jid)) ?? res[0];
+                    return entry?.status?.status ?? null;
+                }
+                return res?.status ?? null;
+            }
+            catch {
+                return null;
+            }
+        },
+        async updateBlockStatus(jid, action) {
+            const fn = sock.updateBlockStatus;
+            await fn(jid, action);
+        },
+        async addOrEditContact(jid, info) {
+            await sock.addOrEditContact(jid, info);
+        },
+        async removeContact(jid) {
+            await sock.removeContact(jid);
+        },
+        // ── groups ─────────────────────────────────────────────────────────────
+        async groupMetadata(jid) {
+            const meta = await sock.groupMetadata(jid);
+            return {
+                subject: meta.subject,
+                participants: meta.participants.map(p => ({
+                    id: jidNormalizedUser(p.id),
+                    isAdmin: p.admin === "admin" || p.admin === "superadmin",
+                    isSuperAdmin: p.admin === "superadmin",
+                    phoneNumber: p.phoneNumber,
+                })),
+            };
+        },
+        async groupParticipantsUpdate(jid, users, action) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const res = await sock.groupParticipantsUpdate(jid, users, action);
+            return res;
+        },
+        async groupUpdateSubject(jid, subject) {
+            await sock.groupUpdateSubject(jid, subject);
+        },
+        async groupUpdateDescription(jid, description) {
+            await sock.groupUpdateDescription(jid, description);
+        },
+        async groupInviteCode(jid) {
+            return await sock.groupInviteCode(jid);
+        },
+        async groupRevokeInvite(jid) {
+            return await sock.groupRevokeInvite(jid);
+        },
+        // ── profile ────────────────────────────────────────────────────────────
+        async updateProfilePicture(jid, buffer) {
+            await sock.updateProfilePicture(jid, buffer);
+        },
+        async updateProfileName(name) {
+            await sock.updateProfileName(name);
+        },
+        async updateProfileStatus(status) {
+            await sock.updateProfileStatus(status);
+        },
+        // ── me ─────────────────────────────────────────────────────────────────
+        me() {
+            const u = sock.user;
+            const id = u?.id ? jidNormalizedUser(u.id) : "";
+            return { id, lid: u?.lid };
+        },
+        // ── verification primitive ──────────────────────────────────────────
+        // sendFallbackGuard calls this right after sendText resolves to confirm
+        // the message actually landed. The Baileys in-memory store is updated
+        // synchronously by the `messages.upsert` listener (store.ts), and
+        // own-sent messages land there as soon as sock.sendMessage returns —
+        // so the first lookup is effectively free (no network round-trip).
+        async getHistory(jid, opts) {
+            const limit = opts?.limit ?? 5;
+            const chatMsgs = store.messages.get(jid);
+            if (!chatMsgs || chatMsgs.size === 0)
+                return [];
+            // Newest-first so callers can slice `limit` off the head; we sort
+            // by messageTimestamp (seconds) and fall back to insertion order
+            // for messages synced together (same timestamp) so ordering stays
+            // stable across reads.
+            const all = [...chatMsgs.values()];
+            all.sort((a, b) => {
+                const ta = Number(a.messageTimestamp ?? 0);
+                const tb = Number(b.messageTimestamp ?? 0);
+                if (ta !== tb)
+                    return tb - ta;
+                return 0;
+            });
+            return all.slice(0, limit).map(toBotMessage);
+        },
+        // ── media (download) ───────────────────────────────────────────────────
+        async downloadMedia(msg, opts) {
+            // Resolve the Baileys message envelope needed by `downloadMediaMessage`.
+            // Preferred path: if the caller already carries the embedded message
+            // payload (synthetic `BotMessage` for a quoted message, whose
+            // `_raw.contextInfo.quotedMessage` is the full WAMessageContent),
+            // build the envelope directly from that. This avoids the silent
+            // failure mode where the quoted message's original envelope has
+            // aged out of the store's per-chat ring buffer.
+            //
+            // Fallback: the regular case (downloading media for the incoming
+            // message itself, or any other BotMessage that has a real envelope
+            // in the store) — look it up by (chatId, id).
+            const embedded = msg._raw;
+            const embeddedContent = embedded?.contextInfo?.quotedMessage;
+            const raw = embeddedContent
+                ? {
+                    key: {
+                        id: embedded.contextInfo?.stanzaId ?? msg.id,
+                        remoteJid: msg.chatId,
+                        fromMe: false,
+                        participant: embedded.contextInfo?.participant ?? undefined,
+                    },
+                    message: embeddedContent,
+                }
+                : store.messages.get(msg.chatId)?.get(msg.id);
+            if (!raw)
+                return null;
+            try {
+                const buffer = await downloadMediaMessage(raw, "buffer", {}, {
+                    logger: silentBaileysLogger,
+                    reuploadRequest: sock.updateMediaMessage,
+                });
+                if (!buffer || !Buffer.isBuffer(buffer))
+                    return null;
+                // Animated sticker → mp4 is handled by the caller (api/index.ts
+                // wa.downloadMedia) — kept at the api layer for now.
+                if (opts?.asMp4) {
+                    // No animated-sticker conversion here for now (would couple to
+                    // ffmpeg + node-webpmux). Caller does it.
+                }
+                return { mimetype: msg.mimetype ?? "application/octet-stream", data: buffer };
+            }
+            catch (err) {
+                logger.warn(`[waContract] downloadMedia failed: ${err.message}`);
+                return null;
+            }
+        },
+    };
+    // ── Rebind helpers (post-reconnect in drivers/baileys/index.ts) ────────
+    //
+    // We need to keep references to the handlers we registered on the old
+    // sock.ev so we can remove them on a fresh socket — otherwise the old
+    // socket would leak listeners and every reconnect would double the
+    // fan-out work. The trick is the handler bodies close over `emit` and
+    // `toBotMessage`, which read from module-local state that doesn't change.
+    function bindSockEventsExternal(s) {
+        const ev = s.ev;
+        const handlers = new Map();
+        function register(event, h) {
+            handlers.set(event, h);
+            ev.on(event, h);
+        }
+        register("messages.upsert", (arg) => {
+            const { messages, type } = arg;
+            emit("messages.upsert", { messages: messages.map(toBotMessage), type });
+        });
+        register("messages.update", (arg) => {
+            const updates = arg;
+            emit("messages.update", { updates });
+        });
+        register("messaging-history.set", (arg) => {
+            const { chats, contacts, messages } = arg;
+            emit("messaging-history.set", {
+                chats: chats.map(chatSummary),
+                contacts: contacts.map(contactSummary),
+                messages: (messages ?? []).map(toBotMessage),
+            });
+        });
+        register("chats.upsert", (arg) => {
+            emit("chats.upsert", { chats: arg.map(chatSummary) });
+        });
+        register("chats.update", (arg) => {
+            emit("chats.update", { updates: arg });
+        });
+        register("contacts.upsert", (arg) => {
+            emit("contacts.upsert", { contacts: arg.map(contactSummary) });
+        });
+        register("contacts.update", (arg) => {
+            emit("contacts.update", { updates: arg.map(contactSummary) });
+        });
+        register("group-participants.update", (arg) => {
+            const { id, participants } = arg;
+            emit("group-participants.update", { id, participants });
+        });
+        register("groups.update", (arg) => {
+            emit("groups.update", { updates: arg });
+        });
+        register("connection.update", (arg) => {
+            const { connection, lastDisconnect } = arg;
+            emit("connection.update", {
+                connection,
+                lastDisconnect: lastDisconnect?.error ? { statusCode: lastDisconnect.error.output?.statusCode } : undefined,
+            });
+        });
+        boundHandlers.set(s, handlers);
+    }
+    function unbindSockEvents(s) {
+        const handlers = boundHandlers.get(s);
+        if (!handlers)
+            return;
+        const ev = s.ev;
+        for (const [event, h] of handlers) {
+            ev.off(event, h);
+        }
+        boundHandlers.delete(s);
+    }
+    // ── Handle returned to drivers/baileys/index.ts ────────────────────────
+    // Hang the raw `sock` off the contract via a private symbol so
+    // `drivers/baileys/api/index.ts` (the Baileys-only plugin-context
+    // builder) can pull it back when it needs a Baileys-only operation
+    // (poll decryption, gif detection, message envelope decoding for the
+    // helpers that don't yet have a driver-neutral equivalent). The symbol
+    // is shared via Symbol.for() so the api file and the adapter can agree
+    // on the same key without a top-level import. No other module in the
+    // codebase sees this — the rest of the kernel talks only to WaContract.
+    const RAW_SOCK = Symbol.for("manybot.baileys.rawSocket");
+    contract[RAW_SOCK] = sock;
+    return {
+        contract,
+        rebind(newSock) {
+            unbindSockEvents(sock);
+            sock = newSock;
+            bindSockEventsExternal(newSock);
+            // Keep the symbol attached to the contract pointing at the new
+            // socket too — api/index.ts caches the contract object, so the
+            // symbol slot is the only way it sees the rebind.
+            contract[RAW_SOCK] = newSock;
+        },
+        unbind(oldSock) {
+            unbindSockEvents(oldSock);
+        },
+    };
+}
+// ── Helpers used inside the adapter above ────────────────────────────────────
+//
+// `buildQuotedOpts` and `toFlatKey` are defined inside the
+// `createBaileysAdapter` closure (so they can see the `store`) — only
+// `toSentRef` and `silentBaileysLogger` remain module-scoped helpers.
+function toSentRef(raw, fallbackChatId) {
+    const r = raw;
+    return {
+        id: r?.key?.id ?? "",
+        chatId: r?.key?.remoteJid ?? fallbackChatId,
+        timestamp: Date.now(),
+    };
+}
+/**
+ * pino-shape shim for Baileys' downloadMediaMessage — see the in-source
+ * explanation in api/index.ts (same shape, kept here for the adapter).
+ */
+const silentBaileysLogger = {
+    level: "silent",
+    child() { return silentBaileysLogger; },
+    trace() { },
+    debug() { },
+    info() { },
+    warn(obj, msg) { logger.warn(`[baileys]`, msg ?? obj); },
+    error(obj, msg) { logger.error(`[baileys]`, msg ?? obj); },
+};