jsdecryptor 4.0.3

package/davexcore/media/shazam.js

@@ -0,0 +1,251 @@
+const { downloadContentFromMessage } = require('@whiskeysockets/baileys');
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+const { UploadFileUgu } = require('../../davelib/uploader');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const DEBUG = true;
+function debugLog(message, data = null) {
+    if (DEBUG) {
+        console.log(`[SHAZAM] ${message}`, data ? JSON.stringify(data, null, 2) : '');
+    }
+}
+
+async function getMediaBuffer(message, type) {
+    try {
+        debugLog(`Checking for ${type} media...`);
+        const m = message.message || {};
+        let messageType, fileExt, downloadType;
+
+        switch (type) {
+            case 'audio':
+                if (m.audioMessage) {
+                    messageType = m.audioMessage;
+                    fileExt = '.mp3';
+                    downloadType = 'audio';
+                    debugLog('Found audio message');
+                }
+                break;
+            case 'video':
+                if (m.videoMessage) {
+                    messageType = m.videoMessage;
+                    fileExt = '.mp4';
+                    downloadType = 'video';
+                    debugLog('Found video message');
+                }
+                break;
+            case 'image':
+                if (m.imageMessage) {
+                    messageType = m.imageMessage;
+                    fileExt = '.jpg';
+                    downloadType = 'image';
+                    debugLog('Found image message');
+                }
+                break;
+        }
+
+        if (messageType) {
+            debugLog(`Downloading ${type} content...`);
+            const stream = await downloadContentFromMessage(messageType, downloadType);
+            const chunks = [];
+            for await (const chunk of stream) {
+                chunks.push(chunk);
+            }
+            const buffer = Buffer.concat(chunks);
+            debugLog(`Downloaded ${type} buffer size:`, { size: buffer.length, type });
+            return { buffer, ext: fileExt, type };
+        }
+
+        debugLog(`No ${type} message found`);
+        return null;
+    } catch (error) {
+        console.error(`[SHAZAM] Error getting ${type} buffer:`, error.message);
+        return null;
+    }
+}
+
+async function getQuotedMediaBuffer(message, type) {
+    try {
+        debugLog(`Checking quoted message for ${type}...`);
+        const quoted = message.message?.extendedTextMessage?.contextInfo?.quotedMessage || null;
+        if (!quoted) {
+            debugLog('No quoted message found');
+            return null;
+        }
+        debugLog('Found quoted message, checking for media...');
+        return await getMediaBuffer({ message: quoted }, type);
+    } catch (error) {
+        console.error(`[SHAZAM] Error getting quoted ${type} buffer:`, error.message);
+        return null;
+    }
+}
+
+async function getAllMediaBuffers(message) {
+    debugLog('Scanning for all media types...');
+    const mediaTypes = ['audio', 'video', 'image'];
+
+    // Check current message
+    for (const type of mediaTypes) {
+        const media = await getMediaBuffer(message, type);
+        if (media) {
+            debugLog(`Found media in current message:`, { type: media.type, size: media.buffer.length });
+            return media;
+        }
+    }
+
+    debugLog('No media found in current message, checking quoted...');
+
+    // Check quoted message
+    for (const type of mediaTypes) {
+        const media = await getQuotedMediaBuffer(message, type);
+        if (media) {
+            debugLog(`Found media in quoted message:`, { type: media.type, size: media.buffer.length });
+            return media;
+        }
+    }
+
+    debugLog('No media found in current or quoted message');
+    return null;
+}
+
+async function shazamCommand(sock, chatId, message) {
+    let tempPath = null;
+
+    try {
+        debugLog('Shazam command started', { chatId, messageId: message.key.id });
+
+        const fakeContact = createFakeContact(message);
+        const botName = getBotName();
+
+        const media = await getAllMediaBuffers(message);
+
+        if (!media) {
+            debugLog('No media found - sending instructions');
+            await sock.sendMessage(chatId, {
+                text: `✦ *SHAZAM*
+
+Send or reply to:
+• Audio / Voice note
+• Video with audio
+• Image
+
+To identify the song`
+            }, { quoted: fakeContact });
+            return;
+        }
+
+        debugLog('Media found, creating temp file...', { type: media.type, size: media.buffer.length });
+
+        const tempDir = path.join(__dirname, '../temp');
+        if (!fs.existsSync(tempDir)) {
+            debugLog('Creating temp directory...');
+            fs.mkdirSync(tempDir, { recursive: true });
+        }
+
+        tempPath = path.join(tempDir, `${Date.now()}_${media.type}${media.ext}`);
+        fs.writeFileSync(tempPath, media.buffer);
+        debugLog('Temp file created:', { path: tempPath, size: media.buffer.length });
+
+        let mediaUrl = '';
+        try {
+            debugLog('Uploading to Uguu...');
+            const res = await UploadFileUgu(tempPath);
+            debugLog('Uguu upload response:', res);
+
+            // Robust parsing of Uguu response
+            if (typeof res === 'string') {
+                mediaUrl = res;
+            } else if (res.url) {
+                mediaUrl = res.url;
+            } else if (res.url_full) {
+                mediaUrl = res.url_full;
+            } else if (res.data?.url) {
+                mediaUrl = res.data.url;
+            } else if (res.data?.url_full) {
+                mediaUrl = res.data.url_full;
+            }
+
+            if (!mediaUrl) {
+                debugLog('Uguu response structure unexpected:', res);
+            }
+        } catch (uploadError) {
+            console.error('[SHAZAM] Upload error:', uploadError);
+            throw new Error(`Upload failed: ${uploadError.message}`);
+        }
+
+        if (!mediaUrl) {
+            debugLog('No media URL obtained from upload');
+            await sock.sendMessage(chatId, { text: `✦ Failed to upload media` }, { quoted: fakeContact });
+            return;
+        }
+
+        debugLog('Media uploaded successfully, URL:', mediaUrl);
+
+        let resultText = '';
+        try {
+            debugLog('Calling Shazam API...', { url: mediaUrl });
+            const response = await axios.get(`https://apiskeith.vercel.app/ai/shazam`, {
+                params: { url: mediaUrl },
+                timeout: 30000
+            });
+
+            debugLog('Shazam API response:', { status: response.status, data: response.data });
+
+            const song = response.data?.result || response.data;
+
+            if (song && (song.title || song.artists)) {
+                resultText = `✦ *SONG IDENTIFIED*
+    
+  Title: ${song.title || 'Unknown'}
+  Artist: ${song.artists || 'Unknown'}
+  Album: ${song.album || 'N/A'}
+  Release: ${song.release_date || 'N/A'}
+
+  Source: ${media.type}`;
+                debugLog('Song identified successfully');
+            } else {
+                resultText = `✦ Could not identify song from this ${media.type}`;
+                debugLog('No song identified from Shazam API');
+            }
+        } catch (apiError) {
+            console.error('[SHAZAM] API error:', apiError.message);
+            debugLog('Shazam API error details:', {
+                code: apiError.code,
+                response: apiError.response?.data,
+                status: apiError.response?.status
+            });
+
+            if (apiError.code === 'ECONNREFUSED') {
+                resultText = `✦ Service unavailable, try again later`;
+            } else if (apiError.response?.status === 404) {
+                resultText = `✦ Song not found, try clearer audio`;
+            } else {
+                resultText = `✦ Recognition failed for this ${media.type}`;
+            }
+        }
+
+        debugLog('Sending result to user...');
+        await sock.sendMessage(chatId, { text: resultText }, { quoted: fakeContact });
+
+    } catch (error) {
+        console.error('[SHAZAM] General error:', error.message);
+        debugLog('General error details:', { stack: error.stack });
+
+        const fakeContact = createFakeContact(message);
+        await sock.sendMessage(chatId, {
+            text: `✦ Failed: ${error.message}`
+        }, { quoted: fakeContact });
+    } finally {
+        if (tempPath && fs.existsSync(tempPath)) {
+            try {
+                fs.unlinkSync(tempPath);
+                debugLog('Temp file cleaned up');
+            } catch (cleanupError) {
+                console.error('[SHAZAM] Cleanup error:', cleanupError.message);
+            }
+        }
+    }
+}
+
+module.exports = shazamCommand;

