@vanzxy/baileys 2.0.0

package/lib/Utils/templates.js

@@ -0,0 +1,151 @@
+// Vanz@Add --- ported from Bail-master addons/templates.ts (type-only
+// annotations dropped; behavior unchanged).
+export class TemplateManager {
+    templates = new Map();
+    generateId() {
+        return `tpl_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    extractVariables(content) {
+        const regex = /\{\{(\w+)(?::([^}]*))?\}\}/g;
+        const variables = [];
+        const seen = new Set();
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const name = match[1];
+            if (!name || seen.has(name))
+                continue;
+            seen.add(name);
+            variables.push({ name, defaultValue: match[2], required: !match[2] });
+        }
+        return variables;
+    }
+    create(options) {
+        const template = {
+            id: options.id ?? this.generateId(),
+            name: options.name,
+            content: options.content,
+            description: options.description,
+            category: options.category,
+            variables: this.extractVariables(options.content),
+            createdAt: new Date(),
+            updatedAt: new Date()
+        };
+        this.templates.set(template.id, template);
+        return template;
+    }
+    get(id) {
+        return this.templates.get(id);
+    }
+    getByName(name) {
+        return Array.from(this.templates.values()).find((t) => t.name === name);
+    }
+    getAll() {
+        return Array.from(this.templates.values());
+    }
+    getByCategory(category) {
+        return Array.from(this.templates.values()).filter((t) => t.category === category);
+    }
+    update(id, updates) {
+        const template = this.templates.get(id);
+        if (!template)
+            return undefined;
+        if (updates.content)
+            updates.variables = this.extractVariables(updates.content);
+        const updated = { ...template, ...updates, updatedAt: new Date() };
+        this.templates.set(id, updated);
+        return updated;
+    }
+    delete(id) {
+        return this.templates.delete(id);
+    }
+    renderContent(content, data = {}) {
+        return content.replace(/\{\{(\w+)(?::([^}]*))?\}\}/g, (match, name, defaultValue) => {
+            const value = data[name];
+            if (value !== undefined && value !== null)
+                return String(value);
+            if (defaultValue !== undefined)
+                return defaultValue;
+            return match;
+        });
+    }
+    render(id, data = {}) {
+        const template = this.templates.get(id);
+        if (!template)
+            throw new Error(`Template not found: ${id}`);
+        return this.renderContent(template.content, data);
+    }
+    validate(id, data) {
+        const template = this.templates.get(id);
+        if (!template)
+            throw new Error(`Template not found: ${id}`);
+        const missing = template.variables.filter((v) => v.required && !(v.name in data)).map((v) => v.name);
+        return { valid: missing.length === 0, missing };
+    }
+    export() {
+        return JSON.stringify(Array.from(this.templates.values()), null, 2);
+    }
+    import(json, overwrite = false) {
+        const templates = JSON.parse(json);
+        let imported = 0;
+        for (const t of templates) {
+            if (!overwrite && this.templates.has(t.id))
+                continue;
+            this.templates.set(t.id, { ...t, createdAt: new Date(t.createdAt), updatedAt: new Date(t.updatedAt) });
+            imported++;
+        }
+        return imported;
+    }
+}
+/** Ready-made templates covering common bot scenarios (order, welcome, reminder, etc). */
+export const PRESET_TEMPLATES = {
+    ORDER_CONFIRMATION: {
+        name: 'Order Confirmation',
+        category: 'order',
+        content: `✅ *Order Confirmed!*\n\nOrder ID: #{{orderId}}\nCustomer: {{customerName}}\nDate: {{orderDate}}\n\n📦 *Items:*\n{{items}}\n\n💰 *Total: {{total}}*\n\nThank you! 🙏`
+    },
+    WELCOME: {
+        name: 'Welcome Message',
+        category: 'greeting',
+        content: `👋 *Welcome, {{name}}!*\n\nThank you for joining {{companyName:us}}!\nNeed help? Reply to this message!`
+    },
+    REMINDER: {
+        name: 'Reminder',
+        category: 'notification',
+        content: `⏰ *Reminder*\n\nHi {{name}},\n\n📋 {{subject}}\n📅 Date: {{date}}\n🕐 Time: {{time}}\n📍 Location: {{location:TBD}}`
+    },
+    SUPPORT_TICKET: {
+        name: 'Support Ticket',
+        category: 'support',
+        content: `🎫 *Support Ticket Created*\n\nTicket #: {{ticketId}}\nSubject: {{subject}}\n\nHi {{name}},\n\nWe received your request! Response time: {{responseTime:24 hours}} 🙏`
+    },
+    BIRTHDAY: {
+        name: 'Birthday Wishes',
+        category: 'greeting',
+        content: `🎂 *Happy Birthday, {{name}}!* 🎉\n\nWishing you a wonderful day!\n\n🎁 Use code: {{code}} for {{discount:10}}% off! 🥳`
+    },
+    INVOICE: {
+        name: 'Invoice',
+        category: 'invoice',
+        content: `🧾 *Invoice {{invoiceNumber}}*\n\nBilled to: {{customerName}}\nInvoice date: {{invoiceDate}}\nDue date: {{dueDate:on receipt}}\n\n📋 *Items:*\n{{items}}\n\nSubtotal: {{subtotal}}\n💰 *Total: {{total}}*\n\nThank you for your business! 🙏`
+    }
+};
+export const createTemplateManager = (includePresets = true) => {
+    const manager = new TemplateManager();
+    if (includePresets) {
+        for (const [key, template] of Object.entries(PRESET_TEMPLATES)) {
+            manager.create({ ...template, id: key.toLowerCase() });
+        }
+    }
+    return manager;
+};
+export const renderTemplate = (content, data = {}) => {
+    return content.replace(/\{\{(\w+)(?::([^}]*))?\}\}/g, (match, name, defaultValue) => {
+        const value = data[name];
+        if (value !== undefined && value !== null)
+            return String(value);
+        if (defaultValue !== undefined)
+            return defaultValue;
+        return match;
+    });
+};
+//# sourceMappingURL=templates.js.map

