@hansaka02/baileys 7.3.4 → 7.3.6

package/lib/Utils/generics.js

@@ -12,116 +12,10 @@ const {
   getAllBinaryNodeChildren
 } = require("../WABinary")
 const { sha256 } = require("./crypto")
-const { platform } = require("os")
 const { proto } = require("../../WAProto")
 const { version } = require("../Defaults/baileys-version.json")
 const { DisconnectReason } = require("../Types")
 
-const COMPANION_PLATFORM_MAP = {
-    'Chrome': '49',
-    'Edge': '50',
-    'Firefox': '51',
-    'Opera': '53',
-    'Safari': '54',
-    'Brave': '1.79.112',
-    'Vivaldi': '6.2.3105.58',
-    'Tor': '12.5.3',
-    'Yandex': '23.7.1',
-    'Falkon': '22.08.3',
-    'Epiphany': '44.2'
-}
-
-const PLATFORM_MAP = {
-    'aix': 'AIX',
-    'darwin': 'Mac OS',
-    'win32': 'Windows',
-    'android': 'Android',
-    'freebsd': 'FreeBSD',
-    'openbsd': 'OpenBSD',
-    'sunos': 'Solaris',
-    'linux': 'Linux',
-    'ubuntu': 'Ubuntu',
-    'ios': 'iOS',
-    'baileys': 'Baileys', 
-    'chromeos': 'Chrome OS',
-    'tizen': 'Tizen',
-    'watchos': 'watchOS',
-    'wearos': 'Wear OS',
-    'harmonyos': 'HarmonyOS',
-    'kaios': 'KaiOS',
-    'smarttv': 'Smart TV',
-    'raspberrypi': 'Raspberry Pi OS',
-    'symbian': 'Symbian',
-    'blackberry': 'Blackberry OS',
-    'windowsphone': 'Windows Phone'
-}
-
-const PLATFORM_VERSIONS = {
-    'ubuntu': '22.04.4',
-    'darwin': '18.5', 
-    'win32': '10.0.22631', 
-    'android': '14.0.0',
-    'freebsd': '13.2',
-    'openbsd': '7.3',
-    'sunos': '11',
-    'linux': '6.5',
-    'ios': '18.2',
-    'baileys': '6.5.0', 
-    'chromeos': '117.0.5938.132',
-    'tizen': '6.5',
-    'watchos': '10.1',
-    'wearos': '4.1',
-    'harmonyos': '4.0.0',
-    'kaios': '3.1',
-    'smarttv': '23.3.1',
-    'raspberrypi': '11 (Bullseye)',
-    'symbian': '3',
-    'blackberry': '10.3.3',
-    'windowsphone': '8.1'
-}
-
-const Browsers = {
-    ubuntu: (browser) => {
-        return [PLATFORM_MAP['ubuntu'], browser, PLATFORM_VERSIONS['ubuntu']]
-    },
-    macOS: (browser) => {
-        return [PLATFORM_MAP['darwin'], browser, PLATFORM_VERSIONS['darwin']]
-    },
-    windows: (browser) => {
-        return [PLATFORM_MAP['win32'], browser, PLATFORM_VERSIONS['win32']]
-    },
-    linux: (browser) => {
-        return [PLATFORM_MAP['linux'], browser, PLATFORM_VERSIONS['linux']]
-    },
-    solaris: (browser) => {
-        return [PLATFORM_MAP['sunos'], browser, PLATFORM_VERSIONS['sunos']]
-    },
-    baileys: (browser) => {
-        return [PLATFORM_MAP['baileys'], browser, PLATFORM_VERSIONS['baileys']]
-    },
-    android: (browser) => {
-        return [PLATFORM_MAP['android'], browser, PLATFORM_VERSIONS['android']]
-    },
-    iOS: (browser) => {
-        return [PLATFORM_MAP['ios'], browser, PLATFORM_VERSIONS['ios']]
-    },
-    kaiOS: (browser) => {
-        return [PLATFORM_MAP['kaios'], browser, PLATFORM_VERSIONS['kaios']]
-    },
-    chromeOS: (browser) => {
-        return [PLATFORM_MAP['chromeos'], browser, PLATFORM_VERSIONS['chromeos']]
-    },
-    appropriate: (browser) => {
-        const platform = platform()
-        const platformName = PLATFORM_MAP[platform] || 'Unknown OS'
-        return [platformName, browser, PLATFORM_VERSIONS[platform] || 'latest']
-    },
-    custom: (platform, browser, version) => {
-        const platformName = PLATFORM_MAP[platform.toLowerCase()] || platform
-        return [platformName, browser, version || PLATFORM_VERSIONS[platform] || 'latest']
-    }
-}
-
 const Itsuki = async () => {
     try {
         const response = await fetch('https://raw.githubusercontent.com/Itsukichann/database/refs/heads/main/itsuki.json', {
@@ -140,31 +34,34 @@ const Itsuki = async () => {
 }
 
 const BufferJSON = {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     replacer: (k, value) => {
         if (Buffer.isBuffer(value) || value instanceof Uint8Array || value?.type === 'Buffer') {
             return { type: 'Buffer', data: Buffer.from(value?.data || value).toString('base64') }
         }
         return value
     },
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     reviver: (_, value) => {
-        if (typeof value === 'object' && !!value && (value.buffer === true || value.type === 'Buffer')) {
-            const val = value.data || value.value
-            return typeof val === 'string' ? Buffer.from(val, 'base64') : Buffer.from(val || [])
+        if (typeof value === 'object' && value !== null && value.type === 'Buffer' && typeof value.data === 'string') {
+            return Buffer.from(value.data, 'base64')
         }
+        
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            const keys = Object.keys(value)
+            
+            if (keys.length > 0 && keys.every(k => !isNaN(parseInt(k, 10)))) {
+                const values = Object.values(value)
+                
+                if (values.every(v => typeof v === 'number')) {
+                    return Buffer.from(values)
+                }
+            }
+        }
+        
         return value
     }
 }
 
-const getPlatformId = (browser) => {
-    const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()]
-    return platformType ? platformType.toString() : '1'
-}
-
-const getKeyAuthor = (key, meId = 'me') => {
-  return key?.fromMe ? meId : key?.participant || key?.remoteJid || ''
-}
+const getKeyAuthor = (key, meId = 'me') => (key?.fromMe ? meId : key?.participantAlt || key?.remoteJidAlt || key?.participant || key?.remoteJid) || ''
 
 const writeRandomPadMax16 = (msg) => {
     const pad = randomBytes(1)
@@ -230,9 +127,7 @@ const debouncedTimeout = (intervalMs = 1000, task) => {
     }
 }
 
-const delay = (ms) => {
-	return delayCancellable(ms).delay
-}
+const delay = (ms) => delayCancellable(ms).delay
 
 const delayCancellable = (ms) => {
     const stack = new Error().stack
@@ -295,7 +190,7 @@ const generateParticipantHashV2 = (participants) => {
     participants.sort()
     const sha256Hash = sha256(Buffer.from(participants.join(''))).toString('base64')
     return '2:' + sha256Hash.slice(0, 6)
-};
+}
 
 function bindWaitForEvent(ev, event) {
     return async (check, timeoutMs) => {
@@ -491,15 +386,22 @@ const getCallStatusFromNode = ({ tag, attrs }) => {
     return status
 }
 
+const UNEXPECTED_SERVER_CODE_TEXT = 'Unexpected server response: '
+
 const getCodeFromWSError = (error) => {
     let statusCode = 500
-    if (error?.message?.includes('Unexpected server response: ')) {
-        const code = +(error?.message.slice('Unexpected server response: '.length))
+    
+    if (error?.message?.includes(UNEXPECTED_SERVER_CODE_TEXT)) {
+        const code = +error?.message.slice(UNEXPECTED_SERVER_CODE_TEXT.length)
+        
         if (!Number.isNaN(code) && code >= 400) {
             statusCode = code
         }
     }
-    else if (error?.code?.startsWith('E') || error?.message?.includes('time out')) {
+    else if (
+    error?.code?.startsWith('E') ||
+        error?.message?.includes('timed out')) {
+        // handle ETIMEOUT, ENOTFOUND etc
         statusCode = 408
     }
     return statusCode
@@ -560,10 +462,8 @@ const asciiDecode = (...codes) => {
 }
 
 module.exports = {
-  Browsers, 
   Itsuki, 
   BufferJSON, 
-  getPlatformId, 
   getKeyAuthor, 
   writeRandomPadMax16, 
   unpadRandomMax16, 

package/lib/Utils/history.js

@@ -6,7 +6,6 @@ const { promisify } = require("util")
 const { inflate } = require("zlib")
 const { proto } = require("../../WAProto")
 const { WAMessageStubType } = require("../Types")
-const { isJidUser } = require("../WABinary")
 const { toNumber } = require("./generics")
 const { normalizeMessageContent } = require("./messages")
 const { downloadContentFromMessage } = require("./messages-media")
@@ -67,12 +66,7 @@ const processHistoryMessage = (item) => {
             break
         case proto.HistorySync.HistorySyncType.PUSH_NAME:
             for (const c of item.pushnames) {
-                contacts.push({ 
-                	id: c.id, 
-                    name: c.name || undefined, 
-                    lid: c.lidJid || undefined, 
-                    jid: isJidUser(c.id) ? c.id : undefined
-                }) 
+                contacts.push({ id: c.id, notify: c.pushname })
             }
             break
     }
@@ -86,7 +80,15 @@ const processHistoryMessage = (item) => {
 }
 
 const downloadAndProcessHistorySyncNotification = async (msg, options) => {
-    const historyMsg = await downloadHistory(msg, options)
+    let historyMsg
+    
+    if (msg.initialHistBootstrapInlinePayload) {
+        historyMsg = proto.HistorySync.decode(await inflatePromise(msg.initialHistBootstrapInlinePayload))
+    }
+    else {
+        historyMsg = await downloadHistory(msg, options)
+    }
+    
     return processHistoryMessage(historyMsg)
 }
 

package/lib/Utils/index.js

@@ -47,7 +47,7 @@ __exportStar(require("./history"), exports)
 __exportStar(require("./chat-utils"), exports)
 __exportStar(require("./lt-hash"), exports)
 __exportStar(require("./auth-utils"), exports)
-__exportStar(require("./baileys-event-stream"), exports)
+__exportStar(require("./browser-utils"), exports)
 __exportStar(require("./use-multi-file-auth-state"), exports)
 __exportStar(require("./link-preview"), exports)
 __exportStar(require("./event-buffer"), exports)

package/lib/Utils/link-preview.js

@@ -2,6 +2,7 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
+const { unfurl } = require('unfurl.js')
 const { prepareWAMessageMedia } = require("./messages")
 const {
   getHttpStream, 
@@ -22,38 +23,24 @@ const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) =>
  * @param text first matched URL in text
  * @returns the URL info required to generate link preview
  */
-const getUrlInfo = async (text, opts = { thumbnailWidth: THUMBNAIL_WIDTH_PX, fetchOpts: { timeout: 3000 }}) => {
+const getUrlInfo = async (text, opts = { thumbnailWidth: THUMBNAIL_WIDTH_PX, fetchOpts: { timeout: 3000 } }) => {
     try {
-        const retries = 0
-        const maxRetry = 5
-        const { getLinkPreview } = await Promise.resolve().then(() => __importStar(require('link-preview-js')))
         let previewLink = text
+        
         if (!text.startsWith('https://') && !text.startsWith('http://')) {
             previewLink = 'https://' + previewLink
         }
-        const info = await getLinkPreview(previewLink, {
+        
+        const { open_graph: info } = await unfurl(previewLink, {
             ...opts.fetchOpts,
-            followRedirects: 'follow',
-            handleRedirects: (baseURL, forwardedURL) => {
-                const urlObj = new URL(baseURL)
-                const forwardedURLObj = new URL(forwardedURL)
-                if (retries >= maxRetry) {
-                    return false
-                }
-                if (forwardedURLObj.hostname === urlObj.hostname
-                    || forwardedURLObj.hostname === 'www.' + urlObj.hostname
-                    || 'www.' + forwardedURLObj.hostname === urlObj.hostname) {
-                    retries + 1
-                    return true
-                }
-                else {
-                    return false
-                }
-            },
-            headers: opts.fetchOpts
-        })
+            oembed: false, 
+            compress: true, 
+            size: 0,
+            follow: 50
+        }) 
+        
         if (info && 'title' in info && info.title) {
-            const [image] = info.images
+            const image = info.images?.[0]?.url
             const urlInfo = {
                 'canonical-url': info.url,
                 'matched-text': text,
@@ -61,22 +48,20 @@ const getUrlInfo = async (text, opts = { thumbnailWidth: THUMBNAIL_WIDTH_PX, fet
                 description: info.description,
                 originalThumbnailUrl: image
             }
+            
             if (opts.uploadImage) {
-                const { imageMessage } = await messages_1.prepareWAMessageMedia({ image: { url: image } }, {
+                const { imageMessage } = await prepareWAMessageMedia({ image: { url: image } }, {
                     upload: opts.uploadImage,
                     mediaTypeOverride: 'thumbnail-link',
                     options: opts.fetchOpts
                 })
-                urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail
-                    ? Buffer.from(imageMessage.jpegThumbnail)
-                    : undefined
+                
+                urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined
                 urlInfo.highQualityThumbnail = imageMessage || undefined
             }
             else {
                 try {
-                    urlInfo.jpegThumbnail = image
-                        ? (await getCompressedJpegThumbnail(image, opts)).buffer
-                        : undefined
+                    urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined
                 }
                 catch (error) {
                     opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail')

package/lib/Utils/lt-hash.js

@@ -10,48 +10,54 @@ const { hkdf } = require("./crypto")
  * if the same series of mutations was made sequentially.
  */
 const o = 128
-class d {
+
+class LTHash {
     constructor(e) {
         this.salt = e
     }
-    add(e, t) {
-        var r = this
+    
+    async add(e, t) {
         for (const item of t) {
-            e = r._addSingle(e, item)
+            e = await this._addSingle(e, item)
         }
         return e
     }
-    subtract(e, t) {
-        var r = this
+    
+    async subtract(e, t) {
         for (const item of t) {
-            e = r._subtractSingle(e, item)
+            e = await this._subtractSingle(e, item)
         }
         return e
     }
-    subtractThenAdd(e, t, r) {
-        var n = this
-        return n.add(n.subtract(e, r), t)
+    
+    async subtractThenAdd(e, addList, subtractList) {
+        const subtracted = await this.subtract(e, subtractList)
+        return this.add(subtracted, addList)
     }
+    
     async _addSingle(e, t) {
-        var r = this
-        const n = new Uint8Array(await hkdf(Buffer.from(t), o, { info: r.salt })).buffer
-        return r.performPointwiseWithOverflow(await e, n, ((e, t) => e + t))
+        const derived = new Uint8Array(await hkdf(Buffer.from(t), o, { info: this.salt })).buffer
+        return this.performPointwiseWithOverflow(e, derived, (a, b) => a + b)
     }
+    
     async _subtractSingle(e, t) {
-        var r = this
-        const n = new Uint8Array(await hkdf(Buffer.from(t), o, { info: r.salt })).buffer
-        return r.performPointwiseWithOverflow(await e, n, ((e, t) => e - t))
+        const derived = new Uint8Array(await hkdf(Buffer.from(t), o, { info: this.salt })).buffer
+        return this.performPointwiseWithOverflow(e, derived, (a, b) => a - b)
     }
-    performPointwiseWithOverflow(e, t, r) {
-        const n = new DataView(e), i = new DataView(t), a = new ArrayBuffer(n.byteLength), s = new DataView(a)
-        for (let e = 0; e < n.byteLength; e += 2) {
-            s.setUint16(e, r(n.getUint16(e, !0), i.getUint16(e, !0)), !0)
+    
+    performPointwiseWithOverflow(e, t, op) {
+        const n = new DataView(e)
+        const i = new DataView(t)
+        const out = new ArrayBuffer(n.byteLength)
+        const s = new DataView(out)
+        for (let offset = 0; offset < n.byteLength; offset += 2) {
+            s.setUint16(offset, op(n.getUint16(offset, true), i.getUint16(offset, true)), true)
         }
-        return a
+        return out
     }
 }
 
-const LT_HASH_ANTI_TAMPERING = new d('WhatsApp Patch Integrity')
+const LT_HASH_ANTI_TAMPERING = new LTHash('WhatsApp Patch Integrity')
 
 module.exports = {
   LT_HASH_ANTI_TAMPERING

package/lib/Utils/make-mutex.js

@@ -2,43 +2,41 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
+const { Mutex: AsyncMutex } = require("async-mutex")
+
 const makeMutex = () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let task = Promise.resolve()
-    let taskTimeout
+    const mutex = new AsyncMutex()
     return {
         mutex(code) {
-            task = (async () => {
-                // wait for the previous task to complete
-                // if there is an error, we swallow so as to not block the queue
-                try {
-                    await task
-                }
-                catch (_a) { }
-                try {
-                    // execute the current task
-                    const result = await code()
-                    return result
-                }
-                finally {
-                    clearTimeout(taskTimeout)
-                }
-            })()
-            // we replace the existing task, appending the new piece of execution to it
-            // so the next task will have to wait for this one to finish
-            return task
-        },
+            return mutex.runExclusive(code)
+        }
     }
 }
 
 const makeKeyedMutex = () => {
-    const map = {}
+    const map = new Map()
     return {
-        mutex(key, task) {
-            if (!map[key]) {
-                map[key] = makeMutex()
+        async mutex(key, task) {
+            let entry = map.get(key)
+            
+            if (!entry) {
+                entry = { mutex: new AsyncMutex(), refCount: 0 }
+                map.set(key, entry)
+            }
+            
+            entry.refCount++
+            
+            try {
+                return await entry.mutex.runExclusive(task)
+            }
+            finally {
+                entry.refCount--
+                
+                // only delete it if this is still the current entry
+                if (entry.refCount === 0 && map.get(key) === entry) {
+                    map.delete(key)
+                }
             }
-            return map[key].mutex(task)
         }
     }
 }

package/lib/Utils/message-retry-manager.js

@@ -7,6 +7,8 @@ const { LRUCache } = require("lru-cache")
 /** Number of sent messages to cache in memory for handling retry receipts */
 const RECENT_MESSAGES_SIZE = 512
 
+const MESSAGE_KEY_SEPARATOR = '\u0000'
+
 /** Timeout for session recreation - 1 hour */
 const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000 // 1 hour in milliseconds
 
@@ -16,8 +18,18 @@ class MessageRetryManager {
     constructor(logger, maxMsgRetryCount) {
         this.logger = logger
         this.recentMessagesMap = new LRUCache({
-            max: RECENT_MESSAGES_SIZE
+            max: RECENT_MESSAGES_SIZE,
+            ttl: 5 * 60 * 1000,
+            ttlAutopurge: true,
+            dispose: (_value, key) => {
+                const separatorIndex = key.lastIndexOf(MESSAGE_KEY_SEPARATOR)
+                if (separatorIndex > -1) {
+                    const messageId = key.slice(separatorIndex + MESSAGE_KEY_SEPARATOR.length)
+                    this.messageKeyIndex.delete(messageId)
+                }
+            }
         })
+        this.messageKeyIndex = new Map()
         this.sessionRecreateHistory = new LRUCache({
             ttl: RECREATE_SESSION_TIMEOUT * 2,
             ttlAutopurge: true
@@ -39,27 +51,33 @@ class MessageRetryManager {
         }
         this.maxMsgRetryCount = maxMsgRetryCount
     }
+    
     /**
      * Add a recent message to the cache for retry handling
      */
     addRecentMessage(to, id, message) {
         const key = { to, id }
         const keyStr = this.keyToString(key)
+        
         // Add new message
         this.recentMessagesMap.set(keyStr, {
             message,
             timestamp: Date.now()
         })
+        this.messageKeyIndex.set(id, keyStr)
         this.logger.debug(`Added message to retry cache: ${to}/${id}`)
     }
+    
     /**
      * Get a recent message from the cache
      */
     getRecentMessage(to, id) {
         const key = { to, id }
         const keyStr = this.keyToString(key)
+        
         return this.recentMessagesMap.get(keyStr)
     }
+    
     /**
      * Check if a session should be recreated based on retry count and history
      */
@@ -73,16 +91,20 @@ class MessageRetryManager {
                 recreate: true
             }
         }
+        
         // Only consider recreation if retry count > 1
         if (retryCount < 2) {
             return { reason: '', recreate: false }
         }
+        
         const now = Date.now()
         const prevTime = this.sessionRecreateHistory.get(jid)
+        
         // If no previous recreation or it's been more than an hour
         if (!prevTime || now - prevTime > RECREATE_SESSION_TIMEOUT) {
             this.sessionRecreateHistory.set(jid, now)
             this.statistics.sessionRecreations++
+            
             return {
                 reason: 'retry count > 1 and over an hour since last recreation',
                 recreate: true
@@ -90,26 +112,31 @@ class MessageRetryManager {
         }
         return { reason: '', recreate: false }
     }
+    
     /**
      * Increment retry counter for a message
      */
     incrementRetryCount(messageId) {
         this.retryCounters.set(messageId, (this.retryCounters.get(messageId) || 0) + 1)
         this.statistics.totalRetries++
+        
         return this.retryCounters.get(messageId)
     }
+    
     /**
      * Get retry count for a message
      */
     getRetryCount(messageId) {
         return this.retryCounters.get(messageId) || 0
     }
+    
     /**
      * Check if message has exceeded maximum retry attempts
      */
     hasExceededMaxRetries(messageId) {
         return this.getRetryCount(messageId) >= this.maxMsgRetryCount
     }
+    
     /**
      * Mark retry as successful
      */
@@ -118,14 +145,19 @@ class MessageRetryManager {
         // Clean up retry counter for successful message
         this.retryCounters.delete(messageId)
         this.cancelPendingPhoneRequest(messageId)
+        this.removeRecentMessage(messageId)
     }
+    
     /**
      * Mark retry as failed
      */
     markRetryFailed(messageId) {
         this.statistics.failedRetries++
         this.retryCounters.delete(messageId)
+        this.cancelPendingPhoneRequest(messageId)
+        this.removeRecentMessage(messageId)
     }
+    
     /**
      * Schedule a phone request with delay
      */
@@ -134,24 +166,40 @@ class MessageRetryManager {
         this.cancelPendingPhoneRequest(messageId)
         this.pendingPhoneRequests[messageId] = setTimeout(() => {
             delete this.pendingPhoneRequests[messageId]
+            
             this.statistics.phoneRequests++
+            
             callback()
         }, delay)
-        this.logger.debug(`Scheduled phone request for message ${messageId} with ${delay}ms delay`)
+        this.logger.debug(`Scheduled phone request for message ${messageId} with ${delay}ms delay`);
     }
+    
     /**
      * Cancel pending phone request
      */
     cancelPendingPhoneRequest(messageId) {
         const timeout = this.pendingPhoneRequests[messageId]
+        
         if (timeout) {
             clearTimeout(timeout)
+            
             delete this.pendingPhoneRequests[messageId]
+            
             this.logger.debug(`Cancelled pending phone request for message ${messageId}`)
         }
     }
+    
     keyToString(key) {
-        return `${key.to}:${key.id}`
+        return `${key.to}${MESSAGE_KEY_SEPARATOR}${key.id}`
+    }
+    
+    removeRecentMessage(messageId) {
+        const keyStr = this.messageKeyIndex.get(messageId)
+        
+        if (!keyStr) return
+        
+        this.recentMessagesMap.delete(keyStr)
+        this.messageKeyIndex.delete(messageId)
     }
 }