@blckrose/baileys 1.2.6 → 1.2.8

package/lib/Socket/messages-recv.js

@@ -205,7 +205,7 @@ export const makeMessagesRecvSocket = (config) => {
                             message: messageProto,
                             messageTimestamp: +child.attrs.t
                         }).toJSON();
-                        await upsertMessage(fullMessage, 'append');
+                        await upsertMessage(fullMessage, 'notify');
                         logger.info('Processed plaintext newsletter message');
                     }
                     catch (error) {

package/lib/Socket/messages-send.js

@@ -562,7 +562,6 @@ export const makeMessagesSocket = (config) => {
                     content: bytes
                 });
                 logger.debug({ msgId, extraAttrs }, `sending newsletter message to ${jid}`);
-                logger.debug({ additionalAttributes }, '[blckrose-debug] newsletter stanza attrs');
                 const stanza = {
                     tag: 'message',
                     attrs: {
@@ -1085,6 +1084,9 @@ export const makeMessagesSocket = (config) => {
         else if (message.stickerMessage) {
             return 'sticker';
         }
+        else if (message.stickerPackMessage) {
+            return 'sticker_pack';
+        }
         else if (message.listMessage) {
             return 'list';
         }
@@ -1545,6 +1547,12 @@ export const makeMessagesSocket = (config) => {
                     messageId: generateMessageIDV2(sock.user?.id),
                     ...options
                 });
+                if (content?.audio && options?.contextInfo) {
+                    const msgContent = fullMsg.message;
+                    if (msgContent?.audioMessage) {
+                        msgContent.audioMessage.contextInfo = options.contextInfo;
+                    }
+                }
                 // Extract handle from newsletter upload (set by prepareWAMessageMedia)
                 if (!mediaHandle) {
                     const msgContent = fullMsg.message;

package/lib/Utils/messages-media.js

@@ -29,7 +29,7 @@ export const hkdfInfoKey = (type) => {
 };
 export const getRawMediaUploadData = async (media, mediaType, logger) => {
     const { stream } = await getStream(media);
-    logger?.debug('got stream for raw upload');
+
     const hasher = Crypto.createHash('sha256');
     const filePath = join(tmpdir(), mediaType + generateMessageIDV2());
     const fileWriteStream = createWriteStream(filePath);
@@ -46,7 +46,7 @@ export const getRawMediaUploadData = async (media, mediaType, logger) => {
         await once(fileWriteStream, 'finish');
         stream.destroy();
         const fileSha256 = hasher.digest();
-        logger?.debug('hashed data for raw upload');
+
         return {
             filePath: filePath,
             fileSha256,
@@ -210,7 +210,6 @@ export async function getAudioWaveform(buffer, logger) {
         }
         // Skip audio-decode for large buffers (> 3MB)
         if (audioData.length > 3 * 1024 * 1024) {
-            logger?.debug('audio buffer too large for waveform decode, skipping');
             return undefined;
         }
         const audioBuffer = await decoder(audioData);
@@ -232,7 +231,6 @@ export async function getAudioWaveform(buffer, logger) {
         return waveform;
     }
     catch (e) {
-        logger?.debug('Failed to generate waveform: ' + e);
     }
 }
 
@@ -250,45 +248,8 @@ export const toBuffer = async (stream) => {
     stream.destroy();
     return Buffer.concat(chunks);
 };
-/**
- * Convert audio buffer ke MP3 menggunakan ffmpeg.
- * Return buffer MP3 baru, atau buffer asli jika ffmpeg tidak tersedia / gagal.
- */
-export const convertAudioToMp3 = async (inputBuffer, logger) => {
-    const { spawn } = await import('child_process');
-    return new Promise((resolve) => {
-        const ff = spawn('ffmpeg', [
-            '-hide_banner', '-loglevel', 'error',
-            '-i', 'pipe:0',          // input dari stdin
-            '-vn',                    // no video
-            '-ar', '44100',           // sample rate
-            '-ac', '2',               // stereo
-            '-b:a', '128k',           // bitrate
-            '-f', 'mp3',              // output format
-            'pipe:1'                  // output ke stdout
-        ], { stdio: ['pipe', 'pipe', 'pipe'] });
 
-        const chunks = [];
-        ff.stdout.on('data', chunk => chunks.push(chunk));
-        ff.stderr.on('data', d => logger?.debug('[ffmpeg] ' + d.toString().trim()));
 
-        ff.on('close', code => {
-            if (code === 0 && chunks.length > 0) {
-                resolve(Buffer.concat(chunks));
-            } else {
-                logger?.warn(`ffmpeg exited with code ${code}, using original audio`);
-                resolve(inputBuffer); // fallback ke original
-            }
-        });
-        ff.on('error', (err) => {
-            logger?.warn('ffmpeg not found or failed: ' + err.message + ', using original audio');
-            resolve(inputBuffer); // fallback
-        });
-
-        ff.stdin.write(inputBuffer);
-        ff.stdin.end();
-    });
-};
 
 export const getStream = async (item, opts) => {
     if (Buffer.isBuffer(item)) {
@@ -323,7 +284,6 @@ export async function generateThumbnail(file, mediaType, options) {
     }
     else if (mediaType === 'video') {
         // Video thumbnail generation skipped (ffmpeg removed)
-        options.logger?.debug('video thumbnail generation skipped (no ffmpeg)');
     }
     return {
         thumbnail,
@@ -345,37 +305,9 @@ export const getHttpStream = async (url, options = {}) => {
 
 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 semua audio ke MP3 ─────────────────────────────────────
-    // Kecuali: ptt (voice note) tetap ogg/opus, dan yang sudah MP3
-    if (mediaType === 'audio' && !isPtt && !forceOpus) {
-        try {
-            const rawBuf = await toBuffer(finalStream);
-            // Cek apakah sudah MP3 (magic bytes: ID3 atau FF E*)
-            const isAlreadyMp3 = (rawBuf[0] === 0x49 && rawBuf[1] === 0x44 && rawBuf[2] === 0x33)
-                || (rawBuf[0] === 0xFF && (rawBuf[1] & 0xE0) === 0xE0);
-            if (!isAlreadyMp3) {
-                logger?.debug('converting audio to MP3 via ffmpeg');
-                const mp3Buf = await convertAudioToMp3(rawBuf, logger);
-                finalStream = toReadable(mp3Buf);
-                logger?.debug('audio converted to MP3 successfully');
-            } else {
-                finalStream = toReadable(rawBuf);
-                logger?.debug('audio already MP3, skipping conversion');
-            }
-        } catch (err) {
-            logger?.warn('audio conversion failed, using original: ' + err.message);
-            // finalStream sudah di-consume, perlu re-fetch — re-use dari getStream
-            const { stream: s2 } = await getStream(media, opts);
-            finalStream = s2;
-        }
-    }
-    // ── End auto-convert ─────────────────────────────────────────────────────
-
     const mediaKey = Crypto.randomBytes(32);
     const { cipherKey, iv, macKey } = await getMediaKeys(mediaKey, mediaType);
     const encWriteStream = new Readable({ read: () => {}, highWaterMark: 64 * 1024 });
@@ -434,8 +366,6 @@ export const encryptedStream = async (media, mediaType, { logger, saveOriginalFi
         if (writeStream) await once(writeStream, 'finish');
         finalStream.destroy();
 
-        logger?.debug('encrypted data successfully');
-
         return {
             mediaKey,
             encWriteStream,
@@ -682,11 +612,9 @@ const uploadWithFetch = async ({ url, filePath, headers, timeoutMs, agent }) =>
  */
 const uploadMedia = async (params, logger) => {
     if (isNodeRuntime()) {
-        logger?.debug('Using Node.js https module for upload (avoids undici buffering bug)');
         return uploadWithNodeHttp(params);
     }
     else {
-        logger?.debug('Using web-standard Fetch API for upload');
         return uploadWithFetch(params);
     }
 };
@@ -725,12 +653,10 @@ export const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, opt
         let mediaPath = MEDIA_PATH_MAP[mediaType];
         if (newsletter) {
             mediaPath = mediaPath?.replace('/mms/', '/newsletter/newsletter-');
-            logger.debug(`[blckrose-debug] newsletter upload | mediaType=${mediaType} path=${mediaPath} bufferLen=${reqBuffer?.length}`);
         }
         for (const { hostname, maxContentLengthBytes } of hosts) {
             const auth = encodeURIComponent(uploadInfo.auth);
             const url = `https://${hostname}${mediaPath}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`;
-            logger.debug(`[blckrose-debug] uploading to url=${url.slice(0, 80)}...`);
 
             let result;
             try {
@@ -758,7 +684,6 @@ export const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, opt
                         fbid: result.fbid,
                         ts: result.ts
                     };
-                    logger.debug({ mediaUrl: result.url, directPath: result.direct_path, handle: result.handle }, '[blckrose-debug] upload success');
                     break;
                 }
                 else {
@@ -868,8 +793,6 @@ const MEDIA_RETRY_STATUS_MAP = {
 
 export const prepareStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts, isPtt, forceOpus } = {}) => {
     const { stream, type } = await getStream(media, opts);
-    logger?.debug('fetched media stream');
-
     let buffer = await toBuffer(stream);
 
     let opusConverted = false;
@@ -887,7 +810,6 @@ export const prepareStream = async (media, mediaType, { logger, saveOriginalFile
         }
         const fileLength = buffer.length;
         const fileSha256 = Crypto.createHash('sha256').update(buffer).digest();
-        logger?.debug('prepared plain stream successfully');
         return {
             mediaKey: undefined,
             encWriteStream: buffer,

package/lib/Utils/messages.js

@@ -172,16 +172,7 @@ export const prepareWAMessageMedia = async (message, options) => {
         uploadData.fileName = 'file';
     }
     if (!uploadData.mimetype) {
-        if (mediaType === 'audio') {
-            uploadData.mimetype = await detectAudioMimetype(uploadData.media);
-        } else {
-            uploadData.mimetype = MIMETYPE_MAP[mediaType];
-        }
-    }
-    // Setelah auto-convert ke MP3, override mimetype ke audio/mpeg
-    // Kecuali PTT (voice note) tetap ogg/opus
-    if (mediaType === 'audio' && !uploadData.ptt) {
-        uploadData.mimetype = 'audio/mpeg';
+        uploadData.mimetype = MIMETYPE_MAP[mediaType];
     }
     if (cacheableKey) {
         const mediaBuff = await options.mediaCache.get(cacheableKey);
@@ -195,13 +186,11 @@ export const prepareWAMessageMedia = async (message, options) => {
     }
     const isNewsletter = !!options.jid && isJidNewsletter(options.jid);
     if (isNewsletter) options.newsletter = true;
-    console.log('[blckrose-debug] prepareWAMessageMedia mediaType=%s isNewsletter=%s ptt=%s mimetype=%s', mediaType, !!options.newsletter, uploadData.ptt, uploadData.mimetype);
     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 || !!options.backgroundColor);
     const requiresAudioBackground = options.backgroundColor && mediaType === 'audio';
     const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation || requiresWaveformProcessing;
-    console.log('[blckrose-debug] stream path selected newsletter=%s using=%s', !!options.newsletter, options.newsletter ? 'prepareStream' : 'encryptedStream');
     let streamResult;
     try {
         streamResult = await (options.newsletter ? prepareStream : encryptedStream)(
@@ -215,11 +204,9 @@ export const prepareWAMessageMedia = async (message, options) => {
             }
         );
     } catch (streamErr) {
-        console.error('[blckrose-debug] stream ERROR:', streamErr?.message, streamErr?.stack);
         throw streamErr;
     }
     const { mediaKey, encWriteStream, bodyPath, fileEncSha256, fileSha256, fileLength, didSaveToTmpPath } = streamResult;
-    console.log('[blckrose-debug] stream prepared fileLength=%s hasMediaKey=%s', fileLength, !!mediaKey);
 
     const fileEncSha256B64 = (options.newsletter ? fileSha256 : fileEncSha256 ?? fileSha256).toString('base64');
 
@@ -231,7 +218,6 @@ export const prepareWAMessageMedia = async (message, options) => {
                 timeoutMs: options.mediaUploadTimeoutMs,
                 newsletter: !!options.newsletter
             });
-            console.log('[blckrose-debug] upload done mediaUrl=%s directPath=%s handle=%s', result?.mediaUrl, result?.directPath, result?.handle);
             return result;
         })(),
         (async () => {
@@ -261,12 +247,9 @@ export const prepareWAMessageMedia = async (message, options) => {
                     logger?.debug('computed audio duration');
                 }
                 if (requiresWaveformProcessing) {
-                    console.log('[blckrose-debug] waveform processing bodyPath=%s', bodyPath);
                     try {
-                        // newsletter: bodyPath undefined, pakai encWriteStream buffer langsung
                         uploadData.waveform = await getAudioWaveform(bodyPath || encWriteStream, logger);
                     } catch (err) {
-                        console.error('[blckrose-debug] waveform ERROR:', err?.message);
                     }
                     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]);
@@ -292,7 +275,6 @@ export const prepareWAMessageMedia = async (message, options) => {
             logger?.warn('failed to remove tmp file');
         }
     });
-    console.log('[blckrose-debug] Promise.all done uploadHandle=%s mediaUrl=%s directPath=%s', uploadHandle, mediaUrl, directPath);
     const obj = WAProto.Message.fromObject({
         [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
             url: uploadHandle ? undefined : mediaUrl,
@@ -303,7 +285,8 @@ export const prepareWAMessageMedia = async (message, options) => {
             fileLength,
             mediaKeyTimestamp: uploadHandle ? undefined : unixTimestampSeconds(),
             ...uploadData,
-            media: undefined
+            media: undefined,
+            ...(options?.contextInfo ? { contextInfo: options.contextInfo } : {})
         })
     });
     if (uploadData.ptv) {
@@ -315,8 +298,6 @@ export const prepareWAMessageMedia = async (message, options) => {
         obj._uploadHandle = uploadHandle;
     }
     if (mediaType === 'audio') {
-        const am = obj.audioMessage;
-        logger?.debug({ url: am?.url, directPath: am?.directPath, hasMediaKey: !!am?.mediaKey, seconds: am?.seconds, ptt: am?.ptt, mimetype: am?.mimetype, fileLength: am?.fileLength, uploadHandle }, '[blckrose-debug] audioMessage built');
     }
     if (cacheableKey) {
         logger?.debug({ cacheableKey }, 'set cache');
@@ -694,24 +675,99 @@ export const generateWAMessageContent = async (message, options) => {
         const { zip } = _require('fflate');
         const { stickers, cover, name, publisher, packId, description } = message.stickerPack;
 
-        // ── Step 1: fetch & zip all stickers ─────────────────────────────────
+        // ── Validasi jumlah sticker ───────────────────────────────────────────
+        if (stickers.length > 60) {
+            throw new Boom('Sticker pack exceeds the maximum limit of 60 stickers', { statusCode: 400 });
+        }
+        if (stickers.length === 0) {
+            throw new Boom('Sticker pack must contain at least one sticker', { statusCode: 400 });
+        }
+
+        const stickerPackId = packId || generateMessageIDV2();
+        const [_sharp, _jimp] = await Promise.all([import('sharp').catch(() => null), import('jimp').catch(() => null)]);
+        const lib = _sharp ? { sharp: _sharp } : _jimp ? { jimp: _jimp } : null;
+        if (!lib) throw new Boom('No image processing library available (install sharp or jimp)');
+
+        // ── Helper: deteksi WebP dari magic bytes ─────────────────────────────
+        const isWebPBuffer = (buf) => (
+            buf.length >= 12 &&
+            buf[0] === 0x52 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x46 &&
+            buf[8] === 0x57 && buf[9] === 0x45 && buf[10] === 0x42 && buf[11] === 0x50
+        );
+
+        // ── Helper: deteksi animasi WebP (VP8X/ANIM/ANMF chunks) ─────────────
+        const isAnimatedWebP = (buf) => {
+            if (!isWebPBuffer(buf)) return false;
+            let offset = 12;
+            while (offset < buf.length - 8) {
+                const fourCC = buf.toString('ascii', offset, offset + 4);
+                const chunkSize = buf.readUInt32LE(offset + 4);
+                if (fourCC === 'VP8X') {
+                    const flagsOffset = offset + 8;
+                    if (flagsOffset < buf.length && (buf[flagsOffset] & 0x02)) return true;
+                } else if (fourCC === 'ANIM' || fourCC === 'ANMF') {
+                    return true;
+                }
+                offset += 8 + chunkSize + (chunkSize % 2);
+            }
+            return false;
+        };
+
+        // ── Step 1: proses & zip semua sticker ────────────────────────────────
         const stickerData = {};
         const stickerPromises = stickers.map(async (s, i) => {
-            const { stream } = await getStream(s.sticker);
+            const { stream } = await getStream(s.data || s.sticker);
             const buffer = await toBuffer(stream);
-            const hash = sha256(buffer).toString('base64url');
-            const fileName = `${i.toString().padStart(2, '0')}_${hash}.webp`;
-            stickerData[fileName] = [new Uint8Array(buffer), { level: 0 }];
+
+            let webpBuffer;
+            let isAnimated = false;
+            if (isWebPBuffer(buffer)) {
+                webpBuffer = buffer;
+                isAnimated = isAnimatedWebP(buffer);
+            } else if ('sharp' in lib && lib.sharp) {
+                webpBuffer = await lib.sharp.default(buffer).webp().toBuffer();
+            } else {
+                throw new Boom(
+                    'No image processing library (sharp) available for converting sticker to WebP. ' +
+                    'Either install sharp or provide stickers in WebP format.'
+                );
+            }
+
+            if (webpBuffer.length > 1024 * 1024) {
+                throw new Boom(`Sticker at index ${i} exceeds the 1MB size limit`, { statusCode: 400 });
+            }
+
+            const hash = sha256(webpBuffer).toString('base64').replace(/\//g, '-');
+            const fileName = `${hash}.webp`;
+            stickerData[fileName] = [new Uint8Array(webpBuffer), { level: 0 }];
             return {
                 fileName,
                 mimetype: 'image/webp',
-                isAnimated: s.isAnimated || false,
-                isLottie: s.isLottie || false,
+                isAnimated,
                 emojis: s.emojis || [],
                 accessibilityLabel: s.accessibilityLabel || ''
             };
         });
         const stickerMetadata = await Promise.all(stickerPromises);
+
+        // ── Step 2: proses cover & masukkan ke dalam ZIP ──────────────────────
+        const trayIconFileName = `${stickerPackId}.webp`;
+        const coverBuffer = await toBuffer((await getStream(cover)).stream);
+
+        let coverWebpBuffer;
+        if (isWebPBuffer(coverBuffer)) {
+            coverWebpBuffer = coverBuffer;
+        } else if ('sharp' in lib && lib.sharp) {
+            coverWebpBuffer = await lib.sharp.default(coverBuffer).webp().toBuffer();
+        } else {
+            throw new Boom(
+                'No image processing library (sharp) available for converting cover to WebP. ' +
+                'Either install sharp or provide cover in WebP format.'
+            );
+        }
+        stickerData[trayIconFileName] = [new Uint8Array(coverWebpBuffer), { level: 0 }];
+
+        // ── Step 3: buat ZIP buffer ───────────────────────────────────────────
         const zipBuffer = await new Promise((resolve, reject) => {
             zip(stickerData, (err, data) => {
                 if (err) reject(err);
@@ -719,83 +775,77 @@ export const generateWAMessageContent = async (message, options) => {
             });
         });
 
-        // ── Step 2: fetch cover buffer ────────────────────────────────────────
-        const coverBuffer = await toBuffer((await getStream(cover)).stream);
-
-        // ── Step 3: encrypt zip (generates random mediaKey) ───────────────────
+        // ── Step 4: encrypt ZIP (generate random mediaKey) ────────────────────
         const stickerPackUpload = await encryptedStream(zipBuffer, 'sticker-pack', {
             logger: options.logger,
             opts: options.options
         });
 
-        // ── Step 4: encrypt cover with the SAME mediaKey as the zip ──────────
-        // StickerPackMessage proto has no thumbnailMediaKey field, so WA uses the
-        // pack's mediaKey to decrypt the thumbnail too.
-        const { getMediaKeys: _getMediaKeys } = await import('./messages-media.js');
-        const _Crypto = (await import('crypto')).default;
-        const { cipherKey: covCipherKey, iv: covIv, macKey: covMacKey } = await _getMediaKeys(
-            stickerPackUpload.mediaKey, 'sticker-pack'
-        );
-        const covAes = _Crypto.createCipheriv('aes-256-cbc', covCipherKey, covIv);
-        let covHmac = _Crypto.createHmac('sha256', covMacKey).update(covIv);
-        const covSha256Plain = _Crypto.createHash('sha256').update(coverBuffer).digest();
-        const covEncPart1 = covAes.update(coverBuffer);
-        const covEncPart2 = covAes.final();
-        covHmac.update(covEncPart1).update(covEncPart2);
-        const covMac = covHmac.digest().slice(0, 10);
-        const covEncBody = Buffer.concat([covEncPart1, covEncPart2, covMac]);
-        const covFileEncSha256 = _Crypto.createHash('sha256').update(covEncBody).digest();
-
-        // ── Step 5: upload zip and cover in parallel ──────────────────────────
-        const [stickerPackUploadResult, coverUploadResult] = await Promise.all([
-            options.upload(stickerPackUpload.encWriteStream, {
-                fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
-                mediaType: 'sticker-pack',
-                timeoutMs: options.mediaUploadTimeoutMs
-            }),
-            options.upload(covEncBody, {
-                fileEncSha256B64: covFileEncSha256.toString('base64'),
-                mediaType: 'sticker-pack',
-                timeoutMs: options.mediaUploadTimeoutMs
-            })
-        ]);
-
-        // ── Step 6: get thumbnail dimensions ─────────────────────────────────
-        let thumbWidth = 320, thumbHeight = 320;
-        try {
-            const { extractImageThumb } = await import('./messages-media.js');
-            const { original } = await extractImageThumb(coverBuffer);
-            if (original?.width) thumbWidth = original.width;
-            if (original?.height) thumbHeight = original.height;
-        } catch (_) {}
+        // ── Step 5: upload ZIP ────────────────────────────────────────────────
+        const stickerPackUploadResult = await options.upload(stickerPackUpload.encWriteStream, {
+            fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
+            mediaType: 'sticker-pack',
+            timeoutMs: options.mediaUploadTimeoutMs
+        });
 
-        // ── Step 7: build stickerPackMessage ─────────────────────────────────
-        const imageDataHash = sha256(coverBuffer).toString('base64');
-        const stickerPackId = packId || generateMessageIDV2();
+        // ── Step 6: build stickerPackMessage ──────────────────────────────────
         m.stickerPackMessage = {
             name,
             publisher,
             stickerPackId,
             packDescription: description,
             stickerPackOrigin: WAProto.Message.StickerPackMessage.StickerPackOrigin.THIRD_PARTY,
-            stickerPackSize: stickerPackUpload.fileLength,
+            stickerPackSize: zipBuffer.length,
             stickers: stickerMetadata,
-            // main zip encryption fields
             fileSha256: stickerPackUpload.fileSha256,
             fileEncSha256: stickerPackUpload.fileEncSha256,
             mediaKey: stickerPackUpload.mediaKey,
             directPath: stickerPackUploadResult.directPath,
             fileLength: stickerPackUpload.fileLength,
             mediaKeyTimestamp: unixTimestampSeconds(),
-            trayIconFileName: `${stickerPackId}.png`,
-            imageDataHash,
-            // thumbnail fields: correct proto names, encrypted with SAME mediaKey as zip
-            thumbnailDirectPath: coverUploadResult.directPath,
-            thumbnailSha256: covSha256Plain,
-            thumbnailEncSha256: covFileEncSha256,
-            thumbnailHeight: thumbHeight,
-            thumbnailWidth: thumbWidth
+            trayIconFileName
         };
+
+        // ── Step 7: generate & upload thumbnail (pakai mediaKey yang sama) ────
+        try {
+            let thumbnailBuffer;
+            if ('sharp' in lib && lib.sharp) {
+                thumbnailBuffer = await lib.sharp.default(coverBuffer).resize(252, 252).jpeg().toBuffer();
+            } else if ('jimp' in lib && lib.jimp) {
+                const jimpImage = await (lib.jimp.Jimp || lib.jimp.default).read(coverBuffer);
+                thumbnailBuffer = await jimpImage.resize({ w: 252, h: 252 }).getBuffer('image/jpeg');
+            } else {
+                throw new Error('No image processing library available for thumbnail generation');
+            }
+
+            if (!thumbnailBuffer || thumbnailBuffer.length === 0) {
+                throw new Error('Failed to generate thumbnail buffer');
+            }
+
+            const thumbUpload = await encryptedStream(thumbnailBuffer, 'thumbnail-sticker-pack', {
+                logger: options.logger,
+                opts: options.options,
+                mediaKey: stickerPackUpload.mediaKey
+            });
+
+            const thumbUploadResult = await options.upload(thumbUpload.encWriteStream, {
+                fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'),
+                mediaType: 'thumbnail-sticker-pack',
+                timeoutMs: options.mediaUploadTimeoutMs
+            });
+
+            Object.assign(m.stickerPackMessage, {
+                thumbnailDirectPath: thumbUploadResult.directPath,
+                thumbnailSha256: thumbUpload.fileSha256,
+                thumbnailEncSha256: thumbUpload.fileEncSha256,
+                thumbnailHeight: 252,
+                thumbnailWidth: 252,
+                imageDataHash: sha256(thumbnailBuffer).toString('base64')
+            });
+        } catch (e) {
+            options.logger?.warn?.(`Thumbnail generation failed: ${e}`);
+        }
+
         m.stickerPackMessage.contextInfo = {
             ...(message.contextInfo || {}),
             ...(message.mentions ? { mentionedJid: message.mentions } : {})
@@ -1225,7 +1275,6 @@ export const generateWAMessage = async (jid, content, options) => {
     options.logger = options?.logger?.child({ msgId: options.messageId });
     // Pass jid + newsletter flag to generateWAMessageContent (like wiley)
     const _isNewsletter = typeof jid === 'string' && jid.endsWith('@newsletter');
-    console.log('[blckrose-debug] generateWAMessage jid=%s isNewsletter=%s contentKeys=%s', jid, _isNewsletter, Object.keys(content || {}).join(','));
     return generateWAMessageFromContent(jid, await generateWAMessageContent(content, { newsletter: _isNewsletter, ...options, jid }), options);
 };
 /** Get the key to access the true type of content */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blckrose/baileys",
   "type": "module",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "description": "A WebSockets library for interacting with WhatsApp Web",
   "keywords": [
     "whatsapp",
@@ -48,7 +48,13 @@
     "@cacheable/node-cache": "^1.4.0",
     "@hapi/boom": "^9.1.3",
     "async-mutex": "^0.5.0",
+    "audio-decode": "^3.0.0",
+    "axios": "^1.13.6",
     "cache-manager": "^5.7.6",
+    "chalk": "^5.3.0",
+    "cheerio": "^1.2.0",
+    "fflate": "^0.8.2",
+    "gradient-string": "^3.0.0",
     "libsignal": "git+https://github.com/whiskeysockets/libsignal-node",
     "lru-cache": "^11.1.0",
     "music-metadata": "^11.7.0",
@@ -56,20 +62,14 @@
     "pino": "^9.6",
     "protobufjs": "^7.2.4",
     "whatsapp-rust-bridge": "0.5.2",
-    "ws": "^8.13.0",
-    "chalk": "^5.3.0",
-    "fflate": "^0.8.2"
+    "ws": "^8.13.0"
   },
   "peerDependencies": {
-    "audio-decode": "^2.1.3",
     "jimp": "^1.6.0",
     "link-preview-js": "^3.0.0",
     "sharp": "*"
   },
   "peerDependenciesMeta": {
-    "audio-decode": {
-      "optional": true
-    },
     "jimp": {
       "optional": true
     },