jsdecryptor 4.0.3

package/davexcore/media/stickertelegram.js

@@ -0,0 +1,133 @@
+const fetch = require('node-fetch');
+const { writeExifImg } = require('../../davelib/exif');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const delay = time => new Promise(res => setTimeout(res, time));
+const fs = require('fs');
+const path = require('path');
+const webp = require('node-webpmux');
+const crypto = require('crypto');
+const { exec } = require('child_process');
+const settings = require('../../daveset');
+
+async function stickerTelegramCommand(sock, chatId, msg) {
+    try {
+        const pushname = msg.pushName || "Unknown User";
+
+        const text = msg.message?.conversation?.trim() || 
+                     msg.message?.extendedTextMessage?.text?.trim() || '';
+
+        const args = text.split(' ').slice(1);
+        
+        if (!args[0]) {
+            return sock.sendMessage(chatId, { 
+                text: '⚠️ Please enter the Telegram sticker URL!\nExample:\n.tg https://t.me/addstickers/Porcientoreal'
+            });
+        }
+
+        if (!args[0].match(/(https:\/\/t.me\/addstickers\/)/gi)) {
+            return sock.sendMessage(chatId, { 
+                text: '❌ Invalid URL!\nUse a valid Telegram sticker pack link.'
+            });
+        }
+
+        const packName = args[0].replace("https://t.me/addstickers/", "");
+        const botToken = settings.telegram_token || '7801479976:AAGuPL0a7kXXBYz6XUSR_ll2SR5V_W6oHl4';
+
+        // Fetch sticker pack metadata
+        const response = await fetch(
+            `https://api.telegram.org/bot${botToken}/getStickerSet?name=${encodeURIComponent(packName)}`
+        );
+
+        const stickerSet = await response.json();
+        if (!stickerSet.ok) {
+            throw new Error("Invalid Telegram sticker pack");
+        }
+
+        await sock.sendMessage(chatId, { 
+            text: `Found ${stickerSet.result.stickers.length} stickers\nStarting download...`
+        });
+
+        const tmpDir = path.join(process.cwd(), 'tmp');
+        if (!fs.existsSync(tmpDir)) fs.mkdirSync(tmpDir, { recursive: true });
+
+        let successCount = 0;
+
+        for (let i = 0; i < stickerSet.result.stickers.length; i++) {
+            try {
+                const sticker = stickerSet.result.stickers[i];
+
+                const fileInfo = await fetch(
+                    `https://api.telegram.org/bot${botToken}/getFile?file_id=${sticker.file_id}`
+                );
+                const fileData = await fileInfo.json();
+                if (!fileData.ok) continue;
+
+                const fileUrl = `https://api.telegram.org/file/bot${botToken}/${fileData.result.file_path}`;
+                const imageBuffer = await (await fetch(fileUrl)).buffer();
+
+                const tempInput = path.join(tmpDir, `temp_input_${Date.now()}_${i}`);
+                const tempOutput = path.join(tmpDir, `sticker_${Date.now()}_${i}.webp`);
+                fs.writeFileSync(tempInput, imageBuffer);
+
+                const isAnimated = sticker.is_animated || sticker.is_video;
+
+                const ffmpegCommand = isAnimated
+                    ? `ffmpeg -i "${tempInput}" -vf "scale=512:-1:force_original_aspect_ratio=decrease,fps=15,pad=512:512:(ow-iw)/2:(oh-ih)/2:color=#00000000" -c:v libwebp -lossless 0 -q:v 60 "${tempOutput}"`
+                    : `ffmpeg -i "${tempInput}" -vf "scale=512:-1:force_original_aspect_ratio=decrease,pad=512:512:(ow-iw)/2:(oh-ih)/2:color=#00000000" -vcodec libwebp -lossless 0 -q:v 75 "${tempOutput}"`;
+
+                await new Promise((resolve, reject) => {
+                    exec(ffmpegCommand, (err) => err ? reject(err) : resolve());
+                });
+
+                const webpBuffer = fs.readFileSync(tempOutput);
+
+                const img = new webp.Image();
+                await img.load(webpBuffer);
+
+                const metadata = {
+                    "sticker-pack-id": crypto.randomBytes(32).toString("hex"),
+                    "sticker-pack-name": pushname,
+                    "emojis": sticker.emoji ? [sticker.emoji] : ["🤖"]
+                };
+
+                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(metadata), "utf8");
+                const exif = Buffer.concat([exifAttr, jsonBuffer]);
+                exif.writeUIntLE(jsonBuffer.length, 14, 4);
+
+                img.exif = exif;
+
+                const finalBuffer = await img.save(null);
+
+                await sock.sendMessage(chatId, { sticker: finalBuffer });
+
+                successCount++;
+                await delay(800);
+
+                fs.unlinkSync(tempInput);
+                fs.unlinkSync(tempOutput);
+
+            } catch (err) {
+                console.error(`❌ Error on sticker ${i}`, err);
+                continue;
+            }
+        }
+
+        await sock.sendMessage(chatId, { 
+            text: `✅ Successfully downloaded ${successCount}/${stickerSet.result.stickers.length} stickers!`
+        });
+
+    } catch (error) {
+        console.error('❌ stickerTelegramCommand Error:', error);
+        await sock.sendMessage(chatId, { 
+            text: '❌ Failed to process Telegram stickers.\nCheck the link and try again.' 
+        });
+    }
+}
+
+module.exports = stickerTelegramCommand;

