@pontalabs/baileys 1.0.1 → 1.0.3

package/lib/Signal/libsignal.js

@@ -43,7 +43,7 @@ const sender_key_record_1 = require("./Group/sender-key-record");
 const Group_1 = require("./Group");
 const LIDMappingStore_1 = require("./lid-mapping") 
 
-// FIX: sebelumnya pontasockets gak punya deteksi perubahan identity key sama
+// FIX: sebelumnya pontalabs gak punya deteksi perubahan identity key sama
 // sekali. Kalau identity kontak berubah (kontak install ulang WA, atau kena
 // resync multi-device pas ada linked device lain online), sesi lama tetap
 // dipakai terus dan selalu gagal decrypt "Bad MAC" berulang-ulang sampai

package/lib/Socket/messages-send.js

@@ -1,5 +1,5 @@
 "use strict"
-// 18 7 2026
+
 var __importDefault = (this && this.__importDefault) || function(mod) {
     return (mod && mod.__esModule) ? mod : {
         "default": mod
@@ -59,6 +59,7 @@ const makeMessagesSocket = (config) => {
 
     const messageRetryManager = enableRecentMessageCache ? new Utils_1.MessageRetryManager(logger, maxMsgRetryCount) : null
     const encryptionMutex = make_keyed_mutex_1.makeKeyedMutex()
+    const devicesMutex = make_keyed_mutex_1.makeMutex()
     let mediaConn
 
     const refreshMediaConn = async (forceGet = false) => {
@@ -295,6 +296,24 @@ const makeMessagesSocket = (config) => {
 
         const result = await executeUSyncQuery(query)
         if (result) {
+            // FIX: pontalabs sebelumnya gak pernah nyimpen mapping LID<->PN
+            // dari hasil USync device query ini (nuiisweety nyimpen + langsung
+            // force-refresh session buat LID yang baru ketemu). Tanpa ini,
+            // pengiriman ke kontak yang butuh LID addressing bisa tetep pakai
+            // address PN yang salah/basi -> penerima gak bisa decrypt balasan
+            // bot ("Menunggu pesan ini...").
+            const lidResults = (result.list || []).filter(item => !!item.lid)
+            if (lidResults.length > 0) {
+                try {
+                    await signalRepository.lidMapping.storeLIDPNMappings(
+                        lidResults.map(item => ({ lid: item.lid, pn: item.id }))
+                    )
+                    const lids = lidResults.map(item => item.lid)
+                    await assertSessions(lids, true)
+                } catch (error) {
+                    logger.warn({ error, count: lidResults.length }, 'failed to store/refresh LID mappings from device sync')
+                }
+            }
             const extracted = Utils_1.extractDeviceJids(result?.list, authState.creds.me.id, ignoreZeroDevices)
             const deviceMap = {}
             for (const item of extracted) {
@@ -318,16 +337,18 @@ const makeMessagesSocket = (config) => {
                 }
             }
 
-            if (userDevicesCache.mset) {
-                await userDevicesCache.mset(Object.entries(deviceMap).map(([key, value]) => ({
-                    key,
-                    value
-                })))
-            } else {
-                for (const key in deviceMap) {
-                    if (deviceMap[key]) await userDevicesCache.set(key, deviceMap[key])
+            await devicesMutex.mutex(async () => {
+                if (userDevicesCache.mset) {
+                    await userDevicesCache.mset(Object.entries(deviceMap).map(([key, value]) => ({
+                        key,
+                        value
+                    })))
+                } else {
+                    for (const key in deviceMap) {
+                        if (deviceMap[key]) await userDevicesCache.set(key, deviceMap[key])
+                    }
                 }
-            }
+            })
         }
         return deviceResults
     }
@@ -339,11 +360,17 @@ const makeMessagesSocket = (config) => {
         if (force) {
             jidsRequiringFetch = jids;
         } else {
-            const addrs = jids.map(jid => (signalRepository.jidToSignalProtocolAddress(jid)));
-            const sessions = await authState.keys.get('session', addrs);
+            // FIX: sebelumnya cuma ngecek "ada record tersimpan atau enggak"
+            // (truthy check di authState.keys.get('session', ...)). Record
+            // yang kosong/stale/rusak (misal device grup yang session-nya
+            // kebentuk tapi gak pernah kepakai/keisi ratchet) tetep truthy,
+            // jadi dianggap "udah punya sesi" padahal libsignal-nya beneran
+            // kosong -> pas encrypt muncul "SessionError: No sessions".
+            // validateSession ngecek session-nya beneran ada & "open" enggak,
+            // bukan cuma record-nya ada.
             for (const jid of jids) {
-                const signalId = signalRepository.jidToSignalProtocolAddress(jid);
-                if (!sessions[signalId]) {
+                const sessionValidation = await signalRepository.validateSession(jid);
+                if (!sessionValidation.exists) {
                     jidsRequiringFetch.push(jid);
                 }
             }
@@ -1135,6 +1162,14 @@ const makeMessagesSocket = (config) => {
             return message
         },
         sendStatusMentions: async (content, jids = []) => {
+            const MAX_STATUS_MENTIONS = 5
+            if (jids.length > MAX_STATUS_MENTIONS) {
+                logger.warn(
+                    { requested: jids.length, max: MAX_STATUS_MENTIONS },
+                    `sendStatusMentions: max ${MAX_STATUS_MENTIONS} mentions per status, truncating`
+                )
+                jids = jids.slice(0, MAX_STATUS_MENTIONS)
+            }
             const userJid = WABinary_1.jidNormalizedUser(authState.creds.me.id)
             let allUsers = new Set()
             allUsers.add(userJid)

package/lib/Utils/auth-utils.js

@@ -81,92 +81,96 @@ function makeCacheableSignalKeyStore(store, logger, _cache) {
     }
 }
 
-// Module-level specialized mutexes for pre-key operations
-const preKeyMutex = new mutex_1.Mutex()
-const signedPreKeyMutex = new mutex_1.Mutex()
-
-/**
- * Get the appropriate mutex for the key type
- */
-const getPreKeyMutex = (keyType) => {
-    return keyType === 'signed-pre-key' ? signedPreKeyMutex : preKeyMutex
-}
-
 /**
- * Handles pre-key operations with mutex protection
+ * Handles pre-key operations.
+ *
+ * IMPORTANT: locking for this function is provided by the CALLER via the
+ * session-scoped `getKeyTypeMutex(keyType)` mutex (the same one used by
+ * get()/set() for that key type). We intentionally do NOT acquire our own
+ * mutex here anymore.
+ *
+ * Previously this used module-level singleton mutexes (`preKeyMutex`,
+ * `signedPreKeyMutex`) declared OUTSIDE `addTransactionCapability`. Because
+ * those were created once per process (not once per auth state / socket),
+ * every session running in the same Node process shared the exact same
+ * lock. That caused two problems:
+ *   1. Unrelated sessions serialized on each other's pre-key writes
+ *      (needless contention/latency when running multiple accounts).
+ *   2. The lock domain didn't match the one used by get()/withMutexes()
+ *      (`getKeyTypeMutex`), so reads/writes and deletion-validation could
+ *      interleave without real mutual exclusion (TOCTOU race on the
+ *      "does this key still exist" check), which is what let pre-key /
+ *      signed-pre-key state get corrupted under concurrent access.
  */
 async function handlePreKeyOperations(data, keyType, transactionCache, mutations, logger, isInTransaction, state) {
-    const mutex = getPreKeyMutex(keyType)
-    await mutex.runExclusive(async () => {
-        const keyData = data[keyType]
-        if (!keyData)
-            return
-            
-        // Ensure structures exist
-        transactionCache[keyType] = transactionCache[keyType] || {}
-        mutations[keyType] = mutations[keyType] || {}
-        
-        // Separate deletions from updates for batch processing
-        const deletionKeys = []
-        const updateKeys = []
-        
-        for (const keyId in keyData) {
-            if (keyData[keyId] === null) {
-                deletionKeys.push(keyId)
-            }
-            else {
-                updateKeys.push(keyId)
-            }
+    const keyData = data[keyType]
+    if (!keyData)
+        return
+
+    // Ensure structures exist
+    transactionCache[keyType] = transactionCache[keyType] || {}
+    mutations[keyType] = mutations[keyType] || {}
+
+    // Separate deletions from updates for batch processing
+    const deletionKeys = []
+    const updateKeys = []
+
+    for (const keyId in keyData) {
+        if (keyData[keyId] === null) {
+            deletionKeys.push(keyId)
         }
-        
-        // Process updates first (no validation needed)
-        for (const keyId of updateKeys) {
-            if (transactionCache[keyType]) {
-                transactionCache[keyType][keyId] = keyData[keyId]
-            }
-            if (mutations[keyType]) {
-                mutations[keyType][keyId] = keyData[keyId]
-            }
+        else {
+            updateKeys.push(keyId)
         }
-        
-        // Process deletions with validation
-        if (deletionKeys.length === 0)
-            return
-            
-        if (isInTransaction) {
-            // In transaction, only allow deletion if key exists in cache
-            for (const keyId of deletionKeys) {
-                if (transactionCache[keyType]) {
-                    transactionCache[keyType][keyId] = null
-                    if (mutations[keyType]) {
-                        // Mark for deletion in mutations
-                        mutations[keyType][keyId] = null
-                    }
-                }
-                else {
-                    logger.warn(`Skipping deletion of non-existent ${keyType} in transaction: ${keyId}`)
-                }
-            }
-            return
+    }
+
+    // Process updates first (no validation needed)
+    for (const keyId of updateKeys) {
+        if (transactionCache[keyType]) {
+            transactionCache[keyType][keyId] = keyData[keyId]
         }
-        
-        // Outside transaction, batch validate all deletions
-        if (!state)
-            return
-            
-        const existingKeys = await state.get(keyType, deletionKeys)
+        if (mutations[keyType]) {
+            mutations[keyType][keyId] = keyData[keyId]
+        }
+    }
+
+    // Process deletions with validation
+    if (deletionKeys.length === 0)
+        return
+
+    if (isInTransaction) {
+        // In transaction, only allow deletion if key exists in cache
         for (const keyId of deletionKeys) {
-            if (existingKeys[keyId]) {
-                if (transactionCache[keyType])
-                    transactionCache[keyType][keyId] = null
-                if (mutations[keyType])
+            if (transactionCache[keyType]) {
+                transactionCache[keyType][keyId] = null
+                if (mutations[keyType]) {
+                    // Mark for deletion in mutations
                     mutations[keyType][keyId] = null
+                }
             }
             else {
-                logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`)
+                logger.warn(`Skipping deletion of non-existent ${keyType} in transaction: ${keyId}`)
             }
         }
-    })
+        return
+    }
+
+    // Outside transaction, batch validate all deletions
+    if (!state)
+        return
+
+    const existingKeys = await state.get(keyType, deletionKeys)
+    for (const keyId of deletionKeys) {
+        if (existingKeys[keyId]) {
+            if (transactionCache[keyType])
+                transactionCache[keyType][keyId] = null
+            if (mutations[keyType])
+                mutations[keyType][keyId] = null
+        }
+        else {
+            logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`)
+        }
+    }
 }
 
 /**
@@ -179,27 +183,34 @@ function handleNormalKeyOperations(data, key, transactionCache, mutations) {
 }
 
 /**
- * Process pre-key deletions with validation
+ * Process pre-key / signed-pre-key deletions with validation.
+ *
+ * NOTE: this is only ever called from inside a `withMutexes([..., keyType, ...])`
+ * block in `set()` below, which already holds the session-scoped
+ * `getKeyTypeMutex(keyType)` lock for the duration of the call. It must NOT
+ * acquire its own mutex here - `async-mutex`'s Mutex is not reentrant, so
+ * doing so would either deadlock (if it tried to re-acquire the same lock)
+ * or - as in the previous version - silently acquire a *different*, global
+ * lock that gave no real protection at all.
  */
 async function processPreKeyDeletions(data, keyType, state, logger) {
-    const mutex = getPreKeyMutex(keyType)
-    await mutex.runExclusive(async () => {
-        const keyData = data[keyType]
-        if (!keyData)
-            return
-            
-        // Validate deletions
-        for (const keyId in keyData) {
-            if (keyData[keyId] === null) {
-                const existingKeys = await state.get(keyType, [keyId])
-                if (!existingKeys[keyId]) {
-                    logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`)
-                    if (data[keyType])
-                        delete data[keyType][keyId]
-                }
-            }
+    const keyData = data[keyType]
+    if (!keyData)
+        return
+
+    // Validate deletions
+    const deletionIds = Object.keys(keyData).filter(id => keyData[id] === null)
+    if (deletionIds.length === 0)
+        return
+
+    const existingKeys = await state.get(keyType, deletionIds)
+    for (const keyId of deletionIds) {
+        if (!existingKeys[keyId]) {
+            logger.warn(`Skipping deletion of non-existent ${keyType}: ${keyId}`)
+            if (data[keyType])
+                delete data[keyType][keyId]
         }
-    })
+    }
 }
 
 /**
@@ -403,9 +414,13 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
                 for (const key_ in data) {
                     const key = key_
                     transactionCache[key] = transactionCache[key] || {}
-                    // Special handling for pre-keys and signed-pre-keys
+                    // Special handling for pre-keys and signed-pre-keys.
+                    // Locked via the session-scoped getKeyTypeMutex(key) so this can't
+                    // interleave with a concurrent non-transactional get()/set() for the
+                    // same key type on this SAME auth state - no cross-session locking,
+                    // no lock-domain mismatch.
                     if (key === 'pre-key' || key === 'signed-pre-key') {
-                        await handlePreKeyOperations(data, key, transactionCache, mutations, logger, true)
+                        await getKeyTypeMutex(key).runExclusive(() => handlePreKeyOperations(data, key, transactionCache, mutations, logger, true))
                     }
                     else {
                         // Normal handling for other key types
@@ -442,7 +457,7 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
                             // Process pre-keys and signed-pre-keys separately with specialized mutexes
                             for (const key_ in nonSenderKeyData) {
                                 const keyType = key_
-                                if (keyType === 'pre-key') {
+                                if (keyType === 'pre-key' || keyType === 'signed-pre-key') {
                                     await processPreKeyDeletions(nonSenderKeyData, keyType, state, logger)
                                 }
                             }
@@ -457,7 +472,7 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
                         // Process pre-keys and signed-pre-keys separately with specialized mutexes
                         for (const key_ in data) {
                             const keyType = key_
-                            if (keyType === 'pre-key') {
+                            if (keyType === 'pre-key' || keyType === 'signed-pre-key') {
                                 await processPreKeyDeletions(data, keyType, state, logger)
                             }
                         }

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

@@ -165,7 +165,7 @@ const getDecryptionJid = async (sender, repository) => {
     if (!mapped) {
         return sender
     }
-    // FIX: pontasockets gak punya migrateSession (beda dari levvleys) yang
+    // FIX: pontalabs gak punya migrateSession (beda dari levvleys) yang
     // mindahin sesi Signal dari address PN ke address LID begitu mapping
     // disimpan. Jadi mapping doang gak jamin ada sesi beneran di address LID
     // itu -- kalau dipaksa pakai, decrypt gagal "No session record" walau
@@ -184,7 +184,7 @@ const getDecryptionJid = async (sender, repository) => {
     return sender
 }
 
-// FIX: pontasockets sebelumnya gak pernah menyimpan mapping LID<->PN saat pesan
+// FIX: pontalabs sebelumnya gak pernah menyimpan mapping LID<->PN saat pesan
 // masuk (levvleys punya storeMappingFromEnvelope, di sini gak ada). Akibatnya
 // untuk kontak yang pakai addressing LID, getDecryptionJid bisa gagal nemuin
 // sesi yang benar secara intermiten (tergantung cache mapping ada atau belum),

package/lib/Utils/rich-message-utils.js

@@ -2,7 +2,7 @@
 
 /**
  * rich-message-utils.js
- * @pontasockets-baileys
+ * @pontalabs-baileys
  * Tambahkan file ini ke: node_modules/@whiskeysockets/baileys/lib/Utils/rich-message-utils.js
  */
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pontalabs/baileys",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "PontaLabs Baileys is a lightweight, modern, and customizable WhatsApp Web API library built on Baileys.",
   "keywords": [
     "facebook",
@@ -17,7 +17,7 @@
     "url": "git+ssh://git@github.com/pontalabs/baileys.git"
   },
   "license": "MIT",
-  "author": "PontaLabs",
+  "author": "Pontalabs",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -25,12 +25,14 @@
     "WAProto/**/*"
   ],
   "scripts": {
-    "test": "jest"
+    "test": "jest",
+    "format": "prettier --write \"src/**/*.{ts,js,json,md}\"",
+    "lint": "tsc && eslint src --ext .js,.ts",
+    "lint:fix": "npm run format && npm run lint -- --fix"
   },
   "dependencies": {
     "@adiwajshing/keyed-db": "^0.2.4",
     "@cacheable/node-cache": "1.5.3",
-    "@pontasockets/eslint-config": "^1.0.0",
     "libsignal": "^6.0.0",
     "@hapi/boom": "^9.1.3",
     "async-mutex": "^0.5.0",
@@ -48,16 +50,24 @@
     "ws": "^8.13.0"
   },
   "devDependencies": {
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.31.0",
     "@types/jest": "^29.5.14",
     "@types/node": "^16.0.0",
     "@types/ws": "^8.0.0",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "@whiskeysockets/eslint-config": "^1.0.0",
     "conventional-changelog-cli": "^2.2.2",
-    "eslint": "^8.0.0",
+    "eslint": "^9",
+    "eslint-config-prettier": "^10.1.2",
+    "eslint-plugin-prettier": "^5.4.0",
     "jest": "^30.1.1",
     "jimp": "^1.6.1",
     "json": "^11.0.0",
     "link-preview-js": "^3.0.5",
     "open": "^8.4.2",
+    "prettier": "^3.5.3",
     "release-it": "^15.10.3",
     "ts-jest": "^29.4.1",
     "ts-node": "^10.8.1",