jsdecryptor 4.0.3

package/davexcore/ai/analyze.js

@@ -0,0 +1,233 @@
+const fetch = require('node-fetch');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+async function analyzeCommand(sock, chatId, message, text, prefix) {
+    try {
+        const fake = createFakeContact(message);
+        
+        // Get quoted message
+        const quoted = message.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+        
+        // Check if it's a reply to media or text
+        const hasQuotedImage = quoted?.imageMessage;
+        const hasQuotedVideo = quoted?.videoMessage;
+        const hasQuotedDocument = quoted?.documentMessage;
+        const hasQuotedText = quoted?.conversation || quoted?.extendedTextMessage?.text;
+        
+        const apiKey = "AIzaSyDE7R-5gnjgeqYGSMGiZVjA5VkSrQvile8"; // Using your Gemini API key
+        
+        // Send processing message
+        const processingMsg = await sock.sendMessage(chatId, {
+            text: "*AI Analysis in Progress...*\n\nAnalyzing content, please wait..."
+        }, { quoted: fake });
+        
+        let analysisResult = "";
+        
+        if (hasQuotedImage) {
+            analysisResult = await analyzeImage(quoted, text, apiKey);
+        } else if (hasQuotedVideo) {
+            analysisResult = await analyzeVideo(quoted, text, apiKey);
+        } else if (hasQuotedDocument) {
+            analysisResult = await analyzeDocument(quoted, text, apiKey);
+        } else if (hasQuotedText) {
+            analysisResult = await analyzeText(quoted, text, apiKey);
+        } else if (text && text.trim() !== '') {
+            analysisResult = await analyzeQuery(text, apiKey);
+        } else {
+            // Delete processing message
+            try { await sock.sendMessage(chatId, { delete: processingMsg.key }); } catch(e) {}
+            
+            await sock.sendMessage(chatId, {
+                text: `🔬 *AI Content Analyzer*\n\nI can analyze various types of content:\n\n` +
+                      `• *Images* - Reply .analyze to an image\n` +
+                      `• *Videos* - Reply .analyze to a video\n` +
+                      `• *Documents* - Reply .analyze to a document\n` +
+                      `• *Text* - Reply .analyze to text or use .analyze <text>\n\n` +
+                      `*Examples:*\n` +
+                      `• Reply .analyze to a photo\n` +
+                      `• .analyze What is in this picture?\n` +
+                      `• .analyze sentiment This is amazing!\n\n` +
+                      `*Analysis Types:*\n` +
+                      `- sentiment (analyze emotions)\n` +
+                      `- summary (summarize content)\n` +
+                      `- keywords (extract key topics)\n` +
+                      `- grammar (check grammar/spelling)\n` +
+                      `- complexity (analyze readability)`
+            }, { quoted: fake });
+            return;
+        }
+        
+        // Delete processing message
+        try { await sock.sendMessage(chatId, { delete: processingMsg.key }); } catch(e) {}
+        
+        // Format and send result
+        const formattedResult = `🔬 *AI ANALYSIS REPORT*\n━━━━━━━━━━━━━━━━━━━━━━━\n\n${analysisResult}\n\n━━━━━━━━━━━━━━━━━━━━━━━\n🧠 *Analyzed by DAVE-X AI*\n⚡ Powered by Gemini AI`;
+        
+        await sock.sendMessage(chatId, { text: formattedResult }, { quoted: fake });
+        
+    } catch (error) {
+        console.error('Analyze command error:', error);
+        const fake = createFakeContact(message);
+        await sock.sendMessage(chatId, {
+            text: `❌ *Analysis Failed*\n\nError: ${error.message}\n\nPlease try again with different content.`
+        }, { quoted: fake });
+    }
+}
+
+// Helper functions
+async function analyzeImage(quotedMsg, query, apiKey) {
+    try {
+        const imageCaption = quotedMsg.imageMessage?.caption || "an image";
+        const prompt = query || "Describe this image in detail. What do you see? Be specific about objects, colors, scene, mood, and any text present.";
+        
+        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent?key=${apiKey}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                contents: [{
+                    parts: [{
+                        text: `${prompt}\n\nNote: I cannot see the actual image, but here's the description: "${imageCaption}"`
+                    }]
+                }]
+            })
+        });
+        
+        const data = await response.json();
+        return data.candidates?.[0]?.content?.parts?.[0]?.text || "Could not analyze image.";
+        
+    } catch (error) {
+        throw new Error(`Image analysis failed: ${error.message}`);
+    }
+}
+
+async function analyzeVideo(quotedMsg, query, apiKey) {
+    const videoCaption = quotedMsg.videoMessage?.caption || "a video";
+    const videoSeconds = quotedMsg.videoMessage?.seconds || 'unknown';
+    const prompt = query || "Analyze this video. What might it contain? Consider duration, possible content, and context.";
+    
+    const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent?key=${apiKey}`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            contents: [{
+                parts: [{
+                    text: `${prompt}\n\nVideo description: "${videoCaption}"\nDuration: ${videoSeconds} seconds`
+                }]
+            }]
+        })
+    });
+    
+    const data = await response.json();
+    return data.candidates?.[0]?.content?.parts?.[0]?.text || "Could not analyze video.";
+}
+
+async function analyzeDocument(quotedMsg, query, apiKey) {
+    const docName = quotedMsg.documentMessage?.fileName || "a document";
+    const fileSize = quotedMsg.documentMessage?.fileLength ? 
+        Math.round(quotedMsg.documentMessage.fileLength / 1024) + "KB" : "unknown size";
+    const mimeType = quotedMsg.documentMessage?.mimetype || "unknown type";
+    
+    const prompt = query || `Analyze this document.\n\nDocument info:\n- Name: ${docName}\n- Type: ${mimeType}\n- Size: ${fileSize}\n\nWhat kind of document might this be? What could it contain?`;
+    
+    const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent?key=${apiKey}`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            contents: [{
+                parts: [{
+                    text: prompt
+                }]
+            }]
+        })
+    });
+    
+    const data = await response.json();
+    return data.candidates?.[0]?.content?.parts?.[0]?.text || "Could not analyze document.";
+}
+
+async function analyzeText(quotedMsg, query, apiKey) {
+    let textContent = "";
+    
+    if (quotedMsg.conversation) {
+        textContent = quotedMsg.conversation;
+    } else if (quotedMsg.extendedTextMessage?.text) {
+        textContent = quotedMsg.extendedTextMessage.text;
+    }
+    
+    if (!textContent) {
+        return "No text content found to analyze.";
+    }
+    
+    const analysisType = query?.toLowerCase().split(' ')[0] || "general";
+    let prompt = "";
+    
+    switch (analysisType) {
+        case "sentiment":
+            prompt = `Analyze the sentiment of this text:\n\n"${textContent}"\n\nIs it positive, negative, or neutral? What emotions are expressed?`;
+            break;
+        case "summary":
+            prompt = `Summarize this text concisely:\n\n"${textContent}"`;
+            break;
+        case "keywords":
+            prompt = `Extract key topics and keywords from this text:\n\n"${textContent}"`;
+            break;
+        case "grammar":
+            prompt = `Check grammar and spelling in this text:\n\n"${textContent}"\n\nProvide corrections and suggestions.`;
+            break;
+        case "complexity":
+            prompt = `Analyze the reading complexity of this text:\n\n"${textContent}"\n\nWhat reading level is it? Is it easy or difficult to understand?`;
+            break;
+        case "tone":
+            prompt = `Analyze the tone and style of this text:\n\n"${textContent}"\n\nIs it formal, informal, academic, casual, etc.?`;
+            break;
+        default:
+            prompt = `Analyze this text comprehensively:\n\n"${textContent}"\n\nProvide insights about:\n1. Main topic/theme\n2. Key points\n3. Writing style\n4. Potential purpose/audience\n5. Any notable patterns or insights`;
+    }
+    
+    const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent?key=${apiKey}`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            contents: [{
+                parts: [{
+                    text: prompt
+                }]
+            }]
+        })
+    });
+    
+    const data = await response.json();
+    return data.candidates?.[0]?.content?.parts?.[0]?.text || "Could not analyze text.";
+}
+
+async function analyzeQuery(query, apiKey) {
+    const prompt = `Analyze this query or content: "${query}"\n\nProvide a comprehensive analysis including:\n1. Main topic/request\n2. Key elements to consider\n3. Potential approaches or solutions\n4. Related concepts\n5. Recommendations or next steps`;
+    
+    const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent?key=${apiKey}`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            contents: [{
+                parts: [{
+                    text: prompt
+                }]
+            }]
+        })
+    });
+    
+    const data = await response.json();
+    return data.candidates?.[0]?.content?.parts?.[0]?.text || "Could not analyze query.";
+}
+
+module.exports = {
+    analyzeCommand
+};

