@nexustechpro/baileys 2.0.6 → 2.1.2

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

@@ -1,121 +1,214 @@
-import { Mutex } from 'async-mutex';
-import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises';
-import { join } from 'path';
-import { proto } from '../../WAProto/index.js';
-import { initAuthCreds } from './auth-utils.js';
-import { BufferJSON } from './generics.js';
-// We need to lock files due to the fact that we are using async functions to read and write files
-// https://github.com/WhiskeySockets/Baileys/issues/794
-// https://github.com/nodejs/node/issues/26338
-// Use a Map to store mutexes for each file path
-const fileLocks = new Map();
-// Get or create a mutex for a specific file path
+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 { proto } from '../../WAProto/index.js'
+import { initAuthCreds } from './auth-utils.js'
+import { BufferJSON } from './generics.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 fileLocks = new Map()
 const getFileLock = (path) => {
-    let mutex = fileLocks.get(path);
-    if (!mutex) {
-        mutex = new Mutex();
-        fileLocks.set(path, mutex);
-    }
-    return mutex;
-};
+    if (!fileLocks.has(path)) fileLocks.set(path, new Mutex())
+    return fileLocks.get(path)
+}
+const releaseFileLock = (path) => {
+    if (fileLocks.has(path) && !fileLocks.get(path).isLocked()) fileLocks.delete(path)
+}
+
+// ─── Checksum ─────────────────────────────────────────────────────────────────
+const computeChecksum = (data) => createHash('sha256').update(data).digest('hex')
+
 /**
- * stores the full authentication state in a single folder.
- * Far more efficient than singlefileauthstate
+ * Production-grade multi-file auth state for Baileys.
+ * Atomic writes, checksum integrity, and smart prekey cleanup.
+ * Compatible with standard Baileys auth folder format.
  *
- * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
- * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
- * */
-export const useMultiFileAuthState = async (folder) => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ * @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 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}`)
+    } else {
+        await mkdir(folder, { recursive: true })
+    }
+
+    // ─── Atomic Write ────────────────────────────────────────────────────────────
     const writeData = async (data, file) => {
-        const filePath = join(folder, fixFileName(file));
-        const mutex = getFileLock(filePath);
-        return mutex.acquire().then(async (release) => {
+        const fp = filePath(file)
+        const tp = tmpPath(file)
+        const mutex = getFileLock(fp)
+        const release = await mutex.acquire()
+        try {
+            const serialized = JSON.stringify(data, BufferJSON.replacer)
+            const checksum = computeChecksum(serialized)
+            const payload = JSON.stringify({ data: JSON.parse(serialized), __checksum: checksum })
+            await writeFile(tp, payload)
             try {
-                await writeFile(filePath, JSON.stringify(data, BufferJSON.replacer));
+                await rename(tp, fp)
+            } catch {
+                await writeFile(fp, payload)
+                await unlink(tp).catch(() => { })
             }
-            finally {
-                release();
-            }
-        });
-    };
+        } finally {
+            release()
+            releaseFileLock(fp)
+        }
+    }
+
+    // ─── Read with Checksum Verification ─────────────────────────────────────────
     const readData = async (file) => {
+        const fp = filePath(file)
+        const mutex = getFileLock(fp)
+        const release = await mutex.acquire()
         try {
-            const filePath = join(folder, fixFileName(file));
-            const mutex = getFileLock(filePath);
-            return await mutex.acquire().then(async (release) => {
-                try {
-                    const data = await readFile(filePath, { encoding: 'utf-8' });
-                    return JSON.parse(data, BufferJSON.reviver);
-                }
-                finally {
-                    release();
+            const raw = await readFile(fp, { encoding: 'utf-8' }).catch(() => null)
+            if (!raw) return null
+            try {
+                const parsed = JSON.parse(raw)
+                if (parsed.__checksum) {
+                    const expected = computeChecksum(JSON.stringify(parsed.data))
+                    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)
                 }
-            });
-        }
-        catch (error) {
-            return null;
-        }
-    };
+                // 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(() => { })
+                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) }
+    }
+
+    // ─── Remove File ────────────────────────────────────────────────────────────
     const removeData = async (file) => {
+        const fp = filePath(file)
+        const mutex = getFileLock(fp)
+        const release = await mutex.acquire()
         try {
-            const filePath = join(folder, fixFileName(file));
-            const mutex = getFileLock(filePath);
-            return mutex.acquire().then(async (release) => {
-                try {
-                    await unlink(filePath);
-                }
-                catch {
-                }
-                finally {
-                    release();
-                }
-            });
+            await unlink(fp).catch(() => { })
+        } finally {
+            release()
+            releaseFileLock(fp)
         }
-        catch { }
-    };
-    const folderInfo = await stat(folder).catch(() => { });
-    if (folderInfo) {
-        if (!folderInfo.isDirectory()) {
-            throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`);
+    }
+
+    // ─── 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 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
+        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))
+            }
+            if (!targets.length) return
+            await Promise.all(targets.map(f => unlink(f).catch(() => { })))
+            lastCleanupAt = Date.now()
+            lastCleanedPreKeyId = creds.nextPreKeyId
+            logger?.info({ deleted: targets.length, minId }, 'prekey cleanup complete')
+        } catch (err) {
+            logger?.warn({ err }, 'prekey cleanup failed')
+        } finally {
+            cleanupRunning = false
         }
     }