package/lib/Utils/use-cache-manager-auth-state.d.ts

@@ -0,0 +1,13 @@
+import type { AuthenticationState } from '../Types/index.js';
+/** Minimal interface compatible with any cache-manager v5 store (Redis, Memcached, keyv, @cacheable/node-cache, etc). */
+export type CacheManagerStore = {
+    set(key: string, value: string, ttl?: number): Promise<void>;
+    get(key: string): Promise<string | undefined | null>;
+    del(key: string): Promise<void>;
+    keys(pattern?: string): Promise<string[]>;
+};
+export declare const useCacheManagerAuthState: (store: CacheManagerStore, sessionKey: string) => Promise<{
+    state: AuthenticationState;
+    saveCreds: () => Promise<void>;
+    clearState: () => Promise<void>;
+}>;

package/lib/Utils/use-cache-manager-auth-state.js

@@ -0,0 +1,82 @@
+// Ported from @queenanya/baileys `addons/use-cache-manager-auth-state.ts`
+// (that fork credits it to `@innovatorssoft/baileys` make-cache-manager-store.js).
+// Adjustments for @vanzxy/baileys: import paths rewired to this fork's
+// Utils layout (auth-utils.js / generics.js), otherwise logic-for-logic
+// identical to the original — including the 2-year TTL on `creds` and the
+// `sessionKey*` wildcard sweep in `clearState()`.
+//
+// Store interface required (matches any cache-manager v5-compatible store,
+// e.g. Redis/Memcached/keyv, or this fork's own @cacheable/node-cache dep):
+//   store.get(key)              -> string | undefined | null
+//   store.set(key, value, ttl?) -> void
+//   store.del(key)              -> void
+//   store.keys(pattern?)        -> string[]   (used by clearState() for the wildcard sweep)
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+
+export const useCacheManagerAuthState = async (store, sessionKey) => {
+    const defaultKey = (file) => `${sessionKey}:${file}`;
+    const writeData = async (file, data) => {
+        const ttl = file === 'creds' ? 63115200 : undefined; // 2 years for creds
+        await store.set(defaultKey(file), JSON.stringify(data, BufferJSON.replacer), ttl);
+    };
+    const readData = async (file) => {
+        try {
+            const data = await store.get(defaultKey(file));
+            return data !== null && data !== undefined ? JSON.parse(data, BufferJSON.reviver) : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const removeData = async (file) => {
+        try {
+            await store.del(defaultKey(file));
+        }
+        catch {
+            console.error(`[useCacheManagerAuthState] Error removing ${file} from session ${sessionKey}`);
+        }
+    };
+    const clearState = async () => {
+        try {
+            const keys = await store.keys(`${sessionKey}*`);
+            await Promise.all(keys.map((key) => store.del(key)));
+        }
+        catch {
+            // best-effort — not every store backend supports pattern listing
+        }
+    };
+    const creds = (await readData('creds')) || initAuthCreds();
+    return {
+        clearState,
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}`);
+                        if (type === 'app-state-sync-key' && value) {
+                            value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }));
+                    return data;
+                },
+                set: async (data) => {
+                    const tasks = [];
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id];
+                            const key = `${category}-${id}`;
+                            tasks.push(value ? writeData(key, value) : removeData(key));
+                        }
+                    }
+                    await Promise.all(tasks);
+                }
+            }
+        },
+        saveCreds: () => writeData('creds', creds)
+    };
+};

package/lib/Utils/use-multi-file-auth-state.d.ts

@@ -0,0 +1,10 @@
+export function useMultiFileAuthState(folder: any): Promise<{
+    state: {
+        creds: any;
+        keys: {
+            get: (type: any, ids: any) => Promise<{}>;
+            set: (data: any) => Promise<void>;
+        };
+    };
+    saveCreds: () => Promise<any>;
+}>;

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

@@ -0,0 +1,167 @@
+import { Mutex } from 'async-mutex';
+import { mkdir, readFile, readdir, 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
+const getFileLock = (path) => {
+    let mutex = fileLocks.get(path);
+    if (!mutex) {
+        mutex = new Mutex();
+        fileLocks.set(path, mutex);
+    }
+    return mutex;
+};
+// Vanz@Fix 25-08-26 (ENOSPC guard) --- useMultiFileAuthState writes one small file PER key id
+// (session-*, sender-key-*, sender-key-memory-*, pre-key-*, app-state-sync-key-*, ...) and never
+// prunes any of them on its own. Over months of uptime — especially in busy groups, where a
+// sender-key-memory file is created per (group, participant) pair — this silently accumulates into
+// hundreds of thousands of tiny files. That can hit the filesystem's inode/file-count ceiling and
+// start throwing ENOSPC on writes long before disk *space* usage looks anywhere near full (a
+// classic symptom: panel shows plenty of free MiB/GiB, but writes still fail with ENOSPC). When
+// that happens mid-session, auth writes (including the app-state-sync key from the "App state key
+// not present!" issue) fail silently and never actually persist.
+//
+// `sender-key-memory-*` entries are pure dedup/anti-replay cache — safe to delete anytime; Baileys
+// regenerates them on demand with zero functional loss (worst case: one redundant re-decrypt). They
+// also tend to be the single biggest contributor to file count in active groups, so they're the
+// safest and highest-impact thing to prune automatically. Everything else (creds, real sessions,
+// pre-keys, app-state-sync-keys) is left completely untouched — this never touches those.
+export const pruneStaleAuthFiles = async (folder, { maxAgeDays = 14, categories = ['sender-key-memory'], dryRun = false } = {}) => {
+    let entries;
+    try {
+        entries = await readdir(folder);
+    }
+    catch {
+        return { scanned: 0, removed: 0 };
+    }
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+    let scanned = 0;
+    let removed = 0;
+    await Promise.all(entries.map(async (name) => {
+        if (!categories.some((cat) => name.startsWith(`${cat}-`) && name.endsWith('.json'))) return;
+        scanned++;
+        const filePath = join(folder, name);
+        try {
+            const info = await stat(filePath);
+            if (info.mtimeMs < cutoff) {
+                if (!dryRun) await unlink(filePath).catch(() => { });
+                removed++;
+            }
+        }
+        catch {
+            // file vanished between readdir and stat — fine, nothing to prune
+        }
+    }));
+    return { scanned, removed };
+};
+/**
+ * stores the full authentication state in a single folder.
+ * Far more efficient than singlefileauthstate
+ *
+ * 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
+    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 readData = async (file) => {
+        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();
+                }
+            });
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    const removeData = async (file) => {
+        try {
+            const filePath = join(folder, fixFileName(file));
+            const mutex = getFileLock(filePath);
+            return mutex.acquire().then(async (release) => {
+                try {
+                    await unlink(filePath);
+                }
+                catch {
+                }
+                finally {
+                    release();
+                }
+            });
+        }
+        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`);
+        }
+    }
+    else {
+        await mkdir(folder, { recursive: true });
+    }
+    // Vanz@Fix 25-08-26 (ENOSPC guard) --- best-effort prune on every startup. Failures here must
+    // never block auth from loading, so this is intentionally fire-and-forget with its own catch.
+    pruneStaleAuthFiles(folder).catch(() => { });
+    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 = {};
+                    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);
+                        }
+                        data[id] = value;
+                    }));
+                    return data;
+                },
+                set: async (data) => {
+                    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));
+                        }
+                    }
+                    await Promise.all(tasks);
+                }
+            }
+        },
+        saveCreds: async () => {
+            return writeData(creds, 'creds.json');
+        }
+    };
+};
+//# sourceMappingURL=use-multi-file-auth-state.js.map

