jsdecryptor 4.0.3

package/davexcore/downloads/spotify.js

@@ -0,0 +1,133 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const AXIOS_DEFAULTS = {
+    timeout: 60000,
+    headers: {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Accept': 'application/json, text/plain, */*'
+    }
+};
+
+async function tryRequest(getter, attempts = 3) {
+    let lastError;
+    for (let i = 1; i <= attempts; i++) {
+        try {
+            return await getter();
+        } catch (err) {
+            lastError = err;
+            if (i < attempts) {
+                await new Promise(r => setTimeout(r, i * 1000));
+            }
+        }
+    }
+    throw lastError;
+}
+
+async function spotifyCommand(sock, chatId, message) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    
+    try {
+        const rawText = message.message?.conversation?.trim() ||
+            message.message?.extendedTextMessage?.text?.trim() ||
+            message.message?.imageMessage?.caption?.trim() ||
+            message.message?.videoMessage?.caption?.trim() ||
+            '';
+
+        const used = (rawText || '').split(/\s+/)[0] || '.spotify';
+        const query = rawText.slice(used.length).trim();
+
+        if (!query) {
+            await sock.sendMessage(chatId, { 
+                text: `✦ *${botName}* Spotify\n\nUse: .spotify <song name>\nExample: .spotify Blinding Lights` 
+            }, { quoted: fake });
+            return;
+        }
+
+        await sock.sendMessage(chatId, {
+            react: { text: '🔍', key: message.key }
+        });
+
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}*\nSearching: ${query}...`
+        }, { quoted: fake });
+
+        const apiUrl = `https://apiskeith.top/download/spotify?q=${encodeURIComponent(query)}`;
+        let result = null;
+        let downloadUrl = null;
+
+        try {
+            const res = await tryRequest(() => axios.get(apiUrl, AXIOS_DEFAULTS));
+            if (res?.data?.status && res?.data?.result?.track) {
+                const track = res.data.result.track;
+                downloadUrl = track.downloadLink;
+                result = {
+                    title: track.title || track.name,
+                    artist: track.artist,
+                    cover: track.thumbnail,
+                    duration: track.duration,
+                    popularity: track.popularity
+                };
+            }
+        } catch (err) {
+            console.log('Spotify API failed:', err.message);
+        }
+
+        if (!downloadUrl || !result) {
+            throw new Error('No results found');
+        }
+
+        await sock.sendMessage(chatId, {
+            react: { text: '⬇️', key: message.key }
+        });
+
+        let caption = `✦ *${botName}* Spotify\n\n`;
+        caption += `Title: ${result.title || 'Unknown'}\n`;
+        caption += `Artist: ${result.artist || 'Unknown'}\n`;
+        if (result.duration) caption += `Duration: ${result.duration}\n`;
+        if (result.popularity) caption += `Popularity: ${result.popularity}\n`;
+
+        if (result.cover) {
+            await sock.sendMessage(chatId, { 
+                image: { url: result.cover }, 
+                caption 
+            }, { quoted: fake });
+        } else {
+            await sock.sendMessage(chatId, { 
+                text: caption 
+            }, { quoted: fake });
+        }
+
+        const safeTitle = (result.title || 'spotify').replace(/[\\/:*?"<>|]/g, '');
+        await sock.sendMessage(chatId, {
+            audio: { url: downloadUrl },
+            mimetype: 'audio/mpeg',
+            fileName: `${safeTitle}.mp3`
+        }, { quoted: fake });
+
+        await sock.sendMessage(chatId, {
+            react: { text: '✅', key: message.key }
+        });
+
+    } catch (error) {
+        console.error('Spotify error:', error.message);
+
+        let errorMsg = '✦ Failed to download.';
+        if (error.message.includes('No results')) {
+            errorMsg = '✦ No results found.';
+        } else if (error.message.includes('timeout')) {
+            errorMsg = '✦ Request timeout.';
+        }
+
+        await sock.sendMessage(chatId, { 
+            text: errorMsg
+        }, { quoted: fake });
+        
+        await sock.sendMessage(chatId, {
+            react: { text: '❌', key: message.key }
+        });
+    }
+}
+
+module.exports = spotifyCommand;

package/davexcore/downloads/tiktok.js

@@ -0,0 +1,167 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const processedMessages = new Set();
+
+async function downloadAndValidate(downloadUrl, timeout = 60000) {
+    const response = await axios({
+        url: downloadUrl,
+        method: 'GET',
+        responseType: 'arraybuffer',
+        timeout: timeout,
+        maxRedirects: 5,
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        },
+        validateStatus: (status) => status >= 200 && status < 400
+    });
+
+    const buffer = Buffer.from(response.data);
+
+    if (buffer.length < 5000) {
+        throw new Error('File too small, likely not video');
+    }
+
+    const headerStr = buffer.slice(0, 50).toString('utf8').toLowerCase();
+    if (headerStr.includes('<!doctype') || headerStr.includes('<html') || headerStr.includes('bad gateway')) {
+        throw new Error('Received HTML instead of video');
+    }
+
+    return buffer;
+}
+
+async function tiktokCommand(sock, chatId, message) {
+    const senderId = message.key.participant || message.key.remoteJid;
+    const fake = createFakeContact(senderId);
+    const botName = getBotName();
+
+    try {
+        if (processedMessages.has(message.key.id)) return;
+        processedMessages.add(message.key.id);
+        setTimeout(() => processedMessages.delete(message.key.id), 5 * 60 * 1000);
+
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text;
+        if (!text) {
+            return await sock.sendMessage(chatId, { 
+                text: `✦ *${botName}* TikTok\n\nUse: .tiktok <url>` 
+            }, { quoted: fake });
+        }
+
+        const url = text.split(' ').slice(1).join(' ').trim();
+        if (!url) {
+            return await sock.sendMessage(chatId, { 
+                text: `✦ *${botName}* TikTok\n\nProvide a TikTok link` 
+            }, { quoted: fake });
+        }
+
+        const tiktokPatterns = [/tiktok\.com\//, /vm\.tiktok\.com\//, /vt\.tiktok\.com\//];
+        if (!tiktokPatterns.some(p => p.test(url))) {
+            return await sock.sendMessage(chatId, { text: `✦ *${botName}*\nInvalid TikTok link` }, { quoted: fake });
+        }
+
+        await sock.sendMessage(chatId, { react: { text: '⏳', key: message.key } });
+
+        const apis = [
+            {
+                name: 'iamtkm',
+                url: `https://iamtkm.vercel.app/downloaders/tiktokdl?apikey=tkm&url=${encodeURIComponent(url)}`,
+                parse: d => ({
+                    video: d?.result?.no_watermark || d?.result?.watermark,
+                    audio: d?.result?.audio,
+                    title: d?.result?.title || 'TikTok Video'
+                }),
+                check: d => d?.status && d?.result
+            },
+            {
+                name: 'Keith fbdown',
+                url: `https://apiskeith.top/download/tiktok?url=${encodeURIComponent(url)}`,
+                parse: d => ({
+                    video: d?.result?.no_watermark || d?.result?.video || d?.result?.url,
+                    audio: d?.result?.audio,
+                    title: d?.result?.title || 'TikTok Video'
+                }),
+                check: d => d?.status && d?.result
+            },
+            {
+                name: 'BK9',
+                url: `https://bk9.fun/download/tiktok?url=${encodeURIComponent(url)}`,
+                parse: d => ({
+                    video: d?.BK9?.no_watermark || d?.BK9?.video || d?.BK9?.url || d?.BK9,
+                    audio: d?.BK9?.audio,
+                    title: d?.BK9?.title || 'TikTok Video'
+                }),
+                check: d => d?.BK9
+            },
+            {
+                name: 'Dreaded',
+                url: `https://api.dreaded.site/api/tiktok?url=${encodeURIComponent(url)}`,
+                parse: d => ({
+                    video: d?.result?.no_watermark || d?.result?.video || d?.result?.url,
+                    audio: d?.result?.audio,
+                    title: d?.result?.title || 'TikTok Video'
+                }),
+                check: d => d?.result
+            },
+            {
+                name: 'Siputzx',
+                url: `https://api.siputzx.my.id/api/d/tiktok?url=${encodeURIComponent(url)}`,
+                parse: d => ({
+                    video: d?.data?.no_watermark || d?.data?.video || d?.data?.url,
+                    audio: d?.data?.audio,
+                    title: d?.data?.title || 'TikTok Video'
+                }),
+                check: d => d?.data
+            }
+        ];
+
+        let result = null;
+
+        for (const api of apis) {
+            try {
+                const res = await axios.get(api.url, { timeout: 15000 });
+                if (api.check(res.data)) {
+                    result = api.parse(res.data);
+                    if (result?.video && typeof result.video === 'string' && result.video.startsWith('http')) {
+                        break;
+                    }
+                    result = null;
+                }
+            } catch {}
+        }
+
+        if (!result?.video) {
+            return await sock.sendMessage(chatId, { 
+                text: `✦ *${botName}*\nFailed to download. Try again later.` 
+            }, { quoted: fake });
+        }
+
+        try {
+            await sock.sendMessage(chatId, {
+                video: { url: result.video },
+                mimetype: "video/mp4",
+                caption: `✦ *${botName}* - am know invisible 🔥`
+            }, { quoted: fake });
+        } catch {
+            try {
+                const buffer = await downloadAndValidate(result.video);
+                await sock.sendMessage(chatId, {
+                    video: buffer,
+                    mimetype: "video/mp4",
+                    caption: `✦ *${botName}* - am know invisible 🔥`
+                }, { quoted: fake });
+            } catch (dlErr) {
+                return await sock.sendMessage(chatId, { 
+                    text: `✦ *${botName}*\nFailed to send video: ${dlErr.message}` 
+                }, { quoted: fake });
+            }
+        }
+
+        await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+
+    } catch (error) {
+        console.error('TikTok command error:', error.message);
+        await sock.sendMessage(chatId, { text: `✦ *${botName}*\nFailed to download.` }, { quoted: fake });
+    }
+}
+
+module.exports = { tiktokCommand };

package/davexcore/downloads/tiktokaudio.js

@@ -0,0 +1,158 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function downloadAndValidate(downloadUrl, timeout = 60000) {
+    const response = await axios({
+        url: downloadUrl,
+        method: 'GET',
+        responseType: 'arraybuffer',
+        timeout: timeout,
+        maxRedirects: 5,
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        },
+        validateStatus: (status) => status >= 200 && status < 400
+    });
+
+    const buffer = Buffer.from(response.data);
+
+    if (buffer.length < 5000) {
+        throw new Error('File too small, likely not audio');
+    }
+
+    const headerStr = buffer.slice(0, 50).toString('utf8').toLowerCase();
+    if (headerStr.includes('<!doctype') || headerStr.includes('<html') || headerStr.includes('bad gateway')) {
+        throw new Error('Received HTML instead of audio');
+    }
+
+    return buffer;
+}
+
+async function tiktokaudioCommand(sock, chatId, message) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+
+    const text = message.message?.conversation || 
+                 message.message?.extendedTextMessage?.text || '';
+
+    const url = text.split(' ').slice(1).join(' ').trim();
+
+    if (!url) {
+        return sock.sendMessage(chatId, { 
+            text: `*${botName} TIKTOK AUDIO*\n\nUsage: .tiktokaudio <url>\nExample: .tiktokaudio https://vm.tiktok.com/abc123`
+        }, { quoted: fake });
+    }
+
+    const tiktokPatterns = [/tiktok\.com\//, /vm\.tiktok\.com\//, /vt\.tiktok\.com\//];
+    if (!tiktokPatterns.some(p => p.test(url))) {
+        return sock.sendMessage(chatId, { 
+            text: `*${botName}*\nInvalid TikTok link!`
+        }, { quoted: fake });
+    }
+
+    try {
+        await sock.sendMessage(chatId, { 
+            react: { text: '🎵', key: message.key } 
+        });
+
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nDownloading TikTok audio...`
+        }, { quoted: fake });
+
+        // Using the same working APIs as main TikTok command
+        const apis = [
+            {
+                name: 'iamtkm',
+                url: `https://iamtkm.vercel.app/downloaders/tiktokdl?apikey=tkm&url=${encodeURIComponent(url)}`,
+                parse: d => ({
+                    audio: d?.result?.audio,
+                    title: d?.result?.title || 'TikTok Audio'
+                }),
+                check: d => d?.status && d?.result
+            },
+            {
+                name: 'Keith',
+                url: `https://apiskeith.top/download/tiktok?url=${encodeURIComponent(url)}`,
+                parse: d => ({
+                    audio: d?.result?.audio,
+                    title: d?.result?.title || 'TikTok Audio'
+                }),
+                check: d => d?.status && d?.result
+            },
+            {
+                name: 'BK9',
+                url: `https://bk9.fun/download/tiktok?url=${encodeURIComponent(url)}`,
+                parse: d => ({
+                    audio: d?.BK9?.audio,
+                    title: d?.BK9?.title || 'TikTok Audio'
+                }),
+                check: d => d?.BK9
+            },
+            {
+                name: 'Dreaded',
+                url: `https://api.dreaded.site/api/tiktok?url=${encodeURIComponent(url)}`,
+                parse: d => ({
+                    audio: d?.result?.audio,
+                    title: d?.result?.title || 'TikTok Audio'
+                }),
+                check: d => d?.result
+            },
+            {
+                name: 'Siputzx',
+                url: `https://api.siputzx.my.id/api/d/tiktok?url=${encodeURIComponent(url)}`,
+                parse: d => ({
+                    audio: d?.data?.audio,
+                    title: d?.data?.title || 'TikTok Audio'
+                }),
+                check: d => d?.data
+            }
+        ];
+
+        let audioUrl = null;
+        let title = 'TikTok Audio';
+
+        for (const api of apis) {
+            try {
+                const res = await axios.get(api.url, { timeout: 15000 });
+                if (api.check(res.data)) {
+                    const result = api.parse(res.data);
+                    if (result?.audio && typeof result.audio === 'string' && result.audio.startsWith('http')) {
+                        audioUrl = result.audio;
+                        title = result.title || 'TikTok Audio';
+                        console.log(`✅ ${api.name} API working for audio`);
+                        break;
+                    }
+                }
+            } catch (err) {
+                console.log(`${api.name} API failed:`, err.message);
+            }
+        }
+
+        if (!audioUrl) {
+            throw new Error('All audio download APIs are currently unavailable');
+        }
+
+        // Download the audio
+        const audioBuffer = await downloadAndValidate(audioUrl);
+
+        // Send the audio
+        await sock.sendMessage(chatId, {
+            audio: audioBuffer,
+            mimetype: "audio/mpeg",
+            ptt: false,
+            caption: `*${botName} TIKTOK AUDIO*\n\n📌 *${title}*`
+        }, { quoted: fake });
+
+        await sock.sendMessage(chatId, { 
+            react: { text: '✅', key: message.key } 
+        });
+
+    } catch (error) {
+        console.error("TikTok Audio Error:", error);
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\n❌ Error: ${error.message || "Failed to download TikTok audio"}`
+        }, { quoted: fake });
+    }
+}
+
+module.exports = tiktokaudioCommand;

package/davexcore/downloads/video.js

@@ -0,0 +1,188 @@
+const axios = require('axios');
+const yts = require('yt-search');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const AXIOS_DEFAULTS = {
+    timeout: 60000,
+    headers: {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Accept': 'application/json, text/plain, */*'
+    }
+};
+
+async function tryRequest(getter, attempts = 3) {
+    let lastError;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        try {
+            return await getter();
+        } catch (err) {
+            lastError = err;
+            if (attempt < attempts) {
+                await new Promise(r => setTimeout(r, 1000 * attempt));
+            }
+        }
+    }
+    throw lastError;
+}
+
+// EliteProTech API - Primary
+async function getEliteProTechVideoByUrl(youtubeUrl) {
+    const apiUrl = `https://eliteprotech-apis.zone.id/ytdown?url=${encodeURIComponent(youtubeUrl)}&format=mp4`;
+    const res = await tryRequest(() => axios.get(apiUrl, AXIOS_DEFAULTS));
+    if (res?.data?.success && res?.data?.downloadURL) {
+        return {
+            download: res.data.downloadURL,
+            title: res.data.title
+        };
+    }
+    throw new Error('EliteProTech ytdown returned no download');
+}
+
+async function getYupraVideoByUrl(youtubeUrl) {
+    const apiUrl = `https://api.yupra.my.id/api/downloader/ytmp4?url=${encodeURIComponent(youtubeUrl)}`;
+    const res = await tryRequest(() => axios.get(apiUrl, AXIOS_DEFAULTS));
+    if (res?.data?.success && res?.data?.data?.download_url) {
+        return {
+            download: res.data.data.download_url,
+            title: res.data.data.title,
+            thumbnail: res.data.data.thumbnail
+        };
+    }
+    throw new Error('Yupra returned no download');
+}
+
+async function getOkatsuVideoByUrl(youtubeUrl) {
+    const apiUrl = `https://okatsu-rolezapiiz.vercel.app/downloader/ytmp4?url=${encodeURIComponent(youtubeUrl)}`;
+    const res = await tryRequest(() => axios.get(apiUrl, AXIOS_DEFAULTS));
+    // shape: { status, creator, url, result: { status, title, mp4 } }
+    if (res?.data?.result?.mp4) {
+        return { download: res.data.result.mp4, title: res.data.result.title };
+    }
+    throw new Error('Okatsu ytmp4 returned no mp4');
+}
+
+async function videoCommand(sock, chatId, message) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    
+    try {
+        const text = message.message?.conversation || message.message?.extendedTextMessage?.text;
+        const searchQuery = text.split(' ').slice(1).join(' ').trim();
+
+        if (!searchQuery) {
+            await sock.sendMessage(chatId, { 
+                text: `✦ *${botName}* Video\n\nUse: .video <query or url>\nExample: .video never gonna give you up` 
+            }, { quoted: fake });
+            return;
+        }
+
+        // Determine if input is a YouTube link
+        let videoUrl = '';
+        let videoTitle = '';
+        let videoThumbnail = '';
+        
+        if (searchQuery.startsWith('http://') || searchQuery.startsWith('https://')) {
+            videoUrl = searchQuery;
+        } else {
+            // Search YouTube for the video
+            const { videos } = await yts(searchQuery);
+            if (!videos || videos.length === 0) {
+                await sock.sendMessage(chatId, { 
+                    text: `✦ No videos found` 
+                }, { quoted: fake });
+                return;
+            }
+            videoUrl = videos[0].url;
+            videoTitle = videos[0].title;
+            videoThumbnail = videos[0].thumbnail;
+        }
+
+        // Send thumbnail immediately
+        try {
+            const ytId = (videoUrl.match(/(?:youtu\.be\/|v=)([a-zA-Z0-9_-]{11})/) || [])[1];
+            const thumb = videoThumbnail || (ytId ? `https://i.ytimg.com/vi/${ytId}/sddefault.jpg` : undefined);
+            const captionTitle = videoTitle || searchQuery;
+            if (thumb) {
+                await sock.sendMessage(chatId, {
+                    image: { url: thumb },
+                    caption: `✦ *${botName}*\n${captionTitle}\n\nDownloading...`
+                }, { quoted: fake });
+            }
+        } catch (e) { console.error('[VIDEO] thumb error:', e?.message || e); }
+
+        // Validate YouTube URL
+        let urls = videoUrl.match(/(?:https?:\/\/)?(?:youtu\.be\/|(?:www\.|m\.)?youtube\.com\/(?:watch\?v=|v\/|embed\/|shorts\/|playlist\?list=)?)([a-zA-Z0-9_-]{11})/gi);
+        if (!urls) {
+            await sock.sendMessage(chatId, { 
+                text: `✦ Invalid YouTube link` 
+            }, { quoted: fake });
+            return;
+        }
+
+        // Try multiple APIs with fallback chain: EliteProTech -> Yupra -> Okatsu
+        let videoData;
+        let downloadSuccess = false;
+
+        // List of API methods to try
+        const apiMethods = [
+            { name: 'EliteProTech', method: () => getEliteProTechVideoByUrl(videoUrl) },
+            { name: 'Yupra', method: () => getYupraVideoByUrl(videoUrl) },
+            { name: 'Okatsu', method: () => getOkatsuVideoByUrl(videoUrl) }
+        ];
+
+        // Try each API until we successfully get video data
+        for (const apiMethod of apiMethods) {
+            try {
+                videoData = await apiMethod.method();
+                const videoUrl_check = videoData.download || videoData.dl || videoData.url;
+
+                if (!videoUrl_check) {
+                    console.log(`${apiMethod.name} returned no download URL, trying next API...`);
+                    continue; // Try next API
+                }
+
+                downloadSuccess = true;
+                break; // Success! Exit the loop
+            } catch (apiErr) {
+                // API call failed, try next API
+                console.log(`${apiMethod.name} API failed:`, apiErr.message);
+                continue;
+            }
+        }
+
+        // If all APIs failed, throw error
+        if (!downloadSuccess || !videoData) {
+            throw new Error('All download sources failed. The content may be unavailable or blocked in your region.');
+        }
+
+        // Send video directly using the download URL
+        await sock.sendMessage(chatId, {
+            video: { url: videoData.download || videoData.dl || videoData.url },
+            mimetype: 'video/mp4',
+            fileName: `${(videoData.title || videoTitle || 'video').replace(/[^\w\s-]/g, '')}.mp4`,
+            caption: `✦ *${botName}*\n${videoData.title || videoTitle || 'Video'}`
+        }, { quoted: fake });
+
+    } catch (error) {
+        console.error('[VIDEO] Command Error:', error?.message || error);
+
+        // Provide more specific error messages
+        let errorMessage = `✦ Failed to download video`;
+        
+        if (error.message && error.message.includes('blocked')) {
+            errorMessage = `✦ Download blocked. Content unavailable.`;
+        } else if (error.response?.status === 451 || error.status === 451) {
+            errorMessage = `✦ Content unavailable (451)`;
+        } else if (error.message && error.message.includes('All download sources failed')) {
+            errorMessage = `✦ All download sources failed`;
+        } else if (error.message) {
+            errorMessage = `✦ ${error.message}`;
+        }
+
+        await sock.sendMessage(chatId, { 
+            text: errorMessage 
+        }, { quoted: fake });
+    }
+}
+
+module.exports = videoCommand;