jsdecryptor 4.0.3

package/davexcore/utility/delete.js

@@ -0,0 +1,182 @@
+const isAdmin = require('../../davelib/isAdmin');
+const store = require('../../davelib/lightweight_store');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function deleteCommand(sock, chatId, message, senderId) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    
+    try {
+        const isGroup = chatId.endsWith('@g.us');
+        let isSenderAdmin = true;
+        let isBotAdmin = true;
+
+        if (isGroup) {
+            const adminStatus = await isAdmin(sock, chatId, senderId);
+            isSenderAdmin = adminStatus.isSenderAdmin;
+            isBotAdmin = adminStatus.isBotAdmin;
+
+            if (!isBotAdmin) {
+                await sock.sendMessage(chatId, { 
+                    text: `✦ Bot needs to be admin` 
+                }, { quoted: fake });
+                return;
+            }
+
+            if (!isSenderAdmin && !message.key.fromMe) {
+                await sock.sendMessage(chatId, { 
+                    text: `✦ Admin only command` 
+                }, { quoted: fake });
+                return;
+            }
+        } else {
+            // Private chat: only allow if sender is the chat owner
+            if (senderId !== chatId && !message.key.fromMe) {
+                await sock.sendMessage(chatId, { 
+                    text: `✦ Only chat owner can delete` 
+                }, { quoted: fake });
+                return;
+            }
+        }
+
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text || '';
+        const parts = text.trim().split(/\s+/);
+        let countArg = 1;
+        if (parts.length > 1) {
+            const maybeNum = parseInt(parts[1], 10);
+            if (!isNaN(maybeNum) && maybeNum > 0) countArg = Math.min(maybeNum, 20);
+        }
+
+        const ctxInfo = message.message?.extendedTextMessage?.contextInfo || {};
+        const mentioned = Array.isArray(ctxInfo.mentionedJid) && ctxInfo.mentionedJid.length > 0 ? ctxInfo.mentionedJid[0] : null;
+        const repliedParticipant = ctxInfo.participant || null;
+        const repliedMsgId = ctxInfo.stanzaId || null;
+
+        let targetUser = null;
+        
+        if (repliedParticipant && repliedMsgId) {
+            targetUser = repliedParticipant;
+        } else if (mentioned) {
+            targetUser = mentioned;
+        } else {
+            targetUser = isGroup ? null : chatId;
+        }
+
+        if (!targetUser) {
+            await sock.sendMessage(chatId, { 
+                text: `✦ Reply to a user or mention them` 
+            }, { quoted: fake });
+            return;
+        }
+
+        // Get messages from store
+        const chatMessages = store.messages[chatId] || [];
+        if (chatMessages.length === 0) {
+            await sock.sendMessage(chatId, { 
+                text: `✦ No messages in store for this chat` 
+            }, { quoted: fake });
+            return;
+        }
+
+        const toDelete = [];
+        const seenIds = new Set();
+
+        // Add command message to deletion list (optional - remove if you don't want to delete the command)
+        if (message.key?.id) {
+            toDelete.push({
+                key: {
+                    id: message.key.id,
+                    remoteJid: chatId,
+                    participant: senderId,
+                    fromMe: message.key.fromMe || false
+                }
+            });
+            seenIds.add(message.key.id);
+        }
+
+        // Add replied message if exists
+        if (repliedMsgId && repliedParticipant) {
+            const repliedMsg = chatMessages.find(m => 
+                m.key.id === repliedMsgId && 
+                (m.key.participant === repliedParticipant || m.key.remoteJid === repliedParticipant)
+            );
+            
+            if (repliedMsg && !seenIds.has(repliedMsg.key.id)) {
+                toDelete.push(repliedMsg);
+                seenIds.add(repliedMsg.key.id);
+            } else {
+                // Try direct deletion
+                try {
+                    await sock.sendMessage(chatId, {
+                        delete: {
+                            remoteJid: chatId,
+                            fromMe: false,
+                            id: repliedMsgId,
+                            participant: repliedParticipant
+                        }
+                    });
+                    countArg--;
+                } catch (e) {}
+            }
+        }
+
+        // Find messages from target user
+        const userMessages = chatMessages.filter(m => {
+            const participant = m.key.participant || m.key.remoteJid;
+            return participant === targetUser && !seenIds.has(m.key.id) && !m.message?.protocolMessage;
+        });
+
+        // Sort by timestamp (newest first)
+        userMessages.sort((a, b) => (b.messageTimestamp || 0) - (a.messageTimestamp || 0));
+
+        // Add up to countArg messages
+        for (const msg of userMessages) {
+            if (toDelete.length >= countArg + 1) break;
+            if (!seenIds.has(msg.key.id)) {
+                toDelete.push(msg);
+                seenIds.add(msg.key.id);
+            }
+        }
+
+        if (toDelete.length === 0) {
+            await sock.sendMessage(chatId, { 
+                text: `✦ No recent messages found` 
+            }, { quoted: fake });
+            return;
+        }
+
+        let deletedCount = 0;
+        for (const m of toDelete) {
+            try {
+                const msgParticipant = m.key.participant || targetUser;
+                await sock.sendMessage(chatId, {
+                    delete: {
+                        remoteJid: chatId,
+                        fromMe: m.key.fromMe || false,
+                        id: m.key.id,
+                        participant: msgParticipant
+                    }
+                });
+                deletedCount++;
+                await new Promise(r => setTimeout(r, 300));
+            } catch (e) {
+                console.error('Delete error:', e.message);
+            }
+        }
+
+        // Remove command message from count in response
+        const actualDeleted = deletedCount - (message.key?.id ? 1 : 0);
+        
+        await sock.sendMessage(chatId, { 
+            text: `✦ Deleted ${actualDeleted} message${actualDeleted !== 1 ? 's' : ''}` 
+        }, { quoted: fake });
+
+    } catch (err) {
+        console.error('Delete command error:', err);
+        await sock.sendMessage(chatId, { 
+            text: `✦ Failed to delete messages` 
+        }, { quoted: fake });
+    }
+}
+
+module.exports = deleteCommand;

