@pontasockets/baileys 1.0.1 → 1.0.3

package/README.md

@@ -242,6 +242,27 @@ sock.sendMessage(jid, content, options?)
 
 #### Standard Messages
 
+<details>
+<summary><b>📦 Sticker Pack</b></summary>
+<br>
+
+```js
+sock.sendMessage(jid, {
+  stickerPack: {
+    name: 'Koleksi Ponta',
+    publisher: 'PontaCT',
+    description: 'Sticker pack pertama',
+    cover: { url: 'https://example.jpg' },
+    stickers: [
+      { sticker: { url: 'https://example.webp' }, emojis: ['😂'] },
+      { sticker: { url: 'https://example.webp' }, emojis: ['🔥'] }
+    ]
+  }
+})
+```
+
+</details>
+
 <details>
 <summary><b>📝 Text Message</b></summary>
 <br>

package/lib/Defaults/index.js

@@ -79,7 +79,7 @@ exports.DEFAULT_CONNECTION_CONFIG = {
     linkPreviewImageThumbnailWidth: 192,
     transactionOpts: { maxCommitRetries: 10, delayBetweenTriesMs: 3000 },
     generateHighQualityLinkPreview: false,
-    enableAutoSessionRecreation: false, 
+    enableAutoSessionRecreation: true, 
     enableRecentMessageCache: false, 
     options: {},
     appStateMacVerification: {

package/lib/Signal/libsignal.js

@@ -111,6 +111,24 @@ function makeLibSignalRepository(auth, onWhatsAppFunc, logger) {
         },
         jidToSignalProtocolAddress(jid) {
             return jidToSignalProtocolAddress(jid).toString();
+        },
+        // Dipakai oleh sendRetryRequest (messages-recv.js) untuk enableAutoSessionRecreation.
+        // Sebelumnya dipanggil tapi tidak pernah diimplementasikan di sini, jadi fitur auto
+        // session recreation diam-diam selalu gagal (ketangkep try/catch, cuma log warning).
+        async validateSession(jid) {
+            try {
+                const addr = jidToSignalProtocolAddress(jid);
+                const session = await storage.loadSession(addr.toString());
+                if (!session) {
+                    return { exists: false, reason: 'no session' };
+                }
+                if (typeof session.haveOpenSession === 'function' && !session.haveOpenSession()) {
+                    return { exists: false, reason: 'no open session' };
+                }
+                return { exists: true };
+            } catch (error) {
+                return { exists: false, reason: 'validation error' };
+            }
         }
     };
 }

package/lib/Socket/messages-recv.js

@@ -55,6 +55,13 @@ const makeMessagesRecvSocket = (config) => {
     } = sock
 
     const retryMutex = make_mutex_1.makeMutex()
