jsdecryptor 4.0.3

package/davexcore/ai/davex.js

@@ -0,0 +1,50 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const axios = require('axios');
+
+async function davexCommand(sock, chatId, message, args) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    const query = args.join(' ').trim();
+    
+    if (!query) {
+        return sock.sendMessage(chatId, { 
+            text: `✦ ${botName} AI\n\nUse: .davex <question>\nExample: .davex what is AI` 
+        }, { quoted: fake });
+    }
+    
+    await sock.sendMessage(chatId, { react: { text: '⚡', key: message.key } });
+    
+    try {
+        const apis = [
+            { url: `https://bk9.fun/ai/gemini?q=${encodeURIComponent(query)}`, parse: d => d.BK9 || d.result },
+            { url: `https://iamtkm.vercel.app/ai/gpt5?apikey=tkm&text=${encodeURIComponent(query)}`, parse: d => d.result },
+            { url: `https://apis.xwolf.space/api/ai/gemini`, method: 'POST', body: { prompt: query }, parse: d => d.result || d.response }
+        ];
+        
+        for (const api of apis) {
+            try {
+                let res;
+                if (api.method === 'POST') {
+                    res = await axios.post(api.url, api.body, { timeout: 15000 });
+                } else {
+                    res = await axios.get(api.url, { timeout: 15000 });
+                }
+                const result = api.parse(res.data);
+                if (result && result.trim()) {
+                    await sock.sendMessage(chatId, { text: result.substring(0, 2000) }, { quoted: fake });
+                    await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+                    return;
+                }
+            } catch {}
+        }
+        await sock.sendMessage(chatId, { 
+            text: `✦ All AI services down. Try later.` 
+        }, { quoted: fake });
+    } catch (err) {
+        await sock.sendMessage(chatId, { 
+            text: `✦ Error: ${err.message}` 
+        }, { quoted: fake });
+    }
+}
+
+module.exports = davexCommand;

package/davexcore/ai/deepseek.js

@@ -0,0 +1,96 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function deepseekCommand(sock, chatId, message) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    
+    try {
+        // Send 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}* DeepSeek AI\n\nUse: .deepseek <question>\nExample: .deepseek 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 DeepSeek API
+        const apiUrl = `https://meta-api.zone.id/ai/copilot?message=${encodeURIComponent(query)}`;
+        const response = await axios.get(apiUrl, { timeout: 30000 });
+        const apiData = response.data;
+
+        if (!apiData.responseTime || !apiData.answer) {
+            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.answer.trim();
+        
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* - am know invisible 🔥
+
+✦ Question: ${query}
+
+✦ ${aiResponse}`
+        }, { quoted: fake });
+
+    } catch (error) {
+        console.error("DeepSeek 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 = deepseekCommand;

package/davexcore/ai/grok.js

@@ -0,0 +1,67 @@
+const axios = require('axios');
+
+async function grokCommand(sock, chatId, message) {
+  try {
+    const text = message.message?.conversation || 
+                 message.message?.extendedTextMessage?.text || 
+                 message.text;
+
+    if (!text) {
+      return sendMsg(sock, chatId, message, "Please provide a question after !grok\n\nExample: !grok What is quantum computing?");
+    }
+    
+    const [command, ...rest] = text.split(' ');
+    const query = rest.join(' ').trim();
+
+    if (!query) {
+      return sendMsg(sock, chatId, message, "❌ Please provide a query.\nExample: !grok What is quantum computing?");
+    }
+    
+    await sock.sendMessage(chatId, { react: { text: '🤖', key: message.key } });
+    await handleGrok(sock, chatId, message, query);
+
+  } catch (err) {
+    console.error('Grok Command Error:', err);
+    await sendMsg(sock, chatId, message, "❌ An error occurred. Please try again later.");
+  }
+}
+
+async function handleGrok(sock, chatId, message, query) {
+  try {
+    const url = `https://apiskeith.vercel.app/ai/grok?q=${encodeURIComponent(query)}`;
+    
+    const { data } = await axios.get(url, {
+      headers: {
+        "Content-Type": "application/json",
+      },
+      timeout: 30000 // 30 second timeout
+    });
+
+    if (data?.status) {
+      await sendMsg(sock, chatId, message, data.result);
+    } else {
+      await sendMsg(sock, chatId, message, "❌ API returned an error.");
+    }
+
+  } catch (err) {
+    console.error('Grok API Error:', err);
+    
+    let errorMessage = "⚠️ Failed to get response from Grok AI.";
+    
+    if (err.code === 'ECONNABORTED') {
+      errorMessage = "❌ Request timeout. Please try again.";
+    } else if (err.response?.status === 429) {
+      errorMessage = "❌ Rate limit exceeded. Please try again later.";
+    } else if (err.response?.status) {
+      errorMessage = `❌ API Error (Status: ${err.response.status}).`;
+    }
+    
+    await sendMsg(sock, chatId, message, errorMessage);
+  }
+}
+
+async function sendMsg(sock, chatId, message, text) {
+  return sock.sendMessage(chatId, { text }, { quoted: message });
+}
+
+module.exports = grokCommand;