package/davexcore/utility/encrypt.js

@@ -0,0 +1,99 @@
+let Obfuscator;
+try { Obfuscator = require("javascript-obfuscator"); } catch { Obfuscator = null; }
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const lastUsed = new Map();
+const COOLDOWN_MS = 10000;
+
+function extractQuotedText(message) {
+    const contextInfo = 
+        message.message?.extendedTextMessage?.contextInfo ||
+        message.message?.imageMessage?.contextInfo ||
+        message.message?.videoMessage?.contextInfo ||
+        message.message?.documentMessage?.contextInfo ||
+        message.message?.audioMessage?.contextInfo;
+
+    if (!contextInfo?.quotedMessage) return null;
+
+    const quoted = contextInfo.quotedMessage;
+
+    return (
+        quoted.conversation ||
+        quoted.extendedTextMessage?.text ||
+        quoted.imageMessage?.caption ||
+        quoted.videoMessage?.caption ||
+        quoted.documentMessage?.caption ||
+        null
+    );
+}
+
+async function encryptCommand(sock, chatId, message) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    const senderId = message.key.participant || message.key.remoteJid;
+
+    const now = Date.now();
+    if (lastUsed.has(senderId) && now - lastUsed.get(senderId) < COOLDOWN_MS) {
+        const wait = Math.ceil((COOLDOWN_MS - (now - lastUsed.get(senderId))) / 1000);
+        return sock.sendMessage(chatId, { 
+            text: `*${botName}*\nPlease wait ${wait}s before using this again.`
+        }, { quoted: fake });
+    }
+
+    const rawText = message.message?.conversation || 
+                    message.message?.extendedTextMessage?.text || '';
+    const inlineCode = rawText.split(' ').slice(1).join(' ').trim();
+    const quotedCode = extractQuotedText(message);
+    const code = inlineCode || quotedCode;
+
+    if (!code) {
+        return sock.sendMessage(chatId, { 
+            text: `*${botName} OBFUSCATE*\n\nUsage:\n.encrypt <javascript code>\n.encrypt (reply to code message)`
+        }, { quoted: fake });
+    }
+
+    if (!Obfuscator) {
+        return sock.sendMessage(chatId, { 
+            text: `*${botName}*\nObfuscator module not installed.\nRun: npm install javascript-obfuscator`
+        }, { quoted: fake });
+    }
+
+    lastUsed.set(senderId, now);
+
+    try {
+        const obfuscationResult = Obfuscator.obfuscate(code, {
+            compact: true,
+            controlFlowFlattening: true,
+            controlFlowFlatteningThreshold: 1,
+            numbersToExpressions: true,
+            simplify: true,
+            stringArrayShuffle: true,
+            splitStrings: true,
+            stringArrayThreshold: 1
+        });
+
+        const encryptedCode = obfuscationResult.getObfuscatedCode();
+
+        if (encryptedCode.length > 4000) {
+            const buffer = Buffer.from(encryptedCode, 'utf-8');
+            await sock.sendMessage(chatId, {
+                document: buffer,
+                fileName: 'obfuscated.js',
+                mimetype: 'application/javascript',
+                caption: `*${botName}*\nObfuscated code (${encryptedCode.length} chars)`
+            }, { quoted: fake });
+        } else {
+            await sock.sendMessage(chatId, { 
+                text: encryptedCode
+            }, { quoted: fake });
+        }
+
+    } catch (error) {
+        console.error("Encrypt Error:", error);
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nFailed to obfuscate code.\nMake sure it is valid JavaScript.`
+        }, { quoted: fake });
+    }
+}
+
+module.exports = encryptCommand;

package/davexcore/utility/ethicalhacking.js

@@ -0,0 +1,108 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const axios = require('axios');
+
+async function ipLookupCommand(sock, chatId, message, args) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    const ip = args[0]?.trim();
+    
+    if (!ip) {
+        return sock.sendMessage(chatId, { 
+            text: `✦ *${botName}* IP Lookup\n\nUse: .iplookup <ip>\nExample: .iplookup 8.8.8.8` 
+        }, { quoted: fake });
+    }
+    
+    await sock.sendMessage(chatId, { react: { text: '⏳', key: message.key } });
+    
+    try {
+        const res = await axios.get(`http://ip-api.com/json/${ip}`, { timeout: 10000 });
+        const d = res.data;
+        if (d.status === 'success') {
+            const text = `✦ *${botName}* IP Lookup\n\nIP: ${d.query}\nCountry: ${d.country}\nRegion: ${d.regionName}\nCity: ${d.city}\nZIP: ${d.zip}\nISP: ${d.isp}\nOrg: ${d.org}\nTimezone: ${d.timezone}\nLat: ${d.lat}\nLon: ${d.lon}`;
+            await sock.sendMessage(chatId, { text }, { quoted: fake });
+            await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+        } else {
+            await sock.sendMessage(chatId, { 
+                text: `✦ *${botName}*\nInvalid IP or lookup failed` 
+            }, { quoted: fake });
+            await sock.sendMessage(chatId, { react: { text: '❌', key: message.key } });
+        }
+    } catch (err) {
+        await sock.sendMessage(chatId, { 
+            text: `✦ *${botName}*\nError: ${err.message}` 
+        }, { quoted: fake });
+        await sock.sendMessage(chatId, { react: { text: '❌', key: message.key } });
+    }
+}
+
+async function whoIsCommand(sock, chatId, message, args) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    const domain = args[0]?.trim();
+    
+    if (!domain) {
+        return sock.sendMessage(chatId, { 
+            text: `✦ *${botName}* WHOIS\n\nUse: .whois <domain>\nExample: .whois google.com` 
+        }, { quoted: fake });
+    }
+    
+    await sock.sendMessage(chatId, { react: { text: '⏳', key: message.key } });
+    
+    try {
+        const res = await axios.get(`https://bk9.fun/tools/whois?q=${encodeURIComponent(domain)}`, { timeout: 15000 });
+        const result = res.data?.BK9 || res.data?.result;
+        if (result) {
+            const text = typeof result === 'object' 
+                ? `✦ *${botName}* WHOIS: ${domain}\n\n${JSON.stringify(result, null, 2).substring(0, 2000)}` 
+                : `✦ *${botName}* WHOIS: ${domain}\n\n${String(result).substring(0, 2000)}`;
+            await sock.sendMessage(chatId, { text }, { quoted: fake });
+            await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+        } else {
+            await sock.sendMessage(chatId, { 
+                text: `✦ *${botName}*\nNo WHOIS data found for ${domain}` 
+            }, { quoted: fake });
+            await sock.sendMessage(chatId, { react: { text: '❌', key: message.key } });
+        }
+    } catch (err) {
+        await sock.sendMessage(chatId, { 
+            text: `✦ *${botName}*\nError: ${err.message}` 
+        }, { quoted: fake });
+        await sock.sendMessage(chatId, { react: { text: '❌', key: message.key } });
+    }
+}
+
+async function reverseipCommand(sock, chatId, message, args) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    const ip = args[0]?.trim();
+    
+    if (!ip) {
+        return sock.sendMessage(chatId, { 
+            text: `✦ *${botName}* Reverse IP\n\nUse: .reverseip <ip>\nExample: .reverseip 8.8.8.8` 
+        }, { quoted: fake });
+    }
+    
+    await sock.sendMessage(chatId, { react: { text: '⏳', key: message.key } });
+    
+    try {
+        const res = await axios.get(`https://api.hackertarget.com/reverseiplookup/?q=${encodeURIComponent(ip)}`, { timeout: 15000 });
+        if (res.data) {
+            await sock.sendMessage(chatId, { 
+                text: `✦ *${botName}* Reverse IP: ${ip}\n\n${String(res.data).substring(0, 2000)}` 
+            }, { quoted: fake });
+            await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+        } else {
+            await sock.sendMessage(chatId, { 
+                text: `✦ *${botName}*\nNo data found for ${ip}` 
+            }, { quoted: fake });
+            await sock.sendMessage(chatId, { react: { text: '❌', key: message.key } });
+        }
+    } catch (err) {
+        await sock.sendMessage(chatId, { 
+            text: `✦ *${botName}*\nError: ${err.message}` 
+        }, { quoted: fake });
+        await sock.sendMessage(chatId, { react: { text: '❌', key: message.key } });
+    }
+}
+
+module.exports = { ipLookupCommand, whoIsCommand, reverseipCommand };