+    // Mutex terpisah dari processingMutex (dipakai chats.js/messages-send.js) supaya
+    // handleMessage/handleReceipt/handleNotification tidak saling antre di satu antrean
+    // yang sama. Kalau satu pesan lambat diproses (nunggu plugin/group metadata), receipt
+    // & notification lain tetap bisa jalan tanpa nunggu giliran.
+    const messageMutex = make_mutex_1.makeMutex()
+    const receiptMutex = make_mutex_1.makeMutex()
+    const notificationMutex = make_mutex_1.makeMutex()
 
     const groupDataCache = new Map()
     global.groupMetadataCache = async (jid) => {
@@ -674,7 +681,17 @@ const makeMessagesRecvSocket = (config) => {
 
     const handleMexNotification = (id, node) => {
         const operation = node?.attrs?.op_name
-        const content = JSON.parse(node?.content)
+        let content
+        try {
+            content = JSON.parse(node?.content)
+        } catch (parseErr) {
+            logger.debug({ parseErr, node }, 'failed to parse mex notification content, skipping')
+            return
+        }
+        if (!content?.data) {
+            logger.debug({ operation, node }, 'mex notification missing content.data, skipping')
+            return
+        }
 
         let contentPath
         let action
@@ -716,6 +733,17 @@ const makeMessagesRecvSocket = (config) => {
                 contentPath = content.data[Types_1.XWAPaths.DEMOTE]
             }
 
+            // FIX: sebelumnya contentPath.actor.pn diakses langsung tanpa cek dulu.
+            // Kalau operation-nya bukan promote/demote yang beneran (WA ngirim tipe
+            // operasi MEX baru yang belum dikenal library ini), content.data[path]
+            // bisa undefined, dan ini crash dengan "Cannot read properties of
+            // undefined (reading 'actor')". Sekarang di-skip aja kalau gak lengkap,
+            // gak bikin seluruh proses notification gagal.
+            if (!contentPath || !contentPath.actor || !contentPath.user) {
+                logger.debug({ operation, node }, 'unhandled/incomplete mex notification, skipping')
+                return
+            }
+
             ev.emit('newsletter-participants.update', {
                 id,
                 author: contentPath.actor.pn,
@@ -1105,7 +1133,7 @@ const makeMessagesRecvSocket = (config) => {
 
         try {
             await Promise.all([
-                processingMutex.mutex(async () => {
+                receiptMutex.mutex(async () => {
                     const status = Utils_1.getStatusFromReceiptType(attrs.type)
 
                     if (typeof status !== 'undefined' && (
@@ -1195,7 +1223,7 @@ const makeMessagesRecvSocket = (config) => {
 
         try {
             await Promise.all([
-                processingMutex.mutex(async () => {
+                notificationMutex.mutex(async () => {
                     const msg = await processNotification(node)
 
                     if (msg) {
@@ -1241,7 +1269,13 @@ const makeMessagesRecvSocket = (config) => {
 
         if (WABinary_1.getBinaryNodeChild(node, 'unavailable') && !encNode) {
             await sendMessageAck(node)
-            const { key } = Utils_1.decodeMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '').fullMessage
+            let key
+            try {
+                key = Utils_1.decodeMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '').fullMessage.key
+            } catch (error) {
+                logger.error({ err: error, node }, 'failed to decode unavailable message node, skipping placeholder resend')
+                return
+            }
             response = await requestPlaceholderResend(key);
             if (response === 'RESOLVED') {
                 return
@@ -1253,12 +1287,30 @@ const makeMessagesRecvSocket = (config) => {
             }
         }
 
+        let decodeResult
+        try {
+            // decryptMessageNode bisa throw sebelum sempat masuk try/catch utama di bawah
+            // (contoh: bug upstream baileys "No participant in group message" pada node
+            // yang malformed/gak lengkap). Kalau gak ditangkep di sini, exception ini lolos
+            // sebagai unhandled rejection dari handleMessage - baik pas diproses langsung
+            // (live message) maupun lewat offline queue.
+            decodeResult = Utils_1.decryptMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '', signalRepository, logger)
+        } catch (error) {
+            logger.error({ err: error, node }, 'failed to decrypt/decode message node, dropping')
+            try {
+                await sendMessageAck(node, Utils_1.NACK_REASONS.ParsingError)
+            } catch (ackError) {
+                logger.error({ err: ackError }, 'failed to ack undecodable message node')
+            }
+            return
+        }
+
         const {
             fullMessage: msg,
             category,
             author,
             decrypt
-        } = Utils_1.decryptMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '', signalRepository, logger)
+        } = decodeResult
         if (response && msg?.messageStubParameters?.[0] === Utils_1.NO_MESSAGE_FOUND_ERROR_TEXT) {
             msg.messageStubParameters = [Utils_1.NO_MESSAGE_FOUND_ERROR_TEXT, response]
         }
@@ -1285,7 +1337,7 @@ const makeMessagesRecvSocket = (config) => {
 
         try {
             await Promise.all([
-                processingMutex.mutex(async () => {
+                messageMutex.mutex(async () => {
                     await decrypt()
                     if (msg.messageStubType === WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT) {
                         if (msg?.messageStubParameters?.[0] === Utils_1.MISSING_KEYS_ERROR_TEXT) {
@@ -1296,6 +1348,12 @@ const makeMessagesRecvSocket = (config) => {
                         const isPreKeyError = errorMessage.includes('PreKey')
                         logger.debug(`[handleMessage] Attempting retry request for failed decryption`)
 
+                        // .catch() wajib ada: call ini sengaja tidak di-await (biar retry
+                        // request gak ngeblok proses pesan lain), tapi kalau dibiarkan tanpa
+                        // .catch() dan mutex-nya reject, itu jadi unhandled promise rejection
+                        // yang bisa nge-crash seluruh proses Node (default Node behavior sejak
+                        // v15). Ini yang paling mungkin jadi penyebab bot "tiba-tiba disconnect
+                        // dan gak recover" setelah jalan beberapa jam.
                         retryMutex.mutex(async () => {
                             try {
                                 if (!ws.isOpen) {
@@ -1321,7 +1379,7 @@ const makeMessagesRecvSocket = (config) => {
                                         await Utils_1.delay(1000)
                                     } catch (uploadErr) {
                                         logger.error({
-                                            uploadErr
+                                            err: uploadErr
                                         }, 'Pre-key upload failed, proceeding with retry anyway')
                                     }
                                 }
@@ -1341,10 +1399,12 @@ const makeMessagesRecvSocket = (config) => {
                                     await sendRetryRequest(node, !encNode)
                                 } catch (retryErr) {
                                     logger.error({
-                                        retryErr
+                                        err: retryErr
                                     }, 'Failed to send retry after error handling')
                                 }
                             }
+                        }).catch((mutexErr) => {
+                            logger.error({ err: mutexErr }, 'retryMutex task failed unexpectedly')
                         })
                     } else {
                         let type = undefined
@@ -1490,9 +1550,17 @@ const makeMessagesRecvSocket = (config) => {
             ])
         } catch (error) {
             logger.error({
-                error,
+                err: error,
                 node
             }, 'error in handling message')
+            // Kalau exception terjadi sebelum sempat ack (misal error di plugin/group
+            // metadata sebelum baris sendMessageAck), stanza ini wajib tetap di-ack.
+            // Tanpa ini, server WA bisa terus retry/redeliver pesan yang sama berulang-ulang.
+            try {
+                await sendMessageAck(node, Utils_1.NACK_REASONS.UnhandledError)
+            } catch (ackError) {
+                logger.error({ err: ackError }, 'failed to ack message after error')
+            }
         }
     }
 
@@ -1697,19 +1765,36 @@ const makeMessagesRecvSocket = (config) => {
             isProcessing = true
 
             const promise = async () => {
-                while (nodes.length && ws.isOpen) {
-                    const {
-                        type,
-                        node
-                    } = nodes.shift()
-                    const nodeProcessor = nodeProcessorMap.get(type)
-                    if (!nodeProcessor) {
-                        onUnexpectedError(new Error(`unknown offline node type: ${type}`), 'processing offline node')
-                        continue
+                // PENTING: sebelumnya kalau nodeProcessor(node) throw (misal bug upstream
+                // baileys "No participant in group message" pas decrypt node offline yang
+                // malformed), exception itu keluar dari while-loop ini SEBELUM sempat
+                // `isProcessing = false`. Akibatnya isProcessing kepentok true SELAMANYA,
+                // dan enqueue() di bawah selalu langsung `return` tanpa pernah mulai
+                // proses lagi -> semua pesan sesudahnya cuma numpuk di array `nodes` dan
+                // gak pernah diproses lagi sampai bot di-restart total. Ini kemungkinan
+                // besar penyebab "reconnect tapi gak pernah nerima pesan lagi".
+                try {
+                    while (nodes.length && ws.isOpen) {
+                        const {
+                            type,
+                            node
+                        } = nodes.shift()
+                        const nodeProcessor = nodeProcessorMap.get(type)
+                        if (!nodeProcessor) {
+                            onUnexpectedError(new Error(`unknown offline node type: ${type}`), 'processing offline node')
+                            continue
+                        }
+                        try {
+                            await nodeProcessor(node)
+                        } catch (error) {
+                            // Satu node gagal (misal pesan corrupt/participant kosong) TIDAK
+                            // boleh ngeblok node-node lain di belakangnya dalam antrian.
+                            onUnexpectedError(error, 'processing offline node')
+                        }
                     }
-                    await nodeProcessor(node)
+                } finally {
+                    isProcessing = false
                 }
-                isProcessing = false
             }
             promise().catch(error => onUnexpectedError(error, 'processing offline nodes'))
         }
@@ -1721,28 +1806,31 @@ const makeMessagesRecvSocket = (config) => {
 
     const offlineNodeProcessor = makeOfflineNodeProcessor()
 
-    const processNode = (type, node, identifier, exec) => {
+    const processNode = async (type, node, identifier, exec) => {
         const isOffline = !!node.attrs.offline
 
         if (isOffline) {
             offlineNodeProcessor.enqueue(type, node)
         } else {
-            processNodeWithBuffer(node, identifier, exec)
+            await processNodeWithBuffer(node, identifier, exec)
         }
     }
 
     // recv a message
-    ws.on('CB:message', (node) => {
-        processNode('message', node, 'processing message', handleMessage)
+    // Semua handler di-await supaya event 'CB:message'/'CB:call'/'CB:receipt'/'CB:notification'
+    // yang datang beruntun tidak diproses bersamaan tanpa urutan (race condition di state
+    // bersama seperti session & cache).
+    ws.on('CB:message', async (node) => {
+        await processNode('message', node, 'processing message', handleMessage)
     })
     ws.on('CB:call', async (node) => {
-        processNode('call', node, 'handling call', handleCall)
+        await processNode('call', node, 'handling call', handleCall)
     })
-    ws.on('CB:receipt', node => {
-        processNode('receipt', node, 'handling receipt', handleReceipt)
+    ws.on('CB:receipt', async (node) => {
+        await processNode('receipt', node, 'handling receipt', handleReceipt)
     })
     ws.on('CB:notification', async (node) => {
-        processNode('notification', node, 'handling notification', handleNotification)
+        await processNode('notification', node, 'handling notification', handleNotification)
     })
     ws.on('CB:ack,class:message', (node) => {
         handleBadAck(node)

package/lib/Socket/messages-send.js

@@ -826,7 +826,7 @@ const makeMessagesSocket = (config) => {
                 }
             }
 
-            if (!ai && isPrivate) {
+            if (ai && isPrivate) {
                 const botNode = {
                     tag: 'bot',
                     attrs: {

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

@@ -23,13 +23,19 @@ const fileLocks = new Map()
 const getFileLock = (path) => {
 	let mutex = fileLocks.get(path)
 	if (!mutex) {
-		mutex = new async_mutex_1.Mutex() 
+		mutex = new async_mutex_1.Mutex()
 		fileLocks.set(path, mutex)
 	}
 
 	return mutex
 }
 
+// Lepas mutex dari Map begitu tidak dipakai lagi supaya tidak numpuk terus (memory leak)
+// selama proses hidup lama (bot jalan berbulan-bulan dengan ribuan file sesi berbeda).
+const releaseFileLock = (path) => {
+	fileLocks.delete(path)
+}
+
 /**
  * stores the full authentication state in a single folder.
  * Far more efficient than singlefileauthstate
@@ -38,51 +44,56 @@ const getFileLock = (path) => {
  * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
  * */
 const useMultiFileAuthState = async (folder) => {
-    // Debounce timers per file to avoid rapid successive writes hammering disk
-    const writeDebounceTimers = new Map()
-    const WRITE_DEBOUNCE_MS = 300
-
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const writeData = async (data, file) => {
         const filePath = path_1.join(folder, fixFileName(file))
         const mutex = getFileLock(filePath)
         return mutex.acquire().then(async (release) => {
             try {
-                // Atomic write: write to temp file then rename to prevent corruption
+                // Atomic write: write to temp file then rename, agar file tidak pernah
+                // kebaca dalam kondisi setengah tertulis kalau proses mati di tengah jalan.
                 const tmpPath = filePath + '.tmp'
                 await promises_1.writeFile(tmpPath, JSON.stringify(data, generics_1.BufferJSON.replacer))
                 await fsRename(tmpPath, filePath)
             } finally {
                 release()
+                releaseFileLock(filePath)
             }
         })
     }
     const readData = async (file) => {
+        const filePath = path_1.join(folder, fixFileName(file))
         try {
-            const filePath = path_1.join(folder, fixFileName(file))
             const mutex = getFileLock(filePath)
             const data = await mutex.acquire().then(async (release) => {
                 try {
                     return await promises_1.readFile(filePath, { encoding: 'utf-8' })
                 } finally {
                     release()
+                    releaseFileLock(filePath)
                 }
             })
 
             return JSON.parse(data, generics_1.BufferJSON.reviver)
         } catch (error) {
+            // ENOENT (file belum ada) itu normal, tapi kalau isinya rusak/corrupt (JSON parse
+            // gagal) itu wajib kelihatan di log, bukan diam-diam dianggap "null"/hilang.
+            if (error?.code !== 'ENOENT') {
+                console.warn(`[useMultiFileAuthState] Gagal membaca/parse ${filePath}:`, error?.message || error)
+            }
             return null
         }
     }
     const removeData = async (file) => {
+        const filePath = path_1.join(folder, fixFileName(file))
         try {
-            const filePath = path_1.join(folder, fixFileName(file))
             const mutex = getFileLock(filePath)
             await mutex.acquire().then(async (release) => {
                try {
                     await promises_1.unlink(filePath)
                 } finally {
                     release()
+                    releaseFileLock(filePath)
                 }
             })
         } catch {}
@@ -96,9 +107,22 @@ const useMultiFileAuthState = async (folder) => {
     else {
         await promises_1.mkdir(folder, { recursive: true })
     }
-    const fixFileName = (file) => { 
-        return file?.replace(/\//g, '__')?.replace(/:/g, '-') 
+    const fixFileName = (file) => {
+        return file?.replace(/\//g, '__')?.replace(/:/g, '-')
     }
+
+    // Bersihkan file .tmp "yatim" yang tertinggal dari proses sebelumnya yang mati
+    // di tengah proses rename (atomic write). File-file ini tidak berguna dan kalau
+    // dibiarkan menumpuk, cuma buang-buang disk.
+    try {
+        const entries = await promises_1.readdir(folder)
+        await Promise.all(
+            entries
+                .filter((name) => name.endsWith('.tmp'))
+                .map((name) => promises_1.unlink(path_1.join(folder, name)).catch(() => {}))
+        )
+    } catch {}
+
     const creds = await readData('creds.json') || auth_utils_1.initAuthCreds()
     return {
         state: {
@@ -128,24 +152,15 @@ const useMultiFileAuthState = async (folder) => {
                 }
             }
         },
-        // saveCreds debounced by default — aman dipanggil tiap creds.update
-        // tanpa spam disk. Untuk force immediate write, pakai saveCredsNow.
-        saveCreds: () => {
-            const existing = writeDebounceTimers.get('creds.json')
-            if (existing) clearTimeout(existing)
-            const timer = setTimeout(() => {
-                writeDebounceTimers.delete('creds.json')
-                writeData(creds, 'creds.json').catch(err => {
-                    console.error('[useMultiFileAuthState] Failed to save creds.json:', err)
-                })
-            }, WRITE_DEBOUNCE_MS)
-            writeDebounceTimers.set('creds.json', timer)
+        // saveCreds sekarang selalu langsung menulis (tidak didebounce). creds.json adalah
+        // file paling kritis — kalau proses mati tepat di jendela debounce, sesi bisa hilang
+        // atau balik ke state lama sehingga semua pesan gagal didekripsi setelah reconnect.
+        saveCreds: async () => {
+            return writeData(creds, 'creds.json')
         },
-        // Force immediate write — pakai saat disconnect/cleanup agar creds tidak hilang
+        // Tetap disediakan sebagai alias untuk kompatibilitas kode lama yang memanggil
+        // saveCredsNow() secara eksplisit (misal di handler disconnect/cleanup).
         saveCredsNow: async () => {
-            const existing = writeDebounceTimers.get('creds.json')
-            if (existing) clearTimeout(existing)
-            writeDebounceTimers.delete('creds.json')
             return writeData(creds, 'creds.json')
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pontasockets/baileys",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Baileys is a lightweight JavaScript library for interacting with the WhatsApp Web API using WebSocket.",
   "keywords": [
     "facebook",