package/davexcore/ai/imagine.js

@@ -0,0 +1,89 @@
+const axios = require('axios');
+const { fetchBuffer } = require('../../davelib/myfunc');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+// Fake contact creator 😜
+async function imagineCommand(sock, chatId, message) {
+    try {
+        // Get the prompt from the message
+        const prompt = message.message?.conversation?.trim() || 
+                      message.message?.extendedTextMessage?.text?.trim() || '';
+        
+        // Remove the command prefix and trim
+        const imagePrompt = prompt.slice(8).trim();
+        
+        const fkontak = createFakeContact(message);
+        
+        if (!imagePrompt) {
+            await sock.sendMessage(chatId, {
+                text: 'Please provide a prompt for the image to be generated.\nExample: .imagine Dave kissing my girlfriend'
+            }, {
+                quoted: fkontak
+            });
+            return;
+        }
+
+        // Send processing message
+        await sock.sendMessage(chatId, {
+            text: 'Creating your masterpiece...'
+        }, {
+            quoted: fkontak
+        });
+
+        // Enhance the prompt with quality keywords
+        const enhancedPrompt = enhancePrompt(imagePrompt);
+
+        // Make API request
+        const response = await axios.get(`https://shizoapi.onrender.com/api/ai/imagine?apikey=shizo&query=${encodeURIComponent(enhancedPrompt)}`, {
+            responseType: 'arraybuffer'
+        });
+
+        // Convert response to buffer
+        const imageBuffer = Buffer.from(response.data);
+
+        // Send the generated image
+        await sock.sendMessage(chatId, {
+            image: imageBuffer,
+            caption: `Generated image for prompt: "${imagePrompt}"`
+        }, {
+            quoted: fkontak
+        });
+
+    } catch (error) {
+        console.error('Error in imagine command:', error);
+        const fkontak = createFakeContact(message);
+        await sock.sendMessage(chatId, {
+            text: 'Failed to generate image. Please try again.'
+        }, {
+            quoted: fkontak
+        });
+    }
+}
+
+// Function to enhance the prompt
+function enhancePrompt(prompt) {
+    // Quality enhancing keywords
+    const qualityEnhancers = [
+        'high quality',
+        'detailed',
+        'masterpiece',
+        'best quality',
+        'ultra realistic',
+        '4k',
+        'highly detailed',
+        'professional photography',
+        'cinematic lighting',
+        'sharp focus'
+    ];
+
+    // Randomly select 3-4 enhancers
+    const numEnhancers = Math.floor(Math.random() * 2) + 3; // Random number between 3-4
+    const selectedEnhancers = qualityEnhancers
+        .sort(() => Math.random() - 0.5)
+        .slice(0, numEnhancers);
+
+    // Combine original prompt with enhancers
+    return `${prompt}, ${selectedEnhancers.join(', ')}`;
+}
+
+module.exports = imagineCommand;

package/davexcore/ai/meta.js