package/davexcore/utility/fetch.js

@@ -0,0 +1,127 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+async function fetchCommand(sock, chatId, message) {
+    const fkontak = createFakeContact(message);
+
+    try {
+        // Initial reaction
+        await sock.sendMessage(chatId, {
+            react: { text: "🔍", key: message.key }
+        });
+
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text;
+        const url = text.split(' ').slice(1).join(' ').trim();
+
+        if (!url) {
+            return await sock.sendMessage(chatId, { 
+                text: "Please provide a URL." 
+            }, { quoted: fkontak });
+        }
+
+        // Fetch content from URL
+        const response = await axios.get(url, { 
+            responseType: 'arraybuffer',
+            timeout: 10000
+        });
+
+        const contentType = response.headers['content-type'];
+        if (!contentType) {
+            return await sock.sendMessage(chatId, { 
+                text: "No content type returned." 
+            }, { quoted: fkontak });
+        }
+
+        const buffer = Buffer.from(response.data);
+        const filename = url.split('/').pop() || "file";
+
+        // Handle different content types
+        if (contentType.includes('application/json')) {
+            const json = JSON.parse(buffer.toString());
+            return await sock.sendMessage(chatId, { 
+                text: "```json\n" + JSON.stringify(json, null, 2).slice(0, 4000) + "\n```" 
+            }, { quoted: fkontak });
+        }
+
+        if (contentType.includes('text/html')) {
+            const html = buffer.toString();
+            return await sock.sendMessage(chatId, { 
+                text: html.slice(0, 4000) 
+            }, { quoted: fkontak });
+        }
+
+        if (contentType.includes('text/')) {
+            return await sock.sendMessage(chatId, { 
+                text: buffer.toString().slice(0, 4000) 
+            }, { quoted: fkontak });
+        }
+
+        if (contentType.includes('image')) {
+            return await sock.sendMessage(chatId, { 
+                image: buffer
+            }, { quoted: fkontak });
+        }
+
+        if (contentType.includes('video')) {
+            return await sock.sendMessage(chatId, { 
+                video: buffer
+            }, { quoted: fkontak });
+        }
+
+        if (contentType.includes('audio')) {
+            return await sock.sendMessage(chatId, {
+                audio: buffer,
+                mimetype: "audio/mpeg",
+                fileName: filename
+            }, { quoted: fkontak });
+        }
+
+        if (contentType.includes('application/pdf')) {
+            return await sock.sendMessage(chatId, {
+                document: buffer,
+                mimetype: "application/pdf",
+                fileName: filename
+            }, { quoted: fkontak });
+        }
+
+        if (contentType.includes('application')) {
+            return await sock.sendMessage(chatId, {
+                document: buffer,
+                mimetype: contentType,
+                fileName: filename
+            }, { quoted: fkontak });
+        }
+
+        // If no specific type matched
+        await sock.sendMessage(chatId, { 
+            text: "Unsupported content type." 
+        }, { quoted: fkontak });
+
+        // Error reaction
+        await sock.sendMessage(chatId, { 
+            react: { text: '❌', key: message.key } 
+        });
+
+    } catch (error) {
+        console.error('Fetch error:', error.message);
+
+        let errorMessage = "Failed to fetch URL.";
+
+        if (error.message.includes('timeout')) {
+            errorMessage = "Request timeout.";
+        } else if (error.code === 'ENOTFOUND') {
+            errorMessage = "URL not found.";
+        } else if (error.response?.status === 404) {
+            errorMessage = "Page not found.";
+        }
+
+        await sock.sendMessage(chatId, { 
+            text: errorMessage 
+        }, { quoted: fkontak });
+
+        await sock.sendMessage(chatId, { 
+            react: { text: '❌', key: message.key } 
+        });
+    }
+}
+
+module.exports = fetchCommand;

