@nexustechpro/baileys 2.1.0 → 2.1.2

package/lib/Utils/messages.js

@@ -334,7 +334,10 @@ export const generateWAMessageContent = async (message, options = {}) => {
         } else if ('groupInvite' in message) {
             m = await handleGroupInvite(message, options)
         } else if ('stickerPack' in message) {
-            return WAProto.Message.create({ stickerPackMessage: (await prepareStickerPackMessage(message.stickerPack, options)).stickerPackMessage })
+            const result = await prepareStickerPackMessage(message.stickerPack, options)
+            return result.isBatched
+                ? { stickerPackMessage: result.stickerPackMessage, isBatched: true, batchCount: result.batchCount }
+                : WAProto.Message.create({ stickerPackMessage: result.stickerPackMessage })
         } else if ('pin' in message) {
             const messageKey = typeof message.pin === 'boolean'
                 ? (options.quoted?.key || (() => { throw new Boom('No quoted message key found for pin operation') })())
@@ -460,81 +463,99 @@ export const generateWAMessageContent = async (message, options = {}) => {
 // ─── STICKER PACK ─────────────────────────────────────────────────────────────
 export const prepareStickerPackMessage = async (stickerPack, options) => {
     const { stickers, cover, name, publisher, packId, description } = stickerPack
-    if (!stickers?.length) throw new Boom('Sticker pack requires at least one sticker', { statusCode: 400 })
-    if (stickers.length > 120) throw new Boom('Sticker pack exceeds maximum of 120 stickers', { statusCode: 400 })
+    const MAX_STICKER_SIZE = 1024 * 1024
+    const MAX_STICKERS_PER_PACK = 60
 
+    if (!stickers?.length) throw new Boom('Sticker pack must contain at least one sticker', { statusCode: 400 })
+
+    const stickerPackIdValue = packId || generateMessageIDV2()
     const lib = await getImageProcessingLibrary()
-    const packId_ = packId || generateMessageIDV2()
+    const validStickers = []
+    const skippedStickers = []
 
     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
-    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' && offset + 8 < buf.length && (buf[offset + 8] & 0x02)) return true
-            if (fourCC === 'ANIM' || fourCC === 'ANMF') return true
-            offset += 8 + chunkSize + (chunkSize % 2)
-        }
-        return false
-    }
-    const toWebp = async (buffer) => {
-        if ('sharp' in lib && lib.sharp) return await lib.sharp.default(buffer).resize(512, 512, { fit: 'inside', withoutEnlargement: true }).webp({ quality: 75, effort: 6 }).toBuffer()
-        if ('jimp' in lib && lib.jimp) return await lib.jimp.Jimp.read(buffer).then(img => img.getBuffer('image/webp'))
-        throw new Boom('No image processing library available', { statusCode: 500 })
-    }
 
-    const validStickers = []
-    await Promise.all(stickers.map(async (s) => {
+    const stickerPromises = stickers.map(async (s, i) => {
         try {
             const { stream } = await getStream(s.data || s.sticker)
             const buffer = await toBuffer(stream)
-            if (!buffer?.length) return
-            const animated = isAnimatedWebP(buffer)
-            let webpBuffer = isWebPBuffer(buffer) ? buffer : await toWebp(buffer)
-            if (webpBuffer.length > 1024 * 1024) {
-                if ('sharp' in lib && lib.sharp) webpBuffer = await lib.sharp.default(webpBuffer).webp({ quality: 50 }).toBuffer()
-                if (webpBuffer.length > 1024 * 1024) return
+            if (!buffer?.length) { skippedStickers.push({ index: i, reason: 'Empty buffer' }); return null }
+
+            const isWebP = isWebPBuffer(buffer)
+            let webpBuffer
+            try {
+                if (isWebP) webpBuffer = buffer
+                else if ('sharp' in lib && lib.sharp) webpBuffer = await lib.sharp.default(buffer).webp().toBuffer()
+                else if ('jimp' in lib && lib.jimp) webpBuffer = await lib.jimp.Jimp.read(buffer).then(img => img.getBuffer('image/webp'))
+                else { skippedStickers.push({ index: i, reason: 'No image processing library' }); return null }
+            } catch (convertError) {
+                if (!isWebP) { skippedStickers.push({ index: i, reason: `Conversion failed: ${convertError.message}` }); return null }
+                throw convertError
+            }
+
+            if (webpBuffer.length > MAX_STICKER_SIZE) {
+                options.logger?.warn?.(`Sticker at index ${i} exceeds 1MB, compressing...`)
+                try {
+                    if ('sharp' in lib && lib.sharp) webpBuffer = await lib.sharp.default(buffer).webp({ quality: 70 }).toBuffer()
+                    if (webpBuffer.length > MAX_STICKER_SIZE && 'sharp' in lib && lib.sharp) webpBuffer = await lib.sharp.default(buffer).webp({ quality: 50 }).toBuffer()
+                    if (webpBuffer.length > MAX_STICKER_SIZE) { skippedStickers.push({ index: i, reason: 'Still exceeds 1MB after compression' }); return null }
+                    options.logger?.info?.(`Sticker ${i} compressed successfully`)
+                } catch {
+                    skippedStickers.push({ index: i, reason: 'Compression failed' })
+                    return null
+                }
             }
+
             const hash = sha256(webpBuffer).toString('base64').replace(/\//g, '-').replace(/=/g, '')
-            validStickers.push({ fileName: `${hash}.webp`, buffer: webpBuffer, mimetype: 'image/webp', isAnimated: s.isAnimated ?? animated, isLottie: s.isLottie || false, emojis: s.emojis || [], accessibilityLabel: s.accessibilityLabel || '' })
-        } catch (e) { options.logger?.warn({ err: e }, 'failed processing sticker') }
-    }))
+            return { fileName: `${hash}.webp`, webpBuffer, mimetype: 'image/webp', isAnimated: s.isAnimated || false, isLottie: s.isLottie || false, emojis: s.emojis || [], accessibilityLabel: s.accessibilityLabel || '' }
+        } catch (e) {
+            options.logger?.warn({ err: e }, 'failed processing sticker')
+            skippedStickers.push({ index: i, reason: e.message })
+            return null
+        }
+    })
 
+    validStickers.push(...(await Promise.all(stickerPromises)).filter(Boolean))
     if (!validStickers.length) throw new Boom('No valid stickers could be processed', { statusCode: 400 })
 
     const { stream: covStream } = await getStream(cover)
-    const coverBuffer = await toWebp(await toBuffer(covStream))
-
-    const processBatch = async (batch, batchIdx) => {
+    const coverBuffer = await toBuffer(covStream)
+    let coverWebpBuffer
+    if (isWebPBuffer(coverBuffer)) coverWebpBuffer = coverBuffer
+    else if ('sharp' in lib && lib.sharp) coverWebpBuffer = await lib.sharp.default(coverBuffer).webp().toBuffer()
+    else if ('jimp' in lib && lib.jimp) coverWebpBuffer = await lib.jimp.Jimp.read(coverBuffer).then(img => img.getBuffer('image/webp'))
+    else throw new Boom('No image processing library available for cover', { statusCode: 500 })
+
+    const processBatch = async (batch, batchIdx, totalBatches) => {
         const batchData = {}
-        batch.forEach(s => { batchData[s.fileName] = [new Uint8Array(s.buffer), { level: 6 }] })
-        const trayFile = `${packId_}_${batchIdx}.webp`
-        batchData[trayFile] = [new Uint8Array(coverBuffer), { level: 6 }]
-        const zipBuf = await new Promise((resolve, reject) => zip(batchData, { level: 6, memLevel: 9 }, (err, data) => err ? reject(err) : resolve(Buffer.from(data))))
-        if (zipBuf.length > 10 * 1024 * 1024) throw new Boom(`Sticker pack batch ${batchIdx} too large`, { statusCode: 400 })
+        batch.forEach(s => { batchData[s.fileName] = [new Uint8Array(s.webpBuffer), { level: 0 }] })
+        const trayFile = totalBatches > 1 ? `${stickerPackIdValue}_batch${batchIdx}.webp` : `${stickerPackIdValue}.webp`
+        batchData[trayFile] = [new Uint8Array(coverWebpBuffer), { level: 0 }]
+
+        const zipBuf = await new Promise((resolve, reject) => zip(batchData, (err, data) => err ? reject(err) : resolve(Buffer.from(data))))
+
         const upload = await encryptedStream(zipBuf, 'sticker-pack', { logger: options.logger, opts: options.options })
-        const uploadRes = await options.upload(upload.encFilePath || upload.encBuffer, { fileEncSha256B64: upload.fileEncSha256.toString('base64'), mediaType: 'sticker-pack', timeoutMs: options.mediaUploadTimeoutMs || 300000 })
-        await upload.cleanup?.()
+        const uploadRes = await options.upload(upload.encFilePath || upload.encBuffer, { fileEncSha256B64: upload.fileEncSha256.toString('base64'), mediaType: 'sticker-pack', timeoutMs: options.mediaUploadTimeoutMs })
+        if (upload.encFilePath) await fs.unlink(upload.encFilePath).catch(() => { })
 
         let thumbRes = null
         try {
             let thumbBuf
-            if ('sharp' in lib && lib.sharp) thumbBuf = await lib.sharp.default(coverBuffer).resize(252, 252, { fit: 'cover' }).jpeg({ quality: 80 }).toBuffer()
+            if ('sharp' in lib && lib.sharp) thumbBuf = await lib.sharp.default(coverBuffer).resize(252, 252).jpeg().toBuffer()
             else if ('jimp' in lib && lib.jimp) thumbBuf = await lib.jimp.Jimp.read(coverBuffer).then(img => img.resize({ w: 252, h: 252 }).getBuffer('image/jpeg'))
             if (thumbBuf?.length) {
                 const thumbUpload = await encryptedStream(thumbBuf, 'thumbnail-sticker-pack', { logger: options.logger, opts: options.options, mediaKey: upload.mediaKey })
-                thumbRes = await options.upload(thumbUpload.encFilePath || thumbUpload.encBuffer, { fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'), mediaType: 'thumbnail-sticker-pack', timeoutMs: options.mediaUploadTimeoutMs || 60000 })
-                await thumbUpload.cleanup?.()
+                thumbRes = await options.upload(thumbUpload.encFilePath || thumbUpload.encBuffer, { fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'), mediaType: 'thumbnail-sticker-pack', timeoutMs: options.mediaUploadTimeoutMs })
+                if (thumbUpload.encFilePath) await fs.unlink(thumbUpload.encFilePath).catch(() => { })
                 thumbRes._buf = thumbBuf; thumbRes._enc = thumbUpload
             }
         } catch (e) { options.logger?.warn({ err: e }, 'failed generating sticker pack thumbnail') }
 
         return {
-            name: batchIdx > 0 ? `${name} (${batchIdx + 1})` : name, publisher, packDescription: description,
-            stickerPackId: batchIdx > 0 ? `${packId_}_${batchIdx}` : packId_,
-            stickerPackOrigin: proto.Message.StickerPackMessage.StickerPackOrigin.THIRD_PARTY,
+            name: totalBatches > 1 ? `${name} (${batchIdx + 1}/${totalBatches})` : name,
+            publisher, packDescription: description,
+            stickerPackId: totalBatches > 1 ? `${stickerPackIdValue}_${batchIdx}` : stickerPackIdValue,
+            stickerPackOrigin: proto.Message.StickerPackMessage.StickerPackOrigin.USER_CREATED,
             stickerPackSize: zipBuf.length,
             stickers: batch.map(s => ({ fileName: s.fileName, mimetype: s.mimetype, isAnimated: s.isAnimated, isLottie: s.isLottie, emojis: s.emojis, accessibilityLabel: s.accessibilityLabel })),
             fileSha256: upload.fileSha256, fileEncSha256: upload.fileEncSha256, mediaKey: upload.mediaKey,
@@ -543,13 +564,14 @@ export const prepareStickerPackMessage = async (stickerPack, options) => {
         }
     }
 
-    if (validStickers.length > 60) {
+    if (validStickers.length > MAX_STICKERS_PER_PACK) {
         const batches = []
-        for (let i = 0; i < validStickers.length; i += 60) batches.push(validStickers.slice(i, i + 60))
-        const results = await Promise.all(batches.map((b, i) => processBatch(b, i)))
+        for (let i = 0; i < validStickers.length; i += MAX_STICKERS_PER_PACK) batches.push(validStickers.slice(i, i + MAX_STICKERS_PER_PACK))
+        const results = []
+        for (let i = 0; i < batches.length; i++) results.push(await processBatch(batches[i], i, batches.length))
         return { stickerPackMessage: results, isBatched: true, batchCount: batches.length }
     }
-    return { stickerPackMessage: await processBatch(validStickers, 0), isBatched: false }
+    return { stickerPackMessage: await processBatch(validStickers, 0, 1), isBatched: false }
 }
 
 // ─── MESSAGE BUILDERS ─────────────────────────────────────────────────────────
@@ -562,18 +584,21 @@ export const generateWAMessageFromContent = (jid, message, options) => {
     if (quoted && !isJidNewsletter(jid)) {
         const participant = quoted.key.fromMe ? userJid : (quoted.participant || quoted.key.participant || quoted.key.remoteJid)
         const normalizedQuoted = normalizeMessageContent(quoted.message)
-        const quotedType = getContentType(normalizedQuoted)
-        const quotedMsg = proto.Message.fromObject({ [quotedType]: normalizedQuoted[quotedType] })
-        const quotedContent = quotedMsg[quotedType]
-        if (typeof quotedContent === 'object' && quotedContent && 'contextInfo' in quotedContent) delete quotedContent.contextInfo
-        const contextInfo = (innerMessage[key]?.contextInfo) || {}
-        contextInfo.participant = jidNormalizedUser(participant)
-        contextInfo.stanzaId = quoted.key.id
-        contextInfo.quotedMessage = quotedMsg
-        if (jid !== quoted.key.remoteJid) contextInfo.remoteJid = quoted.key.remoteJid
-        if (innerMessage[key]) innerMessage[key].contextInfo = contextInfo
+        if (!normalizedQuoted) {
+            // stub message with no content — skip quoted context
+        } else {
+            const quotedType = getContentType(normalizedQuoted)
+            const quotedMsg = proto.Message.fromObject({ [quotedType]: normalizedQuoted[quotedType] })
+            const quotedContent = quotedMsg[quotedType]
+            if (typeof quotedContent === 'object' && quotedContent && 'contextInfo' in quotedContent) delete quotedContent.contextInfo
+            const contextInfo = (innerMessage[key]?.contextInfo) || {}
+            contextInfo.participant = jidNormalizedUser(participant)
+            contextInfo.stanzaId = quoted.key.id
+            contextInfo.quotedMessage = quotedMsg
+            if (jid !== quoted.key.remoteJid) contextInfo.remoteJid = quoted.key.remoteJid
+            if (innerMessage[key]) innerMessage[key].contextInfo = contextInfo
+        }
     }
-
     if (options?.ephemeralExpiration && key !== 'protocolMessage' && key !== 'ephemeralMessage' && !isJidNewsletter(jid)) {
         innerMessage[key].contextInfo = { ...(innerMessage[key].contextInfo || {}), expiration: options.ephemeralExpiration || WA_DEFAULT_EPHEMERAL }
     }
@@ -680,7 +705,7 @@ export const downloadMediaMessage = async (message, type, options, ctx) => {
 
 export const assertMediaContent = (content) => {
     content = extractMessageContent(content)
-    const mediaContent = content?.documentMessage || content?.imageMessage || content?.videoMessage || content?.audioMessage || content?.stickerMessage
+    const mediaContent = content?.documentMessage || content?.imageMessage || content?.videoMessage || content?.audioMessage || content?.stickerMessage || content?.stickerPackMessage
     if (!mediaContent) throw new Boom('given message is not a media message', { statusCode: 400, data: content })
     return mediaContent
 }

package/lib/Utils/use-multi-file-auth-state.js

@@ -65,7 +65,12 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
             const checksum = computeChecksum(serialized)
             const payload = JSON.stringify({ data: JSON.parse(serialized), __checksum: checksum })
             await writeFile(tp, payload)
-            await rename(tp, fp)
+            try {
+                await rename(tp, fp)
+            } catch {
+                await writeFile(fp, payload)
+                await unlink(tp).catch(() => { })
+            }
         } finally {
             release()
             releaseFileLock(fp)
@@ -84,19 +89,24 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
                 const parsed = JSON.parse(raw)
                 if (parsed.__checksum) {
                     const expected = computeChecksum(JSON.stringify(parsed.data))
-                    if (expected !== parsed.__checksum) throw new Error('checksum mismatch')
+                    if (expected !== parsed.__checksum) {
+                        logger?.warn({ file }, 'checksum mismatch — reinitializing file')
+                        await writeFile(fp, JSON.stringify({ data: parsed.data, __checksum: computeChecksum(JSON.stringify(parsed.data)) })).catch(() => { })
+                        return JSON.parse(JSON.stringify(parsed.data), BufferJSON.reviver)
+                    }
                     return JSON.parse(JSON.stringify(parsed.data), BufferJSON.reviver)
                 }
-                // legacy file without checksum — read as-is for compatibility
+                // legacy file — rewrite with checksum
+                const reserialized = JSON.stringify(JSON.parse(raw, BufferJSON.reviver), BufferJSON.replacer)
+                const checksum = computeChecksum(reserialized)
+                await writeFile(fp, JSON.stringify({ data: JSON.parse(reserialized), __checksum: checksum })).catch(() => { })
                 return JSON.parse(raw, BufferJSON.reviver)
             } catch (err) {
-                logger?.warn({ file, err: err.message }, 'failed to read auth file')
+                logger?.warn({ file, err: err.message }, 'failed to read auth file — reinitializing')
+                await unlink(fp).catch(() => { })
                 return null
             }
-        } finally {
-            release()
-            releaseFileLock(fp)
-        }
+        } finally { release(); releaseFileLock(fp) }
     }
 
     // ─── Remove File ────────────────────────────────────────────────────────────

package/lib/index.js

@@ -31,7 +31,7 @@ const banner = `
 const info = `
 ┌───────────────────────────────────────────────────────────────────────┐
 │  📦 Package: @nexustechpro/baileys                                   │
-│  🔖 Version: 2.1.0                                                  │
+│  🔖 Version: 2.1.2                                                  │
 │  ⚡ Status:  Production Ready                                        │
 ├───────────────────────────────────────────────────────────────────────┤
 │  🚀 Advanced WhatsApp Web API Client                                  │

package/package.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@nexustechpro/baileys",
   "type": "module",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "Advanced WhatsApp Web API built on Baileys — interactive messages, buttons, carousels, products, events, payments, polls, albums, sticker packs and more.",
   "keywords": [
     "whatsapp",
@@ -100,8 +100,8 @@
   "dependencies": {
     "@adiwajshing/keyed-db": "^0.2.4",
     "@cacheable/node-cache": "^1.4.0",
-    "@microlink/mql": "^0.16.1",
     "@hapi/boom": "^9.1.3",
+    "@microlink/mql": "^0.16.1",
     "async-mutex": "^0.5.0",
     "axios": "^1.6.0",
     "cache-manager": "latest",