jsdecryptor 4.0.3

package/davexcore/group/unmute.js

@@ -0,0 +1,45 @@
+const isAdmin = require('../../davelib/isAdmin');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function unmuteCommand(sock, chatId, message) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+
+    const { isSenderAdmin, isBotAdmin } = await isAdmin(sock, chatId, senderId);
+
+    if (!isBotAdmin) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nBot needs admin!` }, { quoted: fake });
+        return { success: false, message: 'Bot not admin' };
+    }
+
+    if (!isSenderAdmin && !message?.key?.fromMe && !db.isSudo(senderId)) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nAdmin only command!` }, { quoted: fake });
+        return { success: false, message: 'Not authorized' };
+    }
+    
+    try {
+        await sock.groupSettingUpdate(chatId, 'not_announcement');
+
+        const metadata = await sock.groupMetadata(chatId);
+        const groupName = metadata?.subject || 'Group';
+
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\n\n${groupName} has been unmuted.`
+        }, { quoted: fake });
+
+        return { success: true, message: `${groupName} unmuted` };
+
+    } catch (error) {
+        console.error('Unmute error:', error.message, 'Line:', error.stack?.split('\n')[1]);
+
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nFailed to unmute.`
+        }, { quoted: fake });
+
+        return { success: false, message: 'Failed', error };
+    }
+}
+
+module.exports = unmuteCommand;

package/davexcore/group/warn.js

