@nexustechpro/baileys 2.0.5 → 2.1.0

package/lib/Utils/tc-token-utils.js

@@ -0,0 +1,162 @@
+import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidMetaAI, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
+// Same phone-number pattern as WABinary's isJidBot, applied against the user
+// part so the check is invariant to @c.us ↔ @s.whatsapp.net normalization.
+const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
+/**
+ * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
+ * storage against malformed notifications — WA Web filters server-side but we
+ * defend here for parity with `WAWebSetTcTokenChatAction.handleIncomingTcToken`.
+ * Works for both pre- and post-normalized JIDs (`@c.us` vs `@s.whatsapp.net`).
+ */
+function isRegularUser(jid) {
+    if (!jid)
+        return false;
+    const user = jid.split('@')[0] ?? '';
+    if (user === '0')
+        return false; // PSA
+    if (BOT_PHONE_REGEX.test(user))
+        return false; // Bot by phone pattern
+    if (isJidMetaAI(jid))
+        return false; // MetaAI (@bot server)
+    return !!(isPnUser(jid) || isLidUser(jid) || isHostedPnUser(jid) || isHostedLidUser(jid) || jid.endsWith('@c.us'));
+}
+const TC_TOKEN_BUCKET_DURATION = 604800; // 7 days
+const TC_TOKEN_NUM_BUCKETS = 4; // ~28-day rolling window
+/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
+export const TC_TOKEN_INDEX_KEY = '__index';
+/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
+export async function readTcTokenIndex(keys) {
+    const data = await keys.get('tctoken', [TC_TOKEN_INDEX_KEY]);
+    const entry = data[TC_TOKEN_INDEX_KEY];
+    if (!entry?.token?.length)
+        return [];
+    try {
+        const parsed = JSON.parse(Buffer.from(entry.token).toString());
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((j) => typeof j === 'string' && j.length > 0 && j !== TC_TOKEN_INDEX_KEY);
+    }
+    catch {
+        return [];
+    }
+}
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+export async function buildMergedTcTokenIndexWrite(keys, addedJids) {
+    const persisted = await readTcTokenIndex(keys);
+    const merged = new Set(persisted);
+    for (const jid of addedJids) {
+        if (jid && jid !== TC_TOKEN_INDEX_KEY)
+            merged.add(jid);
+    }
+    return {
+        [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+    };
+}
+// WA Web has separate sender/receiver AB props for these but they're identical today
+export function isTcTokenExpired(timestamp) {
+    if (timestamp === null || timestamp === undefined)
+        return true;
+    const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp;
+    if (isNaN(ts))
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const cutoffBucket = currentBucket - (TC_TOKEN_NUM_BUCKETS - 1);
+    const cutoffTimestamp = cutoffBucket * TC_TOKEN_BUCKET_DURATION;
+    return ts < cutoffTimestamp;
+}
+export function shouldSendNewTcToken(senderTimestamp) {
+    if (senderTimestamp === undefined)
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION);
+    return currentBucket > senderBucket;
+}
+/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
+export async function resolveTcTokenJid(jid, getLIDForPN) {
+    if (isLidUser(jid))
+        return jid;
+    const lid = await getLIDForPN(jid);
+    return lid ?? jid;
+}
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
+export async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
+    if (issueToLid) {
+        if (isLidUser(jid))
+            return jid;
+        const lid = await getLIDForPN(jid);
+        return lid ?? jid;
+    }
+    if (!isLidUser(jid))
+        return jid;
+    if (getPNForLID) {
+        const pn = await getPNForLID(jid);
+        return pn ?? jid;
+    }
+    return jid;
+}
+export async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
+    try {
+        const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
+        const tcTokenData = await authState.keys.get('tctoken', [storageJid]);
+        const entry = tcTokenData?.[storageJid];
+        const tcTokenBuffer = entry?.token;
+        if (!tcTokenBuffer?.length || isTcTokenExpired(entry?.timestamp)) {
+            if (tcTokenBuffer) {
+                // Preserve senderTimestamp so shouldSendNewTcToken() keeps its dedupe state
+                // after we drop the unusable peer token. Only wipe the record entirely when
+                // there's nothing worth keeping.
+                const cleared = entry?.senderTimestamp !== undefined
+                    ? { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
+                    : null;
+                await authState.keys.set({ tctoken: { [storageJid]: cleared } });
+            }
+            return baseContent.length > 0 ? baseContent : undefined;
+        }
+        baseContent.push({
+            tag: 'tctoken',
+            attrs: {},
+            content: tcTokenBuffer
+        });
+        return baseContent;
+    }
+    catch (error) {
+        return baseContent.length > 0 ? baseContent : undefined;
+    }
+}
+export async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
+    const tokensNode = getBinaryNodeChild(result, 'tokens');
+    if (!tokensNode)
+        return;
+    const tokenNodes = getBinaryNodeChildren(tokensNode, 'token');
+    for (const tokenNode of tokenNodes) {
+        if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
+            continue;
+        }
+        // In notifications tokenNode.attrs.jid is your own device JID, not the sender's
+        const rawJid = jidNormalizedUser(fallbackJid || tokenNode.attrs.jid);
+        if (!isRegularUser(rawJid))
+            continue;
+        const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN);
+        const existingTcData = await keys.get('tctoken', [storageJid]);
+        const existingEntry = existingTcData[storageJid];
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
+        const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0;
+        // timestamp-less tokens would be immediately expired
+        if (!incomingTs)
+            continue;
+        if (existingTs > 0 && existingTs > incomingTs)
+            continue;
+        await keys.set({
+            tctoken: {
+                [storageJid]: {
+                    ...existingEntry,
+                    token: Buffer.from(tokenNode.content),
+                    timestamp: tokenNode.attrs.t
+                }
+            }
+        });
+        onNewJidStored?.(storageJid);
+    }
+}

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

