jsdecryptor 4.0.3

package/davexcore/utility/url.js

@@ -0,0 +1,112 @@
+const { downloadContentFromMessage } = require('@whiskeysockets/baileys');
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+const FormData = require('form-data');
+const { TelegraPh } = require('../../davelib/uploader');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+async function uploadToCatbox(filePath) {
+    const form = new FormData();
+    form.append("reqtype", "fileupload");
+    form.append("fileToUpload", fs.createReadStream(filePath));
+
+    const res = await axios.post("https://catbox.moe/user/api.php", form, {
+        headers: form.getHeaders()
+    });
+
+    return res.data;
+}
+
+async function extractMedia(message) {
+    const m = message.message || {};
+
+    const handlers = {
+        imageMessage: { type: 'image', ext: '.jpg' },
+        videoMessage: { type: 'video', ext: '.mp4' },
+        audioMessage: { type: 'audio', ext: '.mp3' },
+        documentMessage: { type: 'document', ext: null },
+        stickerMessage: { type: 'sticker', ext: '.webp' }
+    };
+
+    for (const key in handlers) {
+        if (m[key]) {
+            const { type, ext } = handlers[key];
+            const stream = await downloadContentFromMessage(m[key], type);
+            const chunks = [];
+            for await (const chunk of stream) chunks.push(chunk);
+
+            if (key === 'documentMessage') {
+                const fileName = m.documentMessage.fileName || 'file.bin';
+                return { buffer: Buffer.concat(chunks), ext: path.extname(fileName) || '.bin' };
+            }
+
+            return { buffer: Buffer.concat(chunks), ext };
+        }
+    }
+
+    return null;
+}
+
+async function extractQuotedMedia(message) {
+    const quoted = message.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+    if (!quoted) return null;
+    return extractMedia({ message: quoted });
+}
+
+async function urlCommand(sock, chatId, message) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fakeContact = createFakeContact(senderId);
+    
+    try {
+        await sock.sendMessage(chatId, { react: { text: '🔺', key: message.key } });
+
+        let media = await extractMedia(message) || await extractQuotedMedia(message);
+
+        if (!media) {
+            return sock.sendMessage(
+                chatId,
+                { text: 'Provide media attachment for link generation' },
+                { quoted: fakeContact }
+            );
+        }
+
+        const tempDir = path.join(__dirname, '../temp');
+        if (!fs.existsSync(tempDir)) fs.mkdirSync(tempDir, { recursive: true });
+
+        const tempPath = path.join(tempDir, `${Date.now()}${media.ext}`);
+        fs.writeFileSync(tempPath, media.buffer);
+
+        let url;
+        try {
+            if (['.jpg', '.png', '.webp'].includes(media.ext)) {
+                try {
+                    url = await TelegraPh(tempPath);
+                } catch {
+                    url = await uploadToCatbox(tempPath);
+                }
+            } else {
+                url = await uploadToCatbox(tempPath);
+            }
+        } finally {
+            setTimeout(() => {
+                if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+            }, 2000);
+        }
+
+        if (!url) {
+            return sock.sendMessage(chatId, { text: 'Media upload unsuccessful' }, { quoted: fakeContact });
+        }
+
+        await sock.sendMessage(
+            chatId,
+            { text: `${url}` },
+            { quoted: fakeContact }
+        );
+
+    } catch (error) {
+        console.error('[URL] error:', error?.message || error);
+        await sock.sendMessage(chatId, { text: 'Media conversion to link failed' }, { quoted: fakeContact });
+    }
+}
+
+module.exports = urlCommand;

package/davexcore/utility/vcf.js

@@ -0,0 +1,84 @@
+const fs = require('fs');
+const path = require('path');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function vcfCommand(sock, chatId, message) {
+    const fkontak = createFakeContact(message);
+    const botName = getBotName();
+
+    try {
+        // Restrict to groups only
+        if (!chatId.endsWith('@g.us')) {
+            await sock.sendMessage(chatId, { 
+                text: `✦ Group command only` 
+            }, { quoted: fkontak });
+            return;
+        }
+
+        // Get group metadata
+        const groupMetadata = await sock.groupMetadata(chatId);
+        const participants = groupMetadata.participants || [];
+
+        // Validate group size
+        if (participants.length < 2) {
+            await sock.sendMessage(chatId, { 
+                text: `✦ Group must have at least 2 members` 
+            }, { quoted: fkontak });
+            return;
+        }
+
+        // Generate VCF content
+        let vcfContent = '';
+        participants.forEach(participant => {
+            const phoneNumber = participant.id.split('@')[0];
+            const displayName = participant.notify || `User_${phoneNumber}`;
+
+            vcfContent += `BEGIN:VCARD\n` +
+                          `VERSION:3.0\n` +
+                          `FN:${displayName}\n` +
+                          `TEL;TYPE=CELL:+${phoneNumber}\n` +
+                          `END:VCARD\n`;
+        });
+
+        // Create temp file
+        const sanitizedGroupName = groupMetadata.subject.replace(/[^\w]/g, '_');
+        const tempDir = path.join(__dirname, '../temp');
+
+        if (!fs.existsSync(tempDir)) {
+            fs.mkdirSync(tempDir, { recursive: true });
+        }
+
+        const vcfPath = path.join(tempDir, `${sanitizedGroupName}.vcf`);
+        fs.writeFileSync(vcfPath, vcfContent);
+
+        // Send VCF file
+        await sock.sendMessage(chatId, {
+            document: fs.readFileSync(vcfPath),
+            mimetype: 'text/vcard',
+            fileName: `${sanitizedGroupName}.vcf`,
+            caption: `✦ *VCF EXPORT*
+    
+  Group: ${groupMetadata.subject}
+  Members: ${participants.length}`
+        }, { quoted: fkontak });
+
+        // Cleanup
+        setTimeout(() => {
+            try {
+                if (fs.existsSync(vcfPath)) {
+                    fs.unlinkSync(vcfPath);
+                }
+            } catch (cleanupError) {
+                // Ignore cleanup errors
+            }
+        }, 5000);
+
+    } catch (error) {
+        console.error('VCF Error:', error.message);
+        await sock.sendMessage(chatId, { 
+            text: `✦ Failed to generate contacts` 
+        }, { quoted: fkontak });
+    }
+}
+
+module.exports = vcfCommand;