package/lib/Utils/use-single-file-auth-state.d.ts

@@ -0,0 +1,10 @@
+export function useSingleFileAuthState(fileName: any): Promise<{
+    state: {
+        creds: any;
+        keys: {
+            get: (type: any, ids: any) => {};
+            set: (data: any) => void;
+        };
+    };
+    saveCreds: () => void;
+}>;

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

@@ -0,0 +1,114 @@
+import { readFile, rename, stat, writeFile } from 'fs/promises';
+import { DEFAULT_CACHE_TTLS } from '../Defaults/index.js';
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+import { LRUCache } from 'lru-cache';
+import { Mutex } from 'async-mutex';
+import defaultLogger from './logger.js';
+// Lia@Changes 25-03-26 --- Add useSingleFileAuthState with integrated cache
+const FLUSH_TIMEOUT_MS = 3000;
+// Lia@Changes 22-04-26 --- Enhanced useSingleFileAuthState with LRUCache
+export const useSingleFileAuthState = async (fileName) => {
+    const cache = new LRUCache({
+        max: 20000,
+        ttl: 1000 * DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+        updateAgeOnGet: false,
+        updateAgeOnHas: false,
+        ttlAutopurge: true
+    });
+    // Lia@Changes 26-04-26 --- Add mutex for prevent race condition
+    const mutex = new Mutex();
+    let fileData = {};
+    let isLoaded = false;
+    let flushTimeout = null;
+    const loadKey = async () => {
+        return await mutex.runExclusive(async () => {
+            if (isLoaded)
+                return;
+            try {
+                const data = JSON.parse(await readFile(fileName, 'utf-8'), BufferJSON.reviver);
+                fileData = data || {};
+                for (const [keyName, value] of Object.entries(fileData)) {
+                    cache.set(keyName, value);
+                }
+            }
+            catch {
+                fileData = {};
+            }
+            isLoaded = true;
+        });
+    };
+    const flushKey = () => {
+        if (flushTimeout)
+            return;
+        flushTimeout = setTimeout(async () => {
+            flushTimeout = null;
+            await mutex.runExclusive(async () => {
+                try {
+                    const tempFile = fileName + '.temp';
+                    await writeFile(tempFile, JSON.stringify(fileData, BufferJSON.replacer));
+                    await rename(tempFile, fileName);
+                }
+                catch (err) {
+                    // Vanz@Fix (bug 58): was silently swallowed — auth session could fail
+                    // to persist (disk full, permission error, etc.) with zero trace.
+                    defaultLogger.error({ err, fileName }, 'failed to flush auth state to disk');
+                }
+            });
+        }, FLUSH_TIMEOUT_MS);
+    };
+    const writeKey = (keyName, value) => {
+        cache.set(keyName, value);
+        fileData[keyName] = value;
+        flushKey();
+    };
+    const removeKey = (keyName) => {
+        cache.delete(keyName);
+        delete fileData[keyName];
+        flushKey();
+    };
+    const fileInfo = await stat(fileName).catch(() => null);
+    if (!fileInfo) {
+        await writeFile(fileName, '{}');
+    }
+    else if (!fileInfo.isFile()) {
+        throw new Error(`found something that is not a file at ${fileName}, either delete it or specify a different location`);
+    }
+    await loadKey();
+    const creds = fileData['creds'] || initAuthCreds();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: (type, ids) => {
+                    const data = {};
+                    for (const id of ids) {
+                        const keyName = type + id;
+                        let value = cache.get(keyName);
+                        if (value === undefined && fileData[keyName] !== undefined) {
+                            value = fileData[keyName];
+                            cache.set(keyName, value);
+                        }
+                        if (type === 'app-state-sync-key' && value) {
+                            value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }
+                    return data;
+                },
+                set: (data) => {
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const keyName = category + id;
+                            const value = data[category][id];
+                            value ? writeKey(keyName, value) : removeKey(keyName);
+                        }
+                    }
+                }
+            }
+        },
+        saveCreds: () => writeKey('creds', creds)
+    };
+};
+//# sourceMappingURL=use-single-file-auth-state.js.map

package/lib/Utils/use-sqlite-auth-state.d.ts

@@ -0,0 +1,11 @@
+export function useSqliteAuthState(opts: any): Promise<{
+    state: {
+        creds: any;
+        keys: {
+            get: (type: any, ids: any) => Promise<{}>;
+            set: (data: any) => Promise<void>;
+        };
+    };
+    saveCreds: () => Promise<void>;
+    close: () => Promise<void>;
+}>;