@nexustechpro/baileys 2.1.3 → 2.1.6

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

@@ -2,17 +2,30 @@ import { Mutex } from 'async-mutex'
 import { mkdir, readFile, rename, stat, unlink, writeFile, readdir } from 'fs/promises'
 import { join } from 'path'
 import { createHash } from 'crypto'
+import { Keyv } from 'keyv'
 import { proto } from '../../WAProto/index.js'
 import { initAuthCreds } from './auth-utils.js'
 import { BufferJSON } from './generics.js'
+import { PROTOCOL_ADAPTERS } from '../WABinary/index.js'
 
-// ─── Constants ────────────────────────────────────────────────────────────────
 const CURRENT_VERSION = 1
 const DEFAULT_PREKEY_RETENTION = 150
 const DEFAULT_CLEANUP_THRESHOLD = 50
 const CLEANUP_INTERVAL_MS = 10 * 60 * 1000
 
-// ─── File Lock Registry ───────────────────────────────────────────────────────
+const bootstrapCreds = (raw) => {
+    const c = raw ?? initAuthCreds()
+    if (!c.__version || c.__version < CURRENT_VERSION) c.__version = CURRENT_VERSION
+    return c
+}
+
+const patchAppStateKey = (type, v) =>
+    type === 'app-state-sync-key' && v ? proto.Message.AppStateSyncKeyData.fromObject(v) : v
+
+const computeChecksum = (data) => createHash('sha256').update(data).digest('hex')
+
+// ─── File-based auth state ────────────────────────────────────────────────────
+
 const fileLocks = new Map()
 const getFileLock = (path) => {
     if (!fileLocks.has(path)) fileLocks.set(path, new Mutex())
@@ -22,31 +35,13 @@ const releaseFileLock = (path) => {
     if (fileLocks.has(path) && !fileLocks.get(path).isLocked()) fileLocks.delete(path)
 }
 
-// ─── Checksum ─────────────────────────────────────────────────────────────────
-const computeChecksum = (data) => createHash('sha256').update(data).digest('hex')
-
-/**
- * Production-grade multi-file auth state for Baileys.
- * Atomic writes, checksum integrity, and smart prekey cleanup.
- * Compatible with standard Baileys auth folder format.
- *
- * @param {string} folder - Directory to store auth files
- * @param {object} [options] - Configuration options
- * @param {number} [options.preKeyRetention=150] - How many recent prekeys to keep
- * @param {number} [options.cleanupThreshold=50] - How many new prekeys trigger a cleanup
- * @param {object} [options.logger] - Optional logger with .info/.warn methods
- */
 export const useMultiFileAuthState = async (folder, options = {}) => {
-    const {
-        preKeyRetention = DEFAULT_PREKEY_RETENTION,
-        cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD,
-        logger,
-    } = options
+    const { preKeyRetention = DEFAULT_PREKEY_RETENTION, cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD, logger } = options
+
     const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-')
     const filePath = (file) => join(folder, fixFileName(file))
     const tmpPath = (file) => filePath(file) + '.tmp'
 
-    // ─── Folder Bootstrap ───────────────────────────────────────────────────────
     const folderInfo = await stat(folder).catch(() => null)
     if (folderInfo) {
         if (!folderInfo.isDirectory()) throw new Error(`Path exists but is not a directory: ${folder}`)
@@ -54,16 +49,13 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
         await mkdir(folder, { recursive: true })
     }
 
-    // ─── Atomic Write ────────────────────────────────────────────────────────────
     const writeData = async (data, file) => {
         const fp = filePath(file)
         const tp = tmpPath(file)
-        const mutex = getFileLock(fp)
-        const release = await mutex.acquire()
+        const release = await getFileLock(fp).acquire()
         try {
             const serialized = JSON.stringify(data, BufferJSON.replacer)
-            const checksum = computeChecksum(serialized)
-            const payload = JSON.stringify({ data: JSON.parse(serialized), __checksum: checksum })
+            const payload = JSON.stringify({ data: JSON.parse(serialized), __checksum: computeChecksum(serialized) })
             await writeFile(tp, payload)
             try {
                 await rename(tp, fp)
@@ -77,11 +69,9 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
         }
     }
 
-    // ─── Read with Checksum Verification ─────────────────────────────────────────
     const readData = async (file) => {
         const fp = filePath(file)
-        const mutex = getFileLock(fp)
-        const release = await mutex.acquire()
+        const release = await getFileLock(fp).acquire()
         try {
             const raw = await readFile(fp, { encoding: 'utf-8' }).catch(() => null)
             if (!raw) return null
@@ -92,28 +82,26 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
                     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 — 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(() => { })
+                await writeFile(fp, JSON.stringify({ data: JSON.parse(reserialized), __checksum: computeChecksum(reserialized) })).catch(() => { })
                 return JSON.parse(raw, BufferJSON.reviver)
             } catch (err) {
                 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 ────────────────────────────────────────────────────────────
     const removeData = async (file) => {
         const fp = filePath(file)
-        const mutex = getFileLock(fp)
-        const release = await mutex.acquire()
+        const release = await getFileLock(fp).acquire()
         try {
             await unlink(fp).catch(() => { })
         } finally {
@@ -122,34 +110,23 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
         }
     }
 
-    // ─── Credentials Bootstrap ──────────────────────────────────────────────────
-    let creds = (await readData('creds.json')) || initAuthCreds()
-    if (!creds.__version) {
-        creds.__version = CURRENT_VERSION
-    } else if (creds.__version < CURRENT_VERSION) {
-        creds.__version = CURRENT_VERSION
-    }
-
-    // ─── Prekey Cleanup ─────────────────────────────────────────────────────────
+    let creds = bootstrapCreds(await readData('creds.json'))
     let cleanupRunning = false
     let lastCleanupAt = 0
     let lastCleanedPreKeyId = creds.nextPreKeyId
 
     const cleanOldPreKeys = async () => {
         const now = Date.now()
-        if (cleanupRunning) return
-        if (now - lastCleanupAt < CLEANUP_INTERVAL_MS) return
+        if (cleanupRunning || now - lastCleanupAt < CLEANUP_INTERVAL_MS) return
         cleanupRunning = true
         try {
             const minId = creds.nextPreKeyId - preKeyRetention
             if (minId <= 0) return
             const files = await readdir(folder)
-            const targets = []
-            for (const file of files) {
-                const match = file.match(/^pre-key-(\d+)\.json(\.tmp)?$/)
-                if (!match) continue
-                if (parseInt(match[1], 10) < minId) targets.push(join(folder, file))
-            }
+            const targets = files
+                .map(f => f.match(/^pre-key-(\d+)\.json(\.tmp)?$/))
+                .filter(m => m && parseInt(m[1], 10) < minId)
+                .map(m => join(folder, m[0]))
             if (!targets.length) return
             await Promise.all(targets.map(f => unlink(f).catch(() => { })))
             lastCleanupAt = Date.now()
@@ -164,7 +141,6 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
 
     cleanOldPreKeys().catch(() => { })
 
-    // ─── Stats ──────────────────────────────────────────────────────────────────
     const getStats = async () => {
         const files = await readdir(folder).catch(() => [])
         const preKeyFiles = files.filter(f => /^pre-key-\d+\.json$/.test(f))
@@ -184,9 +160,7 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
                     const data = {}
                     await Promise.all(ids.map(async (id) => {
                         let value = await readData(`${type}-${id}.json`)
-                        if (type === 'app-state-sync-key' && value) {
-                            value = proto.Message.AppStateSyncKeyData.fromObject(value)
-                        }
+                        if (type === 'app-state-sync-key' && value) value = proto.Message.AppStateSyncKeyData.fromObject(value)
                         data[id] = value
                     }))
                     return data
@@ -204,11 +178,185 @@ export const useMultiFileAuthState = async (folder, options = {}) => {
             },
         },
         saveCreds: async () => {
-            if (creds.nextPreKeyId - lastCleanedPreKeyId >= cleanupThreshold) {
-                cleanOldPreKeys().catch(() => { })
-            }
+            if (creds.nextPreKeyId - lastCleanedPreKeyId >= cleanupThreshold) cleanOldPreKeys().catch(() => { })
             return writeData(creds, 'creds.json')
         },
         getStats,
     }
-}
+}
+
+// ─── Keyv-backed auth state ───────────────────────────────────────────────────
+
+const ser = (v) => {
+    if (v == null) return null
+    const serialized = JSON.stringify(v, BufferJSON.replacer)
+    return { data: JSON.parse(serialized), __checksum: computeChecksum(serialized) }
+}
+
+const unwrapNestedValue = (obj) => {
+    let cur = obj
+    while (cur && typeof cur === 'object' && !Array.isArray(cur) && Object.keys(cur).length === 1 && 'value' in cur) cur = cur.value
+    return cur
+}
+
+const deser = (raw, logger, onRewrite) => {
+    if (raw == null) return null
+    let parsed
+    if (typeof raw === 'string') {
+        try { parsed = JSON.parse(raw) } catch (err) {
+            logger?.warn?.({ err: err.message }, '[Auth] failed to parse stored value — treating as missing')
+            return null
+        }
+    } else {
+        parsed = raw
+    }
+    parsed = unwrapNestedValue(parsed)
+    if (parsed == null) return null
+    if (typeof parsed === 'object' && '__checksum' in parsed) {
+        const innerData = unwrapNestedValue(parsed.data)
+        const serializedInner = JSON.stringify(innerData)
+        const expected = computeChecksum(serializedInner)
+        if (expected !== parsed.__checksum) {
+            logger?.warn?.('[Auth] checksum mismatch or legacy-wrapped value — reinitializing')
+            onRewrite?.(JSON.stringify({ data: innerData, __checksum: expected }))
+        }
+        return JSON.parse(serializedInner, BufferJSON.reviver)
+    }
+    return JSON.parse(JSON.stringify(parsed), BufferJSON.reviver)
+}
+
+// Maps our unified collectionName option to each adapter's actual constructor key
+const COLLECTION_OPTION_KEY = {
+    '@keyv/mongo': 'collection',
+    '@keyv/postgres': 'table',
+    '@keyv/mysql': 'table',
+    '@keyv/sqlite': 'table',
+}
+
+const _adapterCache = new Map()
+export const clearAdapterCache = () => _adapterCache.clear()
+
+const resolveAdapter = async (connectionString, collectionName) => {
+    const cacheKey = collectionName ? `${connectionString}::${collectionName}` : connectionString
+    if (_adapterCache.has(cacheKey)) return _adapterCache.get(cacheKey)
+    let protocol
+    try { protocol = new URL(connectionString).protocol } catch { throw new Error(`[Auth] Invalid connection string: "${connectionString}"`) }
+    const pkg = PROTOCOL_ADAPTERS[protocol]
+    if (!pkg) throw new Error(`[Auth] Unsupported protocol "${protocol}" — supported: redis, mongodb, postgresql, mysql, sqlite, etcd, memcache. Pass a pre-built KeyvStoreAdapter instance for anything else.`)
+    let mod
+    try { mod = await import(pkg) } catch (e) {
+        if (e.code === 'ERR_MODULE_NOT_FOUND') throw new Error(`[Auth] "${pkg}" is required for this backend — install it: npm i ${pkg}`)
+        throw e
+    }
+    const Adapter = mod.default ?? mod[Object.keys(mod)[0]]
+    const optionKey = COLLECTION_OPTION_KEY[pkg]
+    // Pass one merged options object — Postgres/MySQL silently ignore a second positional argument
+    const adapter = (collectionName && optionKey)
+        ? new Adapter({ url: connectionString, uri: connectionString, [optionKey]: collectionName })
+        : new Adapter(connectionString)
+    adapter.setMaxListeners?.(0)
+    _adapterCache.set(cacheKey, adapter)
+    return adapter
+}
+
+const isAdapterLike = (v) => v && typeof v === 'object' && typeof v.get === 'function' && typeof v.set === 'function' && typeof v.delete === 'function' && typeof v.clear === 'function'
+
+const resolveStore = async (backend, collectionName) => {
+    if (backend == null) return null
+    if (typeof backend === 'string') return resolveAdapter(backend, collectionName)
+    if (backend instanceof Keyv) return backend.opts?.store ?? backend.store ?? null
+    if (isAdapterLike(backend)) return backend
+    throw new Error('[Auth] backend must be a connection string, Keyv instance, or KeyvStoreAdapter')
+}
+
+export const useKeyvAuthState = async (sessionId, backend, opts = {}) => {
+    const { preKeyRetention = DEFAULT_PREKEY_RETENTION, cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD, logger, collectionName } = opts
+
+    const store = await resolveStore(backend, collectionName)
+    const keyv = store ? new Keyv({ store, namespace: sessionId }) : new Keyv({ namespace: sessionId })
+    keyv.on('error', (err) => logger?.warn?.({ err: err?.message }, '[Auth] store error'))
+
+    const keyName = (type, id) => `${type}-${id}`
+
+    let creds = bootstrapCreds(deser(await keyv.get('creds'), logger, (fixed) => keyv.set('creds', fixed)))
+    let cleanupRunning = false
+    let lastCleanupAt = 0
+    let lastCleanedPreKeyId = creds.nextPreKeyId
+
+    const cleanOldPreKeys = async () => {
+        const now = Date.now()
+        if (cleanupRunning || now - lastCleanupAt < CLEANUP_INTERVAL_MS) return
+        cleanupRunning = true
+        try {
+            const minId = creds.nextPreKeyId - preKeyRetention
+            if (minId <= 0) return
+            const ids = []
+            for (let id = Math.max(0, lastCleanedPreKeyId - preKeyRetention); id < minId; id++) ids.push(keyName('pre-key', id))
+            if (!ids.length) return
+            await Promise.all(ids.map((k) => keyv.delete(k).catch(() => { })))
+            lastCleanupAt = Date.now()
+            lastCleanedPreKeyId = creds.nextPreKeyId
+            logger?.info?.({ deleted: ids.length, minId }, '[Auth] prekey cleanup done')
+        } catch (e) {
+            logger?.warn?.({ err: e.message }, '[Auth] prekey cleanup failed')
+        } finally {
+            cleanupRunning = false
+        }
+    }
+
+    cleanOldPreKeys().catch(() => { })
+
+    const keys = {
+        get: async (type, ids) => {
+            const data = {}
+            if (!ids.length) return data
+            const rawKeys = ids.map((id) => keyName(type, id))
+            const rawValues = await keyv.getMany(rawKeys)
+            const rewrites = []
+            ids.forEach((id, i) => {
+                data[id] = patchAppStateKey(type, deser(rawValues[i], logger, (fixed) => rewrites.push(keyv.set(rawKeys[i], fixed))))
+            })
+            if (rewrites.length) await Promise.all(rewrites).catch(() => { })
+            return data
+        },
+        set: async (data) => {
+            const setEntries = []
+            const delKeys = []
+            for (const type in data) {
+                for (const id in data[type]) {
+                    const value = data[type][id]
+                    const key = keyName(type, id)
+                    if (value != null) setEntries.push({ key, value: ser(value) })
+                    else delKeys.push(key)
+                }
+            }
+            await Promise.all([
+                setEntries.length ? keyv.setMany(setEntries) : null,
+                delKeys.length ? keyv.deleteMany(delKeys) : null,
+            ])
+        },
+    }
+
+    const saveCreds = async () => {
+        if (creds.nextPreKeyId - lastCleanedPreKeyId >= cleanupThreshold) cleanOldPreKeys().catch(() => { })
+        await keyv.set('creds', ser(creds))
+    }
+
+    const clearSession = async () => {
+        const store = keyv.opts?.store ?? keyv.store
+        if (store && typeof store.deleteMany === 'function' && typeof store.iterator === 'function') {
+            const toDelete = []
+            for await (const [key] of store.iterator(sessionId)) toDelete.push(key)
+            if (toDelete.length) await store.deleteMany(toDelete)
+        } else {
+            await keyv.clear()
+        }
+        await close()
+    }
+
+    const close = async () => { keyv.removeAllListeners?.() }
+
+    return { state: { creds, keys }, saveCreds, clearSession }
+}
+
+export { Keyv }

package/lib/Utils/validate-connection.js

@@ -13,7 +13,9 @@ const getUserAgent = (config) => {
             secondary: config.version[1],
             tertiary: config.version[2]
         },
-        platform: proto.ClientPayload.UserAgent.Platform.WEB,
+        platform: config.browser[1].toLocaleLowerCase().includes('android')
+            ? proto.ClientPayload.UserAgent.Platform.MACOS
+            : proto.ClientPayload.UserAgent.Platform.WEB,
         releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
         osVersion: '0.1',
         device: 'Desktop',
@@ -43,7 +45,9 @@ const getClientPayload = (config) => {
         connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
         userAgent: getUserAgent(config)
     };
-    payload.webInfo = getWebInfo(config);
+    if (!config.browser[1].toLowerCase().includes('android')) {
+        payload.webInfo = getWebInfo(config)
+    }
     return payload;
 };
 export const generateLoginNode = (userJid, config) => {
@@ -61,6 +65,9 @@ export const generateLoginNode = (userJid, config) => {
 };
 const getPlatformType = (platform) => {
     const platformType = platform.toUpperCase();
+    if (platformType === 'ANDROID') {
+        return proto.DeviceProps.PlatformType.ANDROID_PHONE;
+    }
     return (proto.DeviceProps.PlatformType[platformType] ||
         proto.DeviceProps.PlatformType.CHROME);
 };
@@ -77,6 +84,7 @@ export const generateRegistrationNode = ({ registrationId, signedPreKey, signedI
         historySyncConfig: {
             storageQuotaMb: 569150,
             inlineInitialPayloadInE2EeMsg: true,
+            recentSyncDaysLimit: undefined,
             supportCallLogHistory: false,
             supportBotUserAgentChatHistory: true,
             supportCagReactionsAndPolls: true,
@@ -84,7 +92,11 @@ export const generateRegistrationNode = ({ registrationId, signedPreKey, signedI
             supportRecentSyncChunkMessageCountTuning: true,
             supportHostedGroupMsg: true,
             supportFbidBotChatHistory: true,
-            supportMessageAssociation: true
+            supportAddOnHistorySyncMigration: undefined,
+            supportMessageAssociation: true,
+            supportGroupHistory: false,
+            onDemandReady: undefined,
+            supportGuestChat: undefined
         },
         version: {
             primary: 10,

package/lib/WABinary/constants.js

@@ -23,6 +23,20 @@ export const VIOLATION_TYPES = {
     '18': 'Terms of Service Violation',
     '20': 'Illegal Content'
 };
+
+export const PROTOCOL_ADAPTERS = {
+    'redis:': '@keyv/redis',
+    'rediss:': '@keyv/redis',
+    'mongodb:': '@keyv/mongo',
+    'mongodb+srv:': '@keyv/mongo',
+    'postgresql:': '@keyv/postgres',
+    'postgres:': '@keyv/postgres',
+    'mysql:': '@keyv/mysql',
+    'sqlite:': '@keyv/sqlite',
+    'etcd:': '@keyv/etcd',
+    'memcache:': '@keyv/memcache',
+    'memcached:': '@keyv/memcache',
+}
 export const DOUBLE_BYTE_TOKENS = [
     [
         'read-self',

package/lib/index.js

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

package/package.json

@@ -2,9 +2,18 @@
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@nexustechpro/baileys",
   "type": "module",
-  "version": "2.1.3",
+  "version": "2.1.6",
   "description": "Advanced WhatsApp Web API built on Baileys — interactive messages, buttons, carousels, products, events, payments, polls, albums, sticker packs and more.",
   "keywords": [
+    "baileys",
+    "baileys-mod",
+    "baileys-fork",
+    "nexus",
+    "nexusbot",
+    "nexustech",
+    "nexustechpro",
+    "baileys-advanced",
+    "whiskeysockets",
     "whatsapp",
     "whatsapp-api",
     "whatsapp-web",
@@ -24,17 +33,9 @@
     "whatsapp-channel",
     "whatsapp-status",
     "whatsapp-pairing",
-    "baileys",
-    "baileys-mod",
-    "baileys-fork",
-    "baileys-advanced",
-    "whiskeysockets",
     "wa-api",
     "wa-bot",
     "wa-web",
-    "nexus",
-    "nexusbot",
-    "nexustechpro",
     "automation",
     "bot",
     "chatbot",
@@ -101,22 +102,32 @@
     "@adiwajshing/keyed-db": "^0.2.4",
     "@cacheable/node-cache": "^1.4.0",
     "@hapi/boom": "^9.1.3",
+    "@keyv/etcd": "^2.1.1",
+    "@keyv/memcache": "^2.0.2",
+    "@keyv/mongo": "^3.1.0",
+    "@keyv/mysql": "^2.1.10",
+    "@keyv/postgres": "^2.2.3",
+    "@keyv/redis": "^5.1.6",
+    "@keyv/sqlite": "^4.0.8",
     "@microlink/mql": "^0.16.1",
     "async-mutex": "^0.5.0",
     "axios": "^1.6.0",
     "cache-manager": "latest",
     "chalk": "^4.1.2",
     "fflate": "^0.8.2",
+    "ffmpeg-static": "^5.3.0",
     "gradient-string": "^2.0.2",
+    "keyv": "^5.6.0",
     "libphonenumber-js": "^1.13.3",
     "link-preview-js": "^4.0.3",
     "lru-cache": "^11.1.0",
     "music-metadata": "^11.7.0",
+    "node-cache": "^5.1.2",
     "p-queue": "^9.0.0",
     "pino": "^9.6",
+    "prismjs": "^1.30.0",
     "protobufjs": "latest",
     "qrcode-terminal": "^0.12.0",
-    "sharp": "^0.32.0",
     "url-regex-safe": "^4.0.0",
     "uuid": "latest",
     "whatsapp-rust-bridge": "latest",
@@ -157,8 +168,9 @@
   },
   "peerDependencies": {
     "audio-decode": "^2.1.3",
-    "jimp": "^1.6.0",
-    "link-preview-js": "^4.0.3"
+    "jimp": "*",
+    "link-preview-js": "^4.0.3",
+    "sharp": "*"
   },
   "peerDependenciesMeta": {
     "audio-decode": {
@@ -166,6 +178,9 @@
     },
     "jimp": {
       "optional": true
+    },
+    "sharp": {
+      "optional": true
     }
   },
   "packageManager": "yarn@4.9.2",