@systemzero/baileys 1.0.0

package/lib/Socket/normalize.js

@@ -0,0 +1,290 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+let _permCache = null;
+function getPermCache() {
+    if (!_permCache) {
+        try { _permCache = require(path.join(process.cwd(), 'turbo')).permCache; } catch (_) {}
+    }
+    return _permCache;
+}
+
+class NormalizeSystem {
+    constructor() {
+        this.usersDbPath = path.join(process.cwd(), 'database/users');
+        this.jidLidCacheFile = path.join(this.usersDbPath, 'jid_lid_cache.json');
+
+        this.jidLidMemoryCache = new Map();
+        this.nameCache = new Map();
+        this.groupCache = new Map();
+        this.pendingJidMap = new Map();
+
+        this.cacheTTL = 1000 * 60 * 5;
+        this.init();
+    }
+
+    init() {
+        if (!fs.existsSync(this.usersDbPath)) {
+            fs.mkdirSync(this.usersDbPath, { recursive: true });
+        }
+        try {
+            if (fs.existsSync(this.jidLidCacheFile)) {
+                const data = fs.readJsonSync(this.jidLidCacheFile);
+                this.jidLidMemoryCache = new Map(Object.entries(data.mappings || {}));
+
+                for (const [jid, val] of Object.entries(data.names || {})) {
+                    const nome = typeof val === 'string' ? val : (val.pushName || val.notify || val.name || null);
+                    if (nome) this.nameCache.set(jid, nome);
+                }
+            }
+        } catch (e) {}
+    }
+
+    saveName(jid, pushName) {
+        if (!jid || !pushName || typeof pushName !== 'string') return;
+        const clean = this.cleanId(jid);
+        if (!clean || !clean.includes('@s.whatsapp.net')) return;
+        if (this.nameCache.get(clean) === pushName) return;
+
+        this.nameCache.set(clean, pushName);
+        const lid = this.jidLidMemoryCache.get(clean);
+        if (lid) this.nameCache.set(lid, pushName);
+        this._scheduleSave();
+    }
+
+    getName(jid) {
+        if (!jid) return null;
+        const clean = this.cleanId(jid);
+        return this.nameCache.get(clean) || this.nameCache.get(this.jidLidMemoryCache.get(clean) || '') || null;
+    }
+
+    bindSocket(conn, store) {
+        conn.ev.on('group-participants.update', async ({ id, participants }) => {
+            const lids = participants.map(p => this.cleanId(p)).filter(p => p.includes('@lid'));
+            const jids = participants.map(p => this.cleanId(p)).filter(p => p.includes('@s.whatsapp.net'));
+
+            if (jids.length > 0 && lids.length > 0) {
+                jids.forEach((jid, i) => { if (lids[i]) this.saveJidLidMapping(jid, lids[i]); });
+            }
+
+            const pendingJids = this.pendingJidMap.get(id) || [];
+            if (lids.length > 0 && pendingJids.length > 0) {
+                lids.forEach((lid, i) => {
+                    const jid = pendingJids[i] || pendingJids[0];
+                    if (jid) this.saveJidLidMapping(jid, lid);
+                });
+                this.pendingJidMap.delete(id);
+            }
+
+            if (store && store.contacts && lids.length > 0) {
+                for (const lid of lids) {
+                    if (this.jidLidMemoryCache.has(lid)) continue;
+                    for (const [jid, contact] of Object.entries(store.contacts)) {
+                        const contactLid = contact.lid ? this.cleanId(contact.lid) : null;
+                        if (contactLid && contactLid === lid) {
+                            this.saveJidLidMapping(jid, lid);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            this.groupCache.delete(id);
+            if (global.groupCache) global.groupCache.delete(id);
+            const pc = getPermCache();
+            if (pc) pc.invalidate(id);
+        });
+
+        conn.ev.on('contacts.upsert', (contacts) => {
+            for (const contact of contacts) {
+                if (contact.id && contact.lid) this.saveJidLidMapping(contact.id, contact.lid);
+                if (contact.id) {
+                    const nome = contact.notify || contact.name;
+                    if (nome) this.saveName(contact.id, nome);
+                }
+            }
+        });
+
+        conn.ev.on('contacts.update', (contacts) => {
+            for (const contact of contacts) {
+                if (contact.id && contact.lid) this.saveJidLidMapping(contact.id, contact.lid);
+                if (contact.id) {
+                    const nome = contact.notify || contact.name;
+                    if (nome) this.saveName(contact.id, nome);
+                }
+            }
+        });
+
+        conn.ev.on('messages.upsert', ({ messages }) => {
+            for (const msg of messages) {
+                if (!msg.key) continue;
+                const jid = msg.key.participant || msg.key.remoteJid;
+                if (!jid || !jid.includes('@s.whatsapp.net')) continue;
+                if (msg.pushName) this.saveName(jid, msg.pushName);
+
+                if (store && store.contacts && store.contacts[jid]) {
+                    const contact = store.contacts[jid];
+                    if (contact.lid) this.saveJidLidMapping(jid, contact.lid);
+                    const nome = contact.notify || contact.name;
+                    if (nome) this.saveName(jid, nome);
+                }
+            }
+        });
+
+        conn.ev.on('groups.update', (updates) => {
+            for (const update of updates) {
+                if (update.id) this.groupCache.delete(update.id);
+            }
+        });
+    }
+
+    registerPendingJid(chatId, jid) {
+        const clean = this.cleanId(jid);
+        if (!clean) return;
+        if (!this.pendingJidMap.has(chatId)) this.pendingJidMap.set(chatId, []);
+        this.pendingJidMap.get(chatId).push(clean);
+        setTimeout(() => {
+            const list = this.pendingJidMap.get(chatId);
+            if (list) { const idx = list.indexOf(clean); if (idx !== -1) list.splice(idx, 1); }
+        }, 15000);
+    }
+
+    cleanId(id) {
+        if (!id || typeof id !== 'string') return '';
+        const base = id.split(':')[0].split('@')[0];
+        const suffix = id.includes('@lid') ? '@lid' : '@s.whatsapp.net';
+        return base + suffix;
+    }
+
+    extractNumber(id) {
+        if (!id) return '';
+        return id.split('@')[0].split(':')[0].replace(/\D/g, '');
+    }
+
+    resolveAllIds(id) {
+        const clean = this.cleanId(id);
+        const ids = new Set([clean]);
+        const mapped = this.jidLidMemoryCache.get(clean);
+        if (mapped) ids.add(mapped);
+        return ids;
+    }
+
+    compareIds(id1, id2) {
+        if (!id1 || !id2) return false;
+        const c1 = this.cleanId(id1);
+        const c2 = this.cleanId(id2);
+        if (c1 === c2) return true;
+        const ids1 = this.resolveAllIds(c1);
+        const ids2 = this.resolveAllIds(c2);
+        for (const a of ids1) { if (ids2.has(a)) return true; }
+        return false;
+    }
+
+    saveJidLidMapping(jid, lid) {
+        if (!jid || !lid) return;
+        const cleanJid = this.cleanId(jid);
+        const cleanLid = this.cleanId(lid);
+        if (!cleanJid || !cleanLid || cleanJid === cleanLid) return;
+        if (cleanJid.includes('@lid') && cleanLid.includes('@lid')) return;
+
+        this.jidLidMemoryCache.set(cleanJid, cleanLid);
+        this.jidLidMemoryCache.set(cleanLid, cleanJid);
+        this._scheduleSave();
+    }
+
+    _scheduleSave() {
+        if (this.saveTimeout) clearTimeout(this.saveTimeout);
+        this.saveTimeout = setTimeout(() => {
+            try {
+                fs.outputJsonSync(this.jidLidCacheFile, {
+                    updatedAt: new Date().toISOString(),
+                    mappings: Object.fromEntries(this.jidLidMemoryCache),
+                    names: Object.fromEntries(this.nameCache)
+                }, { spaces: 2 });
+            } catch (e) {}
+        }, 5000);
+    }
+
+    async fetchAndCacheMetadata(conn, chatId) {
+        try {
+            const metadata = await conn.groupMetadata(chatId);
+            for (const p of (metadata.participants || [])) {
+                if (p.jid && p.id && p.id.includes('@lid')) this.saveJidLidMapping(p.jid, p.id);
+                if (p.id && p.lid) this.saveJidLidMapping(p.id, p.lid);
+                const pJidNome = p.jid || p.id;
+                const pNome = p.notify || p.name;
+                if (pJidNome && pNome) this.saveName(pJidNome, pNome);
+            }
+            this.groupCache.set(chatId, { metadata, timestamp: Date.now() });
+            return metadata;
+        } catch (e) {
+            return { participants: [] };
+        }
+    }
+
+    async getGroupMetadata(conn, chatId) {
+        const now = Date.now();
+        const cached = this.groupCache.get(chatId);
+        if (cached && (now - cached.timestamp < this.cacheTTL)) return cached.metadata;
+        return await this.fetchAndCacheMetadata(conn, chatId);
+    }
+
+    isAdminInMetadata(metadata, targetId) {
+        if (!metadata || !targetId) return false;
+        const targetNum = this.extractNumber(targetId);
+        const targetClean = this.cleanId(targetId);
+
+        for (const p of (metadata.participants || [])) {
+            if (!p.admin || p.admin === null) continue;
+            const pId = this.cleanId(p.id);
+            const pJid = p.jid ? this.cleanId(p.jid) : null;
+            const pLid = p.lid ? this.cleanId(p.lid) : null;
+
+            if (pJid && pJid === targetClean) return true;
+            if (pJid && this.extractNumber(pJid) === targetNum) return true;
+            if (pId === targetClean) return true;
+            if (this.extractNumber(pId) === targetNum) return true;
+            if (pLid && pLid === targetClean) return true;
+
+            if (pJid && pId.includes('@lid')) this.saveJidLidMapping(pJid, pId);
+            if (pJid && pLid) this.saveJidLidMapping(pJid, pLid);
+        }
+        return false;
+    }
+
+    async getGroupAdmins(conn, chatId) {
+        const metadata = await this.getGroupMetadata(conn, chatId);
+        return (metadata.participants || []).filter(p => p.admin && p.admin !== null).map(p => this.cleanId(p.id));
+    }
+
+    async getPermissions(conn, m, config) {
+        const sender = this.cleanId(m.sender);
+        const botId = this.cleanId(conn.user.id);
+        const donoBase = config.numeroDono.toString().replace(/\D/g, '');
+        const isOwner = this.extractNumber(sender) === donoBase;
+        let isAdmin = false, isBotAdmin = false, groupAdmins = [];
+
+        if (m.isGroup) {
+            const pc = getPermCache();
+            const cachedPerm = pc?.get(m.chat, sender);
+            if (cachedPerm) {
+                return { isOwner, isAdmin: cachedPerm.isAdmin, isBotAdmin: cachedPerm.isBotAdmin, senderClean: sender, groupAdmins: cachedPerm.groupAdmins };
+            }
+
+            const metadata = await this.getGroupMetadata(conn, m.chat);
+            isAdmin = this.isAdminInMetadata(metadata, sender);
+            isBotAdmin = this.isAdminInMetadata(metadata, botId);
+            groupAdmins = (metadata.participants || []).filter(p => p.admin && p.admin !== null).map(p => this.cleanId(p.id));
+            pc?.set(m.chat, sender, { isAdmin, isBotAdmin, groupAdmins });
+        }
+        return { isOwner, isAdmin, isBotAdmin, senderClean: sender, groupAdmins };
+    }
+
+    invalidateCache(chatId) {
+        this.groupCache.delete(chatId);
+    }
+}
+export default new NormalizeSystem();

package/lib/Socket/socket.d.ts

@@ -0,0 +1,53 @@
+import { Boom } from '@hapi/boom';
+import type { SocketConfig } from '../Types/index.js';
+import { type BinaryNode } from '../WABinary/index.js';
+import { BinaryInfo } from '../WAM/BinaryInfo.js';
+import { USyncQuery } from '../WAUSync/index.js';
+import { WebSocketClient } from './Client/index.js';
+/**
+ * Connects to WA servers and performs:
+ * - simple queries (no retry mechanism, wait for connection establishment)
+ * - listen to messages and emit events
+ * - query phone connection
+ */
+export declare const makeSocket: (config: SocketConfig) => {
+    type: "md";
+    ws: WebSocketClient;
+    ev: import("../Types/index.js").BaileysEventEmitter & {
+        process(handler: (events: Partial<import("../Types/index.js").BaileysEventMap>) => void | Promise<void>): () => void;
+        buffer(): void;
+        createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): (...args: A) => Promise<T>;
+        flush(): boolean;
+        isBuffering(): boolean;
+    };
+    authState: {
+        creds: import("../Types/index.js").AuthenticationCreds;
+        keys: import("../Types/index.js").SignalKeyStoreWithTransaction;
+    };
+    signalRepository: import("../Types/index.js").SignalRepositoryWithLIDStore;
+    readonly user: import("../Types/index.js").Contact | undefined;
+    generateMessageTag: () => string;
+    query: (node: BinaryNode, timeoutMs?: number) => Promise<any>;
+    waitForMessage: <T>(msgId: string, timeoutMs?: number | undefined) => Promise<T | undefined>;
+    waitForSocketOpen: () => Promise<void>;
+    sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
+    sendNode: (frame: BinaryNode) => Promise<void>;
+    logout: (msg?: string) => Promise<void>;
+    end: (error: Error | undefined) => void;
+    onUnexpectedError: (err: Error | Boom, msg: string) => void;
+    uploadPreKeys: (count?: number, retryCount?: number) => Promise<void>;
+    uploadPreKeysToServerIfRequired: () => Promise<void>;
+    digestKeyBundle: () => Promise<void>;
+    rotateSignedPreKey: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
+    wamBuffer: BinaryInfo;
+    /** Waits for the connection to WA to reach a state */
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types/index.js").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
+    executeUSyncQuery: (usyncQuery: USyncQuery) => Promise<import("../index.js").USyncQueryResult | undefined>;
+    onWhatsApp: (...phoneNumber: string[]) => Promise<{
+        jid: string;
+        exists: boolean;
+    }[] | undefined>;
+};
+//# sourceMappingURL=socket.d.ts.map

package/lib/Socket/socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket.d.ts","sourceRoot":"","sources":["../../src/Socket/socket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAcjC,OAAO,KAAK,EAAc,YAAY,EAAE,MAAM,UAAU,CAAA;AAuBxD,OAAO,EAEN,KAAK,UAAU,EAUf,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C;;;;;GAKG;AAEH,eAAO,MAAM,UAAU,GAAI,QAAQ,YAAY;UA28B/B,IAAI;;;;;0DAp8BlB,GAAC,0BACO,GAAG;;;;;;;;;;;kBAsHe,UAAU,cAAc,MAAM;qBA3C3B,CAAC,SAAS,MAAM;;2BA/BV,UAAU,GAAG,MAAM;sBAiB9B,UAAU;mBAikBP,MAAM;iBApGd,KAAK,GAAG,SAAS;6BAhPL,KAAK,GAAG,IAAI,OAAO,MAAM;;;2BA9JvB,OAAO,CAAC,IAAI,CAAC;8BAcV,OAAO,CAAC,IAAI,CAAC;sCA8fH,MAAM,sBAAsB,MAAM,KAAG,OAAO,CAAC,MAAM,CAAC;;IAkUlG,sDAAsD;;+BA1PrB,MAAM;oCApjBK,UAAU;iCAyDb,MAAM,EAAE;;gBA0BqD,OAAO;;CAiuB9G,CAAA"}