package/davexcore/media/simage.js

@@ -0,0 +1,74 @@
+const fs = require('fs');
+const fsPromises = require('fs/promises');
+const fse = require('fs-extra');
+const path = require('path');
+const webp = require('webp-converter');
+const { downloadContentFromMessage } = require('@whiskeysockets/baileys');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const tempDir = './temp';
+if (!fs.existsSync(tempDir)) fs.mkdirSync(tempDir);
+
+/**
+ * Schedule deletion of a file after a delay
+ * @param {string} filePath - Path of the file to delete
+ * @param {number} delay - Delay in ms before deletion
+ */
+const scheduleFileDeletion = (filePath, delay = 10000) => {
+    setTimeout(async () => {
+        try {
+            await fse.remove(filePath);
+            console.log(`✅ Deleted: ${filePath}`);
+        } catch (error) {
+            console.error(`❌ Failed to delete ${filePath}:`, error);
+        }
+    }, delay);
+};
+
+/**
+ * Convert a WhatsApp sticker (WEBP) to PNG and send it back
+ * @param {object} sock - Baileys socket instance
+ * @param {object} quotedMessage - Quoted message containing sticker
+ * @param {string} chatId - Chat ID to send the converted image
+ */
+const convertStickerToImage = async (sock, quotedMessage, chatId) => {
+    try {
+        const stickerMessage = quotedMessage?.stickerMessage;
+        if (!stickerMessage) {
+            await sock.sendMessage(chatId, { text: '⚠️ Reply to a sticker with .simage to convert it.' });
+            return;
+        }
+
+        const timestamp = Date.now();
+        const stickerFilePath = path.join(tempDir, `sticker_${timestamp}.webp`);
+        const outputImagePath = path.join(tempDir, `converted_${timestamp}.png`);
+
+        // Download sticker
+        const stream = await downloadContentFromMessage(stickerMessage, 'sticker');
+        let buffer = Buffer.alloc(0);
+        for await (const chunk of stream) buffer = Buffer.concat([buffer, chunk]);
+
+        await fsPromises.writeFile(stickerFilePath, buffer);
+
+        // Convert WEBP → PNG
+        const result = await webp.dwebp(stickerFilePath, outputImagePath, "-o");
+        console.log("WEBP → PNG conversion result:", result);
+
+        // Read and send converted image
+        const imageBuffer = await fsPromises.readFile(outputImagePath);
+        await sock.sendMessage(chatId, { 
+            image: imageBuffer, 
+            caption: '✅ Sticker converted to image!' 
+        });
+
+        // Cleanup
+        scheduleFileDeletion(stickerFilePath);
+        scheduleFileDeletion(outputImagePath);
+
+    } catch (error) {
+        console.error('❌ Error converting sticker:', error);
+        await sock.sendMessage(chatId, { text: 'An error occurred while converting the sticker.' });
+    }
+};
+
+module.exports = convertStickerToImage;