package/davexcore/utility/github.js

@@ -0,0 +1,85 @@
+const moment = require('moment-timezone');
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function githubCommand(sock, chatId, message) {
+    try {
+        const fake = createFakeContact(message);
+        const botName = getBotName();
+
+        await sock.sendMessage(chatId, { react: { text: '🌟', key: message.key } });
+
+        const res = await axios.get('https://api.github.com/repos/Davex-254/DAVE-X', {
+            headers: { 'User-Agent': 'DAVE-X' },
+            timeout: 10000
+        });
+
+        const repo = res.data;
+
+        let txt = `✦ *${botName} REPOSITORY*
+╭─────────────────
+│
+│ Name: ${repo.name}
+│ Owner: ${repo.owner.login}
+│ Private: ${repo.private ? 'Yes' : 'No'}
+│ Size: ${(repo.size / 1024).toFixed(2)} MB
+│ Stars: ⭐ ${repo.stargazers_count}
+│ Forks: 🍴 ${repo.forks_count}
+│ Watchers: 👁 ${repo.watchers_count}
+│ Updated: ${moment(repo.updated_at).format('DD/MM/YY - HH:mm')}
+│ URL: ${repo.html_url}
+│
+╰─────────────────`;
+
+        await sock.sendMessage(chatId, {
+            text: txt,
+            contextInfo: {
+                externalAdReply: {
+                    showAdAttribution: false,
+                    title: repo.name,
+                    body: `⭐ ${repo.stargazers_count}  🍴 ${repo.forks_count}`,
+                    thumbnailUrl: repo.owner.avatar_url,
+                    sourceUrl: repo.html_url,
+                    mediaType: 1,
+                    renderLargerThumbnail: true
+                }
+            }
+        }, { quoted: fake });
+
+        const zipUrl = `https://github.com/Davex-254/DAVE-X/archive/refs/heads/main.zip`;
+        const path = require('path');
+        const fs = require('fs');
+        const zipPath = path.join(__dirname, '../tmp/repo.zip');
+        fs.mkdirSync(path.dirname(zipPath), { recursive: true });
+
+        const zipResponse = await axios.get(zipUrl, {
+            responseType: 'arraybuffer',
+            headers: { 'User-Agent': 'DAVE-X' },
+            timeout: 30000
+        });
+
+        fs.writeFileSync(zipPath, zipResponse.data);
+
+        await sock.sendMessage(chatId, {
+            document: fs.readFileSync(zipPath),
+            mimetype: 'application/zip',
+            fileName: `DAVE-X-${moment().format('DDMMYY')}.zip`,
+            caption: `✦ ${botName} Source Code`
+        }, { quoted: fake });
+
+        fs.unlinkSync(zipPath);
+
+        await sock.sendMessage(chatId, {
+            react: { text: '✅', key: message.key }
+        });
+
+    } catch (error) {
+        console.error('GitHub error:', error.message);
+        const fake = createFakeContact(message);
+        await sock.sendMessage(chatId, {
+            text: `✦ Failed to fetch repository info\n${error.message}`
+        }, { quoted: fake });
+    }
+}
+
+module.exports = githubCommand;

