Spaces:

DeeCeeXxx
/

mywork

Paused

App Files Files Community

DeeCeeXxx commited on Apr 11, 2025

Commit

deef7da

verified ·

1 Parent(s): d35f627

Upload 9 files

Browse files

Files changed (9) hide show

.gitattributes +1 -0
Atomic.zip +3 -0
Image/0.jpg +3 -0
Image/DC.js +1 -0
Procfile +1 -0
app.json +16 -0
app.json.bak +16 -0
bot.js +2645 -0
package.json +17 -85

.gitattributes CHANGED Viewed

@@ -36,3 +36,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 davidcyrilapis-main/public/docs/background-music.mp3 filter=lfs diff=lfs merge=lfs -text
 public/docs/background-music.mp3 filter=lfs diff=lfs merge=lfs -text
 thumb.png filter=lfs diff=lfs merge=lfs -text

 davidcyrilapis-main/public/docs/background-music.mp3 filter=lfs diff=lfs merge=lfs -text
 public/docs/background-music.mp3 filter=lfs diff=lfs merge=lfs -text
 thumb.png filter=lfs diff=lfs merge=lfs -text
+Image/0.jpg filter=lfs diff=lfs merge=lfs -text

Atomic.zip ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:57ce84da49fc5ad268ec599708fda8329714bf769da6c6442292f49426a15c48
+size 258276

Image/0.jpg ADDED Viewed

Git LFS Details

SHA256: 39f12f09d5074e1718a83e552760a15f0e411d13388e5e126da0c60921d01d51
Pointer size: 131 Bytes
Size of remote file: 134 kB

Image/DC.js ADDED Viewed

	@@ -0,0 +1 @@


1	+

Procfile ADDED Viewed

	@@ -0,0 +1 @@


1	+ web: node bot.js

app.json ADDED Viewed

	@@ -0,0 +1,16 @@

+{
+  "name": "Atomic",
+  "description": "A WhatsApp Bot Created By David Cyril",
+  "logo": "https://telegra.ph/file/f6230a0cb5b118fa01561.jpg",
+  "keywords": ["bot", "WhatsApp", "JavaScript"],
+  "success_url": "/",
+  "stack": "heroku-24",
+  "buildpacks": [
+    {
+      "url": "https://github.com/heroku/heroku-buildpack-nodejs.git"
+    }
+  ],
+  "scripts": {
+    "postdeploy": "node index.js"
+  }
+}

app.json.bak ADDED Viewed

	@@ -0,0 +1,16 @@

+{
+  "name": "Queen Anita V4",
+  "description": "A WhatsApp Bot Created By David Cyril",
+  "logo": "https://telegra.ph/file/f6230a0cb5b118fa01561.jpg",
+  "keywords": ["bot", "WhatsApp", "JavaScript"],
+  "success_url": "/",
+  "stack": "heroku-24",
+  "buildpacks": [
+    {
+      "url": "https://github.com/heroku/heroku-buildpack-nodejs.git"
+    }
+  ],
+  "scripts": {
+    "postdeploy": "node index.js"
+  }
+}

bot.js ADDED Viewed

	@@ -0,0 +1,2645 @@