package/davexcore/media/take.js

@@ -0,0 +1,76 @@
+const fs = require('fs');
+const path = require('path');
+const { downloadMediaMessage } = require('@whiskeysockets/baileys');
+const webp = require('node-webpmux');
+const crypto = require('crypto');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+async function takeCommand(sock, chatId, message, args) {
+    const fkontak = createFakeContact(message);
+    
+    try {
+        const pushname = message.pushName || "Unknown User"; 
+        const quotedMessage = message.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+        
+        if (!quotedMessage?.stickerMessage) {
+            await sock.sendMessage(chatId, { text: 'Reply to a sticker with .take <packname>' }, { quoted: fkontak });
+            return;
+        }
+
+        const packname = args.join(' ') || `${pushname}`;
+
+        try {
+            const stickerBuffer = await downloadMediaMessage(
+                {
+                    key: message.message.extendedTextMessage.contextInfo.stanzaId,
+                    message: quotedMessage,
+                    messageType: 'stickerMessage'
+                },
+                'buffer',
+                {},
+                {
+                    logger: console,
+                    reuploadRequest: sock.updateMediaMessage
+                }
+            );
+
+            if (!stickerBuffer) {
+                await sock.sendMessage(chatId, { text: 'Failed to download sticker' }, { quoted: fkontak });
+                return;
+            }
+
+            const img = new webp.Image();
+            await img.load(stickerBuffer);
+
+            const json = {
+                'sticker-pack-id': crypto.randomBytes(32).toString('hex'),
+                'sticker-pack-name': packname,
+                'emojis': ['🤖']
+            };
+
+            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);
+
+            img.exif = exif;
+
+            const finalBuffer = await img.save(null);
+
+            await sock.sendMessage(chatId, {
+                sticker: finalBuffer
+            }, {
+                quoted: fkontak
+            });
+
+        } catch (error) {
+            console.error('Sticker error:', error);
+            await sock.sendMessage(chatId, { text: 'Error processing sticker' }, { quoted: fkontak });
+        }
+
+    } catch (error) {
+        console.error('Take command error:', error);
+        await sock.sendMessage(chatId, { text: 'Command error' }, { quoted: fkontak });
+    }
+}
+
+module.exports = takeCommand;

package/davexcore/media/textmaker.js

