Update main.py

main.py

@@ -1,78 +1,1219 @@
-from fastapi import FastAPI
-from characterai import PyCAI as AnotherAPI
-import requests
-import re 
-import json
-import logging
-
-app = FastAPI()
-
-class VideoLinkExtractor:
-    """Class for extracting video links from HTML content."""
-    
-    def __init__(self, html_content):
-        self.html_content = html_content
-
-    def clean_str(self, s):
-        """Cleans and returns a JSON-encoded string."""
-        try:
-            return json.loads(f'{{"text": "{s}"}}')['text']
-        except json.JSONDecodeError as e:
-            logging.error(f"Error decoding JSON: {e}")
-            return None
-
-    def get_link(self, regex):
-        """Extracts and returns link based on the provided regex."""
-        match = re.search(regex, self.html_content)
-        return self.clean_str(match.group(1)) if match else None
-
-    def get_title(self):
-        """Extracts and returns the title from HTML content."""
-        return self.get_link(r'<title>(.*?)<\/title>')
-
-@app.get("/AnotherAPI/{api_key}/FB_Downloader/")
-async def get_video_links(url: str, api_key: str,):
-    API = AnotherAPI(api_key)    
-    API.chat.new_chat('csTC3hw0Fnj1Whnl0uV1Nb3_oYIillMQtdBH5NEl0Gs')
-    if not url:
-        return {"success": False, "message": "Please provide the URL"}
-    
-    headers = {
-        'sec-fetch-user': '?1',
-        'sec-ch-ua-mobile': '?0',
-        'sec-fetch-site': 'none',
-        'sec-fetch-dest': 'document',
-        'sec-fetch-mode': 'navigate',
-        'cache-control': 'max-age=0',
-        'authority': 'www.facebook.com',
-        'upgrade-insecure-requests': '1',
-        'accept-language': 'en-GB,en;q=0.9,tr-TR;q=0.8,tr;q=0.7,en-US;q=0.6',
-        'sec-ch-ua': '"Google Chrome";v="89", "Chromium";v="89", ";Not A Brand";v="99"',
-        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.114 Safari/537.36',
-        'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9'
+// Time & Date
+const moment = require('moment-timezone'); 
+moment.tz.setDefault("Asia/Kuala_Lumpur");
+
+// Tanggal
+const Tanggal = moment().format('DD-MM-YYYY');
+
+// Waktu 
+const Jam = moment().format('HH:mm');
+
+// Runtime
+const startedAt = moment.tz("Asia/Jakarta");
+const now = moment.tz("Asia/Jakarta");
+const duration = moment.duration(now.diff(startedAt));
+const runtime = `${duration.hours()}:${duration.minutes()}:${duration.seconds()}`;
+
+const BotInfo = `
+                    「 *Monika AI* 」
+
+╠┈┈「 *Info Bot* 」
+╎❏ *Bot Name:* Monika
+╎❏ *Creator:* Another
+╎❏ *Language:* Node.Js & Python
+╎❏ *Time:* ${Jam}
+╎❏ *Date:* ${Tanggal}
+╎❏ *Runtime:* ${runtime}
+╚┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈❖
+
+╠┈┈┈┈「 *Menu* 」┈┈┈┈❖
+╎
+╠┈┈「 *AI* 」
+╎❏ *GPT:* monika/noir
+╎❏ *C.AI:* an/al
+╎❏ *Stable Defusion:* art/txt2img
+╎┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈❖
+╠┈┈「 *Downloader* 」
+╎❏ *YT:* ytmp4/ytmp3
+╎❏ *FB:* fb
+╎❏ *Pinterest:* pinterest
+╎❏ *NHentai:* nh
+╎┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈❖
+╠┈┈「 *Tools* 」
+╎❏ *Sticker:* s/sticker
+╎❏ *Sticker To Img:* ti
+╎❏ *Upscaler:* upscale/2x
+╎❏ *View:* view
+╎❏ *Sauce Anime Scane:* sauce
+╎┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈❖
+╠┈┈「 *Search* 」
+╎❏ *Pinterest Search:* pinsc
+╎┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈❖
+╠┈┈「 *MISC* 」
+╎❏ *Random Waifu:* waifu/neko
+╎❏ *Random Char:* randomchar
+╎❏ *Random Anime:* randomanime
+╎❏ *NSFW:* nsfw/hneko
+╚┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈❖`;
+
+//----------------------------------------------------------------------------------\\
+
+const express = require('express');
+const app = express();
+const PORT = process.env.PORT || 7860;
+
+
+// WhatsApp Bot Code ---------------------------
+const { default: makeWASocket, useMultiFileAuthState, downloadContentFromMessage } = require("@whiskeysockets/baileys");
+const Pino = require("pino");
+const fs = require("fs");
+const ffmpeg = require('fluent-ffmpeg');
+const path = require('path');
+const sharp = require('sharp');
+const fetch = require('node-fetch');
+const axios = require('axios')
+const cheerio = require('cheerio');
+const api_key = "df2e12cdd170b47344738acca42d6fd42becf93a";
+
+//Media Path
+const Media = "tmp/media";
+
+//Fungsi Untuk Menghapus file --------------------------------------------
+const folderPath = 'tmp/media';
+
+const deleteFilesInFolder = (folderPath) => {
+  fs.readdirSync(folderPath).forEach((file) => {
+    const filePath = path.join(folderPath, file);
+
+    try {
+      fs.unlinkSync(filePath);
+      console.log(`File ${filePath} berhasil dihapus`);
+    } catch (err) {
+      console.error(`Gagal menghapus file ${filePath}: ${err.message}`);
+    }
+  });
+};
+// -----------------------------------------------------------------------
+
+const useCODE = process.argv.includes("--useCODE");
+
+let creds;
+
+try {
+  creds = JSON.parse(fs.readFileSync("./tmp/auth/creds.json"));
+} catch (err) {
+  creds = null;
+}
+
+async function connectToWhatsapp() {
+  const auth = await useMultiFileAuthState("tmp/auth");
+
+  let browser;
+
+  if (!creds) {
+    browser = useCODE ? ["Chrome (Linux)", "", ""] : ["Sibay", "Firefox", "1.0.0"];
+  } else {
+    browser = !creds.pairingCode || creds.pairingCode === "" ? ["Sibay", "Firefox", "1.0.0"] : ["Chrome (Linux)", "", ""];
+  }
+
+  console.log(browser);
+
+  const socket = makeWASocket({
+    printQRInTerminal: !useCODE,
+    browser: browser,
+    auth: auth.state,
+    logger: Pino({ level: "silent" }),
+    generateHighQualityLinkPreview: true
+  });
+
+  if (useCODE && !socket.user && !socket.authState.creds.registered) {
+    const question = pertanyaan =>
+      new Promise(resolve => {
+        const readline = require("readline").createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        readline.question(pertanyaan, answer => {
+          resolve(answer);
+          readline.close();
+        });
+      });
+
+    const Nomor_Bot = "6287843194595";
+
+    setTimeout(async function () {
+      const pairingCode = await socket.requestPairingCode(Nomor_Bot);
+      console.log("Pairing code anda: ", pairingCode);
+    }, 3000);
+  }
+
+  socket.ev.on("creds.update", auth.saveCreds);
+  socket.ev.on("connection.update", ({ connection }) => {
+    if (connection === "open") console.log("Nomor WA Yang Terhubung: " + socket.user.id.split(":")[0]);
+    if (connection === "close") connectToWhatsapp();
+  });
+
+  const myNumber = "62895805188618";
+  const processed = []; 
+  
+  socket.ev.on("messages.upsert", ({ messages }) => {
+    const msg = messages[0];
+
+    if(processed.includes(msg.key.id)) return; 
+    processed.push(msg.key.id);
+
+    if(msg.key.remoteJid.endsWith(myNumber + '@s.whatsapp.net')) {
+      // nomor pengirim sama, lanjutkan
+       
+     } 
+     // cek grup chat
+     else if(msg.key.remoteJid.includes('@g.us')) {
+       if(msg.key.participant.endsWith(myNumber + '@s.whatsapp.net')) {
+         // nomor pengirim di grup sama, lanjutkan
+       
+       } else {
+         // bukan nomor saya, abaikan
+         return;
+       }
+     } else {
+       // bukan private/grup chat dari nomor saya, abaikan
+       return;
+     }
+
+    function reply(text) {
+      socket.sendMessage(
+        msg.key.remoteJid,
+        { text: text },
+        { quoted: msg }
+      );
     }
 
-    try:
-        r = requests.get(url, headers=headers)
-        r.raise_for_status()
-        extractor = VideoLinkExtractor(r.text)
+    if (!msg.message) return;
+
+    const msgType = Object.keys(msg.message)[0];
+    const msgText =
+      msgType === "conversation"
+        ? msg.message.conversation
+        : msgType === "extendedTextMessage"
+        ? msg.message.extendedTextMessage.text
+        : msgType === "imageMessage"
+        ? msg.message.imageMessage.caption
+        : "";
+
+    if (!msgText.startsWith(".")) return;
+
+    console.log(`Message Type: ${msgType}\nMessage Text: ${msgText}`);
+
+    const command = msgText.split(" ")[0].slice(1);
+
+    console.log(`Command: ${command}`);
+    const id = msg.key.remoteJid;
+
+    const UserText = msgText.slice(msgText.indexOf(' ') + 1); 
+
+    switch (command.toLowerCase()) {
+
+      case "menu":
+        async function bot_menu() {
+          await socket.sendMessage(id, {
+            text: BotInfo,
+            contextInfo: {
+              forwardingScore: 700,
+              isForwarded: false,
+              forwardedNewsletterMessageInfo: {
+                newsletterJid: '',
+                newsletterName: "Another",
+                serverMessageId: -1
+              },
+              externalAdReply: {
+                showAdAttribution: false,
+                containsAutoReply: true,
+                title: "Will you promise to spend the most time with me?♥",
+                mediaType: 1,
+                thumbnailUrl: "https://i.pinimg.com/564x/fb/de/2e/fbde2e5834e2e1a5adb9d7d9508d79ab.jpg",
+                mediaUrl: "https://monikai.000webhostapp.com/",
+                sourceUrl: "https://monikai.000webhostapp.com/"
+              }
+            }
+          }, {
+            quoted: msg
+          });
+        }
+        bot_menu();
+        break;   
+
+      case "link":
+        reply("Successfully linked");
+        break;
+
+      case "del": case "hapus":
+        if (!msg.message.extendedTextMessage) {
+          return;
+        }
+    
+        const delMsg = {
+          id: msg.message.extendedTextMessage.contextInfo.stanzaId,
+          remoteJid: msg.key.remoteJid,
+          fromMe: true
+        };
+    
+        socket.sendMessage(id, { delete: delMsg })
+          .then(() => {})
+          .catch(err => {
+            reply("Gagal menghapus chat!");
+          });
+        break;
+
+//----------- AI ----------------------------------------------------------------------------------------------------------------------//
+      case "monika":
+        const reaction_case_monika = { react: { text: "❤️", key: msg.key } };
+        socket.sendMessage(id, reaction_case_monika, { quoted: msg }).catch(err => console.error(err));
+
+        async function getResponse() {
+          try {
+            const res = await fetch(`https://yuuki0125-monika-api.hf.space/AnotherAPI/${api_key}/GPT/Monika/${UserText}`);
+            if (!res.ok) {
+              throw new Error("Gagal fetch data");
+            }
+
+            const json = await res.json();
+
+            if (!json.response) {
+              throw new Error("Respon kosong");
+            }
+
+            return json.response;
+
+          } catch (err) {
+            console.error(err);
+          }
+        }
+
+        getResponse().then(res => {
+          socket.sendMessage(id, {
+            text: res,
+            contextInfo: {
+              forwardingScore: 700,
+              isForwarded: false,
+              forwardedNewsletterMessageInfo: {
+                newsletterJid: '',
+                newsletterName: "Another",
+                serverMessageId: -1
+              },
+              externalAdReply: {
+                showAdAttribution: false,
+                containsAutoReply: true,
+                title: "Will you promise to spend the most time with me?♥",
+                mediaType: 1,
+                thumbnailUrl: "https://i.pinimg.com/564x/fb/de/2e/fbde2e5834e2e1a5adb9d7d9508d79ab.jpg",
+                mediaUrl: "https://monikai.000webhostapp.com/",
+                sourceUrl: "https://monikai.000webhostapp.com/"
+              }
+            }
+          }, {
+            quoted: msg
+          });
+        }).catch(err => {
+          console.error(err);
+        });
+        break;
+
+        case "noir":
+          const reaction_case_noir = { react: { text: "♾️", key: msg.key } };
+          socket.sendMessage(id, reaction_case_noir, { quoted: msg }).catch(err => console.error(err));
+  
+          async function getResponse2() {
+            try {
+              const res = await fetch(`https://yuuki0125-noir-api.hf.space/AnotherAPI/${api_key}/GPT/Noir/${UserText}`);
+              if (!res.ok) {
+                throw new Error("Gagal fetch data");
+              }
+  
+              const json = await res.json();
+  
+              if (!json.response) {
+                throw new Error("Respon kosong");
+              }
+  
+              return json.response;
+  
+            } catch (err) {
+              console.error(err);
+            }
+          }
+  
+          getResponse2().then(res => {
+            socket.sendMessage(id, {
+              text: res,
+              contextInfo: {
+                forwardingScore: 700,
+                isForwarded: false,
+                forwardedNewsletterMessageInfo: {
+                  newsletterJid: '',
+                  newsletterName: "Another",
+                  serverMessageId: -1
+                },
+                externalAdReply: {
+                  showAdAttribution: false,
+                  containsAutoReply: true,
+                  title: "Master, is Noir useful to you?",
+                  mediaType: 1,
+                  thumbnailUrl: "https://i.pinimg.com/564x/ca/b9/6e/cab96ec23af20fafbad9f0e33ee32e8d.jpg",
+                  mediaUrl: "https://monikai.000webhostapp.com/",
+                  sourceUrl: "https://monikai.000webhostapp.com/"
+                }
+              }
+            }, {
+              quoted: msg
+            });
+          }).catch(err => {
+            console.error(err);
+          });
+          break;
+
+      case "an":
+        const reaction_case_2b_new = { react: { text: "♾️", key: msg.key } };
+        socket.sendMessage(id, reaction_case_2b_new, { quoted: msg }).catch(err => console.error(err));
+
+        async function characters_ai_new() {
+          let res = await fetch(`https://yuuki0125-characters-api.hf.space/AnotherAPI/2B/new_chat/${api_key}/${UserText}`)
+          if (!res.ok) throw 'Error fetching response';
+          let json = await res.json();
+          if (!json['2b']) throw 'Error!';
+      
+          const respon = json['2b'];
+          socket.sendMessage(id, {
+            text: respon,
+            contextInfo: {
+              forwardingScore: 700,
+              isForwarded: false,
+              forwardedNewsletterMessageInfo: {
+                newsletterJid: '',
+                newsletterName: "Another",
+                serverMessageId: -1
+              },
+              externalAdReply: {
+                showAdAttribution: false,
+                containsAutoReply: true,
+                title: "Glory to mankind",
+                mediaType: 1,
+                thumbnailUrl: "https://i.pinimg.com/564x/51/96/14/519614e68d7dd5c4cd5ca5610dc57fcd.jpg",
+                mediaUrl: "https://monikai.000webhostapp.com/",
+                sourceUrl: "https://monikai.000webhostapp.com/"
+              }
+            }
+          }, {
+            quoted: msg
+          });
+        }
+        characters_ai_new()
+        break;
+
+      case "al":
+        const reaction_case_2b_load = { react: { text: "♾️", key: msg.key } };
+        socket.sendMessage(id, reaction_case_2b_load, { quoted: msg }).catch(err => console.error(err));
+
+        async function characters_ai() {
+          let res = await fetch(`https://yuuki0125-characters-api.hf.space/AnotherAPI/2B/chat/${api_key}/${UserText}`)
+          if (!res.ok) throw 'Error fetching response';
+          let json = await res.json();
+          if (!json['2b']) throw 'Error!';
+      
+          const respon = json['2b'];
+          socket.sendMessage(id, {
+            text: respon,
+            contextInfo: {
+              forwardingScore: 700,
+              isForwarded: false,
+              forwardedNewsletterMessageInfo: {
+                newsletterJid: '',
+                newsletterName: "Another",
+                serverMessageId: -1
+              },
+              externalAdReply: {
+                showAdAttribution: false,
+                containsAutoReply: true,
+                title: "Glory to mankind",
+                mediaType: 1,
+                thumbnailUrl: "https://i.pinimg.com/564x/51/96/14/519614e68d7dd5c4cd5ca5610dc57fcd.jpg",
+                mediaUrl: "https://monikai.000webhostapp.com/",
+                sourceUrl: "https://monikai.000webhostapp.com/"
+              }
+            }
+          }, {
+            quoted: msg
+          });
+        }
+        characters_ai()
+        break;
+
+//----------- Downloader ----------------------------------------------------------------------------------------------------------------------//
+      case 'ytmp3':
+        const reaction_case_audio = { react: { text: "🎧", key: msg.key } };
+        socket.sendMessage(id, reaction_case_audio, { quoted: msg }).catch(err => console.error(err));
+        async function yt_download_mp3() {
+          const youtube_url = UserText;
+          const url_mp3 = `https://yuuki0125-yt-downloader-api.hf.space/AnotherAPI/${api_key}/downloader/YT/mp3/`;
+
+          const params = { youtube_url };
+
+          try {
+            const response = await axios.post(url_mp3, null, { params, responseType: 'arraybuffer' });
+
+            if (response.status === 200) {
+
+              const dirPath = `${Media}`; 
+              if (!fs.existsSync(dirPath)) {
+                fs.mkdirSync(dirPath, { recursive: true });
+              }
+
+              const audioPath = `${Media}/yt_audio.mp3`; 
+              fs.writeFileSync(audioPath, Buffer.from(response.data, 'binary'));
+
+              const convertToOpus = async (inputFile, outputFile) => {
+                const promise = new Promise((resolve, reject) => {
+              
+                  ffmpeg(inputFile)
+                    .audioCodec('libopus')
+                    .audioFrequency(48000)
+                    .on('end', resolve) 
+                    .on('error', reject)
+                    .saveToFile(outputFile, { createDirs: true }); 
+              
+                });
+                await promise;
+              };
+              const inputFile = audioPath;
+              const outputFile = `${Media}/yt_audio.opus`;
+              
+              await convertToOpus(inputFile, outputFile)
+                .catch(err => console.log('Error: ' + err.message)); 
+
+              const buffer = fs.readFileSync(outputFile); 
+              await socket.sendMessage(id, { audio: buffer, mimeType: "audio/mp3" }, { quoted: msg });
+          
+            } else {
+              console.error(`Failed to download audio: ${response.status}`);
+            }
+          } catch (error) {
+            console.error('Error:', error.message);
+          }
+        }
+        yt_download_mp3();
+        break;
+      
+      case 'ytmp4':
+        const reaction_case_video = { react: { text: "▶️", key: msg.key } };
+        socket.sendMessage(id, reaction_case_video, { quoted: msg }).catch(err => console.error(err));
+        async function yt_downloader_mp4() {
+          const youtube_url = UserText;
+          const url_mp3 = `https://yuuki0125-yt-downloader-api.hf.space/AnotherAPI/${api_key}/downloader/YT/mp4/`;
+      
+          const params = { youtube_url };
+      
+          try {
+            const response = await axios.post(url_mp3, null, { params, responseType: 'arraybuffer' });
+      
+            if (response.status === 200) {
+
+              const dirPath = `${Media}`; 
+              if (!fs.existsSync(dirPath)) {
+                fs.mkdirSync(dirPath, { recursive: true });
+              }
+
+              const videoPath = `${Media}/yt_video.mp4`; 
+              await fs.writeFileSync(videoPath, Buffer.from(response.data, 'binary'));
+              socket.sendMessage(id, {video: fs.readFileSync(videoPath), mimeType: "video/mp4"}, { quoted: msg })
+                .then(() => {
+                  deleteFilesInFolder(folderPath);
+                })
+            } else {
+              console.error(`Failed to download audio: ${response.status}`);
+            }
+          } catch (error) {
+            console.error('Error:', error.message);
+          }
+        }
+        yt_downloader_mp4();
+        break;
+
+      case "pinterest":
+        const reaction_case_pinterest = { react: { text: "✨", key: msg.key } };
+        socket.sendMessage(id, reaction_case_pinterest, { quoted: msg }).catch(err => console.error(err));
+        async function Pinterest_Downloader() {
+          const Endpoint = 'https://yuuki0125-pinterest-downloader.hf.space';
+          
+          (async () => {
+            try {
+              const response = await fetch(`${Endpoint}/AnotherAPI/${api_key}/Pinterest/Downloader?url=${UserText}`);
+              if (response.ok) {
+                const data = await response.json();
+                const media_type = data.type;
+                const media_link = data.link;
+      
+                const dirPath = `${Media}`;
+                if (!fs.existsSync(dirPath)) {
+                  fs.mkdirSync(dirPath, { recursive: true });
+                }
+                if(media_type === 'video') {
+                  const video_response = await fetch(media_link);
+                  const video_buffer = await video_response.buffer();
+            
+                  fs.writeFileSync(`${dirPath}/video.mp4`, video_buffer);
+                  socket.sendMessage(
+                    id,
+                    {
+                        video: fs.readFileSync(`${dirPath}/video.mp4`),
+                        mimeType: "video/mp4",
+                        caption: media_link
+                    },
+                    { quoted: msg }
+                )
+                  .then(() => {
+                    deleteFilesInFolder(folderPath);
+                  })
+                } else {
+                  const image_response = await fetch(media_link);
+                  const image_buffer = await image_response.buffer();
+                  fs.writeFileSync(`${dirPath}/Pinterest.png`, image_buffer);
+                  await socket.sendMessage(id, { image: { url: `${dirPath}/Pinterest.png` }, mimeType: "image/png", caption: media_link }, { quoted: msg })
+                    .then(() => {
+                      deleteFilesInFolder(folderPath);
+                    })
+                }
+              } else {
+                console.error(`Error: ${response.status}, ${await response.text()}`);
+              }
+            } catch (error) {
+              console.error(`An error occurred: ${error.message}`);
+            }
+          })();
+        }
+        Pinterest_Downloader()
+        break;
+
+      case "fb":
+        async function FB_Downloader() {
+          const apiUrl = `https://yuuki0125-fb-downloder.hf.space/AnotherAPI/${api_key}/FB_Downloader/?url=${UserText}`;
+    
+          fetch(apiUrl)
+            .then(res => res.json())
+            .then(async data => {
+              if(data.success) {
+                const hdLink = data.links['Download High Quality'];
+                
+                const videoResponse = await fetch(hdLink);
+                const videoBuffer = await videoResponse.buffer();
+
+                const dirPath = `${Media}`;
+                if (!fs.existsSync(dirPath)) {
+                  fs.mkdirSync(dirPath, { recursive: true });
+                }
+
+                fs.writeFile(`${Media}/FB_Downloader.mp4`, videoBuffer, () => {
+                  socket.sendMessage(
+                    id,
+                    {
+                        video: fs.readFileSync(`${Media}/FB_Downloader.mp4`),
+                        mimeType: "video/mp4",
+                        caption: data.title
+                    },
+                    { quoted: msg }
+                )
+                  .then(() => {
+                    deleteFilesInFolder(folderPath);
+                  })  
+                });
+                
+              } else {
+                console.log('Gagal mendapatkan link unduh');
+              }
+            })
+            .catch(err => {
+              console.log('Error:', err);
+            });
+        }
+        FB_Downloader()
+        break;
+
+//----------- Tools ----------------------------------------------------------------------------------------------------------------------//
+      case "ti":
+        const reaction_case_to_img = { react: { text: "✨", key: msg.key } };
+        socket.sendMessage(id, reaction_case_to_img, { quoted: msg }).catch(err => console.error(err));
+    
+        async function stiker_to_img() {
+          try {
+            let mediaMessage;
+            let isReplyToSticker = msg.message?.extendedTextMessage?.contextInfo?.quotedMessage?.stickerMessage;
+    
+            if (isReplyToSticker) {
+              mediaMessage = msg.message?.extendedTextMessage?.contextInfo?.quotedMessage?.stickerMessage;
+            } else {
+              reply('Mohon balas stiker yang ingin dikonversi!');
+            }
+    
+            const stream = await downloadContentFromMessage(mediaMessage, 'sticker');
+    
+            const dirPath = `${Media}`; 
+            if (!fs.existsSync(dirPath)) {
+              fs.mkdirSync(dirPath, { recursive: true });
+            }
+    
+            const filePath = `${dirPath}/sticker-${new Date().getTime()}`;
+            const fileSavePath = `${filePath}.webp`;
+            const imageOutputPath = `${filePath}.png`;
+    
+            const fileStream = fs.createWriteStream(fileSavePath);
+    
+            for await (const chunk of stream) {
+              fileStream.write(chunk);
+            }
+    
+            fileStream.end();
+    
+            fileStream.on('finish', async () => {
+              sharp(fileSavePath)
+                .toFormat('png')
+                .toFile(imageOutputPath, (err) => {
+                  if (err) {
+                    console.log(chalk.red('Gagal mengonversi:'), err);
+                    reply('Maaf Master, terjadi kesalahan saat mengonversi.');
+                    return;
+                  }
+                  socket.sendMessage(id, { image: { url: imageOutputPath }, mimeType: "image/png" }, { quoted: msg })
+                    .then(() => {
+                      deleteFilesInFolder(folderPath);
+                    })
+                    .catch((sendErr) => {
+                      console.error('Gagal mengirim pesan:', sendErr);
+                    });
+                });
+            });
+    
+          } catch (e) {
+            console.log('Gagal mengunduh atau memproses stiker:');
+            reply('Maaf Master, terjadi kesalahan saat memproses.');
+          }
+        }
+    
+        stiker_to_img();
+        break;
+
+      case "s":
+        const reaction_case_stiker = { react: { text: "✨", key: msg.key } };
+        socket.sendMessage(id, reaction_case_stiker, { quoted: msg }).catch(err => console.error(err));
+    
+        async function stiker_maker() {
+          try {
+            let mediaMessage;
+            if (msg.message.imageMessage) {
+              mediaMessage = msg.message.imageMessage;
+            } else if (msg.message?.extendedTextMessage?.contextInfo?.quotedMessage?.imageMessage) {
+              mediaMessage = msg.message?.extendedTextMessage?.contextInfo?.quotedMessage?.imageMessage;
+            } else {
+              reply('Silakan kirim atau reply gambar untuk membuat stiker.');
+            }
+    
+            const stream = await downloadContentFromMessage(mediaMessage, 'image');
+    
+            const dirPath = `${Media}`; ;
+            if (!fs.existsSync(dirPath)) {
+              fs.mkdirSync(dirPath, { recursive: true });
+            }
+    
+            const filePath = `${dirPath}/image-${new Date().getTime()}`;
+            const fileSavePath = `${filePath}.jpg`;
+            const stickerPath = `${filePath}-sticker.webp`;
+    
+            const fileStream = fs.createWriteStream(fileSavePath);
+    
+            for await (const chunk of stream) {
+              fileStream.write(chunk);
+            }
+    
+            fileStream.end();
+    
+            fileStream.on('finish', async () => {
+              sharp(fileSavePath)
+                .resize(512, 512, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
+                .toFormat('webp')
+                .toFile(stickerPath, (err) => {
+                  if (err) {
+                    console.log('Gagal membuat stiker:');
+                    reply('Maaf Master, terjadi error saat membuat sticker.');
+                    return;
+                  }
+                  const stickerBuffer = fs.readFileSync(stickerPath);
+                  socket.sendMessage(id, { sticker: stickerBuffer }, { quoted: msg })
+                    .then(() => {
+                      deleteFilesInFolder(folderPath);
+                    })
+                    .catch((sendErr) => {
+                      console.error('Gagal mengirim pesan:', sendErr);
+                    });
+                });
+            });
+    
+          } catch (e) {
+            console.log('Gagal mengunduh gambar:');
+            reply('Master, terjadi kesalahan saat mengunduh gambar.');
+          }
+        }
+    
+        stiker_maker();
+        break;
+
+      case "upscale":
+        const reaction_case_upscale = { react: { text: "✨", key: msg.key } };
+        socket.sendMessage(id, reaction_case_upscale, { quoted: msg }).catch(err => console.error(err));
+    
+        async function upscaler() {
+          try {
+            let mediaMessage;
+    
+            if (msg.message.imageMessage) {
+              mediaMessage = msg.message.imageMessage;
+            } else if (msg.message?.extendedTextMessage?.contextInfo?.quotedMessage?.imageMessage) {
+              mediaMessage = msg.message?.extendedTextMessage?.contextInfo?.quotedMessage?.imageMessage;
+            } else {
+              reply('Mohon kirim/balas gambar yang ingin di-upscale!');
+            }
+    
+            const stream = await downloadContentFromMessage(mediaMessage, 'image');
+    
+            const dirPath = `${Media}`; 
+            if (!fs.existsSync(dirPath)) {
+              fs.mkdirSync(dirPath, { recursive: true });
+            }
+    
+            const filePath = `${dirPath}/image-${new Date().getTime()}`;
+            const nameIMG = `image-${new Date().getTime()}`;
+            const fileSavePath = `${filePath}.jpg`;
+    
+            const fileStream = fs.createWriteStream(fileSavePath);
+    
+            for await (const chunk of stream) {
+              fileStream.write(chunk);
+            }
+    
+            fileStream.end();
+    
+            const FormData = require('form-data');
+    
+            const base_url = "https://beec-34-141-136-107.ngrok-free.app";
+            const endpoint = "/super_resolution";
+            const image_file_path = fileSavePath;
+    
+            fileStream.on('finish', async () => {
+              try {
+                const fileData = fs.readFileSync(image_file_path);
+                const formData = new FormData();
+                formData.append('file', Buffer.from(fileData), {
+                  filename: (`${nameIMG}.jpg`),
+                  contentType: 'image/jpeg'
+                });
+    
+                const response = await fetch(`${base_url}${endpoint}`, {
+                  method: 'POST',
+                  body: formData
+                });
+    
+                const Upscale = './tmp/images/sticker';
+    
+                if (response.status === 200) {
+                  const outputData = await response.buffer();
+                  fs.writeFileSync(Upscale, outputData);
+                  console.log("Berhasil");
+                } else {
+                  console.log(`Failed. Status code: ${response.status}`);
+                  console.log(await response.text());
+                }
+    
+                socket.sendMessage(id, { image: { url: Upscale }, mimeType: "image/png" }, { quoted: msg })
+                  .then(() => {
+                    deleteFilesInFolder(folderPath);
+                  })
+              } catch (error) {
+                reply('Maaf Master, terjadi kesalahan saat melakukan proses upscale');
+              }
+            });
+    
+          } catch (e) {
+            reply('Master, terjadi kesalahan saat mengunduh gambar.');
+          }
+        }
+    
+        upscaler();
+        break;
 
-        data = {
-            "success": True,
-            "title": extractor.get_title(),
-            "links": {} 
+      case "view":
+        const reaction_case_view = { react: { text: "✨", key: msg.key } };
+        socket.sendMessage(id, reaction_case_view, { quoted: msg }).catch(err => console.error(err));
+      
+        async function viewOnce() {
+          if (msg.message.extendedTextMessage) {
+            const quotedMsg = msg.message.extendedTextMessage.contextInfo.quotedMessage;
+            if (!quotedMsg?.viewOnceMessageV2) {
+              return;
+            }
+      
+            const viewOnce = quotedMsg.viewOnceMessageV2;
+            const message = viewOnce.message;
+      
+            if (message.imageMessage) { 
+              // Image
+              const imageMessage = message.imageMessage;
+      
+              const stream = await downloadContentFromMessage(imageMessage, 'image');
+              let buffer = Buffer.from([]);
+      
+              for await (const chunk of stream) {
+                buffer = Buffer.concat([buffer, chunk]);
+              }
+      
+              const dirPath = `${Media}`;
+              if (!fs.existsSync(dirPath)) {
+                fs.mkdirSync(dirPath, { recursive: true }); 
+              }
+      
+              fs.writeFileSync(`${dirPath}/gambar.png`, buffer);
+      
+              socket.sendMessage(id, { image: { url: `${dirPath}/gambar.png` }}, { quoted: msg });
+      
+            } else if (message.videoMessage) {
+              // Video
+              const videoMessage = message.videoMessage;
+              
+              const stream = await downloadContentFromMessage(videoMessage, 'video');
+              let buffer = Buffer.from([]);
+      
+              for await (const chunk of stream) {
+                buffer = Buffer.concat([buffer, chunk]);
+              }
+              
+              const filePath = `${Media}/video.mp4`; 
+              fs.writeFileSync(filePath, buffer);
+      
+              socket.sendMessage(
+                id,  
+                { video: { url: filePath }, fileName: 'video.mp4'}, 
+                { quoted: msg }
+              );
+            }
+      
+          } else {
+            reply("Chat ini bukan media view once"); 
+          }
         }
+      
+        viewOnce();  
+        break;
 
-        sd_link = extractor.get_link(r'browser_native_sd_url":"([^"]+)"')
-        if sd_link:
-            data["links"]["Download Low Quality"] = sd_link + "&dl=1"
+      case "sc":
+        const reaction_case_sauce = { react: { text: "✨", key: msg.key } };
+        socket.sendMessage(id, reaction_case_sauce, { quoted: msg }).catch(err => console.error(err));
+        async function sauce() {
+          try {
+            let mediaMessage;
+            if (msg.message.imageMessage) {
+              mediaMessage = msg.message.imageMessage;
+            } else if (msg.message?.extendedTextMessage?.contextInfo?.quotedMessage?.imageMessage) {
+              mediaMessage = msg.message?.extendedTextMessage?.contextInfo?.quotedMessage?.imageMessage;
+            } else {
+              reply('Silakan kirim atau reply gambar untuk membuat stiker.');
+            }
+            const stream = await downloadContentFromMessage(mediaMessage, 'image');
+            let buffer = Buffer.from([]);
+        
+            for await (const chunk of stream) {
+              buffer = Buffer.concat([buffer, chunk]);
+            }
+        
+            const dirPath = `${Media}`; ;
+            if (!fs.existsSync(dirPath)) {
+              fs.mkdirSync(dirPath, { recursive: true });
+            }
+            fs.writeFileSync(`${dirPath}/sauce.png`, buffer);
+            const res = await fetch('https://api.trace.moe/search', {
+              method: 'POST',
+              body: fs.createReadStream(`${dirPath}/sauce.png`),
+              headers: { 'Content-Type': 'image/jpeg' }
+            });
+        
+            if (!res.ok) {
+              throw new Error(`Error ${res.status}: ${res.statusText}`);
+            }
+        
+            const data = await res.json();
+            const topResult = data.result[0];
+        
+            let title = topResult.filename;
+            title = title.replace(/\[.*?\] /g, '');
+            title = title.replace(/ \(.*?\)/g, '');
+            title = title.replace(/\.mp4$/g, '');
+        
+            const Episode = topResult.episode;
+            const Similarity = parseInt(topResult.similarity.toFixed(2).replace('.', ''));
+            const VideoLink = topResult.video;
+            const video_path = `${dirPath}/sauce.mp4`
+            const sauce_anime = `
+╎❏ *Judul:* ${title}
+╎❏ *Episode:* ${Episode}
+╎❏ *Similarity:* ${Similarity}%
+            `
+            if (!fs.existsSync(dirPath)) {
+              fs.mkdirSync(dirPath, {recursive: true});
+            }
+            
+            await fetch(VideoLink)
+              .then(res => res.buffer())
+              .then(buffer => fs.writeFileSync(video_path, buffer)) 
+              .catch(err => console.error(err));
+        
+            socket.sendMessage(
+              id,
+              {
+                  video: fs.readFileSync(video_path),
+                  mimeType: "video/mp4",
+                  caption: sauce_anime
+              },
+              { quoted: msg }
+          )
+            .then(() => {
+              deleteFilesInFolder(folderPath);
+            })
+            
+          } catch (err) {
+            console.error(err);
+          }
+        }
+        sauce();
+        break;
 
-        hd_link = extractor.get_link(r'browser_native_hd_url":"([^"]+)"')
-        if hd_link:
-            data["links"]["Download High Quality"] = hd_link + "&dl=1"
+//----------- Search ----------------------------------------------------------------------------------------------------------------------//
+      case "pinsc":
+        const reaction_case_pinterest_search = { react: { text: "✨", key: msg.key } };
+        socket.sendMessage(id, reaction_case_pinterest_search, { quoted: msg }).catch(err => console.error(err));
+        async function pinterest_search_v2(search) {
+          return new Promise(async(resolve, reject) => {
+            axios.get('https://id.pinterest.com/search/pins/?autologin=true&q=' + search, {
+              headers: {
+                "cookie" : "_auth=1; _b=\"AVna7S1p7l1C5I9u0+nR3YzijpvXOPc6d09SyCzO+DcwpersQH36SmGiYfymBKhZcGg=\"; _pinterest_sess=TWc9PSZHamJOZ0JobUFiSEpSN3Z4a2NsMk9wZ3gxL1NSc2k2NkFLaUw5bVY5cXR5alZHR0gxY2h2MVZDZlNQalNpUUJFRVR5L3NlYy9JZkthekp3bHo5bXFuaFZzVHJFMnkrR3lTbm56U3YvQXBBTW96VUgzVUhuK1Z4VURGKzczUi9hNHdDeTJ5Y2pBTmxhc2owZ2hkSGlDemtUSnYvVXh5dDNkaDN3TjZCTk8ycTdHRHVsOFg2b2NQWCtpOWxqeDNjNkk3cS85MkhhSklSb0hwTnZvZVFyZmJEUllwbG9UVnpCYVNTRzZxOXNJcmduOVc4aURtM3NtRFo3STlmWjJvSjlWTU5ITzg0VUg1NGhOTEZzME9SNFNhVWJRWjRJK3pGMFA4Q3UvcHBnWHdaYXZpa2FUNkx6Z3RNQjEzTFJEOHZoaHRvazc1c1UrYlRuUmdKcDg3ZEY4cjNtZlBLRTRBZjNYK0lPTXZJTzQ5dU8ybDdVS015bWJKT0tjTWYyRlBzclpiamdsNmtpeUZnRjlwVGJXUmdOMXdTUkFHRWloVjBMR0JlTE5YcmhxVHdoNzFHbDZ0YmFHZ1VLQXU1QnpkM1FqUTNMTnhYb3VKeDVGbnhNSkdkNXFSMXQybjRGL3pyZXRLR0ZTc0xHZ0JvbTJCNnAzQzE0cW1WTndIK0trY05HV1gxS09NRktadnFCSDR2YzBoWmRiUGZiWXFQNjcwWmZhaDZQRm1UbzNxc21pV1p5WDlabm1UWGQzanc1SGlrZXB1bDVDWXQvUis3elN2SVFDbm1DSVE5Z0d4YW1sa2hsSkZJb1h0MTFpck5BdDR0d0lZOW1Pa2RDVzNySWpXWmUwOUFhQmFSVUpaOFQ3WlhOQldNMkExeDIvMjZHeXdnNjdMYWdiQUhUSEFBUlhUVTdBMThRRmh1ekJMYWZ2YTJkNlg0cmFCdnU2WEpwcXlPOVZYcGNhNkZDd051S3lGZmo0eHV0ZE42NW8xRm5aRWpoQnNKNnNlSGFad1MzOHNkdWtER0xQTFN5Z3lmRERsZnZWWE5CZEJneVRlMDd2VmNPMjloK0g5eCswZUVJTS9CRkFweHc5RUh6K1JocGN6clc1JmZtL3JhRE1sc0NMTFlpMVErRGtPcllvTGdldz0=; _ir=0"
+              }
+            }).then(async({ data }) => {
+              const x = cheerio.load(data);
+              const result = [];
+              const _output = [];
+              x('div > a').get().map(z => {
+                const _url = x(z).find('img').attr('src');
+                result.push(_url);
+              });
+              result.forEach(y => {
+                if (y == undefined) return;
+                _output.push(y.replace(/236/g,'736'));
+              });
+              _output.shift();
+              let dlUrl = _output[Math.floor(Math.random() * _output.length)];
+              resolve({
+                coder: 'Another',
+                result: {
+                  img: dlUrl
+                },
+                warning: 'Nothing'
+              });
+            });
+        
+          });
+        }
+        
+        async function running_pinterest_search_v2(search) {
+          pinterest_search_v2(search).then(async (result) => {
+        
+            const url = result.result.img;
+            
+            const response = await axios({
+              url, 
+              method: 'GET',
+              responseType: 'arraybuffer'
+            });
 
-        return data
+            socket.sendMessage(id, { image: response.data, mimeType: "image/png", caption: url }, { quoted: msg });
+        
+          }).catch(err => {
+            console.log(err);  
+          });
+        }
+        running_pinterest_search_v2(UserText)
+        break;
+        
+//----------- MISC ----------------------------------------------------------------------------------------------------------------------//
+      case "waifu":
+        const reaction_case_waifu = { react: { text: "✨", key: msg.key } };
+        socket.sendMessage(id, reaction_case_waifu, { quoted: msg }).catch(err => console.error(err));
+    
+        async function getWaifu() {
+          try {
+            const res = await fetch('https://api.waifu.pics/sfw/waifu');
+            const json = await res.json();
+    
+            if (!json.url) throw 'Error!';
+    
+            socket.sendMessage(
+              id,
+              { image: { url: json.url }, mimeType: "image/png" },
+              { quoted: msg }
+            );
+    
+          } catch (err) {
+            console.error(err);
+          }
+        }
     
-    except requests.RequestException as e:
-        logging.error(f"Request failed: {e}")
-        return {"success": False, "message": str(e)}
+        getWaifu().catch(err => console.error(err));
+        break;
+
+      case "nsfw":
+        const reaction_case_nsfw = { react: { text: "✨", key: msg.key } };
+        socket.sendMessage(id, reaction_case_nsfw, { quoted: msg }).catch(err => console.error(err));
+
+        async function getNfsw() {
+          try {
+            const res = await fetch('https://api.waifu.pics/nsfw/waifu');
+            const json = await res.json();
+
+            if (!json.url) throw 'Error!';
+
+            socket.sendMessage(
+              id,
+              { image: { url: json.url }, mimeType: "image/png" },
+              { quoted: msg }
+            );
+
+          } catch (err) {
+            console.error(err);
+          }
+        }
+
+        getNfsw().catch(err => console.error(err));
+        break;
+
+      case "neko":
+        const reaction_case_neko = { react: { text: "✨", key: msg.key } };
+        socket.sendMessage(id, reaction_case_neko, { quoted: msg }).catch(err => console.error(err));
+
+        async function getNeko() {
+          try {
+            const res = await fetch('https://api.waifu.pics/sfw/neko');
+            const json = await res.json();
+
+            if (!json.url) throw 'Error!';
+
+            socket.sendMessage(
+              id,
+              { image: { url: json.url }, mimeType: "image/png" },
+              { quoted: msg }
+            );
+
+          } catch (err) {
+            console.error(err);
+          }
+        }
+
+        getNeko().catch(err => console.error(err));
+        break;
+
+      case "hneko":
+        const reaction_case_neko_nfsw = { react: { text: "✨", key: msg.key } };
+        socket.sendMessage(id, reaction_case_neko_nfsw, { quoted: msg }).catch(err => console.error(err));
+
+        async function getNeko_nfsw() {
+          try {
+            const res = await fetch('https://api.waifu.pics/nsfw/neko');
+            const json = await res.json();
+
+            if (!json.url) throw 'Error!';
+
+            socket.sendMessage(
+              id,
+              { image: { url: json.url }, mimeType: "image/png" },
+              { quoted: msg }
+            );
+
+          } catch (err) {
+            console.error(err);
+          }
+        }
+
+        getNeko_nfsw().catch(err => console.error(err));
+        break;
+
+// -------------------------------------------------------------------------------------------------------//
+      case "randomanime":
+        const reaction_case_randomanime = { react: { text: "✨", key: msg.key } };
+        socket.sendMessage(id, reaction_case_randomanime, { quoted: msg }).catch(err => console.error(err));
+        async function random_anime() {
+          try {
+            let res = await fetch(`https://api.jikan.moe/v4/random/anime`);
+            if (!res.ok) throw new Error('Error fetching data');
+            let json = await res.json();
+            if (!json.data) throw new Error('Data not available');
+      
+            const image_anime = json.data.images.jpg.large_image_url;
+            const animeinfo = `✨️ *Title:* ${json.data.title}
+🎆️ *Episodes:* ${json.data.episodes}
+💌️ *Rating:* ${json.data.rated}
+❤️ *Score:* ${json.data.score}
+💚️ *Synopsis:* ${json.data.synopsis}`;
+
+            socket.sendMessage(
+              id,
+              { 
+                image: { url: image_anime }, 
+                caption: animeinfo,
+                mimeType: "image/png" },
+              { quoted: msg }
+            );
+          } catch (error) {
+            console.error(error);
+          }
+        }
+        random_anime();
+        break;
+
+      case "randomchar":
+        const reaction_case_randomchar = { react: { text: "✨", key: msg.key } };
+        socket.sendMessage(id, reaction_case_randomchar, { quoted: msg }).catch(err => console.error(err));
+        async function random_char() {
+          let res = await fetch(`https://api.jikan.moe/v4/random/characters`)
+          if (!res.ok) throw eror
+          let json = await res.json()
+          if (!json.data) throw 'Error!'
+      
+          const animeinfo = `✨️ *Nama:* ${json.data.name}
+🎆️ *Kanji:* ${json.data.name_kanji}
+❤️ *Favorites:* ${json.data.favorites}
+💌️ *About:* ${json.data.about}`
+      
+          reply(animeinfo)
+        }
+        random_char()
+        break;
+    }
+  });
+}
+
+connectToWhatsapp();
+
+app.get('/', (req, res) => {
+    console.log(req.url);
+    res.status(200).send('KEEP ONLINE');
+  });
+  
+  app.use((req, res) => {
+    console.log(req.url);
+    res.status(404).send("EndPoint not found");
+  });
+  
+  app.listen(PORT, () => {
+    console.log(`Server Listening on port ${PORT}`);
+  });