+// Import necessary modules
+const express = require('express');
+const { sinhalaSub } = require("mrnima-moviedl");
+const FormData = require('form-data');
+const { catbox } = require('./catbox'); // Import the Catbox uploader
+const { exec } = require("child_process");
+const yts = require('yt-search'); //
+// Initialize Express app for HTTP server
+const app = express();
+const PORT = process.env.PORT || 3000;
+// Basic HTML response for health check
+app.get('/', (req, res) => {
+  res.send(`
+    <html>
+      <head>
+        <title>Bot Status</title>
+      </head>
+      <body style="text-align: center; margin-top: 50px; font-family: Arial, sans-serif;">
+        <h1 style="color: green;">✅ Connected to Telegram</h1>
+        <p>Your bot is up and running!</p>
+      </body>
+    </html>
+  `);
+});
+// Start the HTTP server
+app.listen(PORT, () => {
+  console.log(`Server is running on http://localhost:${PORT}`);
+});
+//
+const TelegramBot =
+require('node-telegram-bot-api');
+const axios = require('axios');
+const fs = require('fs');
+const apiKey = '7398508893:AAFqoZK_n0FNZ5I9_5L4BpyDSh3YvatZ3B8';
+// Replace 'YOUR_TELEGRAM_BOT_TOKEN' with your bot token
+const bot = new TelegramBot('7398508893:AAFE6xOytstrMZ0PpRa3ieH6SLBy9TR9vq4', { polling: true });
+// Set up a list for tracking muted users
+const mutedUsers = new Set();
+// Anti-link feature variable
+let antiLinkActive = false;
+// Check if user is admin
+const isAdmin = async (chatId, userId) => {
+    try {
+        const member = await bot.getChatMember(chatId, userId);
+        return member.status === 'administrator' || member.status === 'creator';
+    } catch (error) {
+        return false;
+    }
+};
+// /tiktok command
+bot.onText(/\/(tiktok|tt|ttmedia)(?: (.+))?/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const text = match[2]; // Extract the TikTok link from the command
+    if (!text) {
+        // If no TikTok link is provided, send a usage guide
+        return bot.sendMessage(chatId, "❌ Please provide a TikTok link.\nExample: `/tiktok https://www.tiktok.com/@username/video/1234567890`");
+    }
+    bot.sendMessage(chatId, "🔄 Fetching your TikTok media... Please wait.");
+    try {
+        // Fetch TikTok media using the external API
+        const response = await axios.get(`https://api.paxsenix.biz.id/dl/tiktok?url=${encodeURIComponent(text)}`);
+        const data = response.data;
+        if (data && data.downloadsUrl) {
+            // Send the video
+            await bot.sendVideo(chatId, data.downloadsUrl.video);
+            // Send the audio
+            await bot.sendAudio(chatId, data.downloadsUrl.music);
+        } else {
+            bot.sendMessage(chatId, "❌ Unable to fetch TikTok media. Please check the link and try again.");
+        }
+    } catch (error) {
+        console.error("Error during TikTok download command:");
+        bot.sendMessage(chatId, "❌ An error occurred while processing your request. Please try again later.");
+    }
+});
+bot.onText(/\/couplepp/, async (msg) => {
+    const chatId = msg.chat.id;
+    try {
+        // Inform the user that the bot is fetching the pictures
+        await bot.sendMessage(chatId, "🔍 *Fetching couple profile pictures...*", { parse_mode: "Markdown" });
+        // Fetch the data from the API
+        const apiUrl = "https://api.maskser.me/api/randomgambar/couplepp";
+        const response = await axios.get(apiUrl);
+        if (response.data.status) {
+            const { male, female } = response.data.result;
+            // Send the male picture
+            await bot.sendPhoto(chatId, male, {
+                caption: "👦 *Male Picture*",
+                parse_mode: "Markdown"
+            });
+            // Send the female picture
+            await bot.sendPhoto(chatId, female, {
+                caption: "👧 *Female Picture*",
+                parse_mode: "Markdown"
+            });
+        } else {
+            bot.sendMessage(chatId, "❌ Failed to fetch couple pictures. Please try again later.");
+        }
+    } catch (error) {
+        console.error("Error fetching couple pictures:");
+        bot.sendMessage(chatId, "❌ An error occurred while fetching couple pictures. Please try again.");
+    }
+});
+// Handle /gpt command
+bot.onText(/\/gpt (.+)/, async (msg, match) => {
+  const chatId = msg.chat.id;
+  const query = match[1]?.trim();
+  if (!query) {
+    return bot.sendMessage(chatId, "❌ Please provide a prompt after the /gpt command.\nExample: `/gpt What is AI?`", {
+      parse_mode: "Markdown",
+    });
+  }
+  try {
+    // Show typing indicator
+    await bot.sendChatAction(chatId, "typing");
+    // Make a request to the new GPT API
+    const apiUrl = `https://api.paxsenix.biz.id/ai/gpt4?text=${encodeURIComponent(query)}`;
+    const { data } = await axios.get(apiUrl);
+    // Check the API response
+    if (!data.ok || !data.message) {
+      return bot.sendMessage(chatId, `❌ GPT API Error: Unable to fetch a response. Please try again later.`);
+    }
+    // Send the GPT response to the user
+    await bot.sendMessage(chatId, `${data.message}`, { parse_mode: "Markdown" });
+  } catch (error) {
+    console.error("Error fetching GPT response:");
+    await bot.sendMessage(chatId, "❌ An error occurred while fetching the GPT response. Please try again later.");
+  }
+});
+bot.onText(/\/url/, async (msg) => {
+    const chatId = msg.chat.id;
+    // Check if the message is a reply to an image or video
+    const fileId = msg.reply_to_message?.photo?.[msg.reply_to_message.photo.length - 1]?.file_id ||
+                   msg.reply_to_message?.video?.file_id;
+    if (!fileId) {
+        return bot.sendMessage(chatId, "❗ *Reply to an image or video with /url to get a public link.*", { parse_mode: "Markdown" });
+    }
+    try {
+        // React to indicate processing
+        const processingMsg = await bot.sendMessage(chatId, "⏳ *Uploading your file...*", { parse_mode: "Markdown" });
+        // Download the file locally
+        const filePath = await bot.downloadFile(fileId, "./downloads");
+        // Upload the file to Catbox
+        const uploadResponse = await catbox(filePath);
+        // Check and send the result
+        if (uploadResponse.url) {
+            await bot.sendMessage(chatId, `✅ *Upload Successful!*\n\n🔗 *URL:*\n${uploadResponse.url}\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`, { parse_mode: "Markdown" });
+        } else {
+            await bot.sendMessage(chatId, "❌ *Upload Failed. Please try again.*", { parse_mode: "Markdown" });
+        }
+        // Clean up the downloaded file
+        fs.unlinkSync(filePath);
+        await bot.deleteMessage(chatId, processingMsg.message_id);
+    } catch (error) {
+        console.error("Error in /url command:");
+        bot.sendMessage(chatId, `❌ *An error occurred`, { parse_mode: "Markdown" });
+    }
+});
+bot.onText(/\/remini/, async (msg) => {
+    const chatId = msg.chat.id;
+    // Check if the message is a reply to an image
+    const fileId = msg.reply_to_message?.photo?.[msg.reply_to_message.photo.length - 1]?.file_id;
+    if (!fileId) {
+        return bot.sendMessage(chatId, "❗ *Reply to an image with /remini to enhance it.*", { parse_mode: "Markdown" });
+    }
+    try {
+        // React to indicate processing
+        const processingMsg = await bot.sendMessage(chatId, "⏳ *Enhancing your image...*", { parse_mode: "Markdown" });
+        // Download the image locally
+        const filePath = await bot.downloadFile(fileId, "./downloads");
+        // Upload the image to Catbox
+        const uploadResponse = await catbox(filePath);
+        if (!uploadResponse.url) {
+            fs.unlinkSync(filePath); // Clean up the downloaded file
+            return bot.sendMessage(chatId, "❌ *Upload Failed. Please try again.*", { parse_mode: "Markdown" });
+        }
+        const imageUrl = uploadResponse.url; // Get the uploaded image URL
+        // Call the Remini API with the uploaded image URL
+        const enhancedImageUrl = `https://bk9.fun/tools/enhance?url=${encodeURIComponent(imageUrl)}`;
+        // Send the enhanced image back to the user
+        await bot.sendPhoto(chatId, enhancedImageUrl, {
+            caption: `✅ *Successfully Enhanced Your Image!*\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+            parse_mode: "Markdown",
+        });
+        // Clean up the downloaded file
+        fs.unlinkSync(filePath);
+        await bot.deleteMessage(chatId, processingMsg.message_id);
+    } catch (error) {
+        console.error("Error in /remini command:");
+        bot.sendMessage(chatId, `❌ *An error occurred`, { parse_mode: "Markdown" });
+    }
+});
+bot.onText(/\/video (.+)/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const query = match[1]?.trim();
+    if (!query) {
+        return bot.sendMessage(chatId, "❗ *Usage*: `/video <search term>`", { parse_mode: 'Markdown' });
+    }
+    try {
+        const searchMsg = await bot.sendMessage(chatId, "🔍 *Searching for your video...*", { parse_mode: "Markdown" });
+        // Step 1: Search for the video
+        const search = await yts(query);
+        const video = search.all[0]; // Take the first result
+        if (!video) {
+            return bot.sendMessage(chatId, "❌ Video not found!");
+        }
+        // Step 2: Fetch video download link from the API
+        const apiUrl = `https://apis.davidcyriltech.my.id/download/ytmp4`;
+        const response = await axios.get(apiUrl, { params: { url: video.url } });
+        const { success, result } = response.data;
+        if (success && result) {
+            const { title, download_url } = result;
+            const filePath = `./temp/${title.replace(/[^\w\s]/gi, '')}.mp4`;
+            // Step 3: Download video locally
+            const writer = fs.createWriteStream(filePath);
+            const videoStream = await axios({
+                url: download_url,
+                method: 'GET',
+                responseType: 'stream'
+            });
+            videoStream.data.pipe(writer);
+            await new Promise((resolve, reject) => {
+                writer.on('finish', resolve);
+                writer.on('error', reject);
+            });
+            // Step 4: Send the video from local storage
+            await bot.sendVideo(chatId, filePath, {
+                caption: `🎬 *Here is your video:*\n🎥 *${title}*\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+                parse_mode: "Markdown"
+            });
+            // Step 5: Delete the file after sending
+            fs.unlinkSync(filePath);
+        } else {
+            bot.sendMessage(chatId, "❌ Failed to fetch the video. Please try again.");
+        }
+        await bot.deleteMessage(chatId, searchMsg.message_id);
+    } catch (err) {
+        console.error("Error in /video command:", err);
+        bot.sendMessage(chatId, "❌ An error occurred while processing your request.");
+    }
+});
+// /play command
+bot.onText(/\/play(?: (.+))?/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const inputText = match[1];
+    if (!inputText) {
+        return bot.sendMessage(chatId, "❌ Please provide the song name.\nExample: `/play Faded by Alan Walker`");
+    }
+    try {
+        // Notify user that the bot is searching
+        await bot.sendMessage(chatId, "🔍 Searching for your song...");
+        // Perform a YouTube search
+        const search = await yts(inputText);
+        const video = search.all[0];
+        if (!video) {
+            return bot.sendMessage(chatId, "❌ Sorry, I couldn't find the song. Try another keyword.");
+        }
+        // Fetch the song download link using the new API
+        const apiUrl = `https://apis.davidcyriltech.my.id/download/ytmp3?url=${encodeURIComponent(video.url)}`;
+        const response = await axios.get(apiUrl);
+        const { success, result } = response.data;
+        if (success && result) {
+            const { title, thumbnail, download_url } = result;
+            const filename = `./${video.title.replace(/[^a-zA-Z0-9]/g, "_")}.mp3`;
+            // Send song details with thumbnail
+            await bot.sendPhoto(chatId, thumbnail, {
+                caption: `🎶 *Music Player* 🎶\n\n` +
+                    `🎵 *Title:* ${video.title}\n` +
+                    `🔗 [Watch on YouTube](${video.url})\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+                parse_mode: "Markdown",
+            });
+            // Download the audio file
+            const writer = fs.createWriteStream(filename);
+            const { data } = await axios({
+                url: download_url,
+                method: "GET",
+                responseType: "stream",
+            });
+            data.pipe(writer);
+            await new Promise((resolve, reject) => {
+                writer.on("finish", resolve);
+                writer.on("error", reject);
+            });
+            // Send the locally saved audio file
+            await bot.sendAudio(chatId, filename, {
+                caption: `🎧 *Here's your song:*\n🎵 *Title:* ${video.title}\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+                parse_mode: "Markdown",
+            });
+            // Delete the file after sending
+            fs.unlink(filename, (err) => {
+                if (err) console.error("Error deleting file:", err);
+            });
+        } else {
+            bot.sendMessage(chatId, "❌ Unable to download the song. Please try again later.");
+        }
+    } catch (error) {
+        console.error("Error during /play command:", error);
+        bot.sendMessage(chatId, "❌ An error occurred while processing your request. Please try again later.");
+    }
+});
+bot.onText(/\/ytmp3 (.+)/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const youtubeLink = match[1]?.trim();
+    if (!youtubeLink) {
+        return bot.sendMessage(chatId, "❗ *Usage*: `/ytmp3 <YouTube link>`\nExample: `/ytmp3 https://youtube.com/watch?v=iI34LYmJ1Fs`", { parse_mode: 'Markdown' });
+    }
+    try {
+        const loadingMsg = await bot.sendMessage(chatId, "🔍 *Processing your audio...*", { parse_mode: "Markdown" });
+        // Fetch audio download link
+        const apiUrl = `https://apis.davidcyriltech.my.id/download/ytmp3`;
+        const response = await axios.get(apiUrl, { params: { url: youtubeLink } });
+        const { success, result } = response.data;
+        if (success && result) {
+            const { title, download_url } = result;
+            const filename = `./temp/${Date.now()}.mp3`;
+            // Download the audio locally
+            const audioResponse = await axios({
+                url: download_url,
+                method: "GET",
+                responseType: "stream",
+            });
+            const writer = fs.createWriteStream(filename);
+            audioResponse.data.pipe(writer);
+            writer.on("finish", async () => {
+                await bot.sendAudio(chatId, filename, {
+                    caption: `🎧 *${title}*\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+                    parse_mode: "Markdown",
+                });
+                fs.unlinkSync(filename); // Delete after sending
+            });
+        } else {
+            bot.sendMessage(chatId, "❌ Failed to fetch the audio. Please check the link and try again.");
+        }
+        await bot.deleteMessage(chatId, loadingMsg.message_id);
+    } catch (err) {
+        console.error("Error in /ytmp3 command:", err);
+        bot.sendMessage(chatId, "❌ An error occurred while processing your request.");
+    }
+});
+let chatbotActive = {}; // Stores active chatbot users
+let conversationIds = {}; // Stores conversation ID for each user
+bot.onText(/\/gitclone (.+)/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const repoUrl = match[1]?.trim();
+    if (!repoUrl) {
+        return bot.sendMessage(chatId, "❗ *Usage*: `/gitclone <GitHub Repo URL>`\nExample: `/gitclone https://github.com/DeeCeeXxx2/Queen_Anita-V3`", { parse_mode: 'Markdown' });
+    }
+    if (!repoUrl.includes("github.com")) {
+        return bot.sendMessage(chatId, "❌ *Invalid GitHub link! Please provide a valid URL.*");
+    }
+    try {
+        let regex = /(?:https|git)(?::\/\/|@)github\.com[\/:]([^\/:]+)\/(.+)/i;
+        let [, user, repo] = repoUrl.match(regex) || [];
+        repo = repo.replace(/.git$/, "");
+        let zipUrl = `https://api.github.com/repos/${user}/${repo}/zipball`;
+        // Fetch file name from GitHub API
+        let response = await fetch(zipUrl, { method: "HEAD" });
+        let filename = response.headers.get("content-disposition").match(/attachment; filename=(.*)/)[1];
+        await bot.sendDocument(chatId, zipUrl, {
+            caption: `📦 *Repository:* ${repo}\n🔗 *Download Link:* [Click Here](${zipUrl})\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+            parse_mode: "Markdown",
+            fileName: filename + ".zip",
+            mimetype: "application/zip"
+        });
+    } catch (err) {
+        console.error("Error in /gitclone command:", err);
+        bot.sendMessage(chatId, "❌ *An error occurred while fetching the repository. Please try again later.*");
+    }
+});
+bot.onText(/\/chatbot$/, async (msg) => {
+    const chatId = msg.chat.id;
+    await bot.sendMessage(
+        chatId,
+        "❗ *Invalid Command!*\n\nUse:\n✅ `/chatbot on` - To activate AI chat\n❌ `/chatbot off` - To deactivate AI chat",
+        { parse_mode: "Markdown" }
+    );
+});
+bot.onText(/\/mediafire (.+)/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const mediafireUrl = match[1]?.trim();
+    if (!mediafireUrl) {
+        return bot.sendMessage(chatId, "❗ *Usage*: `/mediafire <MediaFire Link>`\nExample: `/mediafire https://www.mediafire.com/file/n6tgcrktbnov1oy/Queen_Anita-V4.zip/file`", { parse_mode: 'Markdown' });
+    }
+    try {
+        const loadingMsg = await bot.sendMessage(chatId, "📥 *Fetching file details...*", { parse_mode: "Markdown" });
+        const apiUrl = `https://apis.davidcyriltech.my.id/mediafire?url=${encodeURIComponent(mediafireUrl)}`;
+        const response = await axios.get(apiUrl);
+        const { success, result } = response.data;
+        if (success && result) {
+            const { fileName, downloadLink } = result;
+            const filePath = path.join(__dirname, "temp", fileName.replace(/[^\w\s]/gi, "_"));
+            // Step 1: Download the file locally
+            const writer = fs.createWriteStream(filePath);
+            const fileResponse = await axios({
+                url: downloadLink,
+                method: "GET",
+                responseType: "stream",
+            });
+            fileResponse.data.pipe(writer);
+            await new Promise((resolve, reject) => {
+                writer.on("finish", resolve);
+                writer.on("error", reject);
+            });
+            // Step 2: Send the file
+            await bot.sendDocument(chatId, filePath, {
+                caption: `📦 *File Name:* ${fileName}\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+                parse_mode: "Markdown",
+            });
+            // Step 3: Delete the file after sending
+            fs.unlinkSync(filePath);
+        } else {
+            bot.sendMessage(chatId, "❌ *Failed to fetch file details! Please check the MediaFire URL and try again.*");
+        }
+        await bot.deleteMessage(chatId, loadingMsg.message_id);
+    } catch (error) {
+        console.error("Error in /mediafire command:", error);
+        bot.sendMessage(chatId, "❌ *An error occurred while processing your request. Please try again later.*");
+    }
+});
+bot.onText(/\/ss (.+)/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const websiteUrl = match[1]?.trim();
+    if (!websiteUrl) {
+        return bot.sendMessage(chatId, "❗ *Usage*: `/ssweb <Website URL>`\nExample: `/ssweb https://example.com`", { parse_mode: 'Markdown' });
+    }
+    try {
+        const loadingMsg = await bot.sendMessage(chatId, "📸 *Capturing screenshot...*", { parse_mode: "Markdown" });
+        const apiUrl = `https://apis.davidcyriltech.my.id/ssweb?url=${encodeURIComponent(websiteUrl)}`;
+        await bot.sendPhoto(chatId, apiUrl, {
+            caption: `🖼️ *Screenshot of:* ${websiteUrl}`,
+            parse_mode: "Markdown"
+        });
+        await bot.deleteMessage(chatId, loadingMsg.message_id);
+    } catch (error) {
+        console.error("Error in /ssweb command:", error);
+        bot.sendMessage(chatId, "❌ *Failed to capture the screenshot. Please try again later.*");
+    }
+});
+bot.onText(/\/ytmp4 (.+)/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const youtubeLink = match[1]?.trim();
+    if (!youtubeLink) {
+        return bot.sendMessage(chatId, "❗ *Usage*: `/ytmp4 <YouTube link>`\nExample: `/ytmp4 https://youtube.com/watch?v=iI34LYmJ1Fs`", { parse_mode: 'Markdown' });
+    }
+    try {
+        const loadingMsg = await bot.sendMessage(chatId, "🔍 *Processing your video...*", { parse_mode: "Markdown" });
+        // Fetch video download link
+        const apiUrl = `https://apis.davidcyriltech.my.id/download/ytmp4`;
+        const response = await axios.get(apiUrl, { params: { url: youtubeLink } });
+        const { success, result } = response.data;
+        if (success && result) {
+            const { title, download_url } = result;
+            const filename = `./temp/${Date.now()}.mp4`;
+            // Download the video locally
+            const videoResponse = await axios({
+                url: download_url,
+                method: "GET",
+                responseType: "stream",
+            });
+            const writer = fs.createWriteStream(filename);
+            videoResponse.data.pipe(writer);
+            writer.on("finish", async () => {
+                await bot.sendVideo(chatId, filename, {
+                    caption: `🎬 *${title}*\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+                    parse_mode: "Markdown",
+                });
+                fs.unlinkSync(filename); // Delete after sending
+            });
+        } else {
+            bot.sendMessage(chatId, "❌ Failed to fetch the video. Please check the link and try again.");
+        }
+        await bot.deleteMessage(chatId, loadingMsg.message_id);
+    } catch (err) {
+        console.error("Error in /ytmp4 command:", err);
+        bot.sendMessage(chatId, "❌ An error occurred while processing your request.");
+    }
+});
+    const path = require("path");
+    // Utility: Validate and fetch direct PixelDrain link
+    async function getDirectPixelDrainLink(fileUrl) {
+      try {
+        const response = await axios.get(fileUrl, { maxRedirects: 0, validateStatus: (status) => status < 400 });
+        return response.headers.location || fileUrl; // Return direct link
+      } catch (error) {
+        console.error("Error validating PixelDrain link:");
+        throw new Error("Invalid or inaccessible PixelDrain link.");
+      }
+    }
+    // Utility: Download file from PixelDrain and save it locally
+    async function downloadFile(fileUrl, downloadPath) {
+      try {
+        const response = await axios({
+          url: fileUrl,
+          method: "GET",
+          responseType: "stream",
+        });
+        const writer = fs.createWriteStream(downloadPath);
+        response.data.pipe(writer);
+        return new Promise((resolve, reject) => {
+          writer.on("finish", () => {
+            console.log(`File downloaded to: ${downloadPath}`);
+            resolve();
+          });
+          writer.on("error", (err) => {
+            console.error("Download error:");
+        reject(err);
+      });
+    });
+  } catch (error) {
+    console.error("Error downloading file:", );
+    throw new Error("Failed to download file.");
+  }
+}
+// Utility: Stream file directly to Telegram
+async function streamFileToTelegram(chatId, filePath, caption) {
+  try {
+    await bot.sendDocument(chatId, filePath, { caption: caption });
+    console.log("File streamed successfully to Telegram.");
+  } catch (error) {
+    console.error("Error streaming file:");
+    throw new Error("Failed to stream file to Telegram.");
+  }
+}
+bot.onText(/\/bible (.+)/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const chapterInput = match[1]?.trim();
+    if (!chapterInput) {
+        return bot.sendMessage(
+            chatId,
+            "❗ *Usage*: `/bible <chapter and verse>`\nExample: `/bible john 3:16`",
+            { parse_mode: "Markdown" }
+        );
+    }
+    const BASE_URL = "https://bible-api.com";
+    try {
+        // Fetch the chapter data from the Bible API
+        const response = await axios.get(`${BASE_URL}/${encodeURIComponent(chapterInput)}`);
+        if (!response.data) {
+            throw new Error("Failed to fetch the Bible chapter. Please check the input and try again.");
+        }
+        const chapterData = response.data;
+        // Format the Bible chapter message
+        const bibleChapter = `
+📖 *The Holy Bible*\n
+📜 *Chapter:* ${chapterData.reference}\n
+📚 *Translation:* ${chapterData.translation_name}\n
+📖 *Number of Verses:* ${chapterData.verses.length}\n
+🔮 *Chapter Content:*\n${chapterData.text}
+        `;
+        // Send the formatted message with an image
+        await bot.sendPhoto(chatId, "./atomic.jpg", {
+            caption: bibleChapter,
+            parse_mode: "Markdown",
+        });
+    } catch (error) {
+        console.error("Error in /bible command:");
+        bot.sendMessage(chatId, `❌ Error: `);
+    }
+});
+bot.onText(/\/text2image (.+)/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const prompt = match[1]; // Extract the prompt from the command
+    // Check if the user provided a prompt
+    if (!prompt) {
+        return bot.sendMessage(chatId, "❌ *Please provide a prompt!* \n\nUsage: `/magicstudio <prompt>`", { parse_mode: "Markdown" });
+    }
+    try {
+        // Inform the user the process has started
+        await bot.sendMessage(chatId, "✨ *Generating image... Please wait!*", { parse_mode: "Markdown" });
+        // API URL to generate the image
+        const apiUrl = `https://bk9.fun/ai/magicstudio?prompt=${encodeURIComponent(prompt)}`;
+        // Fetch the generated image from the API
+        const response = await axios.get(apiUrl, { responseType: "stream" });
+        // Send the image back to the user
+        await bot.sendPhoto(chatId, response.data, {
+            caption: `🖼️ *Here's your generated image for:* \`${prompt}\`\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+            parse_mode: "Markdown"
+        });
+    } catch (error) {
+        console.error("Error generating image:");
+        bot.sendMessage(chatId, "❌ *Failed to generate the image. Please try again later!*", { parse_mode: "Markdown" });
+    }
+});
+// /apk command
+bot.onText(/\/apk (.+)/, async (msg, match) => {
+  const chatId = msg.chat.id;
+  const packageName = match[1]?.trim();
+  if (!packageName) {
+    return bot.sendMessage(chatId, "❗ *Usage*: `/apk <package_name>`\nExample: `/apk com.whatsapp`", { parse_mode: "Markdown" });
+  }
+  try {
+    // Step 1: Fetch APK details from the API
+    const apiUrl = `https://bk9.fun/download/apk?id=${encodeURIComponent(packageName)}`;
+    const response = await axios.get(apiUrl);
+    const { status, BK9 } = response.data;
+    if (!status || !BK9) {
+      return bot.sendMessage(chatId, "❌ APK details not found. Please check the package name and try again.");
+    }
+    // Step 2: Prepare APK details message
+    const apkDetails = `📱 *APK Details*\n\n` +
+      `*Name:* ${BK9.name}\n` +
+      `*Last Updated:* ${BK9.lastup}\n` +
+      `*Package:* \`${BK9.package}\`\n\n` +
+      `\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`;
+    const downloadLink = BK9.dllink;
+    // Step 3: Create Inline Keyboard Button for download link
+    const inlineKeyboard = [
+      [
+        {
+          text: "📥 Download APK",
+          url: downloadLink,
+        },
+      ],
+    ];
+    const options = {
+      reply_markup: {
+        inline_keyboard: inlineKeyboard,
+      },
+      parse_mode: "Markdown",
+    };
+    // Step 4: Send APK details with the download button
+    await bot.sendPhoto(chatId, BK9.icon, {
+      caption: apkDetails,
+      ...options,
+    });
+  } catch (error) {
+    console.error("Error fetching APK details:");
+    await bot.sendMessage(chatId, "❌ An error occurred while fetching APK details. Please try again.");
+  }
+});
+// /movie command
+bot.onText(/\/movie (.+)/, async (msg, match) => {
+  const chatId = msg.chat.id;
+  const query = match[1]?.trim();
+  if (!query) {
+    return bot.sendMessage(chatId, "❌ *Please provide a search query!*\nExample: `/movie Deadpool`", { parse_mode: "Markdown" });
+  }
+  try {
+    // Step 1: Search SinhalaSub for movies
+    const sinhala = await sinhalaSub();
+    const results = await sinhala.search(query);
+    const movies = results.result.slice(0, 10); // Limit results to 10
+    if (!movies.length) {
+      return bot.sendMessage(chatId, `❌ No results found for: *${query}*`, { parse_mode: "Markdown" });
+    }
+    // Step 2: Create Inline Keyboard Buttons for movies
+    const inlineKeyboard = movies.map((movie, index) => [
+      {
+        text: `${index + 1}. ${movie.title}`,
+        callback_data: `movie_${index}`, // Unique identifier for each movie
+      },
+    ]);
+    const options = {
+      reply_markup: {
+        inline_keyboard: inlineKeyboard,
+      },
+      parse_mode: "Markdown",
+    };
+    await bot.sendMessage(chatId, `📽️ *Search Results for:* \`${query}\`\n\nSelect a movie from the list:`, options);
+    // Step 3: Handle movie selection
+    bot.on("callback_query", async (callbackQuery) => {
+      const { data, message } = callbackQuery;
+      // Check if the callback is for this movie selection
+      if (data.startsWith("movie_")) {
+        const selectedIndex = parseInt(data.split("_")[1], 10);
+        const selectedMovie = movies[selectedIndex];
+        const apiUrl = `https://api-site-2.vercel.app/api/sinhalasub/movie?url=${encodeURIComponent(selectedMovie.link)}`;
+        try {
+          // Step 4: Fetch download links
+          const { data: movieData } = await axios.get(apiUrl);
+          const movieDetails = movieData.result;
+          const downloadLinks = movieDetails.dl_links || [];
+          if (!downloadLinks.length) {
+            return bot.sendMessage(chatId, "❌ No PixelDrain links found for this movie.");
+          }
+          // Step 5: Create Inline Keyboard Buttons for direct download links
+          const qualityKeyboard = downloadLinks.map((link) => {
+            const pixelDrainId = link.link.split("/").pop(); // Extract the file ID
+            const directDownloadLink = `https://pixeldrain.com/api/file/${pixelDrainId}?download`; // Use /download endpoint
+            return [
+              {
+                text: `${link.quality} - ${link.size}`,
+                url: directDownloadLink, // Direct download link
+              },
+            ];
+          });
+          const qualityOptions = {
+            reply_markup: {
+              inline_keyboard: qualityKeyboard,
+            },
+            parse_mode: "Markdown",
+          };
+          await bot.sendMessage(
+            chatId,
+            `🎥 *Available Qualities for:* \`${movieDetails.title}\`\n\nSelect a quality to download directly:\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+            qualityOptions
+          );
+          // Acknowledge the callback to avoid timeout errors
+          bot.answerCallbackQuery(callbackQuery.id);
+        } catch (error) {
+          console.error("Error fetching movie details:");
+          await bot.sendMessage(chatId, "❌ Failed to fetch movie details. Please try again.");
+        }
+      }
+    });
+  } catch (error) {
+    console.error("Error executing /movie command:");
+    await bot.sendMessage(chatId, "❌ An error occurred while processing your request.");
+  }
+});
+bot.onText(/\/shazam/, async (msg) => {
+    const chatId = msg.chat.id;
+    // Ensure the command is a reply to an audio or video message
+    const fileId = msg.reply_to_message?.audio?.file_id || msg.reply_to_message?.video?.file_id;
+    if (!fileId) {
+        return bot.sendMessage(chatId, "❌ Please reply to an audio or video file with /shazam to identify it.");
+    }
+    try {
+        // Notify the user that the bot is processing the file
+        const processingMsg = await bot.sendMessage(chatId, "🎵 Identifying the audio... Please wait!");
+        // Download the file locally
+        const filePath = await bot.downloadFile(fileId, "./downloads");
+        // Upload the file to Catbox
+        const uploadResponse = await catbox(filePath);
+        if (!uploadResponse.url) {
+            throw new Error("Failed to upload the file for analysis.");
+        }
+        // Call Shazam API
+        const shazamApiUrl = `https://api.paxsenix.biz.id/tools/shazam?url=${encodeURIComponent(uploadResponse.url)}`;
+        const shazamResponse = await axios.get(shazamApiUrl);
+        const shazamResult = shazamResponse.data;
+        // Handle Shazam API response
+        if (shazamResult?.ok && shazamResult?.track) {
+            const { title, artist, url } = shazamResult.track;
+            const resultMessage = `🎶 *Audio Identified:*\n\n` +
+                `🎵 *Title:* ${title}\n` +
+                `🎤 *Artist:* ${artist}\n` +
+                `[🔗 Listen on Shazam](${url})\n\n` +
+                `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`;
+            await bot.sendMessage(chatId, resultMessage, { parse_mode: "Markdown" });
+        } else {
+            bot.sendMessage(chatId, "❌ Unable to identify the audio. Please try again with a different file.");
+        }
+        // Cleanup local file
+        fs.unlinkSync(filePath);
+        await bot.deleteMessage(chatId, processingMsg.message_id);
+    } catch (error) {
+        console.error("Error in /shazam command:");
+        bot.sendMessage(chatId, "⚠️ An error occurred while processing your request. Please try again later.");
+    }
+});
+bot.onText(/\/(image|img)(?: (.+))?/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const query = match[2]; // Extract the search query from the command
+    if (!query) {
+        return bot.sendMessage(
+            chatId,
+            "❌ Please provide a search query.\n\n*Usage:* `/image <query>`\n*Example:* `/image cats`",
+            { parse_mode: "Markdown" }
+        );
+    }
+    bot.sendMessage(chatId, "🔍 Searching for images... Please wait.");
+    try {
+        // Call the Bing Image Search API
+        const apiResponse = await axios.get(`https://api.siputzx.my.id/api/s/bimg`, {
+            params: { query: query }
+        });
+        if (apiResponse.status === 200 && apiResponse.data.status) {
+            const images = apiResponse.data.data;
+            if (!images || images.length === 0) {
+                return bot.sendMessage(chatId, `❌ No images found for "${query}". Please try another query.`);
+            }
+            // Limit to max 5 images
+            const maxImages = Math.min(images.length, 5);
+            for (let i = 0; i < maxImages; i++) {
+                await bot.sendPhoto(chatId, images[i], {
+                    caption: `🔎 *Image Search Result:*\n\n📄 *Query:* "${query}"\n📷 *Image ${i + 1}/${maxImages}*\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+                    parse_mode: "Markdown"
+                });
+            }
+        } else {
+            bot.sendMessage(chatId, "❌ Failed to fetch images. Please try again later.");
+        }
+    } catch (error) {
+        console.error("Error in /imagesearch command:");
+        bot.sendMessage(
+            chatId,
+            `⚠️ An error occurred:\n\n*Message:*`,
+            { parse_mode: "Markdown" }
+        );
+    }
+});
+bot.onText(/\/(spotifysearch)(?: (.+))?/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const query = match[2]; // Extract the search query from the command
+    if (!query) {
+        return bot.sendMessage(
+            chatId,
+            "❌ Please provide a search query.\n\n*Usage:* `/spotifysearch <query>`\n*Example:* `/spotifysearch Spectre`",
+            { parse_mode: "Markdown" }
+        );
+    }
+    bot.sendMessage(chatId, "🔍 Searching for tracks on Spotify... Please wait.");
+    try {
+        // Call the Spotify Search API
+        const apiResponse = await axios.get(`https://api.giftedtech.my.id/api/search/spotifysearch`, {
+            params: { apikey: "gifted-md", query: query }
+        });
+        if (apiResponse.status === 200 && apiResponse.data.success) {
+            const tracks = apiResponse.data.results;
+            if (!tracks || tracks.length === 0) {
+                return bot.sendMessage(chatId, `❌ No tracks found for "${query}". Please try another query.`);
+            }
+            // Limit to max 5 tracks
+            const maxTracks = Math.min(tracks.length, 5);
+            let message = `🎧 *Spotify Search Results:*\n\n`;
+            tracks.slice(0, maxTracks).forEach((track, index) => {
+                message += `🎵 *${index + 1}. ${track.title}*\n` +
+                           `👤 *Artist:* ${track.artist}\n` +
+                           `⏱️ *Duration:* ${track.duration}\n` +
+                           `🔗 [Listen on Spotify](${track.url})\n\n`;
+            });
+            bot.sendMessage(chatId, message, { parse_mode: "Markdown" });
+        } else {
+            bot.sendMessage(chatId, "❌ Failed to fetch tracks. Please try again later.");
+        }
+    } catch (error) {
+        console.error("Error in /spotifysearch command:");
+        bot.sendMessage(
+            chatId,
+            `⚠️ An error occurred:\n\n*Message:*`,
+            { parse_mode: "Markdown" }
+        );
+    }
+});
+bot.onText(/\/(spotify-download|spotdl)(?: (.+))?/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const spotifyUrl = match[2]; // Extract the Spotify track URL from the command
+    if (!spotifyUrl) {
+        return bot.sendMessage(
+            chatId,
+            "❌ Please provide a Spotify track URL.\n\n*Usage:* `/spotify-download <Spotify URL>`\n*Example:* `/spotify-download https://open.spotify.com/track/2DGa7iaidT5s0qnINlwMjJ`",
+            { parse_mode: "Markdown" }
+        );
+    }
+    bot.sendMessage(chatId, "🔄 Fetching your Spotify track... Please wait.");
+    try {
+        // Call the Spotify Download API
+        const apiResponse = await axios.get(`https://api.giftedtech.my.id/api/download/spotifydl`, {
+            params: { apikey: "gifted-md", url: spotifyUrl }
+        });
+        if (apiResponse.status === 200 && apiResponse.data.success) {
+            const track = apiResponse.data.result;
+            const caption = `🎵 *Spotify Track Downloaded:*\n\n` +
+                            `🔹 *Title:* ${track.title}\n` +
+                            `⏱️ *Duration:* ${track.duration}\n` +
+                            `🎧 *Quality:* ${track.quality}`;
+            // Send the audio file to the user
+            await bot.sendAudio(chatId, track.download_url, {
+                caption: caption,
+                parse_mode: "Markdown",
+                thumb: track.thumbnail, // Optional: Thumbnail as album art
+            });
+        } else {
+            bot.sendMessage(chatId, "❌ Failed to fetch track details. Please check the Spotify URL and try again.");
+        }
+    } catch (error) {
+        console.error("Error in /spotify-download command:");
+        bot.sendMessage(
+            chatId,
+            `⚠️ An error occurred:\n\n*Message:*`,
+            { parse_mode: "Markdown" }
+        );
+    }
+});
+bot.onText(/\/(song)(?: (.+))?/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const query = match[2]; // Extract the search query from the command
+    if (!query) {
+        return bot.sendMessage(
+            chatId,
+            "❌ Please provide a search query.\n\n*Usage:* `/song <song title>`\n*Example:* `/song faded`",
+            { parse_mode: "Markdown" }
+        );
+    }
+    bot.sendMessage(chatId, "🔍 Searching for songs on Spotify... Please wait.");
+    try {
+        // Call the Spotify Search API
+        const searchResponse = await axios.get(`https://api.giftedtech.my.id/api/search/spotifysearch`, {
+            params: { apikey: "gifted", query: query }
+        });
+        if (searchResponse.status === 200 && searchResponse.data.success && searchResponse.data.results.length > 0) {
+            const results = searchResponse.data.results;
+            // Create inline keyboard buttons for the search results
+            const buttons = results.slice(0, 10).map((item) => [
+                { text: `${item.title} - ${item.artist}`, callback_data: `song_${item.id}` }
+            ]);
+            bot.sendMessage(chatId, "🎶 Select a song to download:", {
+                reply_markup: {
+                    inline_keyboard: buttons
+                }
+            });
+        } else {
+            bot.sendMessage(chatId, "❌ No songs found. Please try a different query.");
+        }
+    } catch (error) {
+        console.error("Error in /song command:");
+        bot.sendMessage(chatId, `⚠️ An error occurred:\n\n*Message:*`, { parse_mode: "Markdown" });
+    }
+});
+// Handle button clicks for song selection
+bot.on("callback_query", async (callbackQuery) => {
+    const chatId = callbackQuery.message.chat.id;
+    const data = callbackQuery.data;
+    if (data.startsWith("song_")) {
+        const trackId = data.split("_")[1];
+        bot.sendMessage(chatId, "🔄 Downloading your song... Please wait.");
+        try {
+            // Call the Spotify Download API
+            const downloadResponse = await axios.get(`https://api.giftedtech.my.id/api/download/spotifydl`, {
+                params: { apikey: "gifted", url: `https://open.spotify.com/track/${trackId}` }
+            });
+            if (downloadResponse.status === 200 && downloadResponse.data.success) {
+                const track = downloadResponse.data.result;
+                // Send the audio file
+                await bot.sendAudio(chatId, track.download_url, {
+                    caption: `🔹 *Title:* ${track.title}\n` +
+                             `⏱️ *Duration:* ${track.duration}\n` +
+                             `🎧 *Quality:* ${track.quality}\n\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+                    parse_mode: "Markdown",
+                    thumb: track.thumbnail // Optional: Thumbnail as album art
+                });
+            } else {
+                bot.sendMessage(chatId, "❌ Failed to download the song. Please try again.");
+            }
+        } catch (error) {
+            console.error("Error during song download:");
+            bot.sendMessage(chatId, `⚠️ An error occurred:\n\n*Message:*`, { parse_mode: "Markdown" });
+        }
+    }
+});
+// /facebook command
+bot.onText(/\/(facebook|fb|fbdl|fbdownload)(?: (.+))?/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const text = match[2]; // Extract the Facebook video link from the command
+    // Guide if no link is provided
+    if (!text) {
+        return bot.sendMessage(chatId, "❌ Please provide a Facebook video link.\nExample: `/fb https://www.facebook.com/reel/1256751708994400?mibextid=rS40aB7S9Ucbxw6v`");
+    }
+    // Notify user of processing
+    bot.sendMessage(chatId, "🔄 Fetching your Facebook video... Please wait.");
+    try {
+        // Fetch video data using the new API
+        const apiResponse = await axios.get('https://bk9.fun/download/fb', {
+            params: { url: text },
+        });
+        const responseData = apiResponse.data;
+        // Check if the API response is valid
+        if (responseData.status && responseData.BK9) {
+            const videoData = responseData.BK9;
+            const hdLink = videoData.hd || videoData.sd; // Use HD link if available, fallback to SD
+            const videoTitle = videoData.title || "Facebook Video";
+            // Send the video file directly
+            await bot.sendVideo(chatId, hdLink, {
+                caption: `ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ`,
+                parse_mode: 'Markdown',
+            });
+        } else {
+            bot.sendMessage(chatId, "❌ Failed to fetch the video. Please check the link and try again.");
+        }
+    } catch (error) {
+        console.error("Error in Facebook Downloader:");
+        bot.sendMessage(chatId, "❌ An error occurred while processing your request. Please try again later.");
+    }
+});
+// Temporary storage for mapping callback data to URLs
+const twitterDownloadLinks = new Map();
+bot.onText(/\/twitter (.+)/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const twitterUrl = match[1]?.trim();
+    // Validate input
+    if (!twitterUrl || !twitterUrl.startsWith("http")) {
+        return bot.sendMessage(chatId, "❌ Please provide a valid Twitter link.\nExample: `/twitter https://x.com/elonmusk/status/1870904082564555012`");
+    }
+    // Notify user of processing
+    bot.sendMessage(chatId, "🔄 Fetching Twitter media... Please wait.");
+    try {
+        // Fetch data from the API
+        const apiUrl = `https://api.paxsenix.biz.id/dl/twitter?url=${encodeURIComponent(twitterUrl)}`;
+        const response = await axios.get(apiUrl);
+        const data = response.data;
+        // Check if API returned valid data
+        if (!data.ok) {
+            return bot.sendMessage(chatId, "❌ Failed to fetch Twitter media. Please check the link and try again.");
+        }
+        // Generate unique identifiers for the buttons
+        const uniqueIdHD = `HD_${Date.now()}`;
+        const uniqueIdSD = `SD_${Date.now()}`;
+        const uniqueIdAudio = `Audio_${Date.now()}`;
+        // Store URLs in the mapping
+        if (data.HD) twitterDownloadLinks.set(uniqueIdHD, data.HD);
+        if (data.SD) twitterDownloadLinks.set(uniqueIdSD, data.SD);
+        if (data.audio) twitterDownloadLinks.set(uniqueIdAudio, data.audio);
+        // Inline keyboard for video quality selection
+        const inlineKeyboard = [];
+        if (data.HD) inlineKeyboard.push([{ text: "HD Video", callback_data: uniqueIdHD }]);
+        if (data.SD) inlineKeyboard.push([{ text: "SD Video", callback_data: uniqueIdSD }]);
+        if (data.audio) inlineKeyboard.push([{ text: "Audio Only", callback_data: uniqueIdAudio }]);
+        // Send preview with inline buttons
+        await bot.sendPhoto(chatId, data.thumb, {
+            caption: `🌟 *ATOMIC TWITTER DOWNLOADER!*\n\n🎉 *ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*\n\nSelect the desired quality below:`,
+            parse_mode: "Markdown",
+            reply_markup: {
+                inline_keyboard: inlineKeyboard,
+            },
+        });
+    } catch (error) {
+        console.error("Error in Twitter Downloader:");
+        bot.sendMessage(chatId, "❌ An error occurred while processing your request. Please try again later.");
+    }
+});
+// Handle callback queries for Twitter downloads
+bot.on("callback_query", async (callbackQuery) => {
+    const chatId = callbackQuery.message.chat.id;
+    const data = callbackQuery.data;
+    // Check if the callback data exists in the mapping
+    const url = twitterDownloadLinks.get(data);
+    if (url) {
+        // Notify user that the download is in progress
+        await bot.sendMessage(chatId, "📥 Downloading your media...");
+        try {
+            // Determine the type based on the callback data
+            if (data.startsWith("HD") || data.startsWith("SD")) {
+                await bot.sendVideo(chatId, url, { caption: `🎬ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ` });
+            } else if (data.startsWith("Audio")) {
+                await bot.sendAudio(chatId, url, { caption: "🎵 ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ!" });
+            }
+            // Remove the mapping after successful download
+            twitterDownloadLinks.delete(data);
+        } catch (error) {
+            console.error(`Error sending media:`);
+            await bot.sendMessage(chatId, "❌ Failed to send the requested media. Please try again later.");
+        }
+    } else {
+        bot.sendMessage(chatId, "");
+    }
+    // Acknowledge the callback query to avoid timeout
+    bot.answerCallbackQuery(callbackQuery.id);
+});
+// /instagram command
+bot.onText(/\/(instagram|ig|igvideo|igimage|igdownload|instadl)(?: (.+))?/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const text = match[2]; // Extract the Instagram URL from the command
+    // Guide if no link is provided
+    if (!text || !text.startsWith('http')) {
+        return bot.sendMessage(chatId, "❌ Please provide a valid Instagram link.\nExample: `/instagram https://www.instagram.com/reel/DDgvfkAuBMI/`");
+    }
+    // Notify user of processing
+    bot.sendMessage(chatId, "🔄 Fetching your Instagram media... Please wait.");
+    try {
+        // Fetch Instagram media data using the API
+        const apiResponse = await axios.get('https://api.paxsenix.biz.id/dl/ig', {
+            params: { url: text },
+        });
+        const responseData = apiResponse.data;
+        // Check if the API response is valid
+        if (responseData.ok && responseData.url && responseData.url.length > 0) {
+            const media = responseData.url[0]; // Assume the first item is the main media
+            const mediaUrl = media.url;
+            const mediaType = media.type || "video"; // Default to video
+            if (mediaType === "video") {
+                // Send the video
+                await bot.sendVideo(chatId, mediaUrl, {
+                    caption: `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+                    parse_mode: "Markdown",
+                });
+            } else {
+                // Send the image
+                await bot.sendPhoto(chatId, mediaUrl, {
+                    caption: `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+                    parse_mode: "Markdown",
+                });
+            }
+        } else {
+            bot.sendMessage(chatId, "❌ Failed to fetch media. Please check the link and try again.");
+        }
+    } catch (error) {
+        console.error("Error in Instagram Downloader:");
+        bot.sendMessage(chatId, "❌ An error occurred while processing your request. Please try again later.");
+    }
+});
+// Anti-link command
+// Anti-link toggle commands (Admins only)
+bot.onText(/\/antilink (on|off)/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const userId = msg.from.id;
+    const action = match[1];
+    // Check if the user is an admin
+    if (await isAdmin(chatId, userId)) {
+        if (action === 'on') {
+            antiLinkActive = true;
+            bot.sendMessage(chatId, "Anti-link is now activated!");
+        } else if (action === 'off') {
+            antiLinkActive = false;
+            bot.sendMessage(chatId, "Anti-link is now deactivated!");
+        }
+    } else {
+        bot.sendMessage(chatId, "You don't have permission to use this command.");
+    }
+});
+bot.onText(/\/xvideodownload (.+)?/, async (msg, match) => {
+  const chatId = msg.chat.id;
+  const input = match[1]?.trim(); // Get the user-provided URL (if any)
+  // Check for the last stored video URL or input
+  const url = input || (global.db?.data?.users?.[msg.from.id]?.lastVideoUrl);
+  if (!url) {
+    return bot.sendMessage(chatId, "❌ *No video URL found!*\nPlease provide a valid video link or use `/videosearch` first.", {
+      parse_mode: "Markdown",
+    });
+  }
+  try {
+    // Step 1: Call the video download API
+    const apiUrl = `https://api.agatz.xyz/api/xvideodown?url=${encodeURIComponent(url)}`;
+    const response = await axios.get(apiUrl);
+    const result = response.data;
+    // Step 2: Check if the API returned a valid response
+    if (result.status === 200 && result.data?.url) {
+      const videoStreamUrl = result.data.url;
+      // Step 3: Download the video content
+      const videoResponse = await axios({
+        url: videoStreamUrl,
+        method: 'GET',
+        responseType: 'stream',
+      });
+      // Step 4: Send the video to the user
+      const videoInfo = result.data;
+      const body = `🎥 *Video Details:*\n\n` +
+                   `🔤 *Title:* ${videoInfo.title}\n` +
+                   `👀 *Views:* ${videoInfo.views}\n` +
+                   `👍 *Likes:* ${videoInfo.like_count}\n` +
+                   `👎 *Dislikes:* ${videoInfo.dislike_count}\n` +
+                   `⭐ *Votes:* ${videoInfo.vote}\n` +
+                   `🔗 *Source:* [Watch Original Video](${url})\n\n` +
+                   `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ™*`;
+      await bot.sendMessage(chatId, body, { parse_mode: "Markdown" });
+      bot.sendVideo(chatId, videoResponse.data, {
+        caption: `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+        parse_mode: "Markdown",
+      });
+    } else {
+      bot.sendMessage(chatId, "❌ Failed to fetch the video. Please try again later.");
+    }
+  } catch (error) {
+    console.error("Video Download Error:");
+    bot.sendMessage(chatId, "❌ An error occurred while downloading the video. Please try again.");
+  }
+});
+bot.onText(/\/videodownload (.+)?/, async (msg, match) => {
+  const chatId = msg.chat.id;
+  const input = match[1]?.trim(); // Get the user-provided URL (if any)
+  // Check for the last stored video URL or input
+  const url = input || (global.db?.data?.users?.[msg.from.id]?.lastVideoUrl);
+  if (!url) {
+    return bot.sendMessage(chatId, "❌ *No video URL found!*\nPlease provide a valid video link or use `/xvideosearch` first.", {
+      parse_mode: "Markdown",
+    });
+  }
+  try {
+    // Step 1: Call the video download API
+    const apiUrl = `https://api.agatz.xyz/api/xvideodown?url=${encodeURIComponent(url)}`;
+    const response = await axios.get(apiUrl);
+    const result = response.data;
+    // Step 2: Check if the API returned a valid response
+    if (result.status === 200 && result.data?.url) {
+      const videoInfo = result.data;
+      const videoUrl = videoInfo.url;
+      // Step 3: Prepare the video details for the user
+      const body = `🎥 *Video Details:*\n\n` +
+                   `🔤 *Title:* ${videoInfo.title}\n` +
+                   `👀 *Views:* ${videoInfo.views}\n` +
+                   `👍 *Likes:* ${videoInfo.like_count}\n` +
+                   `👎 *Dislikes:* ${videoInfo.dislike_count}\n` +
+                   `⭐ *Votes:* ${videoInfo.vote}\n` +
+                   `🔗 *URL:* [Watch Original Video](${url})\n\n` +
+                   `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`;
+      // Step 4: Send the video thumbnail and downloadable video to the user
+      await bot.sendPhoto(chatId, videoInfo.thumb, {
+        caption: body,
+        parse_mode: "Markdown",
+      });
+      await bot.sendVideo(chatId, videoUrl, {
+        caption: `*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+        parse_mode: "Markdown",
+      });
+    } else {
+      bot.sendMessage(chatId, "❌ Failed to fetch the video. Please try again later.");
+    }
+  } catch (error) {
+    console.error("Video Download Error:");
+    bot.sendMessage(chatId, "❌ An error occurred while downloading the video. Please try again.");
+  }
+});
+const { randomUUID } = require("crypto");
+// /text2speech command
+bot.onText(/\/text2speech (.+)/, async (msg, match) => {
+  const chatId = msg.chat.id;
+  const input = match[1].trim();
+  if (!input) {
+    return bot.sendMessage(chatId, "❌ *Please provide text to convert to speech!*\nExample: `/text2speech Hello world | en`", {
+      parse_mode: "Markdown",
+    });
+  }
+  try {
+    // Split input into text and optional language code
+    const [text, lang] = input.split("|").map((item) => item.trim());
+    const language = lang || "en"; // Default to 'en' if no language provided
+    if (!text) {
+      return bot.sendMessage(chatId, "❌ *Please provide valid text for the speech conversion.*", {
+        parse_mode: "Markdown",
+      });
+    }
+    const encodedText = encodeURIComponent(text);
+    const apiUrl = `https://bk9.fun/tools/tts?q=${encodedText}&lang=${language}`;
+    // Step 1: Fetch the audio file
+    const response = await axios({
+      method: "GET",
+      url: apiUrl,
+      responseType: "stream",
+    });
+    // Generate a random filename for the audio
+    const fileName = `${randomUUID()}.mp3`;
+    const filePath = `./${fileName}`;
+    // Step 2: Save the audio stream to a file
+    const writer = fs.createWriteStream(filePath);
+    response.data.pipe(writer);
+    writer.on("finish", async () => {
+      try {
+        // Step 3: Send the audio file to the user
+        await bot.sendAudio(chatId, filePath, {
+          caption: `🎙️ *Text-to-Speech Result*\n🌐 *Language:* ${language.toUpperCase()}`,
+          parse_mode: "Markdown",
+        });
+        // Cleanup: Delete the temporary file
+        fs.unlinkSync(filePath);
+        console.log(`Temporary file ${fileName} deleted successfully.`);
+      } catch (sendError) {
+        console.error("Error sending TTS file:");
+        bot.sendMessage(chatId, "❌ Failed to send the generated audio file.");
+        if (fs.existsSync(filePath)) fs.unlinkSync(filePath); // Ensure cleanup
+      }
+    });
+    writer.on("error", (error) => {
+      console.error("Error saving TTS file:");
+      bot.sendMessage(chatId, "❌ Failed to generate or send the audio.");
+    });
+  } catch (error) {
+    console.error("TTS Error:");
+    bot.sendMessage(chatId, "❌ An error occurred while generating speech. Please try again.");
+  }
+});
+// /dog command
+bot.onText(/\/dog/, async (msg) => {
+    const chatId = msg.chat.id;
+    try {
+        const response = await axios.get('https://dog.ceo/api/breeds/image/random');
+        const dogUrl = response.data.message;
+        bot.sendPhoto(chatId, dogUrl);
+    } catch (error) {
+        bot.sendMessage(chatId, 'Could not fetch a dog picture at the moment. Please try again later.');
+    }
+});
+// Function to get currency conversion rate from ExchangeRate-API
+async function getCurrencyConversion(amount, fromCurrency, toCurrency) {
+  try {
+    // Request currency conversion data from ExchangeRate-API
+    const response = await axios.get(`https://v6.exchangerate-api.com/v6/${apiKey}/latest/${fromCurrency}`);
+    const rates = response.data.conversion_rates;
+    const conversionRate = rates[toCurrency];
+    if (conversionRate) {
+      const convertedAmount = (amount * conversionRate).toFixed(2);
+      return `${amount} ${fromCurrency} = ${convertedAmount} ${toCurrency}`;
+    } else {
+      return `Sorry, I couldn't find the conversion rate for ${toCurrency}.`;
+    }
+  } catch (error) {
+    console.error('Error fetching currency conversion:');
+    return 'Oops! Something went wrong. Please try again later.';
+  }
+}
+// Command handler for /currency
+bot.onText(/\/currency (\d+\.?\d*) (\w+) to (\w+)/, async (msg, match) => {
+  const chatId = msg.chat.id;
+  const amount = parseFloat(match[1]);
+  const fromCurrency = match[2].toUpperCase();
+  const toCurrency = match[3].toUpperCase();
+  // Validate the amount
+  if (isNaN(amount) || amount <= 0) {
+    bot.sendMessage(chatId, 'Please provide a valid amount to convert. Example: /currency 100 USD to EUR');
+    return;
+  }
+  const conversionResult = await getCurrencyConversion(amount, fromCurrency, toCurrency);
+  bot.sendMessage(chatId, conversionResult);
+});
+// Flag to indicate when an admin has issued /setgrouppic
+let awaitingGroupPic = new Map();
+// /setgrouppic command (admins only)
+bot.onText(/\/setgrouppic/, async (msg) => {
+    const chatId = msg.chat.id;
+    const userId = msg.from.id;
+    if (msg.chat.type !== 'group' && msg.chat.type !== 'supergroup') {
+        bot.sendMessage(chatId, 'This command can only be used in group chats.');
+        return;
+    }
+    // Check if the user is an admin
+    if (await isAdmin(chatId, userId)) {
+        bot.sendMessage(chatId, 'Please send the new group picture as a photo.');
+        awaitingGroupPic.set(chatId, userId); // Track the admin who issued the command
+    } else {
+        bot.sendMessage(chatId, "You don't have permission to use this command.");
+    }
+});
+// Handle photo uploads for /setgrouppic
+bot.on('photo', async (msg) => {
+    const chatId = msg.chat.id;
+    const userId = msg.from.id;
+    // Check if we are awaiting a photo from an admin
+    if (awaitingGroupPic.get(chatId) === userId) {
+        const photoId = msg.photo[msg.photo.length - 1].file_id;
+        try {
+            const file = await bot.getFile(photoId);
+            const downloadPath = await bot.downloadFile(photoId, './');
+            await bot.setChatPhoto(chatId, fs.createReadStream(downloadPath));
+            bot.sendMessage(chatId, 'Group picture updated successfully!');
+            // Clean up
+            fs.unlinkSync(downloadPath);
+            awaitingGroupPic.delete(chatId); // Remove the flag after setting the picture
+        } catch (error) {
+            console.error('Error:');
+            bot.sendMessage(chatId, 'Failed to update group picture. Make sure I have the required permissions.');
+        }
+    }
+});
+// Kick command
+bot.onText(/\/kick/, async (msg) => {
+    const chatId = msg.chat.id;
+    if (msg.reply_to_message) {
+        const userId = msg.reply_to_message.from.id; // User to kick must be mentioned in reply
+        const requesterId = msg.from.id; // ID of the person issuing the command
+        if (await isAdmin(chatId, requesterId)) {
+            try {
+                await bot.kickChatMember(chatId, userId);
+                bot.sendMessage(chatId, "User has been kicked.");
+                // Optionally, unban the user immediately to allow them to rejoin if necessary
+                setTimeout(() => {
+                    bot.unbanChatMember(chatId, userId);
+                }, 1000);
+            } catch (err) {
+                console.error("Failed to kick user:");
+                bot.sendMessage(chatId, "Failed to kick user. Ensure I have appropriate permissions.");
+            }
+        } else {
+            bot.sendMessage(chatId, "You don't have permission to use this command.");
+        }
+    } else {
+        bot.sendMessage(chatId, "Please reply to a user's message to kick them.");
+    }
+});
+// Mute command
+// Mute command
+bot.onText(/\/mute/, async (msg) => {
+    const chatId = msg.chat.id;
+    const requesterId = msg.from.id;
+    // Check if the user issuing the command is an admin
+    if (await isAdmin(chatId, requesterId)) {
+        if (msg.reply_to_message) {
+            const userId = msg.reply_to_message.from.id; // User to mute must be mentioned in reply
+            mutedUsers.add(userId);
+            bot.sendMessage(chatId, `User has been muted.`);
+        } else {
+            bot.sendMessage(chatId, "Please reply to a user's message to mute them.");
+        }
+    } else {
+        bot.sendMessage(chatId, "You don't have permission to use this command.");
+    }
+});
+// Function to get anime details from Jikan API
+async function getAnimeInfo(animeName) {
+  try {
+    const response = await axios.get(`https://api.jikan.moe/v4/anime?q=${animeName}&limit=1`);
+    const anime = response.data.data[0];
+    if (anime) {
+      const title = anime.title;
+      const synopsis = anime.synopsis;
+      const rating = anime.rating;
+      const imageUrl = anime.images.jpg.image_url;
+      const url = anime.url;
+      return {
+        info: `*${title}*\n\n${synopsis}\n\n*Rating:* ${rating}\n\n[More Info](${url})`,
+        imageUrl: imageUrl,
+      };
+    } else {
+      return { info: 'No anime found with that name.', imageUrl: null };
+    }
+  } catch (error) {
+    console.error('Error fetching anime info:');
+    return { info: 'Oops! Something went wrong.', imageUrl: null };
+  }
+}
+// Command handler for /anime
+bot.onText(/\/anime (.+)/, async (msg, match) => {
+  const chatId = msg.chat.id;
+  const animeName = match[1];
+  const { info, imageUrl } = await getAnimeInfo(animeName);
+  // Send the information as a message
+  bot.sendMessage(chatId, info, { parse_mode: 'Markdown' });
+  // If an image URL is available, send the image
+  if (imageUrl) {
+    bot.sendPhoto(chatId, imageUrl);
+  }
+});
+// Unmute command
+bot.onText(/\/unmute/, (msg) => {
+    const chatId = msg.chat.id;
+    if (msg.reply_to_message) {
+        const userId = msg.reply_to_message.from.id; // User to unmute must be mentioned in reply
+        mutedUsers.delete(userId);
+        bot.sendMessage(chatId, `User has been unmuted.`);
+    } else {
+        bot.sendMessage(chatId, "Please reply to a user's message to unmute them.");
+    }
+});
+// Promote command
+bot.onText(/\/promote/, async (msg) => {
+    const chatId = msg.chat.id;
+    if (msg.reply_to_message) {
+        const userId = msg.reply_to_message.from.id; // User to promote must be mentioned in reply
+        if (await isAdmin(chatId, msg.from.id)) {
+            try {
+                await bot.promoteChatMember(chatId, userId, {
+                    can_change_info: true,
+                    can_post_messages: true,
+                    can_edit_messages: true,
+                    can_delete_messages: true,
+                    can_invite_users: true,
+                    can_restrict_members: true,
+                    can_pin_messages: true,
+                    can_promote_members: true
+                });
+                bot.sendMessage(chatId, "User has been promoted to admin.");
+            } catch (err) {
+                bot.sendMessage(chatId, "Failed to promote user.");
+            }
+        } else {
+            bot.sendMessage(chatId, "You don't have permission to use this command.");
+        }
+    } else {
+        bot.sendMessage(chatId, "Please reply to a user's message to promote them.");
+    }
+});
+// Demote command
+bot.onText(/\/demote/, async (msg) => {
+    const chatId = msg.chat.id;
+    if (msg.reply_to_message) {
+        const userId = msg.reply_to_message.from.id; // User to demote must be mentioned in reply
+        if (await isAdmin(chatId, msg.from.id)) {
+            try {
+                await bot.promoteChatMember(chatId, userId, {
+                    can_change_info: false,
+                    can_post_messages: false,
+                    can_edit_messages: false,
+                    can_delete_messages: false,
+                    can_invite_users: false,
+                    can_restrict_members: false,
+                    can_pin_messages: false,
+                    can_promote_members: false
+                });
+                bot.sendMessage(chatId, "User has been demoted.");
+            } catch (err) {
+                bot.sendMessage(chatId, "Failed to demote user.");
+            }
+        } else {
+            bot.sendMessage(chatId, "You don't have permission to use this command.");
+        }
+    } else {
+        bot.sendMessage(chatId, "Please reply to a user's message to demote them.");
+    }
+});
+// Set name command
+bot.onText(/\/setname (.+)/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const newName = match[1];
+    if (await isAdmin(chatId, msg.from.id)) {
+        try {
+            await bot.setChatTitle(chatId, newName);
+            bot.sendMessage(chatId, `Group name has been changed to "${newName}".`);
+        } catch (err) {
+            bot.sendMessage(chatId, "Failed to change group name.");
+        }
+    } else {
+        bot.sendMessage(chatId, "You don't have permission to use this command.");
+    }
+});
+// /meme command
+bot.onText(/\/meme/, async (msg) => {
+    const chatId = msg.chat.id;
+    try {
+        const response = await axios.get('https://meme-api.herokuapp.com/gimme');
+        const memeUrl = response.data.url;
+        bot.sendPhoto(chatId, memeUrl);
+    } catch (error) {
+        bot.sendMessage(chatId, 'Could not retrieve a meme at the moment. Please try again later.');
+    }
+});
+// /joke command
+bot.onText(/\/joke/, async (msg) => {
+    const chatId = msg.chat.id;
+    try {
+        const response = await axios.get('https://official-joke-api.appspot.com/random_joke');
+        const joke = `${response.data.setup} - ${response.data.punchline}`;
+        bot.sendMessage(chatId, joke);
+    } catch (error) {
+        bot.sendMessage(chatId, 'Failed to fetch a joke. Please try again later.');
+    }
+});
+// /text2pdf command
+bot.onText(/\/text2pdf (.+)/, async (msg, match) => {
+  const chatId = msg.chat.id;
+  const inputText = match[1].trim();
+  if (!inputText) {
+    return bot.sendMessage(
+      chatId,
+      "❌ *Please provide the text to convert into a PDF!*\nExample: `/text2pdf Hello, this is a test.`",
+      { parse_mode: "Markdown" }
+    );
+  }
+  try {
+    // Encode the text to be sent in the URL
+    const encodedText = encodeURIComponent(inputText);
+    const pdfUrl = `https://bk9.fun/tools/pdf?q=${encodedText}`;
+    // Step 1: Fetch the PDF file
+    const response = await axios({
+      method: "GET",
+      url: pdfUrl,
+      responseType: "stream",
+    });
+    // Generate a random file name for the PDF
+    const fileName = `document_${Date.now()}.pdf`;
+    const filePath = `./${fileName}`;
+    // Step 2: Save the PDF stream to a file
+    const writer = require("fs").createWriteStream(filePath);
+    response.data.pipe(writer);
+    writer.on("finish", async () => {
+      // Step 3: Send the PDF file to the user
+      await bot.sendDocument(chatId, filePath, {
+        caption: `✅ Your PDF file has been generated successfully!\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+        parse_mode: "Markdown",
+      });
+      // Cleanup: Delete the temporary file
+      require("fs").unlinkSync(filePath);
+      console.log(`Temporary file ${fileName} deleted successfully.`);
+    });
+    writer.on("error", (error) => {
+      console.error("Error saving PDF file:");
+      bot.sendMessage(chatId, "❌ Failed to generate or send the PDF file.");
+    });
+  } catch (error) {
+    console.error("PDF Generation Error:");
+    bot.sendMessage(chatId, "❌ An error occurred while generating the PDF. Please try again.");
+  }
+});
+bot.onText(/\/xvideosearch (.+)/, async (msg, match) => {
+  const chatId = msg.chat.id;
+  const query = match[1].trim();
+  if (!query) {
+    return bot.sendMessage(chatId, "❌ *Please provide a search query!*\nExample: `/xvideosearch step sister`", {
+      parse_mode: "Markdown",
+    });
+  }
+  try {
+    // Step 1: Call the video search API
+    const apiUrl = `https://api.agatz.xyz/api/xvideo?message=${encodeURIComponent(query)}`;
+    const response = await axios.get(apiUrl);
+    const result = response.data;
+    // Step 2: Check if results exist
+    if (result.status === 200 && result.data.length > 0) {
+      const videoInfo = result.data[0]; // Get the first video result
+      // Step 3: Prepare the message body
+      const body = `🎥 *Video Search Result:*\n\n` +
+                   `🔤 *Title:* ${videoInfo.title}\n` +
+                   `⏱️ *Duration:* ${videoInfo.duration}\n\nᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ`;
+      // Step 4: Add an inline keyboard button with the video link
+      const options = {
+        parse_mode: "Markdown",
+        reply_markup: {
+          inline_keyboard: [
+            [
+              {
+                text: "🔗 Watch Video",
+                url: videoInfo.url,
+              },
+            ],
+          ],
+        },
+      };
+      // Step 5: Send the video thumbnail and details to the user with the button
+      await bot.sendPhoto(chatId, videoInfo.thumb, {
+        caption: body,
+        ...options,
+      });
+    } else {
+      bot.sendMessage(chatId, "❌ No results found. Please try a different query.");
+    }
+  } catch (error) {
+    console.error("Video Search Error:");
+    bot.sendMessage(chatId, "❌ An error occurred while fetching the search results. Please try again.");
+  }
+});
+// Tag all command
+bot.onText(/\/tagall/, async (msg) => {
+    const chatId = msg.chat.id;
+    if (await isAdmin(chatId, msg.from.id)) {
+        const members = await bot.getChatAdministrators(chatId);
+        const memberMentions = members.map(member => {
+            return member.user.username ? `@${member.user.username}` : member.user.first_name;
+        }).join(', ');
+        bot.sendMessage(chatId, `Tagging all members:\n${memberMentions}`);
+    } else {
+        bot.sendMessage(chatId, "You don't have permission to use this command.");
+    }
+});
+// Define the /Aza command
+bot.onText(/\/support/, (msg) => {
+    const chatId = msg.chat.id;
+    const response = "9066528353 OPAY 🇳🇬\nPlease support Developer.";
+    // Send the message
+    bot.sendMessage(chatId, response);
+});
+// Define the /owner command
+bot.onText(/\/owner/, (msg) => {
+    const chatId = msg.chat.id;
+    const response = "@deecee_x";
+    // Send the message
+    bot.sendMessage(chatId, response);
+});
+// /setdescription command
+bot.onText(/\/setdescription (.+)/, (msg, match) => {
+  const chatId = msg.chat.id;
+  const description = match[1];
+  if (msg.chat.type !== 'group' && msg.chat.type !== 'supergroup') {
+    bot.sendMessage(chatId, 'This command can only be used in group chats.');
+    return;
+  }
+  // Check if the user is an admin
+  bot.getChatMember(chatId, msg.from.id).then(member => {
+    if (member.status === 'administrator' || member.status === 'creator') {
+      bot.setChatDescription(chatId, description)
+        .then(() => {
+          bot.sendMessage(chatId, 'Group description updated successfully!');
+        })
+        .catch((error) => {
+          console.error('Error:');
+          bot.sendMessage(chatId, 'Failed to update group description. Make sure I have the required permissions.');
+        });
+    } else {
+      bot.sendMessage(chatId, 'Only group admins can use this command.');
+    }
+  }).catch(error => {
+    console.error('Error fetching chat member:');
+    bot.sendMessage(chatId, 'An error occurred while verifying your admin status.');
+  });
+});
+// Get link command
+bot.onText(/\/getlink/, async (msg) => {
+    const chatId = msg.chat.id;
+    if (await isAdmin(chatId, msg.from.id)) {
+        try {
+            const link = await bot.exportChatInviteLink(chatId);
+            bot.sendMessage(chatId, `Here is your invite link: ${link}`);
+        } catch (err) {
+            bot.sendMessage(chatId, "Failed to get the invite link.");
+        }
+    } else {
+        bot.sendMessage(chatId, "You don't have permission to use this command.");
+    }
+});
+// Welcome and goodbye messages
+bot.on('new_chat_members', (msg) => {
+    const chatId = msg.chat.id;
+    msg.new_chat_members.forEach(user => {
+        bot.sendMessage(chatId, `Welcome ${user.first_name} to the group!`);
+    });
+});
+bot.on('left_chat_member', (msg) => {
+    const chatId = msg.chat.id;
+    const user = msg.left_chat_member;
+    bot.sendMessage(chatId, `${user.first_name} has left the group.`);
+});
+// Anti-link functionality
+bot.on('message', (msg) => {
+    const chatId = msg.chat.id;
+    // Check if anti-link is active
+    if (antiLinkActive && msg.entities) {
+        msg.entities.forEach(entity => {
+            if (entity.type === "url") {
+                bot.deleteMessage(chatId, msg.message_id)
+                    .then(() => {
+                        bot.sendMessage(chatId, "Links are not allowed in this group.");
+                    })
+                    .catch(err => {
+                        console.error("Failed to delete message:");
+                    });
+            }
+        });
+    }
+    // Mute functionality
+    if (mutedUsers.has(msg.from.id)) {
+        bot.deleteMessage(chatId, msg.message_id)
+            .catch(err => {
+                console.error("Failed to delete muted user message:");
+            });
+    }
+});
+bot.onText(/\/txt2image (.+)/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const prompt = match[1]; // Extract the prompt from the command
+    // Check if the user provided a prompt
+    if (!prompt) {
+        return bot.sendMessage(chatId, "❌ *Please provide a prompt!* \n\nUsage: `/magicstudio <prompt>`", { parse_mode: "Markdown" });
+    }
+    try {
+        // Inform the user the process has started
+        await bot.sendMessage(chatId, "✨ *Generating image... Please wait!*", { parse_mode: "Markdown" });
+        // API URL to generate the image
+        const apiUrl = `https://bk9.fun/ai/magicstudio?prompt=${encodeURIComponent(prompt)}`;
+        // Fetch the generated image from the API
+        const response = await axios.get(apiUrl, { responseType: "stream" });
+        // Send the image back to the user
+        await bot.sendPhoto(chatId, response.data, {
+            caption: `🖼️ *Here's your generated image for:* \`${prompt}\`\n\nᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ`,
+            parse_mode: "Markdown"
+        });
+    } catch (error) {
+        console.error("Error generating image:");
+        bot.sendMessage(chatId, "❌ *Failed to generate the image. Please try again later!*", { parse_mode: "Markdown" });
+    }
+});
+bot.onText(/\/flux(?: (.+))?/, async (msg, match) => {
+    const chatId = msg.chat.id;
+    const prompt = match[1]; // Extract the user's prompt from the command
+    if (!prompt) {
+        // If no prompt is provided, send a usage guide
+        return bot.sendMessage(chatId, "❌ Please provide a prompt to generate an image.\n\nExample: `/flux cat`", { parse_mode: "Markdown" });
+    }
+    bot.sendMessage(chatId, "🔄 Generating your image... Please wait.");
+    try {
+        // Call the Flux API to generate the image
+        const apiUrl = `https://apis.davidcyriltech.my.id/flux?prompt=${encodeURIComponent(prompt)}`;
+        // Send the generated image to the user
+        await bot.sendPhoto(chatId, apiUrl, {
+            caption: `✨ *Flux Image Generated*\n\n🔹 *Prompt:* ${prompt}\n*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*`,
+            parse_mode: "Markdown",
+        });
+    } catch (error) {
+        console.error("Error during /flux command:");
+        bot.sendMessage(chatId, "❌ An error occurred while generating the image. Please try again later.");
+    }
+});
+const { shannzCdn } = require("./uploader"); // Import new uploader module
+bot.on("message", async (msg) => {
+  const chatId = msg.chat.id;
+  const text = msg.text?.trim().toLowerCase();
+  if (text === "remini" && msg.reply_to_message?.photo) {
+    try {
+      await bot.sendMessage(chatId, "⏳ Processing your image...");
+      // Step 1: Download Image from Telegram
+      const fileId = msg.reply_to_message.photo[msg.reply_to_message.photo.length - 1].file_id;
+      const file = await bot.getFile(fileId);
+      const fileUrl = `https://api.telegram.org/file/bot${process.env.BOT_TOKEN}/${file.file_path}`;
+      const localFilePath = path.join(__dirname, "downloads", `${fileId}.jpg`);
+      const writer = fs.createWriteStream(localFilePath);
+      const imageResponse = await axios({ url: fileUrl, method: "GET", responseType: "stream" });
+      imageResponse.data.pipe(writer);
+      await new Promise((resolve, reject) => {
+        writer.on("finish", resolve);
+        writer.on("error", reject);
+      });
+      // Step 2: Upload Image to Shannz CDN
+      const uploadResponse = await shannzCdn(localFilePath);
+      console.log("Shannz CDN Response:", uploadResponse);
+      if (!uploadResponse || !uploadResponse.url) {
+        fs.unlinkSync(localFilePath);
+        return bot.sendMessage(chatId, "❌ Failed to upload the image. Please try again.");
+      }
+      const imageUrl = uploadResponse.url;
+      console.log("Uploaded Image URL:", imageUrl);
+      // Step 3: Send Image to Remini API
+      const enhanceUrl = `https://bk9.fun/tools/enhance?url=${encodeURIComponent(imageUrl)}`;
+      console.log("Enhancement API URL:", enhanceUrl);
+      // Step 4: Send Enhanced Image to User
+      await bot.sendPhoto(chatId, enhanceUrl, {
+        caption: "✨ *Image Enhanced Successfully!*",
+        parse_mode: "Markdown",
+      });
+      fs.unlinkSync(localFilePath); // Cleanup
+    } catch (error) {
+      console.error("Error enhancing image:");
+      bot.sendMessage(chatId, `❌ Error`);
+    }
+  }
+});
+// Handle /delete Command
+bot.onText(/\/delete/, async (msg) => {
+  const chatId = msg.chat.id;
+  if (msg.reply_to_message) {
+    try {
+      await bot.deleteMessage(chatId, msg.reply_to_message.message_id);
+      await bot.deleteMessage(chatId, msg.message_id);
+    } catch (error) {
+      bot.sendMessage(chatId, "❌ Unable to delete the message. Check my permissions.");
+    }
+  } else {
+    bot.sendMessage(chatId, "❌ Please reply to a message to delete it.");
+  }
+});
+// Delete Message Command
+bot.onText(/\/delete/, async (msg) => {
+  const chatId = msg.chat.id;
+  if (msg.reply_to_message) {
+    const messageId = msg.reply_to_message.message_id;
+    try {
+      // Delete the replied message
+      await bot.deleteMessage(chatId, messageId);
+      // Optionally delete the command message
+      await bot.deleteMessage(chatId, msg.message_id);
+      // Confirmation message
+      await bot.sendMessage(chatId, "✅ Message deleted successfully.", { reply_to_message_id: msg.message_id });
+    } catch (error) {
+      console.error("Delete message error:");
+      bot.sendMessage(
+        chatId,
+        "❌ Failed to delete the message. Ensure I have the necessary permissions.",
+        { reply_to_message_id: msg.message_id }
+      );
+    }
+  } else {
+    bot.sendMessage(chatId, "❌ Please reply to the message you want to delete.", { reply_to_message_id: msg.message_id });
+  }
+});
+// Start the bot
+bot.onText(/\/help/, (msg) => {
+    const chatId = msg.chat.id;
+    bot.sendMessage(chatId, "Hi I Am Atomic! Use /start for available commands.");
+});
+// Store the start time when the bot starts
+const startTime = Date.now();
+// Command to get bot runtime
+bot.onText(/\/runtime/, (msg) => {
+    const chatId = msg.chat.id;
+    // Calculate runtime
+    const uptimeMs = Date.now() - startTime;
+    const uptimeSeconds = Math.floor(uptimeMs / 1000);
+    const hours = Math.floor(uptimeSeconds / 3600);
+    const minutes = Math.floor((uptimeSeconds % 3600) / 60);
+    const seconds = uptimeSeconds % 60;
+    // Send back the bot runtime
+    bot.sendMessage(chatId, `The bot has been running for ${hours} hours, ${minutes} minutes, and ${seconds} seconds.`);
+});
+// /ping command
+bot.onText(/\/ping/, (msg) => {
+  const chatId = msg.chat.id;
+  const start = Date.now(); // Record the start time
+  bot.sendMessage(chatId, 'Pong!').then(() => {
+    const end = Date.now(); // Record the end time
+    const ping = end - start; // Calculate the difference in milliseconds
+    bot.sendMessage(chatId, `Response time: ${ping} ms`);
+  });
+});
+// Unified /start command
+bot.onText(/\/start/, (msg) => {
+    const chatId = msg.chat.id;
+    // First page: Download Commands
+    const helpMessageDownload = `
+*🔥 ATOMIC BOT MENU 🔥*
+⬇️ *Download Commands*:
+- 🎶 /play <song name>: Download and play music from YouTube.
+- 🎶 /song <song name>: Download and play music from Spotify.
+- 🎥 /tiktok <link>: Download TikTok videos.
+- 📸 /instagram <link>: Download Instagram media.
+- 📘 /fb <link>: Download Facebook videos.
+- 🎥 /video <song name>: Download Music Videos.
+- 🎶 /ytmp3 <link>: Download Music Videos.
+- 🎥 /ytmp4 <link>: Download and play music.
+- 📦 /mediafire <link>: Downloads MediaFire Files
+- 📦 /apk <app name>: Downloads Apk.
+- 📦 /gitclone <llnk>: Downloads files from github
+- 🎬 /movie <movie name>: Downloads movies.
+- 🎬 /twitter <link>: Downloads twitter videos.
+`;
+    bot.sendMessage(chatId, helpMessageDownload, {
+        parse_mode: 'Markdown',
+        reply_markup: {
+            inline_keyboard: [
+                [{ text: "➡️ NEXT", callback_data: "help_next_1" }]
+            ]
+        }
+    });
+});
+// Handle button clicks for pagination
+bot.on('callback_query', (query) => {
+    const chatId = query.message.chat.id;
+    // First "NEXT" button (from Download Menu to Admin Commands)
+    if (query.data === "help_next_1") {
+        const helpMessageAdmin = `🤖 *AI Commands*:
+- 🤖 /chatbot <on / off>: Interact with ai models without using any prefix
+- 🤖 /gpt <query>: Get an AI-powered response.
+- 🔊 /text2speech <text>: Convert text to speech.
+- 🪄 /text2image <prompt>: Generates Any Ai Image of your choice.
+- 🪄 /flux <prompt>: Generates Any Realistic Ai Images.
+`;
+        bot.editMessageText(helpMessageAdmin, {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+            reply_markup: {
+                inline_keyboard: [
+                    [
+                        { text: "⬅️ BACK", callback_data: "help_back_0" },
+                        { text: "➡️ NEXT", callback_data: "help_next_2" }
+                    ]
+                ]
+            }
+        });
+    }
+    // Second "NEXT" button (from Admin Commands to AI Menu)
+    if (query.data === "help_next_2") {
+        const helpMessageAI = `
+🛠️ *Admin Commands*:
+- 👮‍♂️ /kick: Kick a user (reply to their message).
+- 🤐 /mute: Mute a user (reply to their message).
+- 🔓 /unmute: Unmute a user (reply to their message).
+- 📈 /promote: Promote a user to admin (reply to their message).
+- 📉 /demote: Demote an admin (reply to their message).
+- 📝 /setname <new name>: Change the group name.
+- 🔗 /getlink: Get the group invite link.
+- 🚫 /antilink: Toggle anti-link feature.
+- 🖼️ /setgrouppic: Change the group picture.
+- ✏️ /setdescription <text>: Update group description.
+`;
+        bot.editMessageText(helpMessageAI, {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+            reply_markup: {
+                inline_keyboard: [
+                    [
+                        { text: "⬅️ BACK", callback_data: "help_back_1" },
+                        { text: "➡️ NEXT", callback_data: "help_next_3" }
+                    ]
+                ]
+            }
+        });
+    }
+    // Third "NEXT" button (from AI Menu to Tools Menu)
+    if (query.data === "help_next_3") {
+        const helpMessageTools = `
+🔧 *Special Menu*:
+- 🥵 /xvideosearch: <query> searches for adult videos
+- 👙 /xvideodownload: <link> downloads adult videos
+`;
+        bot.editMessageText(helpMessageTools, {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+            reply_markup: {
+                inline_keyboard: [
+                    [
+                        { text: "⬅️ BACK", callback_data: "help_back_2" },
+                        { text: "➡️ NEXT", callback_data: "help_next_4" }
+                    ]
+                ]
+            }
+        });
+    }
+        // Third "NEXT" button (from AI Menu to Tools Menu)
+    if (query.data === "help_next_4") {
+        const helpMessageTools = `
+🔧 *Tools Menu*:
+- 📄 /txt2pdf: Convert text to PDF. (coming soon)
+- 🖇️ /url: Coverts Video, Photo, any file to url
+- 📸 /ss: screenshots a website
+- 😍 /remini: Enhances any low quality image
+- 🥰 /couplepp: sends couples pics
+- 🖼️ /image: searchs for images on the internet
+- 🎙️ /shazam: identifies any music on a video or audio file
+`;
+        bot.editMessageText(helpMessageTools, {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+            reply_markup: {
+                inline_keyboard: [
+                    [
+                        { text: "⬅️ BACK", callback_data: "help_back_3" },
+                        { text: "➡️ NEXT", callback_data: "help_next_5" }
+                    ]
+                ]
+            }
+        });
+    }
+    // Fourth "NEXT" button (from Tools Menu to Utility Commands)
+    if (query.data === "help_next_5") {
+        const helpMessageUtility = `
+📊 *Utility Commands*:
+- ⏳ /runtime: Check the bot's uptime.
+- 🏓 /ping: Check bot's response time.
+- 💸 /currency <amount> <from> to <to>: Convert currencies (e.g., /currency 100 USD to EUR).
+- 🗑️ /delete: Delete a specific message (reply to it).
+`;
+        bot.editMessageText(helpMessageUtility, {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+            reply_markup: {
+                inline_keyboard: [
+                    [
+                        { text: "⬅️ BACK", callback_data: "help_back_4" },
+                        { text: "➡️ NEXT", callback_data: "help_next_6" }
+                    ]
+                ]
+            }
+        });
+    }
+    // Fifth "NEXT" button (from Utility Commands to Other Commands)
+    if (query.data === "help_next_6") {
+        const helpMessageOther = `
+🙋‍♂️ *Other Commands*:
+- 👑 /owner: Show the owner details.
+- 🤝 /support: Support the developer.
+- 📢 /tagall: Tag all group members.
+- 🚀 /start: Welcome message and introduction.
+- ❓ /help: Show this help menu.
+*ᴘᴏᴡᴇʀᴇᴅ ʙʏ ᴅᴀᴠɪᴅ ᴄʏʀɪʟ ᴛᴇᴄʜ*
+`;
+        bot.editMessageText(helpMessageOther, {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+            reply_markup: {
+                inline_keyboard: [
+                    [
+                        { text: "⬅️ BACK", callback_data: "help_back_5" }
+                    ]
+                ]
+            }
+        });
+    }
+    // Handle "BACK" buttons
+    if (query.data === "help_back_0") {
+        bot.editMessageText(helpMessageDownload, {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+            reply_markup: {
+                inline_keyboard: [
+                    [{ text: "➡️ NEXT", callback_data: "help_next_1" }]
+                ]
+            }
+        });
+    }
+    if (query.data === "help_back_1") {
+        const helpMessageAdmin = `
+🛠️ *Admin Commands*:
+- 👮‍♂️ /kick: Kick a user (reply to their message).
+- 🤐 /mute: Mute a user (reply to their message).
+- 🔓 /unmute: Unmute a user (reply to their message).
+- 📈 /promote: Promote a user to admin (reply to their message).
+- 📉 /demote: Demote an admin (reply to their message).
+- 📝 /setname <new name>: Change the group name.
+- 🔗 /getlink: Get the group invite link.
+- 🚫 /antilink: Toggle anti-link feature.
+- 🖼️ /setgrouppic: Change the group picture.
+- ✏️ /setdescription <text>: Update group description.
+`;
+        bot.editMessageText(helpMessageAdmin, {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+            reply_markup: {
+                inline_keyboard: [
+                    [
+                        { text: "⬅️ BACK", callback_data: "help_back_0" },
+                        { text: "➡️ NEXT", callback_data: "help_next_2" }
+                    ]
+                ]
+            }
+        });
+    }
+    if (query.data === "help_back_2") {
+        const helpMessageAI = `
+🤖 *AI Commands*:
+- 🤖 /gpt <query>: Answers any question.
+- 🔊 /text2speech <text>: Convert text to speech. (coming soon)
+- 🔊 /text2speech <text>: Convert text to speech.
+- 🪄 /text2image <prompt>: Generates Any Ai Image of your choice.
+- 🪄 /flux <prompt>: Generates Any Realistic Ai Images.
+`;
+        bot.editMessageText(helpMessageAI, {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+            reply_markup: {
+                inline_keyboard: [
+                    [
+                        { text: "⬅️ BACK", callback_data: "help_back_1" },
+                        { text: "➡️ NEXT", callback_data: "help_next_3" }
+                    ]
+                ]
+            }
+        });
+    }
+    if (query.data === "help_back_3") {
+        const helpMessageTools = `
+🔧 *Special Menu*:
+- 🥵 /xvideosearch: <query> searches for adult videos
+- 👙 /xvideodownload: <link> downloads adult videos
+`;
+        bot.editMessageText(helpMessageTools, {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+            reply_markup: {
+                inline_keyboard: [
+                    [
+                        { text: "⬅️ BACK", callback_data: "help_back_2" },
+                        { text: "➡️ NEXT", callback_data: "help_next_4" }
+                    ]
+                ]
+            }
+        });
+    }
+    if (query.data === "help_back_3") {
+        const helpMessageTools = `
+🔧 *Tools Menu*:
+- 📄 /txt2pdf: Convert text to PDF.
+- 🖇️ /url: Coverts Video, Photo, any file to url
+- 😍 /remini: Enhances any low quality image
+- 🖼️ /image: searchs for images on the internet
+- 🎙️ /shazam: identifies any music on a video or audio file
+`;
+        bot.editMessageText(helpMessageTools, {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+            reply_markup: {
+                inline_keyboard: [
+                    [
+                        { text: "⬅️ BACK", callback_data: "help_back_2" },
+                        { text: "➡️ NEXT", callback_data: "help_next_4" }
+                    ]
+                ]
+            }
+        });
+    }
+    if (query.data === "help_back_4") {
+        const helpMessageUtility = `
+📊 *Utility Commands*:
+- ⏳ /runtime: Check the bot's uptime.
+- 🏓 /ping: Check bot's response time.
+- 💸 /currency <amount> <from> to <to>: Convert currencies (e.g., /currency 100 USD to EUR).
+- 🗑️ /delete: Delete a specific message (reply to it).
+`;
+        bot.editMessageText(helpMessageUtility, {
+            chat_id: chatId,
+            message_id: query.message.message_id,
+            parse_mode: 'Markdown',
+            reply_markup: {
+                inline_keyboard: [
+                    [
+                        { text: "⬅️ BACK", callback_data: "help_back_3" },
+                        { text: "➡️ NEXT", callback_data: "help_next_5" }
+                    ]
+                ]
+            }
+        });
+    }
+});

package.json CHANGED Viewed

@@ -1,95 +1,27 @@
 {
-  "name": "Anita-V4",
   "version": "1.0.0",
-  "description": "Queen Anita V4 - A WhatsApp and Telegram Bot",
   "main": "index.js",
-  "type": "common.js",
   "scripts": {
-    "start": "pm2 start index.js --name Queen_Anita-V4 --deep-monitoring --attach",
-    "stop": "pm2 stop Queen_Anita-V4",
-    "restart": "pm2 restart Queen_Anita-V4"
   },
-  "keywords": [
-    "whatsapp-bot",
-    "telegram-bot",
-    "baileys",
-    "multi-device"
-  ],
-  "author": "David Cyril",
-  "license": "MIT",
   "dependencies": {
-         "@adiwajshing/baileys": "npm:@whiskeysockets/baileys@^6.7.9",
-        "@hapi/boom": "^10.0.1",
-    "node-telegram-bot-api": "^0.61.0",
-    "node-cache": "^5.1.2",
-    "pino": "^8.17.2",
-    "axios": "^1.6.7",
-    "aptoide-scraper": "^1.0.1",
-    "cfonts": "^3.2.0",
-    "chalk": "^4.1.2",
-    "check-disk-space": "^3.3.1",
-    "cheerio": "^1.0.0-rc.12",
-    "child_process": "^1.0.2",
-    "colors": "^1.4.0",
-    "cookie": "^0.6.0",
-    "crypto": "^1.0.1",
-    "d-scrape": "^1.2.0",
-    "dhn-api": "^1.1.3",
-    "dotenv": "^16.3.1",
-    "emoji-regex": "^10.3.0",
-      "express": "^4.19.2",
-    "file-type": "^16.5.3",
-    "fluent-ffmpeg": "^2.1.2",
-    "@ffmpeg-installer/ffmpeg": "^1.1.0",
-    "fs-extra": "^10.0.0",
-    "g-i-s": "^2.1.7",
-    "g4f": "^1.4.3",
-        "@vitalets/google-translate-api": "^8.0.0",
-    "greetify": "^2.0.1",
-    "https-proxy-agent": "^7.0.4",
-    "human-readable": "^0.2.1",
-    "jimp": "^0.16.1",
-    "jsdom": "^25.0.0",
-    "lodash": "latest",
-    "lolcatjs": "^2.4.1",
-    "lowdb": "^7.0.1",
-    "moment-timezone": "^0.5.34",
-    "mal-scraper": "^2.11.4",
-    "mongoose": "^7.1.1",
-    "node-cron": "^3.0.3",
-    "node-fetch": "^2.6.7",
-    "node-id3": "^0.2.6",
-    "node-os-utils": "^1.3.6",
-    "node-webpmux": "^3.1.0",
-    "node-youtube-music": "^0.10.3",
-    "object-query-string": "^1.2.0",
-    "ocr-space-api-wrapper": "^2.2.0",
-    "os": "^0.1.2",
-    "path": "^0.12.7",
-    "perf_hooks": "0.0.1",
-    "performance-now": "*",
-        "pm2": "^5.2.0",
-    "qrcode": "^1.5.3",
-    "qrcode-reader": "^1.0.4",
-    "razzaq-suppress": "^1.0.1",
-    "remove.bg": "^1.3.0",
-    "removebg-id": "^2.0.1",
-    "rimraf": "^5.0.5",
-    "scrape-primbon": "^1.1.0",
-    "scrape-it": "^6.1.3",
-    "similarity": "^1.2.1",
-    "string-similarity": "^4.0.4",
-    "util": "^0.12.5",
-    "wa-sticker-formatter": "^4.4.4",
-    "socks-proxy-agent": "^8.0.3",
-    "steno": "^1.0.0",
-    "syntax-error": "^1.4.0",
-    "yargs": "^17.7.2",
-    "youtube-yts": "^2.0.0",
-    "youtubedl-core": "^4.11.7",
     "yt-search": "^2.12.1"
-  },
   "engines": {
-    "node": ">=14.0.0"
   }
 }

 {
+  "name": "Ebar-",
   "version": "1.0.0",
   "main": "index.js",
   "scripts": {
+    "start": "node bot.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
   },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
   "dependencies": {
+    "axios": "^1.7.7",
+        "crypto": "^1.0.1",
+    "express": "^4.21.1",
+    "form-data": "^4.0.0",
+    "mrnima-moviedl": "1.0.0",
+    "node-telegram-bot-api": "^0.66.0",
+    "webtorrent": "^2.5.10",
     "yt-search": "^2.12.1"
+      },
+  "keywords": ["Atomic", "bot", "Telegram", "multi-device"],
   "engines": {
+    "node": "22.x"
   }
 }