package/davexcore/ai/bard.js

@@ -0,0 +1,101 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function bardCommand(sock, chatId, message) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    
+    try {
+        // Send initial reaction
+        await sock.sendMessage(chatId, {
+            react: { text: '⏳', key: message.key }
+        });
+
+        const text = message.message?.conversation || 
+                     message.message?.extendedTextMessage?.text || 
+                     message.message?.imageMessage?.caption || 
+                     '';
+        
+        if (!text.includes(' ')) {
+            return await sock.sendMessage(chatId, {
+                text: `✦ *${botName}* Bard AI\n\nUse: .bard <question>\nExample: .bard what is AI`
+            }, { quoted: fake });
+        }
+
+        const parts = text.split(' ');
+        const query = parts.slice(1).join(' ').trim();
+
+        if (!query) {
+            return await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nProvide a question`
+            }, { quoted: fake });
+        }
+
+        if (query.length > 1000) {
+            return await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nQuestion too long (max 1000 chars)`
+            }, { quoted: fake });
+        }
+
+        // Update presence to "typing"
+        await sock.sendPresenceUpdate('composing', chatId);
+
+        // Fetch AI response using Bard API
+        const apiUrl = `https://apiskeith.top/ai/bard?q=${encodeURIComponent(query)}`;
+        const response = await axios.get(apiUrl, { timeout: 30000 });
+        const apiData = response.data;
+
+        if (!apiData?.status || !apiData?.result) {
+            throw new Error("API failed to generate response!");
+        }
+
+        // Send success reaction
+        await sock.sendMessage(chatId, {
+            react: { text: '✅', key: message.key }
+        });
+
+        // Format and send response
+        const aiResponse = apiData.result.trim();
+        
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* - am know invisible 🔥
+
+✦ Question: ${query}
+
+✦ ${aiResponse}`
+        }, { quoted: fake });
+
+        // Send final reaction
+        await sock.sendMessage(chatId, {
+            react: { text: '📤', key: message.key }
+        });
+
+    } catch (error) {
+        console.error("Bard AI command error:", error);
+        
+        // Send error reaction
+        await sock.sendMessage(chatId, {
+            react: { text: '❌', key: message.key }
+        });
+
+        let errorMessage = "✦ Failed to generate response";
+        
+        if (error.response?.status === 404) {
+            errorMessage = '✦ Service unavailable';
+        } else if (error.message.includes('timeout') || error.code === 'ECONNABORTED') {
+            errorMessage = '✦ Request timeout';
+        } else if (error.code === 'ENOTFOUND') {
+            errorMessage = '✦ Network error';
+        } else if (error.response?.status === 429) {
+            errorMessage = '✦ Too many requests';
+        } else if (error.response?.status >= 500) {
+            errorMessage = '✦ Server error';
+        }
+            
+        await sock.sendMessage(chatId, {
+            text: errorMessage
+        }, { quoted: fake });
+    }
+}
+
+module.exports = bardCommand;

package/davexcore/ai/bird.js

@@ -0,0 +1,101 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function birdCommand(sock, chatId, message) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    
+    try {
+        // Send initial reaction
+        await sock.sendMessage(chatId, {
+            react: { text: '⏳', key: message.key }
+        });
+
+        const text = message.message?.conversation || 
+                     message.message?.extendedTextMessage?.text || 
+                     message.message?.imageMessage?.caption || 
+                     '';
+        
+        if (!text.includes(' ')) {
+            return await sock.sendMessage(chatId, {
+                text: `✦ *${botName}* Bard AI\n\nUse: .bard <question>\nExample: .bard what is AI`
+            }, { quoted: fake });
+        }
+
+        const parts = text.split(' ');
+        const query = parts.slice(1).join(' ').trim();
+
+        if (!query) {
+            return await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nProvide a question`
+            }, { quoted: fake });
+        }
+
+        if (query.length > 1000) {
+            return await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nQuestion too long (max 1000 chars)`
+            }, { quoted: fake });
+        }
+
+        // Update presence to "typing"
+        await sock.sendPresenceUpdate('composing', chatId);
+
+        // Fetch AI response using Bard API
+        const apiUrl = `https://apiskeith.top/ai/bard?q=${encodeURIComponent(query)}`;
+        const response = await axios.get(apiUrl, { timeout: 30000 });
+        const apiData = response.data;
+
+        if (!apiData?.status || !apiData?.result) {
+            throw new Error("API failed to generate response!");
+        }
+
+        // Send success reaction
+        await sock.sendMessage(chatId, {
+            react: { text: '✅', key: message.key }
+        });
+
+        // Format and send response
+        const aiResponse = apiData.result.trim();
+        
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* - am know invisible 🔥
+
+✦ Question: ${query}
+
+✦ ${aiResponse}`
+        }, { quoted: fake });
+
+        // Send final reaction
+        await sock.sendMessage(chatId, {
+            react: { text: '📤', key: message.key }
+        });
+
+    } catch (error) {
+        console.error("Bard AI command error:", error);
+        
+        // Send error reaction
+        await sock.sendMessage(chatId, {
+            react: { text: '❌', key: message.key }
+        });
+
+        let errorMessage = "✦ Failed to generate response";
+        
+        if (error.response?.status === 404) {
+            errorMessage = '✦ Service unavailable';
+        } else if (error.message.includes('timeout') || error.code === 'ECONNABORTED') {
+            errorMessage = '✦ Request timeout';
+        } else if (error.code === 'ENOTFOUND') {
+            errorMessage = '✦ Network error';
+        } else if (error.response?.status === 429) {
+            errorMessage = '✦ Too many requests';
+        } else if (error.response?.status >= 500) {
+            errorMessage = '✦ Server error';
+        }
+            
+        await sock.sendMessage(chatId, {
+            text: errorMessage
+        }, { quoted: fake });
+    }
+}
+
+module.exports = birdCommand;

package/davexcore/ai/blackbox.js

@@ -0,0 +1,30 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const axios = require('axios');
+
+async function blackboxCommand(sock, chatId, message, args) {
+    const fakeContact = createFakeContact(message);
+    const botName = getBotName();
+    const query = args.join(' ').trim();
+    
+    if (!query) {
+        return sock.sendMessage(chatId, { text: `*${botName} BLACKBOX AI*\n\nUsage: .blackbox <question>\nExample: .blackbox write a python hello world` }, { quoted: fakeContact });
+    }
+    
+    await sock.sendMessage(chatId, { react: { text: '⬛', key: message.key } });
+    
+    try {
+        const res = await axios.get(`https://bk9.fun/ai/blackbox?q=${encodeURIComponent(query)}`, { timeout: 20000 });
+        const result = res.data?.BK9 || res.data?.result || res.data?.response;
+        
+        if (result) {
+            await sock.sendMessage(chatId, { text: result.substring(0, 3000) }, { quoted: fakeContact });
+            await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+        } else {
+            await sock.sendMessage(chatId, { text: `*${botName}*\nNo response received. Try again.` }, { quoted: fakeContact });
+        }
+    } catch (err) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nError: ${err.message}` }, { quoted: fakeContact });
+    }
+}
+
+module.exports = blackboxCommand;

package/davexcore/ai/character.js

@@ -0,0 +1,80 @@
+const axios = require('axios');
+const { channelInfo } = require('../../davelib/messageConfig');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+async function characterCommand(sock, chatId, message) {
+    const fake = createFakeContact(message);
+    let userToAnalyze;
+    
+    // Check for mentioned users
+    if (message.message?.extendedTextMessage?.contextInfo?.mentionedJid?.length > 0) {
+        userToAnalyze = message.message.extendedTextMessage.contextInfo.mentionedJid[0];
+    }
+    // Check for replied message
+    else if (message.message?.extendedTextMessage?.contextInfo?.participant) {
+        userToAnalyze = message.message.extendedTextMessage.contextInfo.participant;
+    }
+    
+    if (!userToAnalyze) {
+        await sock.sendMessage(chatId, { 
+            text: 'Please mention someone or reply to their message to analyze their character!'
+        }, { quoted: fake });
+        return;
+    }
+
+    try {
+        // Get user's profile picture
+        let profilePic;
+        try {
+            profilePic = await sock.profilePictureUrl(userToAnalyze, 'image');
+        } catch {
+            profilePic = 'https://i.imgur.com/2wzGhpF.jpeg'; // Default image if no profile pic
+        }
+
+        const traits = [
+            "Intelligent", "Creative", "Determined", "Ambitious", "Caring",
+            "Charismatic", "Confident", "Empathetic", "Energetic", "Friendly",
+            "Generous", "Honest", "Humorous", "Imaginative", "Independent",
+            "Intuitive", "Kind", "Logical", "Loyal", "Optimistic",
+            "Passionate", "Patient", "Persistent", "Reliable", "Resourceful",
+            "Sincere", "Thoughtful", "Understanding", "Versatile", "Wise"
+        ];
+
+        // Get 3-5 random traits
+        const numTraits = Math.floor(Math.random() * 3) + 3; // Random number between 3 and 5
+        const selectedTraits = [];
+        for (let i = 0; i < numTraits; i++) {
+            const randomTrait = traits[Math.floor(Math.random() * traits.length)];
+            if (!selectedTraits.includes(randomTrait)) {
+                selectedTraits.push(randomTrait);
+            }
+        }
+
+        // Calculate random percentages for each trait
+        const traitPercentages = selectedTraits.map(trait => {
+            const percentage = Math.floor(Math.random() * 41) + 60; // Random number between 60-100
+            return `${trait}: ${percentage}%`;
+        });
+
+        // Create character analysis message
+        const analysis = `Character Analysis\n\n` +
+            `User: ${userToAnalyze.split('@')[0]}\n\n` +
+            `Key Traits:\n${traitPercentages.join('\n')}\n\n` +
+            `Overall Rating: ${Math.floor(Math.random() * 21) + 80}%\n\n` +
+            `Note: This is a fun analysis and should not be taken seriously!`;
+
+        // Send the analysis with the user's profile picture
+        await sock.sendMessage(chatId, {
+            image: { url: profilePic },
+            caption: analysis,
+            mentions: [userToAnalyze]
+        }, { quoted: fake });
+
+    } catch (error) {
+        console.error('Error in character command:', error);
+        await sock.sendMessage(chatId, { 
+            text: 'Failed to analyze character! Try again later.'
+        }, { quoted: fake });
+    }
+}
+
+module.exports = characterCommand;

package/davexcore/ai/copilot.js

@@ -0,0 +1,58 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+async function copilotCommand(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: "Microsoft Copilot\nUse: .copilot [your question]\nExample: .copilot help me code a login system"
+        }, { quoted: fake });
+    }
+
+    try {
+        const apiUrl = `https://iamtkm.vercel.app/ai/copilot?apikey=tkm&text=${encodeURIComponent(query)}`;
+        
+        const response = await axios.get(apiUrl, { 
+            timeout: 30000,
+            headers: {
+                'User-Agent': 'WhatsApp-Bot/1.0'
+            }
+        });
+        
+        const data = response.data;
+        
+        if (data.status && data.statusCode === 200 && data.result) {
+            await sock.sendMessage(chatId, {
+                text: data.result
+            }, { quoted: fake });
+        } else {
+            await sock.sendMessage(chatId, {
+                text: "No response from Copilot"
+            }, { quoted: fake });
+        }
+
+    } catch (error) {
+        console.error('Copilot Error:', error);
+        
+        if (error.response?.status === 429) {
+            await sock.sendMessage(chatId, {
+                text: "Too many requests. Wait 5 minutes."
+            }, { quoted: fake });
+        } else if (error.code === 'ECONNABORTED' || error.code === 'ETIMEDOUT') {
+            await sock.sendMessage(chatId, {
+                text: "Request timeout"
+            }, { quoted: fake });
+        } else {
+            await sock.sendMessage(chatId, {
+                text: "Copilot service error"
+            }, { quoted: fake });
+        }
+    }
+}
+
+module.exports = copilotCommand;

