jsdecryptor 4.0.3

package/davexcore/media/image.js

@@ -0,0 +1,87 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+// Track processed message IDs to prevent duplicate handling
+const processedMessages = new Set();
+async function imageCommand(sock, chatId, message) {
+    const fkontak = createFakeContact(message);
+    
+    try {
+        const msgId = message?.key?.id;
+        if (!msgId) return;
+
+        // Prevent duplicate processing
+        if (processedMessages.has(msgId)) return;
+        processedMessages.add(msgId);
+        setTimeout(() => processedMessages.delete(msgId), 5 * 60 * 1000);
+
+        // Extract text content
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text;
+        if (!text) {
+            return sock.sendMessage(chatId, { 
+                text: "Please provide a search term."
+            }, { quoted: fkontak });
+        }
+
+        // Parse query
+        const query = text.split(' ').slice(1).join(' ').trim();
+        if (!query) {
+            return sock.sendMessage(chatId, { 
+                text: "Please provide a search term."
+            }, { quoted: fkontak });
+        }
+
+        // React indicator
+        await sock.sendMessage(chatId, { react: { text: '🔍', key: message.key } });
+
+        // API call
+        const apiUrl = `https://iamtkm.vercel.app/downloaders/img?apikey=tkm&text=${encodeURIComponent(query)}`;
+        let apiResponse;
+        try {
+            apiResponse = await axios.get(apiUrl);
+        } catch (err) {
+            console.error("Image API error:", err.message);
+            return sock.sendMessage(chatId, { 
+                text: "Image service unavailable."
+            }, { quoted: fkontak });
+        }
+
+        const data = apiResponse?.data;
+        const imageUrls = Array.isArray(data?.result) ? data.result.slice(0, 10) : [];
+
+        if (data?.status && imageUrls.length > 0) {
+            // Send first image with caption
+            await sock.sendMessage(chatId, {
+                image: { url: imageUrls[0] },
+                caption: `Results for: ${query}`
+            }, { quoted: fkontak });
+
+            // Send remaining images without captions
+            for (let i = 1; i < imageUrls.length; i++) {
+                try {
+                    await sock.sendMessage(chatId, {
+                        image: { url: imageUrls[i] }
+                    });
+                    if (i < imageUrls.length - 1) {
+                        await new Promise(res => setTimeout(res, 500));
+                    }
+                } catch (imgErr) {
+                    console.error(`Image error ${i + 1}:`, imgErr.message);
+                }
+            }
+
+        } else {
+            await sock.sendMessage(chatId, { 
+                text: `No images for: ${query}`
+            }, { quoted: fkontak });
+        }
+
+    } catch (error) {
+        console.error("Image command error:", error.message);
+        await sock.sendMessage(chatId, { 
+            text: "Failed to search images."
+        }, { quoted: fkontak });
+    }
+}
+
+module.exports = imageCommand;

package/davexcore/media/imageedit.js