package/davexcore/media/sticker.js

@@ -0,0 +1,134 @@
+const { downloadMediaMessage } = require('@whiskeysockets/baileys');
+const { exec } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const settings = require('../../daveset');
+const webp = require('node-webpmux');
+const crypto = require('crypto');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function stickerCommand(sock, chatId, message) {
+    const fakeContact = createFakeContact(message);
+const pushname= message.pushName || "Unknown User"
+    // The message that will be quoted in the reply.
+    const messageToQuote = message;
+    
+    // The message object that contains the media to be downloaded.
+    let targetMessage = message;
+
+    // If the message is a reply, the target media is in the quoted message.
+    if (message.message?.extendedTextMessage?.contextInfo?.quotedMessage) {
+        // We need to build a new message object for downloadMediaMessage to work correctly.
+        const quotedInfo = message.message.extendedTextMessage.contextInfo;
+        targetMessage = {
+            key: {
+                remoteJid: chatId,
+                id: quotedInfo.stanzaId,
+                participant: quotedInfo.participant
+            },
+            message: quotedInfo.quotedMessage
+        };
+    }
+
+    const mediaMessage = targetMessage.message?.imageMessage || targetMessage.message?.videoMessage || targetMessage.message?.documentMessage;
+
+    if (!mediaMessage) {
+        await sock.sendMessage(chatId, { 
+            text: 'Please reply to an image/video with .sticker, or send an image/video with .sticker as the caption.'
+        },{ quoted: fakeContact });
+        return;
+    }
+
+    try {
+        const mediaBuffer = await downloadMediaMessage(targetMessage, 'buffer', {}, { 
+            logger: undefined, 
+            reuploadRequest: sock.updateMediaMessage 
+        });
+
+        if (!mediaBuffer) {
+            await sock.sendMessage(chatId, {
+                text: 'Failed to download media. Please try again.'
+            }, { quoted: fakeContact });
+            return;
+        }
+
+        // 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 temp file paths
+        const tempInput = path.join(tmpDir, `temp_${Date.now()}`);
+        const tempOutput = path.join(tmpDir, `sticker_${Date.now()}.webp`);
+
+        // Write media to temp file
+        fs.writeFileSync(tempInput, mediaBuffer);
+
+        // Check if media is animated (GIF or video)
+        const isAnimated = mediaMessage.mimetype?.includes('gif') || 
+                          mediaMessage.mimetype?.includes('video') || 
+                          mediaMessage.seconds > 0;
+
+        // Convert to WebP using ffmpeg with optimized settings for animated/non-animated
+        const ffmpegCommand = isAnimated
+            ? `ffmpeg -i "${tempInput}" -vf "scale=512:512:force_original_aspect_ratio=decrease,fps=15,pad=512:512:(ow-iw)/2:(oh-ih)/2:color=#00000000" -c:v libwebp -preset default -loop 0 -vsync 0 -pix_fmt yuva420p -quality 75 -compression_level 6 "${tempOutput}"`
+            : `ffmpeg -i "${tempInput}" -vf "scale=512:512:force_original_aspect_ratio=decrease,format=rgba,pad=512:512:(ow-iw)/2:(oh-ih)/2:color=#00000000" -c:v libwebp -preset default -loop 0 -vsync 0 -pix_fmt yuva420p -quality 75 -compression_level 6 "${tempOutput}"`;
+
+        await new Promise((resolve, reject) => {
+            exec(ffmpegCommand, (error) => {
+                if (error) {
+                    console.error('FFmpeg error:', error);
+                    reject(error);
+                } else resolve();
+            });
+        });
+
+        // Read the WebP file
+        const webpBuffer = fs.readFileSync(tempOutput);
+
+        // Add metadata using webpmux
+        const img = new webp.Image();
+        await img.load(webpBuffer);
+
+        // Create metadata
+        const json = {
+            'sticker-pack-id': crypto.randomBytes(32).toString('hex'),
+            'sticker-pack-name': settings.packname || `${pushname}`,
+            'emojis': ['🫩']
+        };
+
+        // Create exif buffer
+        const exifAttr = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00]);
+        const jsonBuffer = Buffer.from(JSON.stringify(json), 'utf8');
+        const exif = Buffer.concat([exifAttr, jsonBuffer]);
+        exif.writeUIntLE(jsonBuffer.length, 14, 4);
+
+        // Set the exif data
+        img.exif = exif;
+
+        // Get the final buffer with metadata
+        const finalBuffer = await img.save(null);
+
+        // Send the sticker
+        await sock.sendMessage(chatId, { 
+            sticker: finalBuffer
+        },{ quoted: fakeContact });
+
+        // Cleanup temp files
+        try {
+            fs.unlinkSync(tempInput);
+            fs.unlinkSync(tempOutput);
+        } catch (err) {
+            console.error('Error cleaning up temp files:', err);
+        }
+
+    } catch (error) {
+        //console.error('Error in sticker command:', error);
+        await sock.sendMessage(chatId, { 
+            text: 'Failed to create sticker! Try again later.'
+        }, { quoted: fakeContact });
+    }
+}
+
+module.exports = stickerCommand;

