@nexustechpro/baileys 2.0.6 → 2.1.2

package/lib/Utils/decode-wa-message.js

@@ -135,13 +135,13 @@ export function decodeMessageNode(stanza, meId, meLid) {
   const isMe = (jid) => areJidsSameUser(jid, meId)
   const isMeLid = (jid) => areJidsSameUser(jid, meLid)
   if (isPnUser(from) || isLidUser(from) || isHostedLidUser(from) || isHostedPnUser(from)) {
+    if (isMe(from) || isMeLid(from)) {
+      fromMe = true
+    }
     if (recipient && !isJidMetaAI(recipient)) {
-      if (!isMe(from) && !isMeLid(from)) {
+      if (!fromMe) {
         throw new Boom("receipient present, but msg not from me", { data: stanza })
       }
-      if (isMe(from) || isMeLid(from)) {
-        fromMe = true
-      }
       chatId = recipient
     } else {
       chatId = from
@@ -254,12 +254,13 @@ export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
                   })
                 } catch (decryptErr) {
                   const errMsg = decryptErr?.message || decryptErr?.toString() || ''
-                  if (errMsg.includes('invalid sender key session') || errMsg.includes('memory access out of bounds')) {
-                    logger?.debug?.({ group: sender, author: author, errMsg }, '[Signal] Stale/corrupt sender key session, deleting')
+                  if (errMsg.includes('memory access out of bounds')) {
+                    console.error('[Signal] Stale sender key — group:', sender, 'author:', author, 'err:', errMsg)
                     try {
                       await repository.deleteSenderKey(sender, author)
+                      console.error('[Signal] Sender key deleted successfully')
                     } catch (e) {
-                      logger?.warn?.({ err: e }, 'Failed to delete sender key')
+                      console.error('[Signal] Failed to delete sender key:', e)
                     }
                   }
                   throw decryptErr
@@ -267,24 +268,8 @@ export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
                 break
               case "pkmsg":
               case "msg":
-                try {
-                  msgBuffer = await repository.decryptMessage({ jid: decryptionJid, type: e2eType, ciphertext: content })
-                  if (msgBuffer === null) {
-                    throw new Error("DuplicatedMessage")
-                  }
-                } catch (decryptErr) {
-                  const errMsg = decryptErr?.message || decryptErr?.toString() || ''
-                  if ((errMsg.includes('InvalidMessage') || errMsg.includes('BadMac')) && e2eType === 'msg') {
-                    logger?.debug?.({ jid: decryptionJid, errMsg }, '[Signal] Stale session (InvalidMessage/BadMac), deleting')
-                    try {
-                      const toDelete = [decryptionJid]
-                      await repository.deleteSession(toDelete)
-                    } catch { }
-                  }
-                  const cleanError = new Error(errMsg || 'Decryption failed')
-                  cleanError.stack = decryptErr?.stack
-                  throw cleanError
-                }
+                msgBuffer = await repository.decryptMessage({ jid: decryptionJid, type: e2eType, ciphertext: content })
+                if (msgBuffer === null) return // DuplicatedMessage — libsignal already handled it silently
                 break
               case "plaintext":
                 msgBuffer = content
@@ -324,7 +309,7 @@ export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
           } catch (err) {
             const errorMessage = err?.message || err?.toString() || ""
             const errStr = err?.message || (typeof err === "string" ? err : "") || ""
-            const isExpectedDecryptErr = errStr.includes("InvalidPreKeyId") || errStr.includes("SessionNotFound") || errStr.includes("InvalidMessage") || errStr.includes("no sender key state") || errStr.includes("invalid sender key session") || errStr.includes("memory access out of bounds") || errStr.includes("old counter") || errStr.includes("DuplicatedMessage") || errStr.includes("BadMac")
+            const isExpectedDecryptErr = errStr.includes("InvalidPreKeyId") || errStr.includes("SessionNotFound") || errStr.includes("InvalidMessage") || errStr.includes("no sender key state") || errStr.includes("memory access out of bounds") || errStr.includes("old counter") || errStr.includes("DuplicatedMessage") || errStr.includes("BadMac")
               ; (isExpectedDecryptErr ? logger?.debug?.bind(logger) : logger?.error?.bind(logger))?.({ key: fullMessage.key, err, errorMessage, messageType: tag === "plaintext" ? "plaintext" : attrs.type, sender, author }, "failed to decrypt message")
             fullMessage.messageStubType = proto.WebMessageInfo.StubType.CIPHERTEXT
             fullMessage.messageStubParameters = [errorMessage]

package/lib/Utils/key-store.js

@@ -8,7 +8,7 @@ export const migrateIndexKey = async (keys, type) => {
     const oldKey = '_index'
     const newKey = 'index'
     const oldData = await keys.get(type, [oldKey])
-    if (oldData?.[oldKey] && typeof oldData[oldKey] === 'object') { // only migrate if old blob actually exists and has data
+    if (oldData?.[oldKey] !== null && oldData?.[oldKey] !== undefined && typeof oldData[oldKey] === 'object') { // only migrate if old blob actually exists and has data
         await keys.set({ [type]: { [newKey]: oldData[oldKey], [oldKey]: null } })
         return oldData[oldKey]
     }

package/lib/Utils/link-preview.js

@@ -1,108 +1,171 @@
-import { promises as dnsPromises } from 'dns'
 import { getLinkPreview } from 'link-preview-js'
+import mql from '@microlink/mql'
+import { lookup } from 'dns'
+import { promisify } from 'util'
+import { LRUCache } from 'lru-cache'
 import { prepareWAMessageMedia } from './messages.js'
 import { extractImageThumb, getHttpStream } from './messages-media.js'
 
-const THUMBNAIL_WIDTH_PX = 192
-const MAX_REDIRECTS = 5
-const PREVIEW_TIMEOUT = 5000
-// Concurrency pool — max simultaneous link preview fetches
+const dnsLookup = promisify(lookup)
+const THUMBNAIL_WIDTH = 192
+const TIMEOUT = 4_000
 const MAX_CONCURRENT = 20
+const MAX_INFLIGHT = 1000
+
+const _previewCache = new LRUCache({ max: 500, ttl: 1000 * 60 * 10 })
+const _negCache = new LRUCache({ max: 500, ttl: 1000 * 60 * 2 })
+const _thumbCache = new LRUCache({ max: 200, ttl: 1000 * 60 * 30 })
+const _inflight = new Map()
+
 let _active = 0
 const _queue = []
+
 const _drain = () => {
-    if (_queue.length === 0 || _active >= MAX_CONCURRENT) return
+    if (!_queue.length || _active >= MAX_CONCURRENT) return
     _active++
     const { fn, resolve, reject } = _queue.shift()
     fn().then(resolve).catch(reject).finally(() => { _active--; _drain() })
 }
-const _enqueue = fn => new Promise((resolve, reject) => { _queue.push({ fn, resolve, reject }); _drain() })
 
-/** Fetches a remote image and compresses it to a JPEG thumbnail buffer */
+const _enqueue = fn => new Promise((resolve, reject) => {
+    _queue.push({ fn, resolve, reject }); _drain()
+})
+
+const _resolveDNS = async url => {
+    try { return (await dnsLookup(new URL(url).hostname)).address }
+    catch { return new URL(url).hostname }
+}
+
+const _normalize = text => {
+    const t = text.trim()
+    return /^https?:\/\//i.test(t) ? t : `https://${t}`
+}
+
+const _previewType = (mediaType, image) => {
+    if (!mediaType) return image ? 5 : 0
+    const mt = mediaType.toLowerCase()
+    if (mt === 'video' || mt.startsWith('video.')) return 1
+    return mt === 'image' || image ? 5 : 0
+}
+
 const _compressedThumb = async (url, opts) => {
     const stream = await getHttpStream(url, opts.fetchOpts)
-    const result = await extractImageThumb(stream, opts.thumbnailWidth ?? THUMBNAIL_WIDTH_PX)
-    return result.buffer
+    return (await extractImageThumb(stream, opts.thumbnailWidth ?? THUMBNAIL_WIDTH)).buffer
 }
 
-/** Resolves jpegThumbnail + highQualityThumbnail from an image URL, never throws */
 const _resolveThumbnail = async (image, opts) => {
     if (!image) return {}
+    const key = `thumb:${image}`
+    const hit = _thumbCache.get(key)
+    if (hit) return hit
+
+    let thumbs = {}
     if (opts.uploadImage) {
         try {
             const { imageMessage } = await prepareWAMessageMedia(
                 { image: { url: image } },
                 { upload: opts.uploadImage, mediaTypeOverride: 'thumbnail-link', options: opts.fetchOpts }
             )
-            return {
-                jpegThumbnail: imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined,
-                highQualityThumbnail: imageMessage ?? undefined
-            }
-        } catch (err) {
-            opts.logger?.warn({ err: err.message, url: image }, 'upload failed, falling back to compressed thumb')
+            const jpeg = imageMessage?.jpegThumbnail
+                ? Buffer.from(imageMessage.jpegThumbnail)
+                : await _compressedThumb(image, opts).catch(() => undefined)
+            thumbs = { jpegThumbnail: jpeg, highQualityThumbnail: imageMessage ?? undefined }
+        } catch {
+            try { thumbs = { jpegThumbnail: await _compressedThumb(image, opts) } } catch { }
         }
+    } else {
+        try { thumbs = { jpegThumbnail: await _compressedThumb(image, opts) } } catch { }
     }
-    // Fallback: local compression (also used when no uploadImage provided)
+
+    if (thumbs.jpegThumbnail) _thumbCache.set(key, thumbs)
+    return thumbs
+}
+
+const _tryLinkPreview = async (url, opts) => {
     try {
-        return { jpegThumbnail: await _compressedThumb(image, opts) }
+        const info = await getLinkPreview(url, {
+            timeout: opts.fetchOpts?.timeout ?? TIMEOUT,
+            followRedirects: 'follow',
+            resolveDNSHost: _resolveDNS,
+        })
+        if (info?.title) return info
     } catch (err) {
-        opts.logger?.debug({ err: err.stack }, 'compressed thumb failed')
-        return {}
+        opts.logger?.warn({ err: err?.message || err, url }, 'getLinkPreview failed')
     }
+    return undefined
 }
 
-/**
- * Extracts link preview info from a text string or URL.
- * Queued for concurrency control — never throws on preview failure.
- * @param {string} text - Raw text or URL to preview
- * @param {object} opts - Options: thumbnailWidth, fetchOpts, uploadImage, logger
- * @returns {Promise<object|undefined>} urlInfo or undefined if no valid URL/title found
- */
-export const getUrlInfo = (text, opts = {}) => _enqueue(async () => {
-    const fetchOpts = opts.fetchOpts ?? { timeout: PREVIEW_TIMEOUT }
-    const thumbnailWidth = opts.thumbnailWidth ?? THUMBNAIL_WIDTH_PX
-    const resolvedOpts = { ...opts, fetchOpts, thumbnailWidth }
+const _tryMicrolink = async (url, opts) => {
     try {
-        let retries = 0
-        const previewLink = (text.startsWith('https://') || text.startsWith('http://')) ? text : 'https://' + text
-        const info = await getLinkPreview(previewLink, {
-            ...fetchOpts,
-            followRedirects: 'manual',
-            handleRedirects: (baseURL, forwardedURL) => {
-                if (retries >= MAX_REDIRECTS) return false
-                const base = new URL(baseURL)
-                const fwd = new URL(forwardedURL)
-                const sameHost = fwd.hostname === base.hostname || fwd.hostname === 'www.' + base.hostname || 'www.' + fwd.hostname === base.hostname
-                if (sameHost) { retries++; return true }
-                return false
-            },
-            resolveDNSHost: async (url) => {
-                const hostname = new URL(url).hostname
-                try {
-                    const { address } = await dnsPromises.lookup(hostname)
-                    return address
-                } catch {
-                    return hostname
-                }
-            },
-            headers: fetchOpts.headers
-        })
-        if (!info || !('title' in info) || !info.title) return undefined
-        const [image] = info.images ?? []
-        const thumbs = await _resolveThumbnail(image, resolvedOpts)
+        const { data } = await mql(url)
+        if (!data?.title) return undefined
         return {
-            'canonical-url': info.url,
-            'matched-text': text,
-            title: info.title,
-            description: info.description,
-            originalThumbnailUrl: image,
-            ...thumbs
+            url: data.url ?? url,
+            title: data.title,
+            description: data.description ?? '',
+            images: [data.image?.url].filter(Boolean),
+            mediaType: 'website',
         }
     } catch (err) {
-        // Suppress "no valid URL" and missing module errors; re-throw everything else
-        if (!err.message?.includes('receive a valid') && err.code !== 'ERR_MODULE_NOT_FOUND' && err.code !== 'MODULE_NOT_FOUND') {
-            throw err
-        }
+        opts.logger?.warn({ err: err?.message || err, url }, 'microlink failed')
     }
-})
-//# sourceMappingURL=link-preview.js.map
+    return undefined
+}
+
+const _buildResult = async (info, text, opts) => {
+    const [image] = info.images ?? []
+    return {
+        'canonical-url': info.url,
+        'matched-text': text,
+        title: info.title,
+        description: info.description,
+        originalThumbnailUrl: image,
+        previewType: _previewType(info.mediaType, image),
+        ...await _resolveThumbnail(image, opts),
+    }
+}
+
+export const getUrlInfo = (text, opts = {}) => {
+    const url = _normalize(text)
+
+    if (_negCache.has(url)) return Promise.resolve(undefined)
+    if (_previewCache.has(url)) return Promise.resolve(_previewCache.get(url))
+    if (_inflight.has(url)) return _inflight.get(url)
+    if (_inflight.size >= MAX_INFLIGHT) return Promise.resolve(undefined)
+
+    const o = {
+        fetchOpts: { timeout: TIMEOUT, ...opts.fetchOpts },
+        thumbnailWidth: opts.thumbnailWidth ?? THUMBNAIL_WIDTH,
+        uploadImage: opts.uploadImage,
+        logger: opts.logger,
+    }
+
+    const promise = _enqueue(async () => {
+        try {
+            // Primary: link-preview-js
+            let info = await _tryLinkPreview(url, o)
+
+            // Fallback: microlink (if no result or no image)
+            if (!info?.title || !(info.images ?? []).length) {
+                o.logger?.debug({ url }, 'falling back to microlink')
+                info = await _tryMicrolink(url, o) ?? info
+            }
+
+            if (!info?.title) {
+                _negCache.set(url, true)
+                return undefined
+            }
+
+            const result = await _buildResult(info, text, o)
+            _previewCache.set(url, result)
+            return result
+        } catch (err) {
+            _negCache.set(url, true)
+            if (!err.message?.includes('receive a valid')) throw err
+            return undefined
+        }
+    }).finally(() => _inflight.delete(url))
+
+    _inflight.set(url, promise)
+    return promise
+}

package/lib/Utils/messages-media.js

@@ -2,8 +2,8 @@ import { Boom } from '@hapi/boom'
 import { spawn } from 'child_process'
 import * as Crypto from 'crypto'
 import { once } from 'events'
-import { createReadStream, createWriteStream, promises as fs } from 'fs'
-import { tmpdir } from 'os'
+import { createReadStream, createWriteStream, mkdirSync, promises as fs } from 'fs'
+import { tmpdir as osTmpdir } from 'os'
 import { join } from 'path'
 import { Readable, Transform } from 'stream'
 import { URL } from 'url'
@@ -24,6 +24,22 @@ export const getImageProcessingLibrary = async () => {
     throw new Boom('No image processing library available')
 }
 
+// ─── CUSTOM TMPDIR (real disk, fall back to tmpfs if cwd isnt writable (e.g, read-only Docker containers)) ─────────────────────────────────────
+const BAILEYS_TMP_DIR = (() => {
+    const candidates = [
+        join(process.cwd(), '.b-tmp'),
+        join(osTmpdir(), 'b-tmp'),
+    ]
+    for (const dir of candidates) {
+        try {
+            mkdirSync(dir, { recursive: true, mode: 0o700 })
+            return dir
+        } catch { }
+    }
+    return osTmpdir()
+})()
+const tmpdir = () => BAILEYS_TMP_DIR
+
 // ─── FFMPEG ───────────────────────────────────────────────────────────────────
 let ffmpegPathResolved = null
 const getFfmpegPath = async () => {
@@ -42,7 +58,7 @@ export const hkdfInfoKey = (type) => `WhatsApp ${MEDIA_HKDF_KEY_MAPPING[type]} K
 export const getMediaKeys = async (buffer, mediaType) => {
     if (!buffer) throw new Boom('Cannot derive from empty media key')
     if (typeof buffer === 'string') buffer = Buffer.from(buffer.replace('data:;base64,', ''), 'base64')
-    const expandedMediaKey = await hkdf(buffer, 112, { info: hkdfInfoKey(mediaType) })
+    const expandedMediaKey = hkdf(buffer, 112, { info: hkdfInfoKey(mediaType) })
     return {
         iv: expandedMediaKey.slice(0, 16),
         cipherKey: expandedMediaKey.slice(16, 48),
@@ -270,16 +286,18 @@ export const getStream = async (item, opts) => {
     if (Buffer.isBuffer(item)) return { stream: toReadable(item), type: 'buffer' }
     if (item?.stream?.pipe) return { stream: item.stream, type: 'readable' }
     if (item?.pipe) return { stream: item, type: 'readable' }
+    const isHttpUrl = (str) => { try { const u = new URL(str); return u.protocol === 'http:' || u.protocol === 'https:' } catch { return false } }
+
     if (item && typeof item === 'object' && 'url' in item) {
         const urlStr = item.url.toString()
         if (Buffer.isBuffer(item.url)) return { stream: toReadable(item.url), type: 'buffer' }
         if (urlStr.startsWith('data:')) return { stream: toReadable(Buffer.from(urlStr.split(',')[1], 'base64')), type: 'buffer' }
-        if (urlStr.startsWith('http')) return { stream: await getHttpStream(item.url, opts), type: 'remote' }
+        if (isHttpUrl(urlStr)) return { stream: await getHttpStream(item.url, opts), type: 'remote' }
         return { stream: createReadStream(item.url), type: 'file' }
     }
     if (typeof item === 'string') {
         if (item.startsWith('data:')) return { stream: toReadable(Buffer.from(item.split(',')[1], 'base64')), type: 'buffer' }
-        if (item.startsWith('http')) return { stream: await getHttpStream(item, opts), type: 'remote' }
+        if (isHttpUrl(item)) return { stream: await getHttpStream(item, opts), type: 'remote' }
         return { stream: createReadStream(item), type: 'file' }
     }
     throw new Boom(`Invalid input type for getStream: ${typeof item}`, { statusCode: 400 })
@@ -340,52 +358,100 @@ export const encryptedStream = async (media, mediaType, { logger, saveOriginalFi
             finalStream = (await getStream(media, opts)).stream
         }
     }
+
     const mediaKey = providedMediaKey || Crypto.randomBytes(32)
     const { cipherKey, iv, macKey } = await getMediaKeys(mediaKey, mediaType)
-    const encFilePath = join(tmpdir(), mediaType + generateMessageIDV2() + '-enc')
-    const encFileWriteStream = createWriteStream(encFilePath)
-    let originalFileStream, originalFilePath
-    if (saveOriginalFileIfRequired) {
-        originalFilePath = join(tmpdir(), mediaType + generateMessageIDV2() + '-original')
-        originalFileStream = createWriteStream(originalFilePath)
-    }
-    let fileLength = 0
+
     const aes = Crypto.createCipheriv('aes-256-cbc', cipherKey, iv)
     const hmac = Crypto.createHmac('sha256', macKey).update(iv)
     const sha256Plain = Crypto.createHash('sha256')
     const sha256Enc = Crypto.createHash('sha256')
+    const encChunks = []
+    const plainChunks = saveOriginalFileIfRequired ? [] : null
+    let fileLength = 0
+
     try {
         for await (const data of finalStream) {
             fileLength += data.length
-            if (type === 'remote' && opts?.maxContentLength && fileLength > opts.maxContentLength) throw new Boom('content length exceeded', { data: { media, type } })
-            if (originalFileStream && !originalFileStream.write(data)) await once(originalFileStream, 'drain')
+            if (type === 'remote' && opts?.maxContentLength && fileLength > opts.maxContentLength) {
+                throw new Boom('content length exceeded', { data: { media, type } })
+            }
+            if (plainChunks) plainChunks.push(data)
             sha256Plain.update(data)
             const encrypted = aes.update(data)
             sha256Enc.update(encrypted)
             hmac.update(encrypted)
-            encFileWriteStream.write(encrypted)
+            encChunks.push(encrypted)
         }
+
         const finalData = aes.final()
         sha256Enc.update(finalData)
         hmac.update(finalData)
-        encFileWriteStream.write(finalData)
+        encChunks.push(finalData)
+
         const mac = hmac.digest().slice(0, 10)
         sha256Enc.update(mac)
-        encFileWriteStream.write(mac)
-        encFileWriteStream.end()
-        originalFileStream?.end?.()
+        encChunks.push(mac)
+
         finalStream.destroy()
-        logger?.debug('encrypted data successfully')
-        return { mediaKey, bodyPath: originalFilePath, encFilePath, mac, fileEncSha256: sha256Enc.digest(), fileSha256: sha256Plain.digest(), fileLength, opusConverted }
+        logger?.debug('encrypted data in memory')
+
+        const encBuffer = Buffer.concat(encChunks)
+        const fileEncSha256 = sha256Enc.digest()
+        const fileSha256 = sha256Plain.digest()
+
+        let originalFilePath = null
+        if (plainChunks) {
+            try {
+                originalFilePath = join(tmpdir(), mediaType + generateMessageIDV2() + '-original')
+                await fs.writeFile(originalFilePath, Buffer.concat(plainChunks))
+                logger?.debug('saved original file for processing')
+            } catch (err) {
+                logger?.warn({ err: err.message }, 'failed to save original file, bodyPath will be null')
+                originalFilePath = null
+            }
+        }
+        let encFilePath = null
+        let useMemory = false
+
+        try {
+            encFilePath = join(tmpdir(), mediaType + generateMessageIDV2() + '-enc')
+            await fs.writeFile(encFilePath, encBuffer)
+            logger?.debug('wrote enc file to disk')
+        } catch (err) {
+            logger?.warn({ err: err.message, code: err.code }, 'failed to write enc file to disk, falling back to memory upload')
+            if (encFilePath) {
+                try { await fs.unlink(encFilePath) } catch { }
+                encFilePath = null
+            }
+            useMemory = true
+        }
+
+        const cleanup = async () => {
+            if (encFilePath) try { await fs.unlink(encFilePath) } catch { }
+            if (originalFilePath) try { await fs.unlink(originalFilePath) } catch { }
+        }
+
+        return {
+            mediaKey,
+            bodyPath: originalFilePath,
+            encFilePath,
+            encBuffer: useMemory ? encBuffer : null,
+            mac,
+            fileEncSha256,
+            fileSha256,
+            fileLength,
+            opusConverted,
+            cleanup
+        }
     } catch (error) {
-        encFileWriteStream.destroy()
-        originalFileStream?.destroy?.()
         aes.destroy()
         hmac.destroy()
         sha256Plain.destroy()
         sha256Enc.destroy()
         finalStream.destroy()
-        try { await fs.unlink(encFilePath); if (originalFilePath) await fs.unlink(originalFilePath) } catch (err) { logger?.error({ err }, 'failed deleting tmp files') }
+        if (encFilePath) try { await fs.unlink(encFilePath) } catch { }
+        if (originalFilePath) try { await fs.unlink(originalFilePath) } catch { }
         throw error
     }
 }
@@ -459,7 +525,12 @@ export const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, opt
         const toUploadBody = async (input) => {
             if (!input) throw new Boom('Upload input is null or undefined', { statusCode: 400 })
             if (Buffer.isBuffer(input)) return input
-            if (typeof input === 'string') return createReadStream(input)
+            if (typeof input === 'string') {
+                const stream = createReadStream(input)
+                stream.on('end', () => stream.destroy())
+                stream.on('error', () => stream.destroy())
+                return stream
+            }
             if (typeof ReadableStream !== 'undefined' && input instanceof ReadableStream) return Readable.fromWeb(input)
             if (typeof input.pipe === 'function' || typeof input[Symbol.asyncIterator] === 'function') return input
             throw new Boom(`Unsupported upload input type: ${Object.prototype.toString.call(input)}`, { statusCode: 400 })