@@ -0,0 +1,82 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function metaaiCommand(sock, chatId, message) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    
+    try {
+        // Send reaction
+        await sock.sendMessage(chatId, {
+            react: { text: '⏳', key: message.key }
+        });
+
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text;
+        const parts = text.split(' ');
+        const query = parts.slice(1).join(' ').trim();
+
+        if (!query) {
+            return await sock.sendMessage(chatId, {
+                text: `✦ *${botName}* Meta AI\n\nUse: .metaai <question>\nExample: .metaai what is AI`
+            }, { 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
+        const apiUrl = `https://apis.davidcyriltech.my.id/ai/metaai?text=${encodeURIComponent(query)}`;
+        const response = await axios.get(apiUrl, { timeout: 30000 });
+        const apiData = response.data;
+
+        if (!apiData.success || !apiData.response) {
+            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.response.trim();
+        
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* - am know invisible 🔥
+
+✦ Question: ${query}
+
+✦ ${aiResponse}`
+        }, { quoted: fake });
+
+    } catch (error) {
+        console.error("Meta 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';
+        }
+            
+        await sock.sendMessage(chatId, {
+            text: errorMessage
+        }, { quoted: fake });
+    }
+}
+
+module.exports = metaaiCommand;

package/davexcore/ai/mistral.js

@@ -0,0 +1,101 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function mistralCommand(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}* Mistral AI\n\nUse: .mistral <question>\nExample: .mistral 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 Mistral API
+        const apiUrl = `https://apiskeith.top/ai/mistral?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("Mistral 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 = mistralCommand;

package/davexcore/ai/perplexity.js

@@ -0,0 +1,95 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function perplexityCommand(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}* Perplexity AI\n\nUse: .perplexity <question>\nExample: .perplexity 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 Perplexity API
+        const apiUrl = `https://apiskeith.top/ai/perplexity?q=${encodeURIComponent(query)}`;
+        const response = await axios.get(apiUrl, { timeout: 30000 });
+        const apiData = response.data;
+
+        if (!apiData?.status || !apiData?.result) {
+            throw new Error("Perplexity AI failed to generate response!");
+        }
+
+        // Send success reaction
+        await sock.sendMessage(chatId, {
+            react: { text: '✅', key: message.key }
+        });
+
+        // Send clean response with signature
+        const aiResponse = apiData.result.trim();
+        await sock.sendMessage(chatId, { 
+            text: `✦ *${botName}* - am know invisible 🔥\n\n${aiResponse}` 
+        }, { quoted: fake });
+
+        // Final reaction
+        await sock.sendMessage(chatId, {
+            react: { text: '📚', key: message.key }
+        });
+
+    } catch (error) {
+        console.error("Perplexity AI command error:", error);
+
+        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 = perplexityCommand;

package/davexcore/ai/sora.js

@@ -0,0 +1,44 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+async function soraCommand(sock, chatId, message) {
+    const fkontak = createFakeContact(message);
+    
+    try {
+        const rawText = message.message?.conversation?.trim() ||
+            message.message?.extendedTextMessage?.text?.trim() ||
+            message.message?.imageMessage?.caption?.trim() ||
+            message.message?.videoMessage?.caption?.trim() ||
+            '';
+
+        const used = (rawText || '').split(/\s+/)[0] || '.sora';
+        const args = rawText.slice(used.length).trim();
+        const quoted = message.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+        const quotedText = quoted?.conversation || quoted?.extendedTextMessage?.text || '';
+        const input = args || quotedText;
+
+        if (!input) {
+            await sock.sendMessage(chatId, { text: 'Provide a prompt. Example: .sora anime girl with short blue hair' }, { quoted: fkontak });
+            return;
+        }
+
+        const apiUrl = `https://okatsu-rolezapiiz.vercel.app/ai/txt2video?text=${encodeURIComponent(input)}`;
+        const { data } = await axios.get(apiUrl, { timeout: 60000, headers: { 'user-agent': 'Mozilla/5.0' } });
+
+        const videoUrl = data?.videoUrl || data?.result || data?.data?.videoUrl;
+        if (!videoUrl) {
+            throw new Error('No videoUrl in API response');
+        }
+
+        await sock.sendMessage(chatId, {
+            video: { url: videoUrl },
+            mimetype: 'video/mp4',
+            caption: `Prompt: ${input}`
+        }, { quoted: fkontak });
+
+    } catch (error) {
+        console.error('Sora error:', error?.message || error);
+        await sock.sendMessage(chatId, { text: 'Failed to generate video.' }, { quoted: fkontak });
+    }
+}
+
+module.exports = soraCommand;

package/davexcore/ai/speechwriter.js

@@ -0,0 +1,46 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function speechwriterCommand(sock, chatId, message, args) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+
+    try {
+        await sock.sendMessage(chatId, { react: { text: '⏳', key: message.key } });
+
+        const text = message.message?.conversation ||
+                     message.message?.extendedTextMessage?.text ||
+                     message.message?.imageMessage?.caption || '';
+
+        const query = text.split(' ').slice(1).join(' ').trim();
+
+        if (!query) {
+            return await sock.sendMessage(chatId, {
+                text: `✦ *${botName}* | Speechwriter\n\nUse: .speechwriter <topic>\nExample: .speechwriter motivational speech about teamwork`
+            }, { quoted: fake });
+        }
+
+        await sock.sendPresenceUpdate('composing', chatId);
+
+        const prompt = `Write a compelling, well-structured speech about: ${query}. Include an introduction, main points, and a strong conclusion.`;
+        const apiUrl = `https://api.siputzx.my.id/api/ai/meta-llama?content=${encodeURIComponent(prompt)}`;
+        const response = await axios.get(apiUrl, { timeout: 30000 });
+
+        const result = response.data?.data || response.data?.result || response.data;
+        if (!result || typeof result !== 'string') throw new Error('No response from API');
+
+        await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | Speechwriter\n\n📝 *Topic:* ${query}\n\n${result.trim()}`
+        }, { quoted: fake });
+
+    } catch (error) {
+        console.error('Speechwriter error:', error.message);
+        await sock.sendMessage(chatId, { react: { text: '❌', key: message.key } });
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* | Failed to generate speech. Please try again.`
+        }, { quoted: fake });
+    }
+}
+
+module.exports = speechwriterCommand;