@@ -0,0 +1,83 @@
+const isAdmin = require('../../davelib/isAdmin');
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function warnCommand(sock, chatId, senderId, mentionedJids, message) {
+    try {
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (!chatId.endsWith('@g.us')) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nGroup command only!`
+            }, { quoted: fake });
+            return;
+        }
+
+        const { isSenderAdmin, isBotAdmin } = await isAdmin(sock, chatId, senderId);
+            
+        if (!isBotAdmin) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nBot needs to be admin!`
+            }, { quoted: fake });
+            return;
+        }
+
+        if (!isSenderAdmin && !message.key.fromMe && !db.isSudo(senderId)) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nAdmin only command!`
+            }, { quoted: fake });
+            return;
+        }
+
+        let userToWarn;
+
+        if (mentionedJids && mentionedJids.length > 0) {
+            userToWarn = mentionedJids[0];
+        } else if (message.message?.extendedTextMessage?.contextInfo?.participant) {
+            userToWarn = message.message.extendedTextMessage.contextInfo.participant;
+        }
+
+        if (!userToWarn) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nMention or reply to a user to warn them.`
+            }, { quoted: fake });
+            return;
+        }
+
+        const targetAdmin = await isAdmin(sock, chatId, userToWarn);
+        if (targetAdmin.isSenderAdmin) {
+            await sock.sendMessage(chatId, { 
+                text: `*${botName}*\nCannot warn an admin!`
+            }, { quoted: fake });
+            return;
+        }
+
+        const warnCount = db.incrementWarning(chatId, userToWarn);
+        const maxWarnings = 3;
+        const userTag = `@${userToWarn.split('@')[0]}`;
+
+        if (warnCount >= maxWarnings) {
+            await sock.sendMessage(chatId, {
+                text: `*${botName}*\n${userTag} has been kicked!\nReason: ${maxWarnings} warnings`,
+                mentions: [userToWarn]
+            }, { quoted: fake });
+            
+            try {
+                await sock.groupParticipantsUpdate(chatId, [userToWarn], 'remove');
+                db.resetWarning(chatId, userToWarn);
+            } catch (kickError) {
+                console.error('Kick error:', kickError.message, 'Line:', kickError.stack?.split('\n')[1]);
+            }
+        } else {
+            await sock.sendMessage(chatId, {
+                text: `*${botName}*\n${userTag} has been warned!\nWarnings: ${warnCount}/${maxWarnings}`,
+                mentions: [userToWarn]
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Error in warn command:', error.message, 'Line:', error.stack?.split('\n')[1]);
+    }
+}
+
+module.exports = warnCommand;

package/davexcore/group/warnings.js

@@ -0,0 +1,26 @@
+const db = require('../../Database/database');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function warningsCommand(sock, chatId, mentionedJidList, groupId) {
+    if (mentionedJidList.length === 0) {
+        await sock.sendMessage(chatId, { text: 'Please mention a user to check warnings.' });
+        return;
+    }
+
+    const userToCheck = mentionedJidList[0];
+    const targetGroup = groupId || chatId;
+    
+    try {
+        const database = db.getDb();
+        const stmt = database.prepare('SELECT count FROM warnings WHERE group_jid = ? AND user_jid = ?');
+        const result = stmt.get(targetGroup, userToCheck);
+        const warningCount = result ? result.count : 0;
+        
+        await sock.sendMessage(chatId, { text: `User has ${warningCount} warning(s).` });
+    } catch (error) {
+        console.error('Error fetching warnings:', error);
+        await sock.sendMessage(chatId, { text: 'Error fetching warnings.' });
+    }
+}
+
+module.exports = warningsCommand;

package/davexcore/media/anime.js

@@ -0,0 +1,130 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const ANIMU_BASE = 'https://api.some-random-api.com/animu';
+
+function normalizeType(input) {
+    const lower = (input || '').toLowerCase();
+    if (lower === 'facepalm' || lower === 'face_palm') return 'face-palm';
+    if (lower === 'quote' || lower === 'animu-quote' || lower === 'animuquote') return 'quote';
+    return lower;
+}
+
+async function sendAnimu(sock, chatId, message, type) {
+    const fakeContact = createFakeContact(message);
+    // Handle waifu, neko, and loli from different APIs
+    if (type === 'waifu' || type === 'neko') {
+        try {
+            const endpoint = `https://api.siputzx.my.id/api/r/${type}`;
+            const res = await axios.get(endpoint, { responseType: 'arraybuffer' });
+            
+            if (res.status === 200 && res.data) {
+                await sock.sendMessage(
+                    chatId,
+                    { image: res.data, caption: `anime: ${type}` },
+                    { quoted: fakeContact }
+                );
+                return;
+            }
+        } catch (error) {
+            console.error(`Error fetching ${type}:`, error.message);
+            await sock.sendMessage(
+                chatId,
+                { text: `❌ Failed to fetch ${type}.` },
+                { quoted: fakeContact }
+            );
+            return;
+        }
+    }
+
+    if (type === 'loli') {
+        try {
+            const endpoint = 'https://shizoapi.onrender.com/api/sfw/loli?apikey=shizo';
+            const res = await axios.get(endpoint, { responseType: 'arraybuffer' });
+            
+            if (res.status === 200 && res.data) {
+                await sock.sendMessage(
+                    chatId,
+                    { image: res.data, caption: `anime: ${type}` },
+                    { quoted: fakeContact }
+                );
+                return;
+            }
+        } catch (error) {
+            console.error(`Error fetching ${type}:`, error.message);
+            await sock.sendMessage(
+                chatId,
+                { text: `❌ Failed to fetch ${type}.` },
+                { quoted: fakeContact }
+            );
+            return;
+        }
+    }
+
+    // Handle other anime types from some-random-api
+    const endpoint = `${ANIMU_BASE}/${type}`;
+    const res = await axios.get(endpoint);
+    const data = res.data || {};
+
+    // Prefer link (gif/image). Fallback to text quote if available
+    if (data.link) {
+        await sock.sendMessage(
+            chatId,
+            { image: { url: data.link }, caption: `anime: ${type}` },
+            { quoted: fakeContact }
+        );
+        return;
+    }
+    if (data.quote) {
+        await sock.sendMessage(
+            chatId,
+            { text: data.quote },
+            { quoted: fakeContact }
+        );
+        return;
+    }
+
+    await sock.sendMessage(
+        chatId,
+        { text: '❌ Failed to fetch animu.' },
+        { quoted: fakeContact }
+    );
+}
+
+async function animeCommand(sock, chatId, message, args) {
+    const fakeContact = createFakeContact(message);
+    const subArg = args && args[0] ? args[0] : '';
+    const sub = normalizeType(subArg);
+
+    const supported = [
+        'nom', 'poke', 'cry', 'kiss', 'pat', 'hug', 'wink', 'face-palm', 'quote', 'waifu', 'neko', 'loli'
+    ];
+
+    try {
+        if (!sub) {
+            // Fetch supported types from API for dynamic help
+            try {
+                const res = await axios.get(ANIMU_BASE);
+                const apiTypes = res.data && res.data.types ? res.data.types.map(s => s.replace('/animu/', '')).join(', ') : supported.join(', ');
+                await sock.sendMessage(chatId, { text: `Usage: .animu <type>\nTypes: ${apiTypes}` }, { quoted: fakeContact });
+            } catch {
+                await sock.sendMessage(chatId, { text: `Usage: .animu <type>\nTypes: ${supported.join(', ')}` }, { quoted: fakeContact });
+            }
+            return;
+        }
+
+        if (!supported.includes(sub)) {
+            await sock.sendMessage(chatId, { text: `❌ Unsupported type: ${sub}. Try one of: ${supported.join(', ')}` }, { quoted: fakeContact });
+            return;
+        }
+
+        await sendAnimu(sock, chatId, message, sub);
+    } catch (err) {
+        console.error('Error in animu command:', err);
+        await sock.sendMessage(chatId, { text: '❌ An error occurred while fetching animu.' }, { quoted: fakeContact });
+    }
+}
+
+module.exports = { animeCommand };
+
+

package/davexcore/media/attp.js

@@ -0,0 +1,127 @@
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const { writeExifImg, writeExifVid } = require('../../davelib/exif');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+async function attpCommand(sock, chatId, message) {
+    const userMessage = message.message.conversation || message.message.extendedTextMessage?.text || '';
+    const text = userMessage.split(' ').slice(1).join(' ');
+    
+    const fake = createFakeContact(message);
+    
+    if (!text) {
+        await sock.sendMessage(chatId, { text: 'Please provide text after the .attp command.' }, { quoted: fake });
+        return;
+    }
+
+    try {
+        const pushname = message.pushName || 'DAVE-X'
+        const mp4Buffer = await renderBlinkingVideoWithFfmpeg(text);
+        const webpPath = await writeExifVid(mp4Buffer, { packname: `${pushname}` });
+        const webpBuffer = fs.readFileSync(webpPath);
+        try { fs.unlinkSync(webpPath) } catch (_) {}
+        await sock.sendMessage(chatId, { sticker: webpBuffer }, { quoted: fake });
+    } catch (error) {
+        console.error('Error generating local sticker:', error);
+        await sock.sendMessage(chatId, { text: 'Failed to generate the sticker.' }, { quoted: fake });
+    }
+}
+
+module.exports = attpCommand;
+
+function renderTextToPngWithFfmpeg(text) {
+    return new Promise((resolve, reject) => {
+        const fontPath = process.platform === 'win32'
+            ? 'C:/Windows/Fonts/arialbd.ttf'
+            : '/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf';
+
+        const escapeDrawtextText = (s) => s
+            .replace(/\\/g, '\\\\')
+            .replace(/:/g, '\\:')
+            .replace(/'/g, "\\'")
+            .replace(/\[/g, '\\[')
+            .replace(/\]/g, '\\]')
+            .replace(/%/g, '\\%');
+
+        const safeText = escapeDrawtextText(text);
+        const safeFontPath = process.platform === 'win32'
+            ? fontPath.replace(/\\/g, '/').replace(':', '\\:')
+            : fontPath;
+
+        const args = [
+            '-y',
+            '-f', 'lavfi',
+            '-i', 'color=c=#00000000:s=512x512',
+            '-vf', `drawtext=fontfile='${safeFontPath}':text='${safeText}':fontcolor=white:fontsize=56:borderw=2:bordercolor=black@0.6:x=(w-text_w)/2:y=(h-text_h)/2`,
+            '-frames:v', '1',
+            '-f', 'image2',
+            'pipe:1'
+        ];
+
+        const ff = spawn('ffmpeg', args);
+        const chunks = [];
+        const errors = [];
+        ff.stdout.on('data', d => chunks.push(d));
+        ff.stderr.on('data', e => errors.push(e));
+        ff.on('error', reject);
+        ff.on('close', code => {
+            if (code === 0) return resolve(Buffer.concat(chunks));
+            reject(new Error(Buffer.concat(errors).toString() || `ffmpeg exited with code ${code}`));
+        });
+    });
+}
+
+function renderBlinkingVideoWithFfmpeg(text) {
+    return new Promise((resolve, reject) => {
+        const fontPath = process.platform === 'win32'
+            ? 'C:/Windows/Fonts/arialbd.ttf'
+            : '/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf';
+
+        const escapeDrawtextText = (s) => s
+            .replace(/\\/g, '\\\\')
+            .replace(/:/g, '\\:')
+            .replace(/,/g, '\\,')
+            .replace(/'/g, "\\'")
+            .replace(/\[/g, '\\[')
+            .replace(/\]/g, '\\]')
+            .replace(/%/g, '\\%');
+
+        const safeText = escapeDrawtextText(text);
+        const safeFontPath = process.platform === 'win32'
+            ? fontPath.replace(/\\/g, '/').replace(':', '\\:')
+            : fontPath;
+
+        const cycle = 0.3;
+        const dur = 1.8;
+
+        const drawRed = `drawtext=fontfile='${safeFontPath}':text='${safeText}':fontcolor=red:borderw=2:bordercolor=black@0.6:fontsize=56:x=(w-text_w)/2:y=(h-text_h)/2:enable='lt(mod(t\,${cycle})\,0.1)'`;
+        const drawBlue = `drawtext=fontfile='${safeFontPath}':text='${safeText}':fontcolor=blue:borderw=2:bordercolor=black@0.6:fontsize=56:x=(w-text_w)/2:y=(h-text_h)/2:enable='between(mod(t\,${cycle})\,0.1\,0.2)'`;
+        const drawGreen = `drawtext=fontfile='${safeFontPath}':text='${safeText}':fontcolor=green:borderw=2:bordercolor=black@0.6:fontsize=56:x=(w-text_w)/2:y=(h-text_h)/2:enable='gte(mod(t\,${cycle})\,0.2)'`;
+
+        const filter = `${drawRed},${drawBlue},${drawGreen}`;
+
+        const args = [
+            '-y',
+            '-f', 'lavfi',
+            '-i', `color=c=black:s=512x512:d=${dur}:r=20`,
+            '-vf', filter,
+            '-c:v', 'libx264',
+            '-pix_fmt', 'yuv420p',
+            '-movflags', '+faststart+frag_keyframe+empty_moov',
+            '-t', String(dur),
+            '-f', 'mp4',
+            'pipe:1'
+        ];
+
+        const ff = spawn('ffmpeg', args);
+        const chunks = [];
+        const errors = [];
+        ff.stdout.on('data', d => chunks.push(d));
+        ff.stderr.on('data', e => errors.push(e));
+        ff.on('error', reject);
+        ff.on('close', code => {
+            if (code === 0) return resolve(Buffer.concat(chunks));
+            reject(new Error(Buffer.concat(errors).toString() || `ffmpeg exited with code ${code}`));
+        });
+    });
+}

package/davexcore/media/design.js

@@ -0,0 +1,52 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const axios = require('axios');
+
+async function logoCommand(sock, chatId, message, args) {
+    const fakeContact = createFakeContact(message);
+    const botName = getBotName();
+    const text = args.join(' ').trim();
+    
+    if (!text) {
+        return sock.sendMessage(chatId, { text: `*${botName} LOGO MAKER*\n\nUsage: .logo <text>\nMakes a styled logo from your text` }, { quoted: fakeContact });
+    }
+    
+    await sock.sendMessage(chatId, { react: { text: '🎨', key: message.key } });
+    
+    try {
+        const res = await axios.get(`https://api.siputzx.my.id/api/m/ephoto?url=https://en.ephoto360.com/create-3d-hologram-text-effect-online-free-697.html&text=${encodeURIComponent(text)}`, { timeout: 20000 });
+        const imgUrl = res.data?.result || res.data?.url || res.data?.data?.url;
+        if (imgUrl) {
+            await sock.sendMessage(chatId, { image: { url: imgUrl }, caption: `*${botName} LOGO*\nText: ${text}` }, { quoted: fakeContact });
+        } else {
+            await sock.sendMessage(chatId, { text: `*${botName}*\nFailed to generate logo.` }, { quoted: fakeContact });
+        }
+    } catch (err) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nError: ${err.message}` }, { quoted: fakeContact });
+    }
+}
+
+async function carbonCommand(sock, chatId, message, args) {
+    const fakeContact = createFakeContact(message);
+    const botName = getBotName();
+    const code = args.join(' ').trim();
+    
+    if (!code) {
+        return sock.sendMessage(chatId, { text: `*${botName} CARBON*\n\nUsage: .carbon <code>\nGenerates a beautiful code screenshot` }, { quoted: fakeContact });
+    }
+    
+    await sock.sendMessage(chatId, { react: { text: '💻', key: message.key } });
+    
+    try {
+        const res = await axios.get(`https://bk9.fun/tools/carbon?q=${encodeURIComponent(code)}`, { timeout: 20000 });
+        const imgUrl = res.data?.BK9 || res.data?.result;
+        if (imgUrl) {
+            await sock.sendMessage(chatId, { image: { url: imgUrl }, caption: `*${botName} CARBON*` }, { quoted: fakeContact });
+        } else {
+            await sock.sendMessage(chatId, { text: `*${botName}*\nFailed to generate carbon image.` }, { quoted: fakeContact });
+        }
+    } catch (err) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nError: ${err.message}` }, { quoted: fakeContact });
+    }
+}
+
+module.exports = { logoCommand, carbonCommand };

package/davexcore/media/emojimix.js

@@ -0,0 +1,105 @@
+const fetch = require('node-fetch');
+const fs = require('fs');
+const { exec } = require('child_process');
+const path = require('path');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+async function emojimixCommand(sock, chatId, msg) {
+    try {
+        const fake = createFakeContact(msg);
+        
+        // Get the text after command
+        const text = msg.message?.conversation?.trim() || 
+                    msg.message?.extendedTextMessage?.text?.trim() || '';
+        
+        const args = text.split(' ').slice(1);
+        
+        if (!args[0]) {
+            await sock.sendMessage(chatId, { text: 'Example: .emojimix 😎+🥰' }, { quoted: fake });
+            return;
+        }
+
+        if (!text.includes('+')) {
+            await sock.sendMessage(chatId, { 
+                text: 'Separate the emoji with a + sign\n\nExample:\n.emojimix 😎+🥰' 
+            }, { quoted: fake });
+            return;
+        }
+
+        let [emoji1, emoji2] = args[0].split('+').map(e => e.trim());
+
+        // Using Tenor API endpoint
+        const url = `https://tenor.googleapis.com/v2/featured?key=AIzaSyAyimkuYQYF_FXVALexPuGQctUWRURdCYQ&contentfilter=high&media_filter=png_transparent&component=proactive&collection=emoji_kitchen_v5&q=${encodeURIComponent(emoji1)}_${encodeURIComponent(emoji2)}`;
+
+        const response = await fetch(url);
+        const data = await response.json();
+
+        if (!data.results || data.results.length === 0) {
+            await sock.sendMessage(chatId, { 
+                text: 'These emojis cannot be mixed! Try different ones.' 
+            }, { quoted: fake });
+            return;
+        }
+
+        // Get the first result URL
+        const imageUrl = data.results[0].url;
+
+        // Create temp directory if it doesn't exist
+        const tmpDir = path.join(process.cwd(), 'tmp');
+        if (!fs.existsSync(tmpDir)) {
+            fs.mkdirSync(tmpDir, { recursive: true });
+        }
+
+        // Generate random filenames with escaped paths
+        const tempFile = path.join(tmpDir, `temp_${Date.now()}.png`).replace(/\\/g, '/');
+        const outputFile = path.join(tmpDir, `sticker_${Date.now()}.webp`).replace(/\\/g, '/');
+
+        // Download and save the image
+        const imageResponse = await fetch(imageUrl);
+        const buffer = await imageResponse.buffer();
+        fs.writeFileSync(tempFile, buffer);
+
+        // Convert to WebP using ffmpeg with proper path escaping
+        const ffmpegCommand = `ffmpeg -i "${tempFile}" -vf "scale=512:512:force_original_aspect_ratio=decrease,format=rgba,pad=512:512:(ow-iw)/2:(oh-ih)/2:color=#00000000" "${outputFile}"`;
+        
+        await new Promise((resolve, reject) => {
+            exec(ffmpegCommand, (error) => {
+                if (error) {
+                    console.error('FFmpeg error:', error);
+                    reject(error);
+                } else {
+                    resolve();
+                }
+            });
+        });
+
+        // Check if output file exists
+        if (!fs.existsSync(outputFile)) {
+            throw new Error('Failed to create sticker file');
+        }
+
+        // Read the WebP file
+        const stickerBuffer = fs.readFileSync(outputFile);
+
+        // Send the sticker
+        await sock.sendMessage(chatId, { 
+            sticker: stickerBuffer 
+        }, { quoted: fake });
+
+        // Cleanup temp files
+        try {
+            fs.unlinkSync(tempFile);
+            fs.unlinkSync(outputFile);
+        } catch (err) {
+            console.error('Error cleaning up temp files:', err);
+        }
+
+    } catch (error) {
+        console.error('Error in emojimix command:', error);
+        const fake = createFakeContact(msg);
+        await sock.sendMessage(chatId, { 
+            text: 'Failed to mix emojis! Make sure you are using valid emojis.\n\nExample: .emojimix 😎+🥰' 
+        }, { quoted: fake });
+    }
+}
+
+module.exports = emojimixCommand;

package/davexcore/media/getpp.js

@@ -0,0 +1,108 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function getppCommand(sock, chatId, message) {
+    try {
+        const fake = createFakeContact(message);
+        const botName = getBotName();
+        
+        // Check if user is owner
+        const isOwner = message.key.fromMe;
+        if (!isOwner) {
+            const authMsgs = [
+                `✦ Owner only command`,
+                `✦ Sorry, only the boss can use this`,
+                `✦ Privileges required`
+            ];
+            await sock.sendMessage(chatId, { 
+                text: authMsgs[Math.floor(Math.random() * authMsgs.length)]
+            }, { quoted: fake });
+            return;
+        }
+
+        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) {
+            const usageMsgs = [
+                `✦ Mention someone or reply to their message`,
+                `✦ Who's pp? Tag or reply to them`,
+                `✦ Please specify a user`
+            ];
+            await sock.sendMessage(chatId, { 
+                text: usageMsgs[Math.floor(Math.random() * usageMsgs.length)]
+            }, { quoted: fake });
+
+            await sock.sendMessage(chatId, {
+                react: { text: '🗑️', key: message.key }
+            });
+            return;
+        }
+
+        try {
+            // Get user's profile picture
+            let profilePic;
+            try {
+                profilePic = await sock.profilePictureUrl(userToAnalyze, 'image');
+            } catch {
+                profilePic = 'https://files.catbox.moe/lvcwnf.jpg'; // Default image
+            }
+
+            const username = userToAnalyze.split('@')[0];
+            
+            const captionMsgs = [
+                `✦ @${username}'s profile picture`,
+                `✦ PP for @${username}`,
+                `✦ Here's @${username}`
+            ];
+
+            // Send the profile picture to the chat
+            await sock.sendMessage(chatId, {
+                image: { url: profilePic },
+                caption: captionMsgs[Math.floor(Math.random() * captionMsgs.length)],
+                mentions: [userToAnalyze]
+            }, { quoted: fake });
+
+            await sock.sendMessage(chatId, {
+                react: { text: '✅', key: message.key }
+            });
+
+        } catch (error) {
+            console.error('Error in getpp command:', error);
+            
+            const errorMsgs = [
+                `✦ Couldn't fetch that profile`,
+                `✦ No profile picture found`,
+                `✦ User might not have a pp set`
+            ];
+            
+            await sock.sendMessage(chatId, {
+                text: errorMsgs[Math.floor(Math.random() * errorMsgs.length)]
+            }, { quoted: fake });
+        }
+    } catch (error) {
+        console.error('Unexpected error in getppCommand:', error);
+        const fake = createFakeContact(message);
+        const botName = getBotName();
+        
+        const fatalMsgs = [
+            `✦ Something went wrong`,
+            `✦ Unexpected error`,
+            `✦ Command failed`
+        ];
+        
+        await sock.sendMessage(chatId, {
+            text: fatalMsgs[Math.floor(Math.random() * fatalMsgs.length)]
+        }, { quoted: fake });
+    }
+}
+
+module.exports = getppCommand;