package/davexcore/media/stickercrop.js

@@ -0,0 +1,133 @@
+const { downloadMediaMessage } = require('@whiskeysockets/baileys');
+const { exec } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const settings = require('../../daveset');
+const webp = require('node-webpmux');
+const crypto = require('crypto');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function stickercropCommand(sock, chatId, message) {
+    // The message that will be quoted in the reply.
+    const messageToQuote = message;
+    
+    // The message object that contains the media to be downloaded.
+    let targetMessage = message;
+
+    // If the message is a reply, the target media is in the quoted message.
+    if (message.message?.extendedTextMessage?.contextInfo?.quotedMessage) {
+        // We need to build a new message object for downloadMediaMessage to work correctly.
+        const quotedInfo = message.message.extendedTextMessage.contextInfo;
+        targetMessage = {
+            key: {
+                remoteJid: chatId,
+                id: quotedInfo.stanzaId,
+                participant: quotedInfo.participant
+            },
+            message: quotedInfo.quotedMessage
+        };
+    }
+
+    const mediaMessage = targetMessage.message?.imageMessage || targetMessage.message?.videoMessage || targetMessage.message?.documentMessage || targetMessage.message?.stickerMessage;
+
+    if (!mediaMessage) {
+        await sock.sendMessage(chatId, { 
+            text: 'Please reply to an image/video/sticker with .crop, or send an image/video/sticker with .crop as the caption.'
+        },{ quoted: messageToQuote });
+        return;
+    }
+
+    try {
+        const mediaBuffer = await downloadMediaMessage(targetMessage, 'buffer', {}, { 
+            logger: undefined, 
+            reuploadRequest: sock.updateMediaMessage 
+        });
+
+        if (!mediaBuffer) {
+            await sock.sendMessage(chatId, { 
+                text: 'Failed to download media. Please try again.'
+            });
+            return;
+        }
+
+        // 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 temp file paths
+        const tempInput = path.join(tmpDir, `temp_${Date.now()}`);
+        const tempOutput = path.join(tmpDir, `crop_${Date.now()}.webp`);
+
+        // Write media to temp file
+        fs.writeFileSync(tempInput, mediaBuffer);
+
+        // Check if media is animated (GIF or video)
+        const isAnimated = mediaMessage.mimetype?.includes('gif') || 
+                          mediaMessage.mimetype?.includes('video') || 
+                          mediaMessage.seconds > 0;
+
+        // Convert to WebP using ffmpeg with crop to square
+        // The crop filter will center-crop the image to a square
+        const ffmpegCommand = isAnimated
+            ? `ffmpeg -i "${tempInput}" -vf "crop=min(iw\\,ih):min(iw\\,ih),scale=512:512,fps=15" -c:v libwebp -preset default -loop 0 -vsync 0 -pix_fmt yuva420p -quality 75 -compression_level 6 "${tempOutput}"`
+            : `ffmpeg -i "${tempInput}" -vf "crop=min(iw\\,ih):min(iw\\,ih),scale=512:512,format=rgba" -c:v libwebp -preset default -loop 0 -vsync 0 -pix_fmt yuva420p -quality 75 -compression_level 6 "${tempOutput}"`;
+
+        await new Promise((resolve, reject) => {
+            exec(ffmpegCommand, (error) => {
+                if (error) {
+                    console.error('FFmpeg error:', error);
+                    reject(error);
+                } else resolve();
+            });
+        });
+
+        // Read the WebP file
+        const webpBuffer = fs.readFileSync(tempOutput);
+
+        // Add metadata using webpmux
+        const img = new webp.Image();
+        await img.load(webpBuffer);
+
+        // Create metadata
+        const json = {
+            'sticker-pack-id': crypto.randomBytes(32).toString('hex'),
+            'sticker-pack-name': settings.packname || 'Issah-X',
+            'emojis': ['✂️']
+        };
+
+        // Create exif buffer
+        const exifAttr = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00]);
+        const jsonBuffer = Buffer.from(JSON.stringify(json), 'utf8');
+        const exif = Buffer.concat([exifAttr, jsonBuffer]);
+        exif.writeUIntLE(jsonBuffer.length, 14, 4);
+
+        // Set the exif data
+        img.exif = exif;
+
+        // Get the final buffer with metadata
+        const finalBuffer = await img.save(null);
+
+        // Send the sticker
+        await sock.sendMessage(chatId, { 
+            sticker: finalBuffer
+        },{ quoted: messageToQuote });
+
+        // Cleanup temp files
+        try {
+            fs.unlinkSync(tempInput);
+            fs.unlinkSync(tempOutput);
+        } catch (err) {
+            console.error('Error cleaning up temp files:', err);
+        }
+
+    } catch (error) {
+        console.error('Error in stickercrop command:', error);
+        await sock.sendMessage(chatId, { 
+            text: 'Failed to crop sticker! Try with an image.'
+        });
+    }
+}
+
+module.exports = stickercropCommand;