@crysnovax/baileys 2.6.3 → 2.6.4

package/README.md

@@ -721,7 +721,26 @@ sock.sendMessage(jid, {
   ]
 })
 ```
+### Rich preview 
+```
+await sock.sendMessage(jid, {
+    text: 'https://chat.whatsapp.com/CODE',
+    richPreview: true,
+    previewTitle: 'My Group',
+    previewDescription: '42 members · Tap to join',
+    previewImage: imageBufferOrUrl   // Buffer, or a URL string
+})
+```
 
+### WHATSAPP VERIFIED ☑️ ⚉
+send Media messages with verified WhatsApp check ✔️ 
+```
+await sock.sendMessage(jid, {
+    image: buffer,
+    caption: 'Hello',
+    verifiedMe: true
+})
+```
 ---
 
 ## Meta AI Features

package/lib/Socket/messages-send.js

@@ -3,7 +3,7 @@ import { Boom } from '@hapi/boom';
 import { randomBytes } from 'crypto';
 import { proto } from '../../WAProto/index.js';
 import { BIZ_BOT_SUPPORT_PAYLOAD, DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, hasValidAlbumMedia, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
+import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, extractImageThumb, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, hasValidAlbumMedia, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, prepareWAMessageMedia, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
 import { AssociationType } from '../Types/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
 import { makeKeyedMutex, makeMutex } from '../Utils/make-mutex.js';
@@ -1248,6 +1248,139 @@ export const makeMessagesSocket = (config) => {
                 }
                 return fullMsg;
             }
+            // crysnovax@RichPreview --- richPreview:true auto-builds a manually-constructed
+            // extendedTextMessage with a large preview image, bypassing generateWAMessage's
+            // getUrlInfo scraper (which fails on bot-blocked domains like chat.whatsapp.com)
+            // and avoiding the undocumented ~7KB jpegThumbnail size ceiling that causes a
+            // blank/black render on WA clients when exceeded.
+            //
+            // Usage:
+            //   sock.sendMessage(jid, {
+            //       text: 'https://chat.whatsapp.com/CODE',
+            //       richPreview: true,
+            //       previewTitle: 'Group Name',
+            //       previewDescription: '12 members · Tap to join',
+            //       previewImage: imageBufferOrUrl   // Buffer, or a URL string to fetch
+            //   })
+            else if ('richPreview' in content && content.richPreview === true) {
+                const {
+                    richPreview: __rp,
+                    text: previewLink,
+                    previewTitle,
+                    previewDescription,
+                    previewImage,
+                    quoted,
+                    ...restContent
+                } = content;
+
+                if (!previewLink || typeof previewLink !== 'string') {
+                    throw new Boom('richPreview requires a `text` field containing the URL', { statusCode: 400 });
+                }
+
+                // Resolve previewImage into a raw Buffer, whether given as
+                // a Buffer directly or a URL string to fetch
+                let imageBuffer = null;
+                if (previewImage) {
+                    if (Buffer.isBuffer(previewImage)) {
+                        imageBuffer = previewImage;
+                    }
+                    else if (typeof previewImage === 'string') {
+                        try {
+                            const res = await fetch(previewImage);
+                            imageBuffer = Buffer.from(await res.arrayBuffer());
+                        }
+                        catch (err) {
+                            logger?.warn({ err }, 'richPreview: failed to fetch previewImage URL');
+                        }
+                    }
+                }
+
+                // Small embedded jpegThumbnail — kept under the ~7KB ceiling
+                // that causes WA clients to render a blank/black preview if exceeded.
+                // 296px @ quality 50 (fixed internally by extractImageThumb) sits
+                // safely under that threshold while staying as sharp as reliably possible.
+                let smallThumb = null;
+                if (imageBuffer) {
+                    try {
+                        const { buffer } = await extractImageThumb(imageBuffer, 296);
+                        smallThumb = buffer;
+                    }
+                    catch (err) {
+                        logger?.warn({ err }, 'richPreview: failed to generate small thumbnail');
+                    }
+                }
+
+                // Upload the image through the real media pipeline to get a
+                // proper highQualityThumbnail reference (directPath/mediaKey/etc)
+                let hq = null;
+                if (imageBuffer) {
+                    try {
+                        const prepared = await prepareWAMessageMedia({ image: imageBuffer }, { upload: waUploadToServer });
+                        hq = prepared.imageMessage;
+                    }
+                    catch (err) {
+                        logger?.warn({ err }, 'richPreview: failed to upload HQ thumbnail');
+                    }
+                }
+
+                const previewMessage = {
+                    extendedTextMessage: {
+                        text: previewLink,
+                        matchedText: previewLink,
+                        canonicalUrl: previewLink,
+                        title: previewTitle || '',
+                        description: previewDescription || '',
+                        previewType: 5, // IMAGE
+                        jpegThumbnail: smallThumb || undefined,
+                        ...(hq
+                            ? {
+                                thumbnailDirectPath: hq.directPath,
+                                mediaKey: hq.mediaKey,
+                                mediaKeyTimestamp: hq.mediaKeyTimestamp,
+                                thumbnailWidth: hq.width,
+                                thumbnailHeight: hq.height,
+                                thumbnailSha256: hq.fileSha256,
+                                thumbnailEncSha256: hq.fileEncSha256
+                            }
+                            : {}),
+                        ...restContent
+                    }
+                };
+
+                const msgId = options.messageId || generateMessageIDV2(userJid);
+
+                if (quoted) {
+                    previewMessage.extendedTextMessage.contextInfo = {
+                        ...(previewMessage.extendedTextMessage.contextInfo || {}),
+                        stanzaId: quoted.key.id,
+                        participant: jidNormalizedUser(quoted.key.fromMe ? userJid : (quoted.key.participant || quoted.key.remoteJid)),
+                        quotedMessage: quoted.message
+                    };
+                }
+
+                await relayMessage(jid, previewMessage, {
+                    messageId: msgId,
+                    additionalAttributes: options.additionalAttributes || {},
+                    additionalNodes: options.additionalNodes || []
+                });
+
+                const fullMsg = {
+                    key: {
+                        remoteJid: jid,
+                        fromMe: true,
+                        id: msgId
+                    },
+                    message: previewMessage,
+                    messageTimestamp: unixTimestampSeconds()
+                };
+
+                if (config.emitOwnEvents) {
+                    process.nextTick(async () => {
+                        await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+                    });
+                }
+                return fullMsg;
+            }
             else {
                 const fullMsg = await generateWAMessage(jid, content, {
                     logger,

package/lib/Socket/messages-send.js[old]

@@ -1218,6 +1218,36 @@ export const makeMessagesSocket = (config) => {
                     : disappearingMessagesInChat;
                 await groupToggleEphemeral(jid, value);
             }
+            // crysnovax@Status --- status:true flag routes any message type to status@broadcast
+            // Supports: text with backgroundColor + font, image, video, audio, sticker
+            // Usage: sock.sendMessage(jid, { text: 'Hello', status: true, backgroundColor: '#FF0000', font: 2 })
+            //        sock.sendMessage(jid, { audio: buffer, status: true, ptt: false })
+            else if ('status' in content && content.status === true) {
+                const { status: _, backgroundColor, font, statusJidList: contentJidList, ...statusContent } = content;
+                const fullMsg = await generateWAMessage('status@broadcast', statusContent, {
+                    logger,
+                    userJid,
+                    upload: waUploadToServer,
+                    mediaCache: config.mediaCache,
+                    options: config.options,
+                    ...options,
+                    ...(backgroundColor ? { backgroundColor } : {}),
+                    ...(font !== undefined ? { font } : {}),
+                    messageId: generateMessageIDV2(userJid)
+                });
+                await relayMessage('status@broadcast', fullMsg.message, {
+                    messageId: fullMsg.key.id,
+                    statusJidList: contentJidList || options.statusJidList,
+                    additionalAttributes: options.additionalAttributes || {},
+                    additionalNodes: options.additionalNodes || []
+                });
+                if (config.emitOwnEvents) {
+                    process.nextTick(async () => {
+                        await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+                    });
+                }
+                return fullMsg;
+            }
             else {
                 const fullMsg = await generateWAMessage(jid, content, {
                     logger,

package/lib/Utils/messages.js

@@ -1363,6 +1363,44 @@ export const generateWAMessageContent = async (message, options) => {
         m = { spoilerMessage: { message: m } };
         delete message.spoiler;
     }
+    // crysnovax@VerifiedMe --- Add "verifiedMe" boolean to attach a verified
+    // forward badge (✓) on image/video messages only. Uses forwardingScore +
+    // isForwarded + the 0@s.whatsapp.net participant/remoteJid trick (no
+    // newsletter context needed) — confirmed working pattern. Also injects a
+    // synthetic quoted message fallback if none is already present, matching
+    // the same pattern.
+    if (hasOptionalProperty(message, 'verifiedMe') && !!message.verifiedMe) {
+        const messageType = Object.keys(m)[0];
+        const isMediaMessage = messageType === 'imageMessage' || messageType === 'videoMessage';
+        if (isMediaMessage) {
+            const key = m[messageType];
+            const verifiedContext = {
+                isForwarded: true,
+                participant: '0@s.whatsapp.net',
+                remoteJid: '0@s.whatsapp.net'
+            };
+            if ('contextInfo' in key && !!key.contextInfo) {
+                key.contextInfo = { ...key.contextInfo, ...verifiedContext };
+            }
+            else if (key) {
+                key.contextInfo = verifiedContext;
+            }
+            if (options && !options.quoted) {
+                options.quoted = {
+                    key: {
+                        remoteJid: '0@s.whatsapp.net',
+                        fromMe: false,
+                        participant: '0@s.whatsapp.net',
+                        id: '3EB0' + Math.random().toString(16).substring(2, 10).toUpperCase()
+                    },
+                    message: {
+                        conversation: '```ஃ𖠃 CRYSN⚉VA AI🜲```'
+                    }
+                };
+            }
+        }
+        delete message.verifiedMe;
+    }
     // Lia@Changes 02-02-26 --- Add "interactiveAsTemplate" boolean to wrap interactiveMessage into templateMessage
     else if (hasOptionalProperty(message, 'interactiveAsTemplate') && !!message.interactiveAsTemplate) {
         if (!m.interactiveMessage) {