@@ -0,0 +1,106 @@
+const axios = require('axios');
+const mumaker = require('mumaker');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const channelInfo = {};
+
+const messageTemplates = {
+    error: (message) => ({
+        text: message
+    }),
+    success: (text, imageUrl) => ({
+        image: { url: imageUrl },
+        caption: ""
+    })
+};
+
+async function textmakerCommand(sock, chatId, message, q, type) {
+    try {
+        if (!q) {
+            return await sock.sendMessage(chatId, messageTemplates.error("Please provide text to generate\nExample: .metallic Supreme"));
+        }
+
+        // Extract text
+        const text = q.split(' ').slice(1).join(' ');
+
+        if (!text) {
+            return await sock.sendMessage(chatId, messageTemplates.error("Please provide text to generate\nExample: .metallic Supreme"));
+        }
+
+        try {
+            let result;
+            switch (type) {
+                case 'metallic':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/impressive-decorative-3d-metal-text-effect-798.html", text);
+                    break;
+                case 'ice':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/ice-text-effect-online-101.html", text);
+                    break;
+                case 'snow':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/create-a-snow-3d-text-effect-free-online-621.html", text);
+                    break;
+                case 'impressive':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/create-3d-colorful-paint-text-effect-online-801.html", text);
+                    break;
+                case 'matrix':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/matrix-text-effect-154.html", text);
+                    break;
+                case 'light':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/light-text-effect-futuristic-technology-style-648.html", text);
+                    break;
+                case 'neon':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/create-colorful-neon-light-text-effects-online-797.html", text);
+                    break;
+                case 'devil':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/neon-devil-wings-text-effect-online-683.html", text);
+                    break;
+                case 'purple':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/purple-text-effect-online-100.html", text);
+                    break;
+                case 'thunder':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/thunder-text-effect-online-97.html", text);
+                    break;
+                case 'leaves':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/green-brush-text-effect-typography-maker-online-153.html", text);
+                    break;
+                case '1917':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/1917-style-text-effect-523.html", text);
+                    break;
+                case 'arena':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/create-cover-arena-of-valor-by-mastering-360.html", text);
+                    break;
+                case 'hacker':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/create-anonymous-hacker-avatars-cyan-neon-677.html", text);
+                    break;
+                case 'sand':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/write-names-and-messages-on-the-sand-online-582.html", text);
+                    break;
+                case 'blackpink':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/create-a-blackpink-style-logo-with-members-signatures-810.html", text);
+                    break;
+                case 'glitch':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/create-digital-glitch-text-effects-online-767.html", text);
+                    break;
+                case 'fire':
+                    result = await mumaker.ephoto("https://en.ephoto360.com/flame-lettering-effect-372.html", text);
+                    break;
+                default:
+                    return await sock.sendMessage(chatId, messageTemplates.error("Invalid text generator type"));
+            }
+
+            if (!result || !result.image) {
+                throw new Error('No image URL received from the API');
+            }
+
+            await sock.sendMessage(chatId, messageTemplates.success(text, result.image));
+        } catch (error) {
+            console.error('Error in text generator:', error);
+            await sock.sendMessage(chatId, messageTemplates.error(`Error: ${error.message}`));
+        }
+    } catch (error) {
+        console.error('Error in textmaker command:', error);
+        await sock.sendMessage(chatId, messageTemplates.error("An error occurred. Please try again later."));
+    }
+}
+
+module.exports = textmakerCommand; 

package/davexcore/media/toAudio.js

