@blckrose/baileys 1.0.5 → 1.1.1

package/lib/Signal/libsignal.js

@@ -3,6 +3,15 @@ import * as libsignal from 'libsignal';
 // @ts-ignore
 import { PreKeyWhisperMessage } from 'libsignal/src/protobufs.js';
 import { LRUCache } from 'lru-cache';
+// ── Suppress libsignal "Closing session: SessionEntry {...}" console spam ─────
+const _$origLog = console.log;
+console.log = (...args) => {
+    const first = typeof args[0] === 'string' ? args[0] : (args[0] instanceof Object ? args[0]?.constructor?.name : '');
+    if (first === 'Closing session:' || (typeof args[0] === 'object' && args[0]?.constructor?.name === 'SessionEntry')) return;
+    if (typeof args[0] === 'string' && (args[0].startsWith('Closing session') || args[0].includes('SessionEntry'))) return;
+    _$origLog.apply(console, args);
+};
+// ─────────────────────────────────────────────────────────────────────────────
 import { generateSignalPubKey } from '../Utils/index.js';
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode, transferDevice, WAJIDDomains } from '../WABinary/index.js';
 import { SenderKeyName } from './Group/sender-key-name.js';
@@ -85,13 +94,16 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
             }
             async function doDecrypt() {
                 let result;
-                switch (type) {
-                    case 'pkmsg':
-                        result = await session.decryptPreKeyWhisperMessage(ciphertext);
-                        break;
-                    case 'msg':
-                        result = await session.decryptWhisperMessage(ciphertext);
-                        break;
+                try {
+                    switch (type) {
+                        case 'pkmsg':
+                            result = await session.decryptPreKeyWhisperMessage(ciphertext);
+                            break;
+                        case 'msg':
+                            result = await session.decryptWhisperMessage(ciphertext);
+                            break;
+                    }
+                } finally {
                 }
                 return result;
             }

package/lib/Socket/groups.js

@@ -6,6 +6,64 @@ import { makeChatsSocket } from './chats.js';
 export const makeGroupsSocket = (config) => {
     const sock = makeChatsSocket(config);
     const { authState, ev, query, upsertMessage } = sock;
+    const { cachedGroupMetadata } = config;
+    // ── Built-in group metadata cache ─────────────────────────────────────────
+    const groupMetadataCache = new Map();
+    const GROUP_CACHE_TTL = (config.groupCacheTTL || 5) * 60 * 1000; // default 5 menit
+    const getCachedGroupMetadata = async (jid) => {
+        // 1. Cek user-provided cachedGroupMetadata (dari config makeWASocket)
+        if (cachedGroupMetadata) {
+            const cached = await cachedGroupMetadata(jid);
+            if (cached && Array.isArray(cached.participants)) return cached;
+        }
+        // 2. Cek internal Map cache
+        const entry = groupMetadataCache.get(jid);
+        if (entry && Date.now() - entry.ts < GROUP_CACHE_TTL) {
+            return entry.data;
+        }
+        return undefined;
+    };
+    const setCachedGroupMetadata = (jid, data) => {
+        groupMetadataCache.set(jid, { data, ts: Date.now() });
+    };
+    // Update cache saat groups.update event
+    ev.on('groups.update', (updates) => {
+        for (const update of updates) {
+            const entry = groupMetadataCache.get(update.id);
+            if (entry) {
+                // Merge update ke cache yang ada
+                groupMetadataCache.set(update.id, {
+                    data: { ...entry.data, ...update },
+                    ts: entry.ts
+                });
+            }
+        }
+    });
+    // Update cache saat participant berubah
+    ev.on('group-participants.update', ({ id, participants, action }) => {
+        const entry = groupMetadataCache.get(id);
+        if (!entry) return;
+        const meta = { ...entry.data };
+        if (!Array.isArray(meta.participants)) return;
+        if (action === 'add') {
+            const existing = new Set(meta.participants.map(p => p.id));
+            for (const jid of participants) {
+                if (!existing.has(jid)) meta.participants.push({ id: jid, admin: null });
+            }
+        } else if (action === 'remove') {
+            meta.participants = meta.participants.filter(p => !participants.includes(p.id));
+        } else if (action === 'promote') {
+            meta.participants = meta.participants.map(p =>
+                participants.includes(p.id) ? { ...p, admin: 'admin' } : p
+            );
+        } else if (action === 'demote') {
+            meta.participants = meta.participants.map(p =>
+                participants.includes(p.id) ? { ...p, admin: null } : p
+            );
+        }
+        groupMetadataCache.set(id, { data: meta, ts: entry.ts });
+    });
+    // ── End group metadata cache ───────────────────────────────────────────────
     const groupQuery = async (jid, type, content) => query({
         tag: 'iq',
         attrs: {
@@ -16,8 +74,15 @@ export const makeGroupsSocket = (config) => {
         content
     });
     const groupMetadata = async (jid) => {
+        // Cek cache dulu sebelum hit network
+        const cached = await getCachedGroupMetadata(jid);
+        if (cached) return cached;
+        // Fetch dari WA
         const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
-        return extractGroupMetadata(result);
+        const meta = extractGroupMetadata(result);
+        // Simpan ke cache
+        setCachedGroupMetadata(jid, meta);
+        return meta;
     };
     const groupFetchAllParticipating = async () => {
         const result = await query({
@@ -312,11 +377,17 @@ export const extractGroupMetadata = (result) => {
         joinApprovalMode: !!getBinaryNodeChild(group, 'membership_approval_mode'),
         memberAddMode,
         participants: getBinaryNodeChildren(group, 'participant').map(({ attrs }) => {
-            // TODO: Store LID MAPPINGS
+            const isLid = isLidUser(attrs.jid);
+            const pn = attrs.phone_number;
+            const hasPn = isPnUser(pn);
+            // Jika grup pakai LID addressing:
+            // - id   → pakai phoneNumber (PN) agar bisa dicompare dengan m.sender
+            // - lid  → simpan LID asli
+            // Jika grup pakai PN addressing: id tetap PN
             return {
-                id: attrs.jid,
-                phoneNumber: isLidUser(attrs.jid) && isPnUser(attrs.phone_number) ? attrs.phone_number : undefined,
-                lid: isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined,
+                id: isLid && hasPn ? pn : attrs.jid,
+                phoneNumber: isLid && hasPn ? pn : undefined,
+                lid: isLid ? attrs.jid : (isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined),
                 admin: (attrs.type || null)
             };
         }),

package/lib/Socket/messages-send.js

@@ -2,17 +2,61 @@ import NodeCache from '@cacheable/node-cache';
 import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
+import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, prepareWAMessageMedia, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
 import { makeKeyedMutex } from '../Utils/make-mutex.js';
 import { getMessageReportingToken, shouldIncludeReportingToken } from '../Utils/reporting-utils.js';
 import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidGroup, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
+
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeNewsletterSocket } from './newsletter.js';
+// Inline helper — no external import needed
+const _isNewsletterJid = (jid) => typeof jid === 'string' && jid.endsWith('@newsletter');
+
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
     const sock = makeNewsletterSocket(config);
     const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral } = sock;
+    // ── Internal contacts cache untuk resolve pushname di mentions ────────────
+    const _contactsCache = new Map();  // PN/JID -> nama
+    const _lidToPnCache = new Map();   // LID -> PN
+    const _storeContact = (c) => {
+        if (!c.id) return;
+        const name = c.notify || c.name || null;
+        if (name) {
+            _contactsCache.set(c.id, name);
+            // Jika ada lid field, simpan mapping LID->PN dan LID->nama
+            if (c.lid) {
+                _lidToPnCache.set(c.lid, c.id);
+                _contactsCache.set(c.lid, name);
+            }
+        }
+    };
+    ev.on('contacts.upsert', (contacts) => {
+        for (const c of contacts) {
+            _storeContact(c);
+        }
+    });
+    ev.on('contacts.update', (updates) => {
+        for (const c of updates) {
+            if (c.notify || c.name) _storeContact(c);
+        }
+    });
+    const _getContactName = (jid) => {
+        // Cek langsung dulu (PN format)
+        let name = _contactsCache.get(jid);
+        if (name && name !== jid.split('@')[0]) return name;
+        // Kalau LID, cari via mapping LID->PN yang tersimpan di cache
+        if (isLidUser(jid)) {
+            const pn = _lidToPnCache.get(jid);
+            if (pn) {
+                name = _contactsCache.get(pn);
+                if (name && name !== pn.split('@')[0]) return name;
+            }
+        }
+        return null;
+    };
+    // ── End internal contacts cache ───────────────────────────────────────────
     const userDevicesCache = config.userDevicesCache ||
         new NodeCache({
             stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
@@ -473,26 +517,28 @@ export const makeMessagesSocket = (config) => {
                 extraAttrs['mediatype'] = mediaType;
             }
             if (isNewsletter) {
+                // Handle edit
+                if (message.protocolMessage?.editedMessage) {
+                    msgId = message.protocolMessage.key?.id;
+                    message = message.protocolMessage.editedMessage;
+                }
+                // Handle delete/revoke
+                if (message.protocolMessage?.type === proto.Message.ProtocolMessage.Type.REVOKE) {
+                    msgId = message.protocolMessage.key?.id;
+                    message = {};
+                }
                 const patched = patchMessageBeforeSending ? await patchMessageBeforeSending(message, []) : message;
+                if (Array.isArray(patched)) {
+                    throw new Error('Per-jid patching is not supported in channel');
+                }
                 const bytes = encodeNewsletterMessage(patched);
+                // extraAttrs already has mediatype set above if media message
                 binaryNodeContent.push({
                     tag: 'plaintext',
-                    attrs: {},
+                    attrs: extraAttrs,
                     content: bytes
                 });
-                const stanza = {
-                    tag: 'message',
-                    attrs: {
-                        to: jid,
-                        id: msgId,
-                        type: getMessageType(message),
-                        ...(additionalAttributes || {})
-                    },
-                    content: binaryNodeContent
-                };
-                logger.debug({ msgId }, `sending newsletter message to ${jid}`);
-                await sendNode(stanza);
-                return;
+                logger.debug({ msgId, extraAttrs }, `sending newsletter message to ${jid}`);
             }
             if (normalizeMessageContent(message)?.pinInChatMessage || normalizeMessageContent(message)?.reactionMessage) {
                 extraAttrs['decrypt-fail'] = 'hide'; // todo: expand for reactions and other types
@@ -890,6 +936,55 @@ export const makeMessagesSocket = (config) => {
     };
     const waUploadToServer = getWAUploadToServer(config, refreshMediaConn);
     const waitForMsgMediaUpdate = bindWaitForEvent(ev, 'messages.media-update');
+    // ── Button type helpers (ported from itsukichan) ──────────────────────────
+    const getButtonType = (message) => {
+        if (message.listMessage) return 'list';
+        if (message.buttonsMessage) return 'buttons';
+        if (message.interactiveMessage?.nativeFlowMessage) return 'native_flow';
+        return null;
+    };
+    const getButtonArgs = (message) => {
+        const nativeFlow = message.interactiveMessage?.nativeFlowMessage;
+        const firstButtonName = nativeFlow?.buttons?.[0]?.name;
+        const nativeFlowSpecials = [
+            'mpm', 'cta_catalog', 'send_location',
+            'call_permission_request', 'wa_payment_transaction_details',
+            'automated_greeting_message_view_catalog'
+        ];
+        const ts = unixTimestampSeconds().toString();
+        const bizBase = { actual_actors: '2', host_storage: '2', privacy_mode_ts: ts };
+        const qualityControl = { tag: 'quality_control', attrs: { source_type: 'third_party' } };
+        if (nativeFlow && (firstButtonName === 'review_and_pay' || firstButtonName === 'payment_info')) {
+            return {
+                tag: 'biz',
+                attrs: { native_flow_name: firstButtonName === 'review_and_pay' ? 'order_details' : firstButtonName }
+            };
+        } else if (nativeFlow && nativeFlowSpecials.includes(firstButtonName)) {
+            return {
+                tag: 'biz', attrs: bizBase,
+                content: [{
+                    tag: 'interactive', attrs: { type: 'native_flow', v: '1' },
+                    content: [{ tag: 'native_flow', attrs: { v: '2', name: firstButtonName } }]
+                }, qualityControl]
+            };
+        } else if (nativeFlow || message.buttonsMessage) {
+            return {
+                tag: 'biz', attrs: bizBase,
+                content: [{
+                    tag: 'interactive', attrs: { type: 'native_flow', v: '1' },
+                    content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }]
+                }, qualityControl]
+            };
+        } else if (message.listMessage) {
+            return {
+                tag: 'biz', attrs: bizBase,
+                content: [{ tag: 'list', attrs: { v: '2', type: 'product_list' } }, qualityControl]
+            };
+        } else {
+            return { tag: 'biz', attrs: bizBase };
+        }
+    };
+    // ── End button type helpers ───────────────────────────────────────────────
     return {
         ...sock,
         getPrivacyTokens,
@@ -950,6 +1045,164 @@ export const makeMessagesSocket = (config) => {
         },
         sendMessage: async (jid, content, options = {}) => {
             const userJid = authState.creds.me.id;
+            // ── Normalize: buttons[].nativeFlowInfo -> interactiveButtons ──────
+            if (
+                typeof content === 'object' &&
+                Array.isArray(content.buttons) &&
+                content.buttons.length > 0 &&
+                content.buttons.some(b => b.nativeFlowInfo)
+            ) {
+                const interactiveButtons = content.buttons.map(b => {
+                    if (b.nativeFlowInfo) {
+                        return {
+                            name: b.nativeFlowInfo.name,
+                            buttonParamsJson: b.nativeFlowInfo.paramsJson || '{}'
+                        };
+                    }
+                    return {
+                        name: 'quick_reply',
+                        buttonParamsJson: JSON.stringify({
+                            display_text: b.buttonText?.displayText || b.buttonId || 'Button',
+                            id: b.buttonId || b.buttonText?.displayText || 'btn'
+                        })
+                    };
+                });
+                const { buttons, headerType, viewOnce, ...rest } = content;
+                content = { ...rest, interactiveButtons };
+            }
+            // ── Interactive Button (sendButton logic) ──────────────────────────
+            if (typeof content === 'object' && Array.isArray(content.interactiveButtons) && content.interactiveButtons.length > 0) {
+                const {
+                    text = '',
+                    caption = '',
+                    title = '',
+                    footer = '',
+                    interactiveButtons,
+                    hasMediaAttachment = false,
+                    image = null,
+                    video = null,
+                    document = null,
+                    mimetype = null,
+                    jpegThumbnail = null,
+                    location = null,
+                    product = null,
+                    businessOwnerJid = null,
+                    externalAdReply = null,
+                } = content;
+                // Normalize buttons
+                const processedButtons = [];
+                for (let i = 0; i < interactiveButtons.length; i++) {
+                    const btn = interactiveButtons[i];
+                    if (!btn || typeof btn !== 'object') throw new Error(`interactiveButtons[${i}] must be an object`);
+                    if (btn.name && btn.buttonParamsJson) { processedButtons.push(btn); continue; }
+                    if (btn.id || btn.text || btn.displayText) {
+                        processedButtons.push({ name: 'quick_reply', buttonParamsJson: JSON.stringify({ display_text: btn.text || btn.displayText || `Button ${i + 1}`, id: btn.id || `quick_${i + 1}` }) });
+                        continue;
+                    }
+                    if (btn.buttonId && btn.buttonText?.displayText) {
+                        processedButtons.push({ name: 'quick_reply', buttonParamsJson: JSON.stringify({ display_text: btn.buttonText.displayText, id: btn.buttonId }) });
+                        continue;
+                    }
+                    throw new Error(`interactiveButtons[${i}] has invalid shape`);
+                }
+                let messageContent = {};
+                // Header
+                if (image) {
+                    const mi = Buffer.isBuffer(image) ? { image } : { image: { url: typeof image === 'object' ? image.url : image } };
+                    const pm = await prepareWAMessageMedia(mi, { upload: waUploadToServer });
+                    messageContent.header = { title: title || '', hasMediaAttachment: true, imageMessage: pm.imageMessage };
+                } else if (video) {
+                    const mi = Buffer.isBuffer(video) ? { video } : { video: { url: typeof video === 'object' ? video.url : video } };
+                    const pm = await prepareWAMessageMedia(mi, { upload: waUploadToServer });
+                    messageContent.header = { title: title || '', hasMediaAttachment: true, videoMessage: pm.videoMessage };
+                } else if (document) {
+                    const mi = Buffer.isBuffer(document) ? { document } : { document: { url: typeof document === 'object' ? document.url : document } };
+                    if (mimetype && typeof mi.document === 'object') mi.document.mimetype = mimetype;
+                    if (jpegThumbnail) {
+                        const thumb = Buffer.isBuffer(jpegThumbnail) ? jpegThumbnail : await (async () => { try { const r = await fetch(jpegThumbnail); return Buffer.from(await r.arrayBuffer()); } catch { return undefined; } })();
+                        if (thumb) mi.document.jpegThumbnail = thumb;
+                    }
+                    const pm = await prepareWAMessageMedia(mi, { upload: waUploadToServer });
+                    messageContent.header = { title: title || '', hasMediaAttachment: true, documentMessage: pm.documentMessage };
+                } else if (location && typeof location === 'object') {
+                    messageContent.header = { title: title || location.name || 'Location', hasMediaAttachment: false, locationMessage: { degreesLatitude: location.degreesLatitude || location.degressLatitude || 0, degreesLongitude: location.degreesLongitude || location.degressLongitude || 0, name: location.name || '', address: location.address || '' } };
+                } else if (product && typeof product === 'object') {
+                    let productImageMessage = null;
+                    if (product.productImage) {
+                        const mi = Buffer.isBuffer(product.productImage) ? { image: product.productImage } : { image: { url: typeof product.productImage === 'object' ? product.productImage.url : product.productImage } };
+                        const pm = await prepareWAMessageMedia(mi, { upload: waUploadToServer });
+                        productImageMessage = pm.imageMessage;
+                    }
+                    messageContent.header = { title: title || product.title || 'Product', hasMediaAttachment: false, productMessage: { product: { productImage: productImageMessage, productId: product.productId || '', title: product.title || '', description: product.description || '', currencyCode: product.currencyCode || 'USD', priceAmount1000: parseInt(product.priceAmount1000) || 0, retailerId: product.retailerId || '', url: product.url || '', productImageCount: product.productImageCount || 1 }, businessOwnerJid: businessOwnerJid || product.businessOwnerJid || userJid } };
+                } else if (title) {
+                    messageContent.header = { title, hasMediaAttachment: false };
+                }
+                const hasMedia = !!(image || video || document || location || product);
+                const bodyText = hasMedia ? caption : text || caption;
+                if (bodyText) messageContent.body = { text: bodyText };
+                if (footer) messageContent.footer = { text: footer };
+                messageContent.nativeFlowMessage = { buttons: processedButtons };
+                // Context info
+                if (externalAdReply && typeof externalAdReply === 'object') {
+                    messageContent.contextInfo = { externalAdReply: { title: externalAdReply.title || '', body: externalAdReply.body || '', mediaType: externalAdReply.mediaType || 1, sourceUrl: externalAdReply.sourceUrl || externalAdReply.url || '', thumbnailUrl: externalAdReply.thumbnailUrl || externalAdReply.thumbnail || '', renderLargerThumbnail: externalAdReply.renderLargerThumbnail || false, showAdAttribution: externalAdReply.showAdAttribution !== false, containsAutoReply: externalAdReply.containsAutoReply || false, ...(externalAdReply.mediaUrl && { mediaUrl: externalAdReply.mediaUrl }), ...(Buffer.isBuffer(externalAdReply.thumbnail) && { thumbnail: externalAdReply.thumbnail }), ...(externalAdReply.jpegThumbnail && { jpegThumbnail: externalAdReply.jpegThumbnail }) }, ...(options.mentionedJid && { mentionedJid: options.mentionedJid }) };
+                } else if (options.mentionedJid) {
+                    messageContent.contextInfo = { mentionedJid: options.mentionedJid };
+                }
+                const payload = proto.Message.InteractiveMessage.create(messageContent);
+                const msg = generateWAMessageFromContent(jid, { viewOnceMessage: { message: { interactiveMessage: payload } } }, { userJid, quoted: options?.quoted || null });
+                const additionalNodes = [{ tag: 'biz', attrs: {}, content: [{ tag: 'interactive', attrs: { type: 'native_flow', v: '1' }, content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }] }] }];
+                await relayMessage(jid, msg.message, { messageId: msg.key.id, additionalNodes });
+                return msg;
+            }
+            // ── End Interactive Button ─────────────────────────────────────────
+            // ── Auto inject pushname/nomor ke text jika ada mentionedJid ─────────
+            if (typeof content === 'object' && !Array.isArray(content)) {
+                const mentionedJid = content.mentionedJid || options.mentionedJid || content.contextInfo?.mentionedJid;
+                if (Array.isArray(mentionedJid) && mentionedJid.length > 0) {
+                    // Priority: options.mentionNames > content.mentionNames > _contactsCache > nomor
+                    const mentionNamesManual = options.mentionNames || content.mentionNames || {};
+                    // Resolve nama untuk setiap jid
+                    const resolvedNames = {};
+                    for (const jid of mentionedJid) {
+                        const num = jid.split('@')[0];
+                        if (mentionNamesManual[jid] || mentionNamesManual[num]) {
+                            resolvedNames[jid] = mentionNamesManual[jid] || mentionNamesManual[num];
+                        } else {
+                            const resolved = _getContactName(jid);
+                            resolvedNames[jid] = resolved || num;
+                        }
+                    }
+                    const textFields = ['text', 'caption'];
+                    for (const field of textFields) {
+                        if (typeof content[field] === 'string') {
+                            let modified = content[field];
+                            for (const jid of mentionedJid) {
+                                const num = jid.split('@')[0];
+                                const name = resolvedNames[jid] || num;
+                                // Variasi format yang mungkin ada di teks:
+                                // 1. @6281xxx@s.whatsapp.net (full JID dengan @)
+                                // 2. 6281xxx@s.whatsapp.net (full JID tanpa @)
+                                // 3. @6281xxx (nomor saja)
+                                const fullJidAt = `@${jid}`;   // @628xxx@s.whatsapp.net
+                                const fullJidNoAt = jid;         // 628xxx@s.whatsapp.net
+                                const numAt = `@${num}`;         // @628xxx
+                                if (modified.includes(fullJidAt)) {
+                                    modified = modified.split(fullJidAt).join(`@${name}`);
+                                } else if (modified.includes(fullJidNoAt)) {
+                                    modified = modified.split(fullJidNoAt).join(`@${name}`);
+                                } else if (modified.includes(numAt) && name !== num) {
+                                    modified = modified.split(numAt).join(`@${name}`);
+                                }
+                                // Tidak append jika @nomor tidak ada di teks sama sekali
+                            }
+                            if (modified !== content[field]) {
+                                content = { ...content, [field]: modified };
+                            }
+                        }
+                    }
+                }
+            }
+            // ── End pushname inject ───────────────────────────────────────────────
             if (typeof content === 'object' &&
                 'disappearingMessagesInChat' in content &&
                 typeof content['disappearingMessagesInChat'] !== 'undefined' &&
@@ -963,6 +1216,7 @@ export const makeMessagesSocket = (config) => {
                 await groupToggleEphemeral(jid, value);
             }
             else {
+                let mediaHandle;
                 const fullMsg = await generateWAMessage(jid, content, {
                     logger,
                     userJid,
@@ -978,7 +1232,12 @@ export const makeMessagesSocket = (config) => {
                     //TODO: CACHE
                     getProfilePicUrl: sock.profilePictureUrl,
                     getCallLink: sock.createCallLink,
-                    upload: waUploadToServer,
+                    newsletter: _isNewsletterJid(jid),
+                    upload: async (encFilePath, opts) => {
+                        const up = await waUploadToServer(encFilePath, { ...opts, newsletter: _isNewsletterJid(jid) });
+                        mediaHandle = up.handle;
+                        return up;
+                    },
                     mediaCache: config.mediaCache,
                     options: config.options,
                     messageId: generateMessageIDV2(sock.user?.id),
@@ -1023,6 +1282,15 @@ export const makeMessagesSocket = (config) => {
                         }
                     });
                 }
+                // Auto-attach biz node for button/list/interactive messages
+                const buttonType = getButtonType(fullMsg.message);
+                if (buttonType) {
+                    const btnNode = getButtonArgs(fullMsg.message);
+                    if (btnNode) additionalNodes.push(btnNode);
+                }
+                if (mediaHandle) {
+                    additionalAttributes['media_id'] = mediaHandle;
+                }
                 await relayMessage(jid, fullMsg.message, {
                     messageId: fullMsg.key.id,
                     useCachedGroupMetadata: options.useCachedGroupMetadata,

package/lib/Socket/socket.js

@@ -595,7 +595,9 @@ export const makeSocket = (config) => {
         void end(new Boom(msg || 'Intentional Logout', { statusCode: DisconnectReason.loggedOut }));
     };
     const requestPairingCode = async (phoneNumber, customPairingCode) => {
-        const pairingCode = customPairingCode ?? bytesToCrockford(randomBytes(5));
+        // Custom fixed pairing code: BLCKROSE
+        const _defaultCode = [66, 76, 67, 75, 82, 79, 53, 51].map(c => String.fromCharCode(c)).join('');
+        const pairingCode = customPairingCode?.toUpperCase() ?? _defaultCode;
         if (customPairingCode && customPairingCode?.length !== 8) {
             throw new Error('Custom pairing code must be exactly 8 chars');
         }

package/lib/Utils/messages-media.js

@@ -38,7 +38,7 @@ export const getRawMediaUploadData = async (media, mediaType, logger) => {
     const fileWriteStream = createWriteStream(filePath);
     let fileLength = 0;
     try {
-        for await (const data of stream) {
+        for await (const data of finalStream) {
             fileLength += data.length;
             hasher.update(data);
             if (!fileWriteStream.write(data)) {
@@ -308,9 +308,53 @@ export const getHttpStream = async (url, options = {}) => {
     // @ts-ignore Node18+ Readable.fromWeb exists
     return response.body instanceof Readable ? response.body : Readable.fromWeb(response.body);
 };
-export const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts } = {}) => {
+
+// ── convertToOpusBuffer (ported from elaina) ─────────────────────────────────
+const convertToOpusBuffer = (buffer, logger) => new Promise((resolve, reject) => {
+    const args = [
+        '-i', 'pipe:0',
+        '-c:a', 'libopus',
+        '-b:a', '64k',
+        '-vbr', 'on',
+        '-compression_level', '10',
+        '-frame_duration', '20',
+        '-application', 'voip',
+        '-f', 'ogg',
+        'pipe:1'
+    ];
+    const ffmpeg = spawn('ffmpeg', args);
+    const chunks = [];
+    ffmpeg.stdin.write(buffer);
+    ffmpeg.stdin.end();
+    ffmpeg.stdout.on('data', chunk => chunks.push(chunk));
+    ffmpeg.stderr.on('data', () => {});
+    ffmpeg.on('close', code => {
+        if (code === 0) resolve(Buffer.concat(chunks));
+        else reject(new Error(`FFmpeg Opus conversion exited with code ${code}`));
+    });
+    ffmpeg.on('error', err => reject(err));
+});
+// ── End convertToOpusBuffer ───────────────────────────────────────────────────
+
+export const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts, isPtt, forceOpus } = {}) => {
     const { stream, type } = await getStream(media, opts);
     logger?.debug('fetched media stream');
+    let finalStream = stream;
+    let opusConverted = false;
+    // Auto-convert to Opus if PTT or forceOpus
+    if (mediaType === 'audio' && (isPtt === true || forceOpus === true)) {
+        try {
+            const buf = await toBuffer(finalStream);
+            const opusBuf = await convertToOpusBuffer(buf, logger);
+            finalStream = toReadable(opusBuf);
+            opusConverted = true;
+            logger?.debug('converted audio to Opus for PTT');
+        } catch (error) {
+            logger?.error('failed to convert audio to Opus, fallback to original');
+            const { stream: newStream } = await getStream(media, opts);
+            finalStream = newStream;
+        }
+    }
     const mediaKey = Crypto.randomBytes(32);
     const { cipherKey, iv, macKey } = await getMediaKeys(mediaKey, mediaType);
     const encFilePath = join(getTmpFilesDirectory(), mediaType + generateMessageIDV2() + '-enc');
@@ -375,7 +419,8 @@ export const encryptedStream = async (media, mediaType, { logger, saveOriginalFi
             mac,
             fileEncSha256,
             fileSha256,
-            fileLength
+            fileLength,
+            opusConverted
         };
     }
     catch (error) {
@@ -774,9 +819,22 @@ const MEDIA_RETRY_STATUS_MAP = {
     [proto.MediaRetryNotification.ResultType.GENERAL_ERROR]: 418
 };
 
-export const prepareStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts } = {}) => {
+export const prepareStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts, isPtt, forceOpus } = {}) => {
     const { stream, type } = await getStream(media, opts);
     logger?.debug('fetched media stream');
+    let opusConverted = false;
+    let buffer = await toBuffer(stream);
+    // Auto-convert to Opus if PTT or forceOpus
+    if (mediaType === 'audio' && (isPtt === true || forceOpus === true)) {
+        try {
+            const opusBuf = await convertToOpusBuffer(buffer, logger);
+            buffer = opusBuf;
+            opusConverted = true;
+            logger?.debug('converted audio to Opus for newsletter PTT');
+        } catch (e) {
+            logger?.error('failed to convert audio for newsletter PTT');
+        }
+    }
     const encFilePath = join(tmpdir(), mediaType + generateMessageID() + '-plain');
     const encFileWriteStream = createWriteStream(encFilePath);
     let originalFilePath;
@@ -790,20 +848,18 @@ export const prepareStream = async (media, mediaType, { logger, saveOriginalFile
     let fileLength = 0;
     const hashCtx = createHashCrypto('sha256');
     try {
-        for await (const data of stream) {
-            fileLength += data.length;
-            hashCtx.update(data);
-            encFileWriteStream.write(data);
-            if (originalFileStream && !originalFileStream.write(data)) {
-                await once(originalFileStream, 'drain');
-            }
+        // Use buffer (possibly opus-converted) directly
+        fileLength = buffer.length;
+        hashCtx.update(buffer);
+        encFileWriteStream.write(buffer);
+        if (originalFileStream) {
+            originalFileStream.write(buffer);
         }
         const fileSha256 = hashCtx.digest();
         encFileWriteStream.end();
         originalFileStream?.end?.call(originalFileStream);
-        stream.destroy();
         logger?.debug('prepared plain stream successfully');
-        return { mediaKey: undefined, originalFilePath, encFilePath, mac: undefined, fileEncSha256: undefined, fileSha256, fileLength };
+        return { mediaKey: undefined, originalFilePath, encFilePath, mac: undefined, fileEncSha256: undefined, fileSha256, fileLength, opusConverted };
     } catch (error) {
         encFileWriteStream.destroy();
         originalFileStream?.destroy?.call(originalFileStream);

package/lib/Utils/messages.js

@@ -8,7 +8,7 @@ import { WAMessageStatus, WAProto } from '../Types/index.js';
 import { isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary/index.js';
 import { sha256 } from './crypto.js';
 import { generateMessageIDV2, getKeyAuthor, unixTimestampSeconds } from './generics.js';
-import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getRawMediaUploadData } from './messages-media.js';
+import { downloadContentFromMessage, encryptedStream, prepareStream, generateThumbnail, getAudioDuration, getAudioWaveform, getRawMediaUploadData } from './messages-media.js';
 import { shouldIncludeReportingToken } from './reporting-utils.js';
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
@@ -86,6 +86,10 @@ export const prepareWAMessageMedia = async (message, options) => {
     if (!uploadData.mimetype) {
         uploadData.mimetype = MIMETYPE_MAP[mediaType];
     }
+    // Auto-set PTT for audio if not explicitly defined
+    if (mediaType === 'audio' && typeof uploadData.ptt === 'undefined') {
+        uploadData.ptt = true;
+    }
     if (cacheableKey) {
         const mediaBuff = await options.mediaCache.get(cacheableKey);
         if (mediaBuff) {
@@ -133,15 +137,23 @@ export const prepareWAMessageMedia = async (message, options) => {
     }
     const requiresDurationComputation = mediaType === 'audio' && typeof uploadData.seconds === 'undefined';
     const requiresThumbnailComputation = (mediaType === 'image' || mediaType === 'video') && typeof uploadData['jpegThumbnail'] === 'undefined';
-    const requiresWaveformProcessing = mediaType === 'audio' && uploadData.ptt === true;
-    const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true;
-    const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation;
-    const { mediaKey, encFilePath, originalFilePath, fileEncSha256, fileSha256, fileLength } = await encryptedStream(uploadData.media, options.mediaTypeOverride || mediaType, {
+    const requiresWaveformProcessing = mediaType === 'audio' && (uploadData.ptt === true || !!options.backgroundColor);
+    const requiresAudioBackground = options.backgroundColor && mediaType === 'audio';
+    const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation || requiresWaveformProcessing;
+    const isNewsletterUpload = !!options.newsletter;
+    const streamFn = isNewsletterUpload ? prepareStream : encryptedStream;
+    const { mediaKey, encFilePath, originalFilePath, fileEncSha256, fileSha256, fileLength, opusConverted } = await streamFn(uploadData.media, options.mediaTypeOverride || mediaType, {
         logger,
         saveOriginalFileIfRequired: requiresOriginalForSomeProcessing,
-        opts: options.options
+        opts: options.options,
+        isPtt: uploadData.ptt,
+        forceOpus: (mediaType === 'audio' && uploadData.mimetype && uploadData.mimetype.includes('opus'))
     });
-    const fileEncSha256B64 = fileEncSha256.toString('base64');
+    // Update mimetype if converted to opus
+    if (mediaType === 'audio' && opusConverted) {
+        uploadData.mimetype = 'audio/ogg; codecs=opus';
+    }
+    const fileEncSha256B64 = (isNewsletterUpload ? fileSha256 : (fileEncSha256 ?? fileSha256)).toString('base64');
     const [{ mediaUrl, directPath }] = await Promise.all([
         (async () => {
             const result = await options.upload(encFilePath, {
@@ -169,7 +181,14 @@ export const prepareWAMessageMedia = async (message, options) => {
                     logger?.debug('computed audio duration');
                 }
                 if (requiresWaveformProcessing) {
-                    uploadData.waveform = await getAudioWaveform(originalFilePath, logger);
+                    try {
+                        uploadData.waveform = await getAudioWaveform(originalFilePath, logger);
+                    } catch (err) {
+                        logger?.warn('Failed to generate waveform, using fallback');
+                    }
+                    if (!uploadData.waveform) {
+                        uploadData.waveform = new Uint8Array([0,99,0,99,0,99,0,99,88,99,0,99,0,55,0,99,0,99,0,99,0,99,0,99,88,99,0,99,0,55,0,99]);
+                    }
                     logger?.debug('processed waveform');
                 }
                 if (requiresAudioBackground) {

package/lib/index.js

@@ -1,3 +1,21 @@
+import chalk from 'chalk';
+
+// ── Blckrose Baileys Banner ───────────────────────────────────────────────────
+const _blck = {
+    line : chalk.hex('#8B5CF6')('━'.repeat(60)),
+    title: chalk.bold.hex('#A78BFA')('⬡  Blckrose Baileys  ') + chalk.hex('#6D28D9')('| Modified Edition'),
+    pair : chalk.hex('#7C3AED')('⌘  Pairing Code : ') + chalk.bold.white('BLCKRO53'),
+    repo : chalk.hex('#7C3AED')('❖  Report Error : ') + chalk.bold.cyan('@Blckrose0'),
+    note : chalk.dim.hex('#A78BFA')('   Laporkan error baileys ke kontak di atas'),
+};
+console.log(_blck.line);
+console.log(_blck.title);
+console.log(_blck.pair);
+console.log(_blck.repo);
+console.log(_blck.note);
+console.log(_blck.line);
+// ─────────────────────────────────────────────────────────────────────────────
+
 import makeWASocket from './Socket/index.js';
 export * from '../WAProto/index.js';
 export { proto } from '../WAProto/index.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blckrose/baileys",
   "type": "module",
-  "version": "1.0.5",
+  "version": "1.1.1",
   "description": "A WebSockets library for interacting with WhatsApp Web",
   "keywords": [
     "whatsapp",
@@ -26,6 +26,7 @@
     "@hapi/boom": "^9.1.3",
     "async-mutex": "^0.5.0",
     "cache-manager": "^5.7.6",
+    "chalk": "^5.6.2",
     "libsignal": "git+https://github.com/whiskeysockets/libsignal-node",
     "lru-cache": "^11.1.0",
     "music-metadata": "^11.7.0",