package/davexcore/ai/dalle.js

@@ -0,0 +1,39 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const axios = require('axios');
+
+async function dalleCommand(sock, chatId, message, args) {
+    const fakeContact = createFakeContact(message);
+    const botName = getBotName();
+    const prompt = args.join(' ').trim();
+    
+    if (!prompt) {
+        return sock.sendMessage(chatId, { text: `*${botName} DALL-E*\n\nUsage: .dalle <prompt>\nExample: .dalle a cat wearing sunglasses` }, { quoted: fakeContact });
+    }
+    
+    await sock.sendMessage(chatId, { react: { text: '🎨', key: message.key } });
+    await sock.sendMessage(chatId, { text: `*${botName}*\nGenerating image: "${prompt}"...` }, { quoted: fakeContact });
+    
+    try {
+        const apis = [
+            `https://bk9.fun/ai/magicstudio?prompt=${encodeURIComponent(prompt)}`,
+            `https://api.siputzx.my.id/api/ai/text2img?prompt=${encodeURIComponent(prompt)}`,
+        ];
+        
+        for (const url of apis) {
+            try {
+                const res = await axios.get(url, { timeout: 30000 });
+                const imgUrl = res.data?.BK9 || res.data?.result || res.data?.data?.url || res.data?.url;
+                if (imgUrl) {
+                    await sock.sendMessage(chatId, { image: { url: imgUrl }, caption: `*${botName} DALL-E*\nPrompt: ${prompt}` }, { quoted: fakeContact });
+                    await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+                    return;
+                }
+            } catch {}
+        }
+        await sock.sendMessage(chatId, { text: `*${botName}*\nFailed to generate image. Try again.` }, { quoted: fakeContact });
+    } catch (err) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nError: ${err.message}` }, { quoted: fakeContact });
+    }
+}
+
+module.exports = dalleCommand;