package/davexcore/utility/google.js

@@ -0,0 +1,79 @@
+const axios = require("axios");
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+async function googleCommand(sock, chatId, message) {
+    const fake = createFakeContact(message);
+
+    const text = message.message?.conversation || 
+                 message.message?.extendedTextMessage?.text || '';
+
+    const query = text.split(' ').slice(1).join(' ').trim();
+
+    if (!query) {
+        return sock.sendMessage(chatId, { 
+            text: "◈━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━◈\n" +
+                  "│ ❒ ERROR\n" +
+                  "◈━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━◈\n" +
+                  "│ 🚫 Please provide a search term!\n" +
+                  "│ ❒ Example: .google What is treason\n" +
+                  "◈━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━◈"
+        }, { quoted: fake });
+    }
+
+    try {
+        await sock.sendMessage(chatId, { 
+            text: "Searching Google..."
+        }, { quoted: fake });
+
+        let { data } = await axios.get(
+            `https://www.googleapis.com/customsearch/v1?q=${encodeURIComponent(query)}&key=AIzaSyDMbI3nvmQUrfjoCJYLS69Lej1hSXQjnWI&cx=baf9bdb0c631236e5`
+        );
+
+        if (!data.items || data.items.length == 0) {
+            return sock.sendMessage(chatId, { 
+                text: "◈━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━◈\n" +
+                      "│ ❒ ERROR\n" +
+                      "◈━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━◈\n" +
+                      "│ ❌ Unable to find any results\n" +
+                      "◈━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━◈"
+            }, { quoted: fake });
+        }
+
+        let tex = "";
+        tex += "◈━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━◈\n";
+        tex += "│ ❒ GOOGLE SEARCH\n";
+        tex += "◈━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━◈\n";
+        tex += "│ 🔍 Search Term: " + query + "\n";
+        tex += "◈━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━◈\n";
+
+        // Show only first 3 results to avoid message too long
+        const results = data.items.slice(0, 3);
+        
+        for (let i = 0; i < results.length; i++) {
+            tex += "│ ❒ Result " + (i + 1) + "\n";
+            tex += "│ 🪧 Title: " + results[i].title + "\n";
+            tex += "│ 📝 Description: " + results[i].snippet + "\n";
+            tex += "│ 🌐 Link: " + results[i].link + "\n";
+            tex += "◈━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━◈\n";
+        }
+
+        tex += `│ 📊 Total Results: ${data.searchInformation?.formattedTotalResults || 'Unknown'}\n`;
+        tex += `│ ⚡ Search Time: ${data.searchInformation?.formattedSearchTime || 'Unknown'} seconds\n`;
+        tex += "◈━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━◈";
+
+        return sock.sendMessage(chatId, { 
+            text: tex
+        }, { quoted: fake });
+
+    } catch (e) {
+        console.error("Google Search Error:", e);
+        return sock.sendMessage(chatId, { 
+            text: "◈━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━◈\n" +
+                  "│ ❒ ERROR\n" +
+                  "◈━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━◈\n" +
+                  "│ ❌ An error occurred: " + e.message + "\n" +
+                  "◈━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━◈"
+        }, { quoted: fake });
+    }
+}
+
+module.exports = googleCommand;