-    else {
-        await mkdir(folder, { recursive: true });
+
+    cleanOldPreKeys().catch(() => { })
+
+    // ─── Stats ──────────────────────────────────────────────────────────────────
+    const getStats = async () => {
+        const files = await readdir(folder).catch(() => [])
+        const preKeyFiles = files.filter(f => /^pre-key-\d+\.json$/.test(f))
+        return {
+            totalFiles: files.length,
+            preKeyCount: preKeyFiles.length,
+            nextPreKeyId: creds.nextPreKeyId,
+            lastCleanupAt: lastCleanupAt ? new Date(lastCleanupAt).toISOString() : null,
+        }
     }
-    const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-');
-    const creds = (await readData('creds.json')) || initAuthCreds();
+
     return {
         state: {
             creds,
             keys: {
                 get: async (type, ids) => {
-                    const data = {};
+                    const data = {}
                     await Promise.all(ids.map(async (id) => {
-                        let value = await readData(`${type}-${id}.json`);
+                        let value = await readData(`${type}-${id}.json`)
                         if (type === 'app-state-sync-key' && value) {
-                            value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                            value = proto.Message.AppStateSyncKeyData.fromObject(value)
                         }
-                        data[id] = value;
-                    }));
-                    return data;
+                        data[id] = value
+                    }))
+                    return data
                 },
                 set: async (data) => {
-                    const tasks = [];
+                    const tasks = []
                     for (const category in data) {
                         for (const id in data[category]) {
-                            const value = data[category][id];
-                            const file = `${category}-${id}.json`;
-                            tasks.push(value ? writeData(value, file) : removeData(file));
+                            const value = data[category][id]
+                            tasks.push(value ? writeData(value, `${category}-${id}.json`) : removeData(`${category}-${id}.json`))
                         }
                     }
-                    await Promise.all(tasks);
-                }
-            }
+                    await Promise.all(tasks)
+                },
+            },
         },
         saveCreds: async () => {
-            return writeData(creds, 'creds.json');
-        }
-    };
-};
-//# sourceMappingURL=use-multi-file-auth-state.js.map
+            if (creds.nextPreKeyId - lastCleanedPreKeyId >= cleanupThreshold) {
+                cleanOldPreKeys().catch(() => { })
+            }
+            return writeData(creds, 'creds.json')
+        },
+        getStats,
+    }
+}

package/lib/index.js

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

package/package.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@nexustechpro/baileys",
   "type": "module",
-  "version": "2.0.6",
+  "version": "2.1.2",
   "description": "Advanced WhatsApp Web API built on Baileys — interactive messages, buttons, carousels, products, events, payments, polls, albums, sticker packs and more.",
   "keywords": [
     "whatsapp",
@@ -49,7 +49,7 @@
     "events",
     "payments",
     "polls",
-    "album",
+    "albums",
     "sticker-pack",
     "nodejs",
     "typescript",
@@ -98,27 +98,29 @@
     "engine-requirements.js"
   ],
   "dependencies": {
+    "@adiwajshing/keyed-db": "^0.2.4",
     "@cacheable/node-cache": "^1.4.0",
     "@hapi/boom": "^9.1.3",
+    "@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.2.0",
     "gradient-string": "^2.0.2",
     "libphonenumber-js": "^1.13.3",
-    "link-preview-js": "latest",
+    "link-preview-js": "^4.0.3",
     "lru-cache": "^11.1.0",
     "music-metadata": "^11.7.0",
     "p-queue": "^9.0.0",
     "pino": "^9.6",
     "protobufjs": "latest",
+    "qrcode-terminal": "^0.12.0",
     "sharp": "^0.32.0",
+    "url-regex-safe": "^4.0.0",
     "uuid": "latest",
     "whatsapp-rust-bridge": "latest",
-    "ws": "latest",
-    "yarn": "^1.22.22"
+    "ws": "latest"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.1",
@@ -139,7 +141,7 @@
     "jimp": "^1.6.0",
     "jiti": "^2.4.2",
     "json": "^11.0.0",
-    "link-preview-js": "^3.0.4",
+    "link-preview-js": "^4.0.3",
     "lru-cache": "^11.1.0",
     "open": "^8.4.2",
     "pino-pretty": "^13.1.1",
@@ -156,7 +158,7 @@
   "peerDependencies": {
     "audio-decode": "^2.1.3",
     "jimp": "^1.6.0",
-    "link-preview-js": "^3.0.4"
+    "link-preview-js": "^4.0.3"
   },
   "peerDependenciesMeta": {
     "audio-decode": {