@@ -0,0 +1,180 @@
+const { downloadContentFromMessage } = require('@whiskeysockets/baileys');
+const ffmpeg = require('fluent-ffmpeg');
+const fs = require('fs').promises;
+const { tmpdir } = require('os');
+const path = require('path');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+async function toAudioCommand(sock, chatId, message) {
+  const fkontak = createFakeContact(message);
+  let inputPath = '';
+  let outputPath = '';
+  
+  try {
+    const quotedMsg = message.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+    let msg = null;
+    
+    if (quotedMsg) {
+      msg = quotedMsg.videoMessage || quotedMsg.audioMessage || quotedMsg.documentMessage;
+    } else {
+      msg = message.message?.videoMessage || message.message?.audioMessage || message.message?.documentMessage;
+    }
+
+    if (!msg) {
+      await sock.sendMessage(chatId, { 
+        text: "Reply to a video or audio file to convert."
+      }, { quoted: fkontak });
+      return;
+    }
+
+    const mime = msg.mimetype || '';
+    const isVideo = mime.startsWith('video/');
+    const isAudio = mime.startsWith('audio/');
+    const isDocument = msg.documentMessage && (
+      mime.includes('video') || 
+      mime.includes('audio') || 
+      mime.includes('mp4') || 
+      mime.includes('mpeg')
+    );
+
+    if (!isVideo && !isAudio && !isDocument) {
+      await sock.sendMessage(chatId, { 
+        text: "Works on video or audio only."
+      }, { quoted: fkontak });
+      return;
+    }
+
+    await sock.sendMessage(chatId, { text: "Converting..." }, { quoted: fkontak });
+
+    const fileType = isVideo ? 'video' : 'audio';
+    
+    let stream;
+    try {
+      stream = await downloadContentFromMessage(msg, fileType);
+    } catch (downloadErr) {
+      console.error('Download error:', downloadErr);
+      throw new Error(`Download failed: ${downloadErr.message}`);
+    }
+
+    const tempDir = tmpdir();
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(7);
+    
+    const inputExt = mime.includes('mp4') ? 'mp4' : 
+                     mime.includes('webm') ? 'webm' : 
+                     mime.includes('ogg') ? 'ogg' : 
+                     isVideo ? 'mp4' : 'temp';
+    
+    inputPath = path.join(tempDir, `input_${timestamp}_${random}.${inputExt}`);
+    outputPath = path.join(tempDir, `output_${timestamp}_${random}.mp3`);
+    
+    const writeStream = require('fs').createWriteStream(inputPath);
+    
+    await new Promise((resolve, reject) => {
+      stream.on('data', (chunk) => {
+        writeStream.write(chunk);
+      });
+      
+      stream.on('end', () => {
+        writeStream.end();
+        resolve();
+      });
+      
+      stream.on('error', (err) => {
+        writeStream.end();
+        reject(err);
+      });
+      
+      writeStream.on('error', reject);
+    });
+
+    const stats = await fs.stat(inputPath);
+    if (stats.size === 0) {
+      throw new Error('File empty');
+    }
+
+    // Convert using ffmpeg
+    await new Promise((resolve, reject) => {
+      const command = ffmpeg(inputPath)
+        .toFormat('mp3')
+        .audioCodec('libmp3lame')
+        .audioBitrate('192k')
+        .audioChannels(2)
+        .audioFrequency(44100)
+        .on('end', () => {
+          resolve();
+        })
+        .on('error', (err) => {
+          console.error('FFmpeg error:', err.message);
+          reject(new Error(`Conversion failed`));
+        })
+        .save(outputPath);
+
+      setTimeout(() => {
+        if (command && command.ffmpegProc && !command.ffmpegProc.killed) {
+          command.kill('SIGKILL');
+          reject(new Error('Timeout'));
+        }
+      }, 60000);
+    });
+
+    const audioStats = await fs.stat(outputPath);
+    if (audioStats.size === 0) {
+      throw new Error('Output empty');
+    }
+
+    const audioBuffer = await fs.readFile(outputPath);
+    
+    const maxSize = 15 * 1024 * 1024;
+    if (audioBuffer.length > maxSize) {
+      console.warn(`File large: ${(audioBuffer.length / 1024 / 1024).toFixed(2)}MB`);
+    }
+
+    // Send converted audio
+    await sock.sendMessage(chatId, { 
+      audio: audioBuffer, 
+      mimetype: 'audio/mpeg',
+      ptt: false,
+      fileName: `audio_${timestamp}.mp3`
+    }, { quoted: fkontak });
+
+  } catch (err) {
+    console.error("toAudio error:", err.message);
+    
+    let errorMessage = "Conversion failed.";
+    
+    if (err.message.includes('FFmpeg') || err.message.includes('conversion')) {
+      errorMessage = "FFmpeg error. Check install.";
+    } else if (err.message.includes('timeout')) {
+      errorMessage = "Timeout. Try shorter video.";
+    } else if (err.message.includes('empty')) {
+      errorMessage = "File empty or invalid.";
+    } else if (err.message.includes('download')) {
+      errorMessage = "Download failed.";
+    }
+    
+    await sock.sendMessage(chatId, { text: errorMessage }, { quoted: fkontak });
+    
+  } finally {
+    const cleanupPromises = [];
+    
+    if (inputPath) {
+      cleanupPromises.push(
+        fs.unlink(inputPath).catch(err => 
+          console.error(`Delete failed ${inputPath}:`, err.message)
+        )
+      );
+    }
+    
+    if (outputPath) {
+      cleanupPromises.push(
+        fs.unlink(outputPath).catch(err => 
+          console.error(`Delete failed ${outputPath}:`, err.message)
+        )
+      );
+    }
+    
+    await Promise.allSettled(cleanupPromises);
+  }
+}
+
+module.exports = toAudioCommand;

