@innovatorssoft/innovators-bot2 1.2.8

package/index.js

@@ -0,0 +1,1494 @@
+const {
+    makeWASocket,
+    Browsers,
+    useMultiFileAuthState,
+    DisconnectReason,
+    fetchLatestBaileysVersion,
+    fetchLatestWaWebVersion,
+    downloadMediaMessage,
+    getCurrentSenderInfo,
+    // JID Utilities
+    parseJid,
+    plotJid,
+    normalizePhoneToJid,
+    // Anti-Delete
+    MessageStore,
+    createMessageStoreHandler,
+    createAntiDeleteHandler
+} = require('@innovatorssoft/baileys');
+
+const { Sticker, StickerTypes } = require('wa-sticker-formatter');
+
+const { Boom } = require('@hapi/boom');
+const { EventEmitter } = require('events');
+const P = require('pino');
+const fs = require('fs');
+const path = require('path');
+const mime = require('mime');
+const figlet = require('figlet');
+const NodeCache = require('node-cache');
+
+process.title = 'INNOVATORS Soft WhatsApp Server 92 322 4559543'
+
+console.log(figlet.textSync('WELCOME To'))
+console.log(figlet.textSync('INNOVATORS'))
+console.log(figlet.textSync('SOFT'))
+
+class Group {
+    constructor(client, groupData) {
+        this.client = client
+        this.id = groupData.id
+        this.subject = groupData.subject
+        this.creation = groupData.creation
+        this.owner = groupData.owner
+        this.desc = groupData.desc
+        this.participants = groupData.participants
+    }
+}
+
+class WhatsAppClient extends EventEmitter {
+    constructor(config = {}) {
+        super()
+        this.sock = null
+        this.isConnected = false
+        this.sessionName = config.sessionName || 'auth_info_baileys'
+        this._connectionState = 'disconnected'
+        this.authmethod = config.authmethod || 'qr';
+        this._reconnectDelay = 5000;
+        this.pairingPhoneNumber = config.pairingPhoneNumber || null;
+        this.groupMetadataCache = new NodeCache({ stdTTL: 600, checkperiod: 120 });
+        this.messageStore = new MessageStore({
+            maxMessagesPerChat: config.maxMessagesPerChat || 1000,
+            ttl: config.messageTTL || 24 * 60 * 60 * 1000
+        });
+    }
+
+    /**
+     * Helper method to resolve LID to PN (Phone Number) if available and normalize JID
+     * @param {string} jid - The JID to resolve (could be LID or PN)
+     * @returns {Promise<string>} The resolved and normalized PN if LID mapping exists, otherwise the normalized original JID
+     * @private
+     */
+    async _resolveLidToPn(jid) {
+        if (!jid) return jid;
+
+        // If it's a LID, try to resolve it to PN
+        if (jid.endsWith('@lid')) {
+            try {
+                const phoneNumber = await this.getPNForLID(jid);
+                if (phoneNumber) {
+                    // Normalize the resolved PN by removing device ID
+                    return this._normalizeJid(phoneNumber);
+                }
+                return jid; // Return original LID if no PN found
+            } catch (error) {
+                console.error('Error resolving LID to PN:', error);
+                return jid; // Return original JID on error
+            }
+        }
+
+        // If it's already a PN or other format, normalize and return
+        return this._normalizeJid(jid);
+    }
+
+    /**
+     * Normalize JID by removing device ID suffix (e.g., :0)
+     * Converts 923014434335:0@s.whatsapp.net to 923014434335@s.whatsapp.net
+     * @param {string} jid - The JID to normalize
+     * @returns {string} Normalized JID
+     * @private
+     */
+    _normalizeJid(jid) {
+        if (!jid) return jid;
+
+        // Remove device ID (e.g., :0, :1, etc.) from the JID
+        // Pattern: number:deviceId@server becomes number@server
+        return jid.replace(/:\d+@/, '@');
+    }
+
+    async connect() {
+        try {
+
+            if (this._connectionState !== 'connecting') {
+                this._connectionState = 'connecting';
+                this.emit('connecting', 'Connecting to WhatsApp...');
+            }
+
+            const browserConfig = this.authmethod === 'pairing'
+                ? Browsers.windows('chrome')
+                : ["Innovators Soft", "chrome", "1000.26100.275.0"];
+
+            const { version: baileysVersion, isLatest: baileysIsLatest } = await fetchLatestBaileysVersion();
+            const { version: waWebVersion, isLatest: waWebIsLatest } = await fetchLatestWaWebVersion();
+
+            console.log('Using Baileys Version:', baileysVersion, baileysIsLatest ? ' isLatest true' : ' isLatest false');
+            console.log('Using WhatsApp Web Version:', waWebVersion, waWebIsLatest ? ' isLatest true' : ' isLatest false');
+
+            const { state, saveCreds } = await useMultiFileAuthState(this.sessionName)
+            const logger = P({ level: 'silent' })
+
+            this.sock = makeWASocket({
+                auth: state,
+                logger,
+                markOnlineOnConnect: false,
+                syncFullHistory: true,
+                generateHighQualityLinkPreview: true,
+                linkPreviewImageThumbnailWidth: 192,
+                emitOwnEvents: true,
+                browser: browserConfig,
+                version: waWebVersion,
+                cachedGroupMetadata: async (jid) => {
+                    const cached = this.groupMetadataCache.get(jid);
+                    if (cached) {
+                        return cached;
+                    }
+                    try {
+                        const metadata = await this.sock.groupMetadata(jid);
+                        this.groupMetadataCache.set(jid, metadata);
+                        return metadata;
+                    } catch (error) {
+                        console.error(`Error fetching metadata for group ${jid}:`, error);
+                        return null;
+                    }
+                }
+            });
+
+            this.store = this.sock.signalRepository.lidMapping;
+
+
+
+            this.sock.ev.on('connection.update', async (update) => {
+                const { connection, lastDisconnect, qr } = update;
+
+                if (qr && this.authmethod === 'qr') {
+                    this.emit('qr', qr);
+                }
+                if (connection === 'open') {
+                    if (this._connectionState !== 'connected') {
+                        const user = getCurrentSenderInfo(this.sock.authState)
+                        if (user) {
+                            const userInfo = {
+                                name: user.pushName || 'Unknown',
+                                phone: user.phoneNumber,
+                                platform: user.platform || 'Unknown',
+                                isOnline: true
+                            };
+                            this.isConnected = true;
+                            this._connectionState = 'connected';
+                            this.emit('connected', userInfo);
+                        }
+                    }
+                }
+                else if (connection === 'close') {
+                    const shouldReconnect = (lastDisconnect?.error instanceof Boom) ?
+                        lastDisconnect.error?.output?.statusCode !== DisconnectReason.loggedOut : true;
+
+                    if (this._connectionState !== 'disconnected') {
+                        this.isConnected = false;
+                        this._connectionState = 'disconnected';
+                        this.emit('disconnected', lastDisconnect?.error);
+                    }
+
+                    if (shouldReconnect) {
+                        this.connect();
+                    } else if (lastDisconnect?.error?.output?.statusCode === DisconnectReason.loggedOut) {
+                        await this.reinitialize();
+                    }
+                }
+
+                // Handle pairing code request after connection is established but before login
+                if (this.authmethod === 'pairing' && connection === 'connecting' && !state.creds?.registered) {
+                    const phoneNumber = this.pairingPhoneNumber;
+
+                    if (phoneNumber) {
+                        try {
+                            // Wait a bit for the connection to initialize properly
+                            setTimeout(async () => {
+                                const customeCode = "INOVATOR";
+                                try {
+                                    const code = await this.sock.requestPairingCode(phoneNumber, customeCode);
+                                    if (code) {
+                                        // Emit pairing code event so clients can handle it
+                                        this.emit('pairing-code', formatCode(code));
+                                    } else {
+                                        console.log("❌ Pairing code not found.");
+                                    }
+                                } catch (error) {
+                                    console.error('Error requesting pairing code:', error);
+                                    this.emit('error', error);
+                                }
+                            }, 2000); // Wait 2 seconds before requesting pairing code
+                        } catch (error) {
+                            console.error('Error setting timeout for pairing code:', error);
+                            this.emit('error', error);
+                        }
+                    }
+                }
+            })
+
+            /**
+             * Handle incoming messages
+             * @emits WhatsAppClient#message - When a new message is received
+             * @param {object} update - The message update object
+             */
+
+            this.sock.ev.on('messages.upsert', async (update) => {
+                // 📝 Store message for the Anti-Delete system
+                createMessageStoreHandler(this.messageStore)(update);
+
+                try {
+                    if (update.type !== 'notify' || !update.messages?.length) return;
+                    const [message] = update.messages;
+                    if (!message || message.key?.fromMe) return;
+
+                    // 🚫 Ignore all protocol messages (history sync, security notifications, app state sync, deleted messages, etc.)
+                    if (message.message?.protocolMessage) return;
+
+                    const msg = message.message || {};
+
+
+                    let jid = message.key.remoteJid;
+
+                    // Prefer PN (Phone Number) JID over LID for better compatibility
+                    // remoteJidAlt contains the alternate JID (PN if primary is LID, or vice versa)
+                    if (typeof message.key.remoteJidAlt === 'string' &&
+                        message.key.remoteJidAlt.endsWith('@s.whatsapp.net')
+                    ) {
+                        jid = message.key.remoteJidAlt;
+                    }
+                    // Resolve the actual sender (preferring PN over LID)
+                    const participant = message.key.participant || message.participant || null;
+                    const participantAlt = message.key.participantAlt || null;
+
+                    let sender = jid;
+                    if (jid.endsWith('@g.us') || jid === 'status@broadcast') {
+                        sender = (participantAlt && participantAlt.endsWith('@s.whatsapp.net'))
+                            ? participantAlt
+                            : (participant || jid);
+                    }
+
+                    // Resolve LID to PN for sender if needed
+                    sender = await this._resolveLidToPn(sender);
+
+                    const timestamp = new Date((message.messageTimestamp || Date.now()) * 1000);
+
+                    const getText = () =>
+                        msg.conversation ||
+                        msg.extendedTextMessage?.text ||
+                        msg.imageMessage?.caption ||
+                        msg.videoMessage?.caption ||
+                        '';
+
+                    const getButtonText = () => {
+                        if (msg.listResponseMessage)
+                            return msg.listResponseMessage.title || msg.listResponseMessage.description || '';
+                        if (msg.templateButtonReplyMessage)
+                            return msg.templateButtonReplyMessage.selectedDisplayText || msg.templateButtonReplyMessage.selectedId || '';
+                        if (msg.buttonsResponseMessage)
+                            return msg.buttonsResponseMessage.selectedDisplayText || msg.buttonsResponseMessage.selectedButtonId || '';
+                        if (msg.interactiveResponseMessage) {
+                            const i = msg.interactiveResponseMessage;
+                            return i.listResponse?.title ||
+                                i.listResponse?.description ||
+                                i.nativeFlowResponse?.response?.reply ||
+                                i.reply ||
+                                i.buttonReplyMessage?.displayText || '';
+                        }
+                        return '';
+                    };
+
+                    const reply = async (text) => this.sock.sendMessage(jid, { text }, { quoted: message, ai: true });
+
+                    // ✅ Handle status updates (stories)
+                    if (jid === 'status@broadcast') {
+                        this.emit('status', {
+                            from: sender,
+                            sender,
+                            participant,
+                            participantAlt,
+                            body: getText(),
+                            hasMedia: Boolean(msg.imageMessage || msg.videoMessage),
+                            timestamp,
+                            key: message.key,
+                            raw: message,
+                            // Reply to status
+                            reply: async (text) => {
+                                if (!sender) throw new Error('Missing participant JID');
+                                return this.sock.sendMessage(sender, { text }, { quoted: message, ai: true });
+                            },
+                            // 👍 Like (react) to status
+                            like: async (emoji = '❤️') => {
+                                if (!sender) throw new Error('Missing participant JID');
+
+                                // Read the message first
+                                try {
+                                    await this.sock.readMessages([message.key]);
+                                } catch (readError) {
+                                    console.error('Error reading status message:', readError);
+                                }
+
+                                // Then send the reaction
+                                return this.sock.sendMessage(sender, {
+                                    react: {
+                                        text: emoji,
+                                        key: message.key
+                                    }
+                                }, { ai: true });
+                            }
+                        });
+                        return;
+                    }
+
+                    // ✅ Handle normal/chat messages
+                    const buttonText = getButtonText();
+                    const body = buttonText || getText() ||
+                        msg.listResponseMessage?.singleSelectReply?.selectedRowId || '';
+
+                    this.emit('message', {
+                        from: jid,
+                        sender,
+                        participant,
+                        participantAlt,
+                        body,
+                        hasMedia: Boolean(msg.imageMessage || msg.videoMessage || msg.audioMessage || msg.documentMessage),
+                        isGroup: jid.endsWith('@g.us'),
+                        timestamp,
+                        isButtonResponse: Boolean(buttonText),
+                        buttonId: msg?.listResponseMessage?.singleSelectReply?.selectedRowId ||
+                            msg?.templateButtonReplyMessage?.selectedId ||
+                            msg?.buttonsResponseMessage?.selectedButtonId || null,
+                        buttonText,
+                        raw: message,
+                        reply,
+                    });
+                } catch (err) {
+                    console.error('Error processing message:', err);
+                }
+            });
+
+            // 🛡️ Anti-Delete System: Handle message revokes/deletions
+            const antiDeleteHandler = createAntiDeleteHandler(this.messageStore);
+
+            this.sock.ev.on('messages.update', (updates) => {
+                const deletedMessages = antiDeleteHandler(updates);
+                for (const info of deletedMessages) {
+                    let jid = info.key.remoteJid;
+                    if (typeof info.key.remoteJidAlt === 'string' && info.key.remoteJidAlt.endsWith('@s.whatsapp.net')) {
+                        jid = info.key.remoteJidAlt;
+                    }
+
+                    this.emit('message-deleted', {
+                        jid: jid,
+                        originalMessage: info.originalMessage,
+                        key: info.key
+                    });
+                }
+            });
+
+            // 👍 Handle message reactions
+            this.sock.ev.on('messages.reaction', async (reactions) => {
+                try {
+                    for (const reaction of reactions) {
+                        // Get the chat JID, preferring PN over LID
+                        let jid = reaction.key.remoteJid;
+                        if (typeof reaction.key.remoteJidAlt === 'string' &&
+                            reaction.key.remoteJidAlt.endsWith('@s.whatsapp.net')) {
+                            jid = reaction.key.remoteJidAlt;
+                        }
+
+                        // Resolve the sender (who reacted), preferring PN over LID
+                        const participant = reaction.key.participant || null;
+                        const participantAlt = reaction.key.participantAlt || null;
+
+                        let sender = jid;
+                        if (jid.endsWith('@g.us') || jid === 'status@broadcast') {
+                            sender = (participantAlt && participantAlt.endsWith('@s.whatsapp.net'))
+                                ? participantAlt
+                                : (participant || jid);
+                        }
+
+                        // Resolve LID to PN for sender if needed
+                        sender = await this._resolveLidToPn(sender);
+
+                        // Emit the reaction event
+                        this.emit('message-reaction', {
+                            from: jid,
+                            sender: sender,
+                            participant: participant,
+                            participantAlt: participantAlt,
+                            emoji: reaction.reaction?.text || null,
+                            isRemoved: !reaction.reaction?.text,
+                            messageKey: reaction.key,
+                            timestamp: new Date(),
+                            raw: reaction
+                        });
+                    }
+                } catch (error) {
+                    console.error('Error processing message reaction:', error);
+                }
+            });
+
+            // Handle incoming calls
+            this.sock.ev.on('call', async (call) => {
+                try {
+                    // Extract phone number from LID if available
+                    for (const callData of call) {
+                        if (callData.chatId || callData.from) {
+                            const jid = callData.chatId || callData.from;
+
+                            // Resolve LID to PN using the helper method
+                            const resolvedJid = await this._resolveLidToPn(jid);
+                            callData.phoneNumber = resolvedJid.split(':')[0].split('@')[0];
+                        }
+                    }
+
+                    await this.emit('call', call);
+                } catch (error) {
+                    console.error('Error in call handler:', error);
+                    this.emit('error', error);
+                }
+            });
+
+            // Handle LID/PN mapping updates
+            this.sock.ev.on('lid-mapping.update', async (update) => {
+                try {
+                    // Store the mapping for future use
+                    if (update && Object.keys(update).length > 0) {
+                        // The update object contains PN -> LID mappings
+                        // They are automatically stored in sock.signalRepository.lidMapping
+                        this.emit('lid-mapping-update', update);
+                    }
+                } catch (error) {
+                    console.error('Error processing LID mapping update:', error);
+                }
+            });
+
+            // Handle credential updates
+            this.sock.ev.on('creds.update', saveCreds);
+
+            // Handle group events to keep the cache updated
+            this.sock.ev.on('groups.upsert', (groups) => {
+                for (const group of groups) {
+                    this.updateGroupMetadataCache(group.id, group);
+                }
+            });
+
+            this.sock.ev.on('groups.update', (groups) => {
+                for (const group of groups) {
+                    // Get existing cache and update it with new information
+                    const cached = this.groupMetadataCache.get(group.id);
+                    if (cached) {
+                        // Merge the updated fields with existing cached data
+                        const updated = { ...cached, ...group };
+                        this.updateGroupMetadataCache(group.id, updated);
+                    }
+                }
+            });
+
+            this.sock.ev.on('group-participants.update', async (update) => {
+                // When participants change, refresh the group metadata
+                try {
+                    const metadata = await this.sock.groupMetadata(update.id);
+                    this.updateGroupMetadataCache(update.id, metadata);
+                } catch (error) {
+                    // Check if group no longer exists or bot was removed (404 item-not-found)
+                    const isNotFound = error.data === 404 ||
+                        error.message?.includes('item-not-found') ||
+                        error.output?.statusCode === 404;
+
+                    if (isNotFound) {
+                        // Group no longer exists or bot was removed - clean up cache
+                        this.clearGroupMetadataCache(update.id);
+                        this.emit('group-left', {
+                            id: update.id,
+                            reason: 'Group not found or bot was removed'
+                        });
+                    } else {
+                        console.error(`Error refreshing metadata for group ${update.id}:`, error);
+                    }
+                }
+            });
+
+        } catch (error) {
+            console.error('Error in connect:', error);
+            this.emit('error', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Send a message to a chat
+     * @param {string} chatId - The ID of the chat to send the message to
+     * @param {string|object} message - The message content (string) or message object
+     * @param {object} options - Additional options for sending the message
+     * @returns {Promise<object>} The sent message info
+     * @throws {Error} If client is not connected or message sending fails
+     */
+    async sendMessage(chatId, message, options = {}) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        let messageContent = {};
+
+        // Handle different message types
+        if (typeof message === 'string') {
+            messageContent = { text: message };
+        } else if (message && typeof message === 'object') {
+            // Handle different message types
+            switch (message.type) {
+                case 'text':
+                    messageContent = { text: message.text };
+                    if (message.mentions) {
+                        messageContent.mentions = message.mentions;
+                    }
+                    break;
+
+                case 'location':
+                    messageContent = {
+                        location: {
+                            degreesLatitude: message.latitude,
+                            degreesLongitude: message.longitude,
+                            name: message.name,
+                            address: message.address
+                        }
+                    };
+                    break;
+
+                case 'contact':
+                    messageContent = {
+                        contacts: {
+                            displayName: message.fullName,
+                            contacts: [{
+                                displayName: message.fullName,
+                                vcard: `BEGIN:VCARD\nVERSION:3.0\n` +
+                                    `FN:${message.fullName}\n` +
+                                    (message.organization ? `ORG:${message.organization};\n` : '') +
+                                    (message.phoneNumber ? `TEL;type=CELL;type=VOICE;waid=${message.phoneNumber}:+${message.phoneNumber}\n` : '') +
+                                    'END:VCARD'
+                            }]
+                        }
+                    };
+                    break;
+
+                case 'reaction':
+                    messageContent = {
+                        react: {
+                            text: message.emoji,
+                            key: message.messageKey || message.message?.key || message.key
+                        }
+                    };
+                    break;
+
+                default:
+                    throw new Error('Invalid message type');
+            }
+        } else {
+            throw new Error('Invalid message content');
+        }
+
+        try {
+            return await this.sock.sendMessage(chatId, messageContent, { ...options, ai: true });
+        } catch (error) {
+            console.error('Error sending message:', error);
+            throw error;
+        }
+    }
+    /**
+     * Send a media file to a chat
+     * @param {string} chatId - The ID of the chat to send the media to
+     * @param {string} filePath - Path to the media file
+     * @param {object} options - Additional options for the media message
+     * @returns {Promise<object>} The sent message info
+     * @throws {Error} If client is not connected or file not found
+     */
+    async sendMedia(chatId, filePath, options = {}) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            // Check if file exists
+            if (!fs.existsSync(filePath)) {
+                throw new Error('File not found: ' + filePath);
+            }
+
+            const fileExtension = path.extname(filePath).toLowerCase();
+            const caption = options.caption || '';
+            let mediaMessage = {};
+
+            // Handle different media types
+            switch (fileExtension) {
+                case '.gif':
+                case '.mp4':
+                    mediaMessage = {
+                        video: fs.readFileSync(filePath),
+                        caption: caption,
+                        gifPlayback: options.asGif || fileExtension === '.gif',
+                    }
+                    break;
+
+                // Handle audio files
+                case '.mp3':
+                case '.ogg':
+                case '.wav':
+                    mediaMessage = {
+                        audio: {
+                            url: filePath
+                        },
+                        mimetype: 'audio/mp4',
+                    };
+                    break;
+
+                // Handle image files
+                case '.jpg':
+                case '.jpeg':
+                case '.png':
+                    mediaMessage = {
+                        image: fs.readFileSync(filePath),
+                        caption: caption,
+                    };
+                    break;
+
+                default:
+                    throw new Error('Unsupported file type: ' + fileExtension);
+            }
+
+            return await this.sock.sendMessage(chatId, mediaMessage, { ai: true });
+        } catch (error) {
+            console.error('Error sending media:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Send a document to a chat
+     * @param {string} chatId - The ID of the chat to send the document to
+     * @param {string} filePath - Path to the document file
+     * @param {string} [caption=''] - Optional caption for the document
+     * @returns {Promise<object>} The sent message info
+     * @throws {Error} If client is not connected or file not found
+     */
+    async sendDocument(chatId, filePath, caption = '') {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            // Check if file exists
+            if (!fs.existsSync(filePath)) {
+                throw new Error('File not found: ' + filePath);
+            }
+
+            const fileBuffer = fs.readFileSync(filePath);
+            const fileName = path.basename(filePath);
+            const mimeType = mime.getType(filePath);
+
+            return await this.sock.sendMessage(chatId, {
+                document: fileBuffer,
+                caption: caption,
+                mimetype: mimeType,
+                fileName: fileName,
+            }, { ai: true });
+        } catch (error) {
+            console.error('Error sending document:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Send a message with interactive buttons
+     * @param {string} chatId - The ID of the chat to send the message to
+     * @param {object} options - Options for the button message
+     * @param {string} [options.text] - The text content of the message
+     * @param {string} [options.imagePath] - Optional path to an image to include
+     * @param {string} [options.caption] - Caption for the image
+     * @param {string} [options.title] - Title for the message
+     * @param {string} [options.footer] - Footer text for the message
+     * @param {Array} [options.interactiveButtons=[]] - Array of button objects
+     * @param {boolean} [options.hasMediaAttachment=false] - Whether the message has a media attachment
+     * @param {object} [extraOptions={}] - Additional options for the message
+     * @returns {Promise<object>} The sent message info
+     * @throws {Error} If client is not connected or message sending fails
+     */
+    async sendButtons(chatId, options = {}, extraOptions = {}) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        const {
+            text,
+            imagePath,
+            caption,
+            title,
+            footer,
+            interactiveButtons = [],
+            hasMediaAttachment = false,
+        } = options;
+
+        let messageContent = {};
+
+        try {
+            if (imagePath) {
+                // Handle message with image
+                const imageBuffer = fs.readFileSync(imagePath);
+                messageContent = {
+                    image: imageBuffer,
+                    caption: caption,
+                    title: title,
+                    footer: footer,
+                    interactiveButtons: interactiveButtons,
+                    hasMediaAttachment: hasMediaAttachment,
+                };
+            } else {
+                // Handle text-only message
+                messageContent = {
+                    text: text,
+                    title: title,
+                    footer: footer,
+                    interactiveButtons: interactiveButtons,
+                };
+            }
+
+            // Send the message with buttons
+            return await this.sock.sendMessage(chatId, messageContent, { ...extraOptions, ai: true });
+        } catch (error) {
+            console.error('Error sending buttons:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Send an interactive list message
+     * @param {string} chatId - The ID of the chat to send the list to
+     * @param {object} listOptions - Options for the list message
+     * @param {string} listOptions.text - The text content of the message
+     * @param {string} listOptions.title - Title of the list
+     * @param {string} [listOptions.footer=''] - Optional footer text
+     * @param {string} [listOptions.buttonText='Tap here'] - Text for the button
+     * @param {Array<object>} listOptions.sections - Array of section objects
+     * @returns {Promise<object>} The sent message info
+     * @throws {Error} If client is not connected or message sending fails
+     */
+    async SendList(chatId, listOptions) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            const listMessage = {
+                text: listOptions.text,
+                title: listOptions.title,
+                footer: listOptions.footer || '',
+                buttonText: listOptions.buttonText || 'Tap here',
+                sections: listOptions.sections.map((section) => ({
+                    title: section.title,
+                    rows: section.rows.map((row) => ({
+                        title: row.title,
+                        rowId: row.id,
+                        description: row.description,
+                    })),
+                })),
+            };
+
+            return await this.sock.sendMessage(chatId, listMessage, { ai: true });
+        } catch (error) {
+            console.error('Error sending list message:', error);
+            throw error;
+        }
+    }
+    /**
+     * Send an external ad reply with a local image
+     * @param {string} number - The phone number to send the ad to
+     * @param {string} localImagePath - Path to the local image file
+     * @param {string} title - Title of the ad
+     * @param {string} body - Body of the ad
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or message sending fails
+     */
+
+    async sendAdReply(number, msg, imgpath, title, body, sourceurl) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+
+            // Read the local image as Buffer
+            const bufferLocalFile = fs.readFileSync(imgpath);
+
+            // Send message with external ad reply using local image
+            await this.sock.sendMessage(number, {
+                text: msg,
+                contextInfo: {
+                    externalAdReply: {
+                        title: title || 'Ad Title',
+                        body: body || 'Ad Description',
+                        mediaType: 1, // Image
+                        previewType: 0,
+                        showAdAttribution: true,
+                        renderLargerThumbnail: true,
+                        thumbnail: bufferLocalFile,
+                        sourceUrl: sourceurl || 'https://m.facebook.com/innovatorssoft',
+                        mediaUrl: sourceurl || 'https://m.facebook.com/innovatorssoft'
+                    }
+                }
+            }, { ai: true });
+
+        } catch (err) {
+            console.error('Failed to send externalAdReply:', err);
+        }
+    }
+
+    /**
+     * Get all groups the bot is a member of
+     * @returns {Promise<Array<Group>>} Array of Group instances
+     * @throws {Error} If client is not connected or an error occurs
+     */
+    async getAllGroups() {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            const groupsData = await this.sock.groupFetchAllParticipating();
+            return Object.values(groupsData).map(
+                (groupData) => new Group(this, groupData)
+            );
+        } catch (error) {
+            console.error('Error fetching groups:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Add or remove participants from a group
+     * @param {string} groupId - The ID of the group
+     * @param {Array<string>} participantIds - Array of participant IDs to modify
+     * @param {string} action - Action to perform ('add', 'remove', 'promote', 'demote')
+     * @returns {Promise<Array>} Array of results for each participant update
+     * @throws {Error} If client is not connected or an error occurs
+     */
+    async changeGroupParticipants(groupId, participantIds, action) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        const results = [];
+
+        try {
+            for (const participantId of participantIds) {
+                try {
+                    let updateResult = await this.sock.groupParticipantsUpdate(
+                        groupId,
+                        [participantId],
+                        action
+                    );
+
+                    // Baileys may return various formats:
+                    // 1. Array: [{ status: 200, jid: '...' }]
+                    // 2. Array with nested: [{ '123@s.whatsapp.net': { code: 200 } }]
+                    // 3. Direct object: { status: 200, jid: '...' }
+                    let participantResult = Array.isArray(updateResult) ? updateResult[0] : updateResult;
+
+                    // Handle the { [jid]: { code: ... } } format
+                    if (participantResult && typeof participantResult === 'object') {
+                        // Check if the result has the participant JID as a key
+                        const jidKey = Object.keys(participantResult).find(k => k.includes('@'));
+                        if (jidKey && participantResult[jidKey]) {
+                            const innerResult = participantResult[jidKey];
+                            participantResult = {
+                                status: innerResult.code || innerResult.status || 200,
+                                jid: jidKey,
+                                message: innerResult.message || (innerResult.code == 200 ? 'Success' : undefined),
+                                ...innerResult
+                            };
+                        }
+                    }
+
+                    // Normalize status to number
+                    let status = participantResult?.status || participantResult?.code;
+
+                    // If no status but no error, assume success
+                    if (status === undefined && !participantResult?.error) {
+                        status = 200;
+                    }
+
+                    if (action === 'add' && (status === 403 || status === '403')) {
+                        try {
+                            await this.sendGroupInvitation(groupId, participantId, null);
+                            participantResult.invitationSent = true;
+                            participantResult.message = 'Invitation link sent due to privacy settings';
+                            participantResult.status = 403;
+                        } catch (invError) {
+                            participantResult.invitationSent = false;
+                            participantResult.error = 'Privacy restricted, and failed to send invitation link';
+                            participantResult.status = 403;
+                        }
+                    } else if (participantResult) {
+                        participantResult.status = status ? parseInt(status) : 200;
+                        if (participantResult.status === 200) {
+                            participantResult.message = participantResult.message || 'Successfully added to group';
+                        }
+                    }
+
+                    results.push(participantResult || { status: 200, jid: participantId, message: 'Added successfully' });
+                } catch (participantError) {
+
+                    const statusCode = participantError.output?.statusCode || participantError.data?.status;
+
+                    if (action === 'add' && (statusCode === 403 || statusCode === '403')) {
+                        try {
+                            await this.sendGroupInvitation(groupId, participantId, null);
+                            results.push({
+                                status: 403,
+                                jid: participantId,
+                                invitationSent: true,
+                                message: 'Invitation link sent due to privacy settings'
+                            });
+                            continue;
+                        } catch (invError) {
+                            console.error('Failed to send fallback invitation:', invError);
+                        }
+                    }
+
+                    results.push({
+                        status: statusCode || 500,
+                        jid: participantId,
+                        error: participantError.message || 'Unknown error'
+                    });
+                }
+            }
+            return results;
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    /**
+     * Get group name from metadata
+     * @param {string} groupId - The group JID
+     * @returns {Promise<string>} The group name
+     * @private
+     */
+    async _getGroupName(groupId) {
+        try {
+            const metadata = await this.getGroupMetadata(groupId);
+            return metadata.subject || 'Group';
+        } catch (error) {
+            console.error('Error getting group name:', error);
+            return 'Group';
+        }
+    }
+
+    /**
+     * Send a group invitation link to a user
+     * @param {string} groupId - The group JID
+     * @param {string} participantId - The participant JID to send invitation to
+     * @param {string} [customMessage] - Optional custom invitation message
+     * @returns {Promise<object>} The sent message info
+     * @throws {Error} If client is not connected or an error occurs
+     */
+
+    async sendGroupInvitation(groupId, participantId, customMessage) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            // Get group invite code
+            const inviteCode = await this.sock.groupInviteCode(groupId);
+            const groupName = await this._getGroupName(groupId);
+
+            // Create the invitation link
+            const inviteLink = `https://chat.whatsapp.com/${inviteCode}`;
+
+            // Create the invitation message
+            const message = customMessage
+                ? `${customMessage}\n\n${inviteLink}`
+                : `📨 *Group Invitation*\n\n` +
+                `You have been invited to join:\n` +
+                `*${groupName}*\n\n` +
+                `Click the link below to join:\n${inviteLink}`;
+
+            // Send as text message
+            return await this.sock.sendMessage(participantId, {
+                text: message
+            }, { ai: true });
+        } catch (error) {
+            console.error('Error sending group invitation:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Mark a message as read
+     * @param {object|string} messageKey - The message key object or message ID
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or an error occurs
+     */
+    async readMessage(messageKey) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            // If messageKey is a string (legacy), convert to key object format
+            // Otherwise use it directly as a key object
+            if (typeof messageKey === 'string') {
+                // Legacy support: just ID string
+                await this.sock.readMessages([{ id: messageKey }]);
+            } else {
+                // Proper key object with remoteJid, id, fromMe, etc.
+                await this.sock.readMessages([messageKey]);
+            }
+        } catch (error) {
+            console.error('Error marking message as read:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Check if a phone number is registered on WhatsApp
+     * @param {string} phoneNumber - The phone number to check (with country code, without '+')
+     * @returns {Promise<boolean>} True if the number is on WhatsApp, false otherwise
+     * @throws {Error} If an error occurs during the check
+     */
+    async isNumberOnWhatsApp(phoneNumber) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            const result = await this.sock.onWhatsApp(phoneNumber);
+            return result.length > 0 && result[0].exists === true;
+        } catch (error) {
+            console.error('Error checking if number is on WhatsApp:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Get the profile picture URL for a contact or group
+     * @param {string} id - The contact or group JID
+     * @returns {Promise<string|undefined>} The profile picture URL, or undefined if not available
+     */
+    async getProfilePicture(id) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            return await this.sock.profilePictureUrl(id);
+        } catch (error) {
+            // If the error is because the user has no profile picture, return undefined
+            const isStatus = (err, code) => (
+                (err && typeof err.message === 'string' && err.message.includes(String(code))) ||
+                (err && (err.status === code || err.code === code || err.data === code)) ||
+                (err && err.response && err.response.status === code) ||
+                (err && err.output && err.output.statusCode === code)
+            );
+            if (isStatus(error, 404) || isStatus(error, 401)) {
+                return undefined;
+            }
+            console.error('Error getting profile picture:', error);
+            throw error;
+        }
+    }
+    /**
+     * Reject an incoming call
+     * @param {string} callId - The ID of the call to reject
+     * @param {object} callInfo - Additional call information
+     * @returns {Promise<void>}
+     */
+    async rejectCall(callId, callInfo) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            await this.sock.rejectCall(callId, callInfo);
+        } catch (error) {
+            console.error('Error rejecting call:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Get the underlying socket instance
+     * @returns {object} The socket instance
+     */
+    getSock() {
+        return this.sock;
+    }
+
+    /**
+     * Send typing indicator to a chat
+     * @param {string} jid - The JID of the chat
+     * @returns {Promise<void>}
+     */
+    async sendStateTyping(jid) {
+        if (!this.sock) throw new Error('Not connected to WhatsApp');
+        await this.sock.sendPresenceUpdate("composing", jid);
+    }
+
+    /**
+     * Send recording indicator to a chat
+     * @param {string} jid - The JID of the chat
+     * @returns {Promise<void>}
+     */
+    async sendStateRecording(jid) {
+        if (!this.sock) throw new Error('Not connected to WhatsApp');
+        await this.sock.sendPresenceUpdate("recording", jid);
+    }
+
+    /**
+     * Clear typing/recording indicator from a chat
+     * @param {string} jid - The JID of the chat
+     * @returns {Promise<void>}
+     */
+    async clearState(jid) {
+        if (!this.sock) throw new Error('Not connected to WhatsApp');
+        await this.sock.sendPresenceUpdate("paused", jid);
+    }
+
+    /**
+     * Reinitialize the WhatsApp client by clearing the session and reconnecting
+     * @returns {Promise<void>}
+     */
+    async reinitialize() {
+        try {
+            //console.log('Starting session reinitialization...');
+
+            // Reset connection state
+            this.isConnected = false;
+
+            // Clear the session data if it exists
+            if (fs.existsSync(this.sessionName)) {
+                await fs.promises.rm(this.sessionName, {
+                    recursive: true,
+                    force: true,
+                });
+                //console.log('Cleared existing session data');
+            }
+
+            // Clear any existing socket
+            if (this.sock) {
+                try {
+                    this.sock.ev.removeAllListeners();
+                    this.sock.end(undefined);
+                } catch (e) {
+                    console.error('Error while cleaning up socket:', e);
+                }
+                this.sock = null;
+            }
+
+            // Add a small delay before reconnecting
+            await new Promise(resolve => setTimeout(resolve, 1000));
+
+            // Reconnect with a fresh session
+            //console.log('Establishing new connection...');
+            await this.connect(1); // Start with attempt 1
+            this.emit('reinitialized');
+        } catch (error) {
+            console.error('Error during reinitialization:', error);
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Get LID (Local Identifier) for a phone number
+     * @param {string} phoneNumber - Phone number in format: '1234567890@s.whatsapp.net'
+     * @returns {Promise<string|undefined>} The LID for the phone number, or undefined if not found
+     */
+    async getLIDForPN(phoneNumber) {
+        if (!this.sock || !this.store) {
+            throw new Error('Client is not connected');
+        }
+        try {
+            return await this.store.getLIDForPN(phoneNumber);
+        } catch (error) {
+            console.error('Error getting LID for PN:', error);
+            return undefined;
+        }
+    }
+
+    /**
+     * Get Phone Number for a LID (Local Identifier)
+     * @param {string} lid - LID in format: '123456@lid'
+     * @returns {Promise<string|undefined>} The phone number for the LID, or undefined if not found
+     */
+    async getPNForLID(lid) {
+        if (!this.sock || !this.store) {
+            throw new Error('Client is not connected');
+        }
+        try {
+            return await this.store.getPNForLID(lid);
+        } catch (error) {
+            console.error('Error getting PN for LID:', error);
+            return undefined;
+        }
+    }
+
+    /**
+     * Get multiple LIDs for multiple phone numbers
+     * @param {Array<string>} phoneNumbers - Array of phone numbers
+     * @returns {Promise<Array<string>>} Array of LIDs
+     */
+    async getLIDsForPNs(phoneNumbers) {
+        if (!this.sock || !this.store) {
+            throw new Error('Client is not connected');
+        }
+        try {
+            return await this.store.getLIDsForPNs(phoneNumbers);
+        } catch (error) {
+            console.error('Error getting LIDs for PNs:', error);
+            return [];
+        }
+    }
+
+    /**
+     * Get group metadata with caching
+     * @param {string} jid - The group JID
+     * @returns {Promise<object>} The group metadata
+     */
+    async getGroupMetadata(jid) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        // Check cache first
+        const cached = this.groupMetadataCache.get(jid);
+        if (cached) {
+            return cached;
+        }
+
+        // Fetch from WhatsApp if not cached
+        try {
+            const metadata = await this.sock.groupMetadata(jid);
+            // Cache the result
+            this.groupMetadataCache.set(jid, metadata);
+            return metadata;
+        } catch (error) {
+            console.error(`Error fetching metadata for group ${jid}:`, error);
+            throw error;
+        }
+    }
+
+    /**
+     * Update group metadata in cache
+     * @param {string} jid - The group JID
+     * @param {object} metadata - The group metadata
+     */
+    updateGroupMetadataCache(jid, metadata) {
+        if (this.groupMetadataCache) {
+            this.groupMetadataCache.set(jid, metadata);
+        }
+    }
+
+    /**
+     * Clear group metadata from cache
+     * @param {string} jid - The group JID
+     */
+    clearGroupMetadataCache(jid) {
+        if (this.groupMetadataCache) {
+            this.groupMetadataCache.del(jid);
+        }
+    }
+
+    /**
+     * Clear all group metadata from cache
+     */
+    clearAllGroupMetadataCache() {
+        if (this.groupMetadataCache) {
+            this.groupMetadataCache.flushAll();
+        }
+    }
+
+    /**
+     * Log out from WhatsApp
+     * @returns {Promise<boolean>} True if logout was successful
+     * @throws {Error} If logout fails
+     */
+    async logout() {
+        if (!this.sock) {
+            this.emit('logout', 'Already logged out');
+            return true;
+        }
+
+        try {
+            // Properly close the socket connection
+            await this.sock.logout();
+            await this.sock.end();
+            this.sock = null;
+
+            // Remove session data if it exists
+            if (fs.existsSync(this.sessionName)) {
+                fs.rmSync(this.sessionName, {
+                    recursive: true,
+                    force: true,
+                });
+            }
+
+            // Update connection state and emit event
+            this.isConnected = false;
+            this.emit('logout', 'Logged out successfully');
+
+            return true;
+        } catch (error) {
+            console.error('Logout error:', error);
+            this.emit('error', new Error(`Failed to logout: ${error.message}`));
+            throw error;
+        }
+    }
+
+    /**
+     * Download media from a message
+     * @param {object} message - The message object containing media (must have raw property)
+     * @returns {Promise<object|null>} Object with buffer, mimetype, and extension, or null if no media
+     * @throws {Error} If client is not connected or download fails
+     */
+    async downloadMedia(message) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        // Check if message has media
+        const hasMedia = Boolean(
+            message.raw?.message?.imageMessage ||
+            message.raw?.message?.videoMessage ||
+            message.raw?.message?.audioMessage ||
+            message.raw?.message?.documentMessage
+        );
+
+        if (!hasMedia) {
+            return null;
+        }
+
+        try {
+            // Use Baileys' downloadMediaMessage function with the raw message
+            const buffer = await downloadMediaMessage(message.raw, 'buffer', {});
+
+            if (buffer) {
+                // Get the message content to determine file type
+                const messageContent = message.raw.message;
+                let mimetype = 'application/octet-stream';
+
+                // Determine mimetype from the message type
+                if (messageContent.imageMessage) {
+                    mimetype = messageContent.imageMessage.mimetype || 'image/jpeg';
+                } else if (messageContent.videoMessage) {
+                    mimetype = messageContent.videoMessage.mimetype || 'video/mp4';
+                } else if (messageContent.audioMessage) {
+                    mimetype = messageContent.audioMessage.mimetype || 'audio/ogg';
+                } else if (messageContent.documentMessage) {
+                    mimetype = messageContent.documentMessage.mimetype || 'application/octet-stream';
+                }
+
+                // Use mime.getExtension() to get the proper file extension
+                const extension = mime.getExtension(mimetype) || 'bin';
+
+                return {
+                    buffer,
+                    mimetype,
+                    extension,
+                    size: buffer.length
+                };
+            }
+
+            return null;
+        } catch (error) {
+            console.error('Error downloading media:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Parse JID information
+     * @param {string} jid - The JID to parse
+     * @returns {object} JID info (isLid, user, etc.)
+     */
+    parseJid(jid) {
+        return parseJid(jid);
+    }
+
+    /**
+     * Normalize phone number to WhatsApp JID
+     * @param {string} phone - Phone number
+     * @returns {string} Normalized JID
+     */
+    normalizePhoneToJid(phone) {
+        return normalizePhoneToJid(phone);
+    }
+
+    /**
+     * Plot JID (Convert between PN and LID if mapping is available)
+     * @param {string} jid - JID to plot
+     * @returns {string|undefined} Plotted JID
+     */
+    plotJid(jid) {
+        return plotJid(jid);
+    }
+
+    /**
+     * Send a sticker with metadata
+     * @param {string} chatId - Target chat JID
+     * @param {Buffer} webpBuffer - WebP sticker buffer
+     * @param {object} metadata - Sticker metadata (packName, author, etc.)
+     * @returns {Promise<object>} Sent message info
+     */
+    async sendSticker(chatId, buffer, metadata = {}) {
+        if (!this.isConnected) throw new Error('Client is not connected');
+
+        try {
+            const sticker = new Sticker(buffer, {
+                pack: metadata.packName || 'Innovators',
+                author: metadata.author || 'Innovators',
+                type: metadata.type || StickerTypes.FULL,
+                categories: metadata.categories || [],
+                id: metadata.id || 'innovators-bot',
+                quality: metadata.quality || 50
+            });
+
+            const stickerBuffer = await sticker.toBuffer();
+
+            return await this.sock.sendMessage(chatId, {
+                sticker: stickerBuffer
+            }, { ai: true });
+        } catch (error) {
+            console.error('Error generating sticker:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Add EXIF metadata to an existing WebP buffer
+     * @param {Buffer} buffer - WebP buffer
+     * @param {object} metadata - Metadata (packName, author)
+     * @returns {Buffer} Buffer with EXIF
+     */
+    async addExifToSticker(buffer, metadata = {}) {
+        try {
+            const sticker = new Sticker(buffer, {
+                pack: metadata.packName || 'Innovators',
+                author: metadata.author || 'Innovators'
+            });
+            return await sticker.toBuffer();
+        } catch (error) {
+            console.error('Error adding EXIF to sticker:', error);
+            throw error;
+        }
+    }
+}
+
+function formatCode(code) {
+    if (typeof code === 'string' && code.length === 8) {
+        return code.slice(0, 4) + ' - ' + code.slice(4);
+    }
+    return code;
+}
+
+module.exports = {
+    WhatsAppClient: WhatsAppClient,
+    Group: Group,
+}