@@ -0,0 +1,329 @@
+const { GoogleGenerativeAI } = require('@google/generative-ai');
+const { downloadContentFromMessage } = require('@whiskeysockets/baileys');
+const fs = require('fs');
+const path = require('path');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function downloadMedia(message) {
+    try {
+        const stream = await downloadContentFromMessage(message, 'image');
+        let buffer = Buffer.from([]);
+        for await (const chunk of stream) {
+            buffer = Buffer.concat([buffer, chunk]);
+        }
+        return buffer;
+    } catch (error) {
+        console.error('Download error:', error);
+        throw error;
+    }
+}
+
+async function nightCommand(sock, chatId, message, text) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    
+    try {
+        const quoted = message.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+        if (!quoted) {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}* Night\n\nReply to an image with .night`
+            }, { quoted: fake });
+            return;
+        }
+
+        const imageMessage = quoted.imageMessage;
+        if (!imageMessage) {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nReply to an image`
+            }, { quoted: fake });
+            return;
+        }
+
+        const mimeType = imageMessage.mimetype;
+        if (!mimeType || !/image\/(jpe?g|png)/.test(mimeType)) {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nOnly JPEG/PNG images supported`
+            }, { quoted: fake });
+            return;
+        }
+
+        await sock.sendMessage(chatId, { 
+            text: `✦ *${botName}* - am know invisible 🔥\n\nProcessing image...`
+        }, { quoted: fake });
+
+        // Download the image
+        const buffer = await downloadMedia(imageMessage);
+        const base64Image = buffer.toString('base64');
+        const promptText = text || "ubah jadi malam hari";
+
+        const genAI = new GoogleGenerativeAI("AIzaSyDE7R-5gnjgeqYGSMGiZVjA5VkSrQvile8");
+        
+        const contents = [
+            { text: promptText },
+            {
+                inlineData: {
+                    mimeType: mimeType,
+                    data: base64Image
+                }
+            }
+        ];
+        
+        const model = genAI.getGenerativeModel({
+            model: "gemini-2.0-flash-exp-image-generation",
+            generationConfig: {
+                responseModalities: ["Text", "Image"]
+            },
+        });
+        
+        const response = await model.generateContent(contents);
+        
+        let resultImage = null;
+        
+        for (const part of response.response.candidates[0].content.parts) {
+            if (part.inlineData) {
+                const imageData = part.inlineData.data;
+                resultImage = Buffer.from(imageData, "base64");
+                break;
+            }
+        }
+        
+        if (resultImage) {
+            const tempPath = path.join(process.cwd(), "temp", `night_${Date.now()}.png`);
+            
+            if (!fs.existsSync(path.join(process.cwd(), "temp"))) {
+                fs.mkdirSync(path.join(process.cwd(), "temp"), { recursive: true });
+            }
+            
+            fs.writeFileSync(tempPath, resultImage);
+            
+            await sock.sendMessage(chatId, { 
+                image: { url: tempPath },
+                caption: `✦ *${botName}* - am know invisible 🔥`
+            }, { quoted: fake });
+            
+            setTimeout(() => {
+                try {
+                    if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+                } catch (e) {}
+            }, 30000);
+        } else {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nFailed to edit image`
+            }, { quoted: fake });
+        }
+
+    } catch (error) {
+        console.error('Error in night command:', error);
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}*\nError processing image`
+        }, { quoted: fake });
+    }
+}
+
+async function prettyCommand(sock, chatId, message, text) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    
+    try {
+        const quoted = message.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+        if (!quoted) {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}* Pretty\n\nReply to an image with .pretty`
+            }, { quoted: fake });
+            return;
+        }
+
+        const imageMessage = quoted.imageMessage;
+        if (!imageMessage) {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nReply to an image`
+            }, { quoted: fake });
+            return;
+        }
+
+        const mimeType = imageMessage.mimetype;
+        if (!mimeType || !/image\/(jpe?g|png)/.test(mimeType)) {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nOnly JPEG/PNG images supported`
+            }, { quoted: fake });
+            return;
+        }
+
+        await sock.sendMessage(chatId, { 
+            text: `✦ *${botName}* - am know invisible 🔥\n\nProcessing image...`
+        }, { quoted: fake });
+
+        const buffer = await downloadMedia(imageMessage);
+        const base64Image = buffer.toString('base64');
+        const promptText = text || "edit wajah karakter menjadi wajah orang Korea";
+
+        const genAI = new GoogleGenerativeAI("AIzaSyDE7R-5gnjgeqYGSMGiZVjA5VkSrQvile8");
+        
+        const contents = [
+            { text: promptText },
+            {
+                inlineData: {
+                    mimeType: mimeType,
+                    data: base64Image
+                }
+            }
+        ];
+        
+        const model = genAI.getGenerativeModel({
+            model: "gemini-2.0-flash-exp-image-generation",
+            generationConfig: {
+                responseModalities: ["Text", "Image"]
+            },
+        });
+        
+        const response = await model.generateContent(contents);
+        
+        let resultImage = null;
+        
+        for (const part of response.response.candidates[0].content.parts) {
+            if (part.inlineData) {
+                const imageData = part.inlineData.data;
+                resultImage = Buffer.from(imageData, "base64");
+                break;
+            }
+        }
+        
+        if (resultImage) {
+            const tempPath = path.join(process.cwd(), "temp", `pretty_${Date.now()}.png`);
+            
+            if (!fs.existsSync(path.join(process.cwd(), "temp"))) {
+                fs.mkdirSync(path.join(process.cwd(), "temp"), { recursive: true });
+            }
+            
+            fs.writeFileSync(tempPath, resultImage);
+            
+            await sock.sendMessage(chatId, { 
+                image: { url: tempPath },
+                caption: `✦ *${botName}* - am know invisible 🔥`
+            }, { quoted: fake });
+            
+            setTimeout(() => {
+                try {
+                    if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+                } catch (e) {}
+            }, 30000);
+        } else {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nFailed to edit image`
+            }, { quoted: fake });
+        }
+
+    } catch (error) {
+        console.error('Error in pretty command:', error);
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}*\nError processing image`
+        }, { quoted: fake });
+    }
+}
+
+async function uglyCommand(sock, chatId, message, text) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    
+    try {
+        const quoted = message.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+        if (!quoted) {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}* Ugly\n\nReply to an image with .ugly`
+            }, { quoted: fake });
+            return;
+        }
+
+        const imageMessage = quoted.imageMessage;
+        if (!imageMessage) {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nReply to an image`
+            }, { quoted: fake });
+            return;
+        }
+
+        const mimeType = imageMessage.mimetype;
+        if (!mimeType || !/image\/(jpe?g|png)/.test(mimeType)) {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nOnly JPEG/PNG images supported`
+            }, { quoted: fake });
+            return;
+        }
+
+        await sock.sendMessage(chatId, { 
+            text: `✦ *${botName}* - am know invisible 🔥\n\nProcessing image...`
+        }, { quoted: fake });
+
+        const buffer = await downloadMedia(imageMessage);
+        const base64Image = buffer.toString('base64');
+        const promptText = text || "edit wajah karakter menjadi jelek";
+
+        const genAI = new GoogleGenerativeAI("AIzaSyDE7R-5gnjgeqYGSMGiZVjA5VkSrQvile8");
+        
+        const contents = [
+            { text: promptText },
+            {
+                inlineData: {
+                    mimeType: mimeType,
+                    data: base64Image
+                }
+            }
+        ];
+        
+        const model = genAI.getGenerativeModel({
+            model: "gemini-2.0-flash-exp-image-generation",
+            generationConfig: {
+                responseModalities: ["Text", "Image"]
+            },
+        });
+        
+        const response = await model.generateContent(contents);
+        
+        let resultImage = null;
+        
+        for (const part of response.response.candidates[0].content.parts) {
+            if (part.inlineData) {
+                const imageData = part.inlineData.data;
+                resultImage = Buffer.from(imageData, "base64");
+                break;
+            }
+        }
+        
+        if (resultImage) {
+            const tempPath = path.join(process.cwd(), "temp", `ugly_${Date.now()}.png`);
+            
+            if (!fs.existsSync(path.join(process.cwd(), "temp"))) {
+                fs.mkdirSync(path.join(process.cwd(), "temp"), { recursive: true });
+            }
+            
+            fs.writeFileSync(tempPath, resultImage);
+            
+            await sock.sendMessage(chatId, { 
+                image: { url: tempPath },
+                caption: `✦ *${botName}* - am know invisible 🔥`
+            }, { quoted: fake });
+            
+            setTimeout(() => {
+                try {
+                    if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+                } catch (e) {}
+            }, 30000);
+        } else {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nFailed to edit image`
+            }, { quoted: fake });
+        }
+
+    } catch (error) {
+        console.error('Error in ugly command:', error);
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}*\nError processing image`
+        }, { quoted: fake });
+    }
+}
+
+module.exports = {
+    nightCommand,
+    prettyCommand,
+    uglyCommand
+};

package/davexcore/media/img-blur.js

@@ -0,0 +1,70 @@
+const { downloadMediaMessage } = require('@whiskeysockets/baileys');
+const Jimp = require('jimp');
+const webp = require('webp-converter');
+const fs = require('fs');
+const path = require('path');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+// Fake contact creator 😜
+async function blurCommand(sock, chatId, message, quotedMessage) {
+    const inputPath = path.resolve('./temp_input.jpg');
+    const lowQualityPath = path.resolve('./temp_low.webp');
+    const finalPath = path.resolve('./temp_blur.jpg');
+    
+    const fkontak = createFakeContact(message);
+
+    try {
+        // ==== Step 1: Extract image buffer ====
+        let imageBuffer;
+        if (quotedMessage?.imageMessage) {
+            const quoted = { message: { imageMessage: quotedMessage.imageMessage } };
+            imageBuffer = await downloadMediaMessage(quoted, 'buffer', {}, {});
+        } else if (message?.message?.imageMessage) {
+            imageBuffer = await downloadMediaMessage(message, 'buffer', {}, {});
+        } else {
+            return sock.sendMessage(chatId, {
+                text: 'Reply to an image or send an image with caption .blur'
+            }, { quoted: fkontak });
+        }
+
+        // Defensive check
+        if (!imageBuffer) {
+            throw new Error('No image buffer retrieved');
+        }
+
+        // ==== Step 2: Save original buffer ====
+        fs.writeFileSync(inputPath, imageBuffer);
+
+        // ==== Step 3: Convert to low-quality WebP (blur effect) ====
+        await webp.cwebp(inputPath, lowQualityPath, "-q 20", "-v");
+
+        // ==== Step 4: Convert back to JPG with reduced quality ====
+        const blurryImage = await Jimp.read(lowQualityPath);
+        await blurryImage.quality(70).writeAsync(finalPath);
+
+        const finalBuffer = fs.readFileSync(finalPath);
+
+        // ==== Step 5: Send blurred image ====
+        await sock.sendMessage(chatId, {
+            image: finalBuffer,
+            caption: 'Image blurred successfully'
+        }, { quoted: fkontak });
+
+    } catch (error) {
+        console.error("BLUR ERROR:", error);
+        await sock.sendMessage(chatId, {
+            text: 'Failed to blur image.'
+        }, { quoted: fkontak });
+    } finally {
+        // ==== Cleanup temp files safely ====
+        [inputPath, lowQualityPath, finalPath].forEach(file => {
+            if (fs.existsSync(file)) {
+                try { fs.unlinkSync(file); } catch (err) {
+                    console.warn(`Failed to delete ${file}:`, err);
+                }
+            }
+        });
+    }
+}
+
+module.exports = blurCommand;

package/davexcore/media/meme.js

@@ -0,0 +1,35 @@
+const fetch = require('node-fetch');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function memeCommand(sock, chatId, message) {
+    try {
+        const response = await fetch('https://shizoapi.onrender.com/api/memes/cheems?apikey=shizo');
+        
+        // Check if response is an image
+        const contentType = response.headers.get('content-type');
+        if (contentType && contentType.includes('image')) {
+            const imageBuffer = await response.buffer();
+            
+            const buttons = [
+                { buttonId: '.meme', buttonText: { displayText: '🎭 Another Meme' }, type: 1 },
+                { buttonId: '.joke', buttonText: { displayText: '😄 Joke' }, type: 1 }
+            ];
+
+            await sock.sendMessage(chatId, { 
+                image: imageBuffer,
+                caption: "_Here's your  meme! 💀_",
+                buttons: buttons,
+                headerType: 1
+            },{ quoted: fakeContact });
+        } else {
+            throw new Error('Invalid response type from API');
+        }
+    } catch (error) {
+        console.error('Error in meme command:', error);
+        await sock.sendMessage(chatId, { 
+            text: '❌ Failed to fetch meme. Please try again later.'
+        });
+    }
+}
+
+module.exports = memeCommand;

package/davexcore/media/pies.js

@@ -0,0 +1,53 @@
+const fetch = require('node-fetch');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const BASE = 'https://shizoapi.onrender.com/api/pies';
+const VALID_COUNTRIES = ['china', 'indonesia', 'japan', 'korea', 'hijab'];
+
+async function fetchPiesImageBuffer(country) {
+	const url = `${BASE}/${country}?apikey=shizo`;
+	const res = await fetch(url);
+	if (!res.ok) throw new Error(`HTTP ${res.status}`);
+	const contentType = res.headers.get('content-type') || '';
+	if (!contentType.includes('image')) throw new Error('API did not return an image');
+	return res.buffer();
+}
+
+async function piesCommand(sock, chatId, message, args) {
+	const sub = (args && args[0] ? args[0] : '').toLowerCase();
+	if (!sub) {
+		await sock.sendMessage(chatId, { text: `Usage: .pies <country>\nCountries: ${VALID_COUNTRIES.join(', ')}` }, { quoted: fakeContact });
+		return;
+	}
+	if (!VALID_COUNTRIES.includes(sub)) {
+		await sock.sendMessage(chatId, { text: `❌ Unsupported country: ${sub}. Try one of: ${VALID_COUNTRIES.join(', ')}` }, { quoted: fakeContact });
+		return;
+	}
+	try {
+		const imageBuffer = await fetchPiesImageBuffer(sub);
+		await sock.sendMessage(
+			chatId,
+			{ image: imageBuffer, caption: `pies: ${sub}` },
+			{ quoted: fakeContact }
+		);
+	} catch (err) {
+		console.error('Error in pies command:', err);
+		await sock.sendMessage(chatId, { text: '❌ Failed to fetch image. Please try again.' }, { quoted: fakeContact });
+	}
+}
+
+async function piesAlias(sock, chatId, message, country) {
+	try {
+		const imageBuffer = await fetchPiesImageBuffer(country);
+		await sock.sendMessage(
+			chatId,
+			{ image: imageBuffer, caption: `pies: ${country}` },
+			{ quoted: fakeContact }
+		);
+	} catch (err) {
+		console.error(`Error in pies alias (${country}) command:`, err);
+		await sock.sendMessage(chatId, { text: '❌ Failed to fetch image. Please try again.' }, { quoted: fakeContact });
+	}
+}
+
+module.exports = { piesCommand, piesAlias, VALID_COUNTRIES };