package/davexcore/media/togif.js

@@ -0,0 +1,33 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const { downloadMediaMessage } = require('@whiskeysockets/baileys');
+
+async function togifCommand(sock, chatId, message) {
+    const fakeContact = createFakeContact(message);
+    const botName = getBotName();
+    
+    const quotedMsg = message.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+    if (!quotedMsg) {
+        return sock.sendMessage(chatId, { text: `*${botName}*\nReply to a video or animated sticker with .togif` }, { quoted: fakeContact });
+    }
+    
+    const isVideo = quotedMsg.videoMessage;
+    const isSticker = quotedMsg.stickerMessage;
+    
+    if (!isVideo && !isSticker) {
+        return sock.sendMessage(chatId, { text: `*${botName}*\nReply to a video or animated sticker only.` }, { quoted: fakeContact });
+    }
+    
+    await sock.sendMessage(chatId, { react: { text: '🔄', key: message.key } });
+    
+    try {
+        const buffer = await downloadMediaMessage({ message: quotedMsg }, 'buffer', {});
+        if (buffer) {
+            await sock.sendMessage(chatId, { video: buffer, gifPlayback: true, caption: `*${botName}*\nConverted to GIF` }, { quoted: fakeContact });
+            await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+        }
+    } catch (err) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nConversion failed: ${err.message}` }, { quoted: fakeContact });
+    }
+}
+
+module.exports = { togifCommand };

package/davexcore/media/toimg.js

@@ -0,0 +1,26 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const { downloadMediaMessage } = require('@whiskeysockets/baileys');
+
+async function toimgCommand(sock, chatId, message) {
+    const fakeContact = createFakeContact(message);
+    const botName = getBotName();
+    
+    const quotedMsg = message.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+    if (!quotedMsg?.stickerMessage) {
+        return sock.sendMessage(chatId, { text: `*${botName}*\nReply to a sticker with .toimg to convert it to an image.` }, { quoted: fakeContact });
+    }
+    
+    await sock.sendMessage(chatId, { react: { text: '🔄', key: message.key } });
+    
+    try {
+        const buffer = await downloadMediaMessage({ message: quotedMsg }, 'buffer', {});
+        if (buffer) {
+            await sock.sendMessage(chatId, { image: buffer, caption: `*${botName}*\nSticker converted to image` }, { quoted: fakeContact });
+            await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+        }
+    } catch (err) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nConversion failed: ${err.message}` }, { quoted: fakeContact });
+    }
+}
+
+module.exports = toimgCommand;

package/davexcore/media/tomp4.js

@@ -0,0 +1,34 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const { downloadMediaMessage } = require('@whiskeysockets/baileys');
+const fs = require('fs');
+const path = require('path');
+
+async function tomp4Command(sock, chatId, message) {
+    const fakeContact = createFakeContact(message);
+    const botName = getBotName();
+    
+    const quotedMsg = message.message?.extendedTextMessage?.contextInfo?.quotedMessage;
+    if (!quotedMsg) {
+        return sock.sendMessage(chatId, { text: `*${botName}*\nReply to a sticker or GIF with .tomp4` }, { quoted: fakeContact });
+    }
+    
+    const isStickerOrGif = quotedMsg.stickerMessage || (quotedMsg.videoMessage && quotedMsg.videoMessage.gifPlayback) || quotedMsg.imageMessage?.mimetype?.includes('webp');
+    
+    if (!isStickerOrGif) {
+        return sock.sendMessage(chatId, { text: `*${botName}*\nReply to an animated sticker or GIF only.` }, { quoted: fakeContact });
+    }
+    
+    await sock.sendMessage(chatId, { react: { text: '🔄', key: message.key } });
+    
+    try {
+        const buffer = await downloadMediaMessage({ message: quotedMsg }, 'buffer', {});
+        if (buffer) {
+            await sock.sendMessage(chatId, { video: buffer, gifPlayback: false, caption: `*${botName}*\nConverted to MP4` }, { quoted: fakeContact });
+            await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+        }
+    } catch (err) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nConversion failed: ${err.message}` }, { quoted: fakeContact });
+    }
+}
+
+module.exports = { tomp4Command };