package/davexcore/utility/weather.js

@@ -0,0 +1,162 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+/**
+ * Weather Command Handler
+ * @param {object} sock - WhatsApp socket
+ * @param {string} chatId - Chat ID
+ * @param {object} message - Message object
+ */
+async function weatherCommand(sock, chatId, message) {
+    try {
+        // Extract text from message
+        const text = extractMessageText(message);
+        
+        if (!text) {
+            return await sendPromptMessage(sock, chatId, message);
+        }
+
+        // Parse command and query
+        const { command, query } = parseCommand(text);
+        
+        if (!query) {
+            return await sendEmptyQueryMessage(sock, chatId, message);
+        }
+
+        // Process weather request
+        await processWeatherRequest(sock, chatId, message, query);
+        
+    } catch (error) {
+        console.error('Weather Command Error:', error);
+        await sendErrorMessage(sock, chatId, message);
+    }
+}
+
+/**
+ * Extract text from message object
+ */
+function extractMessageText(message) {
+    return message.message?.conversation || 
+           message.message?.extendedTextMessage?.text ||
+           message.text;
+}
+
+/**
+ * Parse command and query from text
+ */
+function parseCommand(text) {
+    const parts = text.split(' ');
+    const command = parts[0].toLowerCase();
+    const query = parts.slice(1).join(' ').trim();
+    
+    return { command, query };
+}
+
+/**
+ * Send initial prompt message
+ */
+async function sendPromptMessage(sock, chatId, message) {
+    const promptText = "Please provide a city name after .weather or .cuaca\n\n" +
+                      "Example: .weather Nairobi";
+    
+    return await sock.sendMessage(chatId, { text: promptText }, { quoted: fakeContact });
+}
+
+/**
+ * Send empty query message
+ */
+async function sendEmptyQueryMessage(sock, chatId, message) {
+    return await sock.sendMessage(chatId, { 
+        text: "⚠️ Please provide a city name!\nExample: .weather Nairobi" 
+    }, { quoted: fakeContact });
+}
+
+/**
+ * Send error message
+ */
+async function sendErrorMessage(sock, chatId, message) {
+    return await sock.sendMessage(chatId, {
+        text: "❌ An error occurred. Please try again later.",
+        contextInfo: {
+            mentionedJid: [message.key.participant || message.key.remoteJid],
+            quotedMessage: message.message
+        }
+    }, { quoted: fakeContact });
+}
+
+/**
+ * Process weather request
+ */
+async function processWeatherRequest(sock, chatId, message, cityQuery) {
+    // Show processing indicator
+    await sock.sendMessage(chatId, {
+        react: { text: '🌤️', key: message.key }
+    });
+
+    try {
+        await handleWeatherAPIRequest(sock, chatId, message, cityQuery);
+    } catch (error) {
+        console.error('API Processing Error:', error);
+        await sendAPIErrorMessage(sock, chatId, message, error);
+    }
+}
+
+/**
+ * Handle weather API request
+ */
+async function handleWeatherAPIRequest(sock, chatId, message, cityQuery) {
+    const apiUrl = `https://rijalganzz.web.id/tools/cuaca?kota=${encodeURIComponent(cityQuery)}`;
+    
+    const response = await axios.get(apiUrl);
+    const data = response.data;
+
+    if (!data || data.status !== 200) {
+        throw new Error('Failed to fetch weather data');
+    }
+
+    const result = data.result;
+    
+    // Format weather message
+    const weatherMsg = formatWeatherMessage(result);
+    
+    await sock.sendMessage(chatId, {
+        text: weatherMsg
+    }, { quoted: fakeContact });
+}
+
+/**
+ * Format weather message from API result
+ */
+function formatWeatherMessage(result) {
+    return `
+🌤️ *Weather in ${result.city || "Unknown"}, ${result.country || "Unknown"}*
+
+📌 Condition: ${result.condition || "-"}
+🌡️ Temperature: ${result.temperature || "-"}
+💧 Humidity: ${result.humidity || "-"}
+💨 Wind: ${result.wind || "-"}
+🧭 Pressure: ${result.pressure || "-"}
+☀️ UV Index: ${result.uv_index || "-"}
+
+🕒 Observation Time: ${result.observation_time || "-"}
+📍 Region: ${result.region || "-"}
+🗺️ Coordinates: ${result.latitude || "-"}, ${result.longitude || "-"}
+    `.trim();
+}
+
+/**
+ * Send API error message
+ */
+async function sendAPIErrorMessage(sock, chatId, message, error) {
+    const errorMessage = "❌ Failed to fetch weather data, please try another city.";
+    
+    await sock.sendMessage(chatId, {
+        text: errorMessage,
+        contextInfo: {
+            mentionedJid: [message.key.participant || message.key.remoteJid],
+            quotedMessage: message.message
+        }
+    }, { quoted: fakeContact });
+}
+
+module.exports = weatherCommand;