@@ -1,121 +1,204 @@
-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) => {
-            try {
-                await writeFile(filePath, JSON.stringify(data, BufferJSON.replacer));
-            }
-            finally {
-                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)
+            await rename(tp, fp)
+        } 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) throw new Error('checksum mismatch')
+                    return JSON.parse(JSON.stringify(parsed.data), BufferJSON.reviver)
                 }
-            });
-        }
-        catch (error) {
-            return null;
+                // legacy file without checksum — read as-is for compatibility
+                return JSON.parse(raw, BufferJSON.reviver)
+            } catch (err) {
+                logger?.warn({ file, err: err.message }, 'failed to read auth file')
+                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/WABinary/constants.js

@@ -17,6 +17,12 @@ export const TAGS = {
     NIBBLE_8: 255,
     PACKED_MAX: 127
 };
+export const VIOLATION_TYPES = {
+    '15': 'Spam/Bulk Messaging',
+    '16': 'Automation/Bot Usage',
+    '18': 'Terms of Service Violation',
+    '20': 'Illegal Content'
+};
 export const DOUBLE_BYTE_TOKENS = [
     [
         'read-self',

package/lib/WABinary/index.js

@@ -3,4 +3,5 @@ export * from './decode.js';
 export * from './generic-utils.js';
 export * from './jid-utils.js';
 export * from './types.js';
+export * from './constants.js';
 //# sourceMappingURL=index.js.map

package/lib/index.js

@@ -1,7 +1,6 @@
 "use strict";
 import gradient from 'gradient-string';
 import makeWASocket from './Socket/index.js';
-import NexusHandler from './Socket/nexus-handler.js';
 const banner = `
 ╔══════════════════════════════════════════════════════════════════╗
 ║                                                                  ║
@@ -32,7 +31,7 @@ const banner = `
 const info = `
 ┌───────────────────────────────────────────────────────────────────────┐
 │  📦 Package: @nexustechpro/baileys                                   │
-│  🔖 Version: 2.0.5                                                   │
+│  🔖 Version: 2.1.0                                                  │
 │  ⚡ Status:  Production Ready                                        │
 ├───────────────────────────────────────────────────────────────────────┤
 │  🚀 Advanced WhatsApp Web API Client                                  │
@@ -63,5 +62,5 @@ export * from './Defaults/index.js';
 export * from './WABinary/index.js';
 export * from './WAM/index.js';
 export * from './WAUSync/index.js';
-export { NexusHandler, makeWASocket };
+export * from './Socket/index.js';
 export default makeWASocket;

package/package.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@nexustechpro/baileys",
   "type": "module",
-  "version": "2.0.5",
+  "version": "2.1.0",
   "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,7 +98,9 @@
     "engine-requirements.js"
   ],
   "dependencies": {
+    "@adiwajshing/keyed-db": "^0.2.4",
     "@cacheable/node-cache": "^1.4.0",
+    "@microlink/mql": "^0.16.1",
     "@hapi/boom": "^9.1.3",
     "async-mutex": "^0.5.0",
     "axios": "^1.6.0",
@@ -106,17 +108,19 @@
     "chalk": "^4.1.2",
     "fflate": "^0.8.2",
     "gradient-string": "^2.0.2",
-    "link-preview-js": "^3.0.4",
+    "libphonenumber-js": "^1.13.3",
+    "link-preview-js": "^4.0.3",
     "lru-cache": "^11.1.0",
     "music-metadata": "^11.7.0",
     "p-queue": "^9.0.0",
     "pino": "^9.6",
-    "uuid": "latest",
     "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",
@@ -137,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",
@@ -154,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": {
@@ -168,4 +172,4 @@
   "engines": {
     "node": ">=20.0.0"
   }
-}
+}