Upload 36 files

plugins/aio.js

@@ -0,0 +1,39 @@
+const { aio } = require('notmebotz-tools');
+
+const handler = async (req, res) => {
+  try {
+    const { url } = req.query;
+
+    if (!url) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: url'
+      });
+    }
+
+    const result = await aio(url);
+    res.json({
+      author: "Herza",
+      success: true,
+      msg: result.data
+  });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'All In One DL',
+  description: 'Download All Video Without WM',
+  type: 'GET',
+  routes: ['api/download/aio'],
+  tags: ['downloader', 'tools', 'misc'],
+  parameters: ['url', 'key'],
+  enabled: true,
+  main: ['Downloader'],
+  handler
+}

plugins/apple.js

@@ -0,0 +1,213 @@
+const axios = require('axios');
+
+const cookieString = "_ga=GA1.1.206983766.1756790346; PHPSESSID=jomn6brkleb5969a3opposidru; quality=m4a; dcount=2; _ga_382FSD5=GS2.1.s1756858170$o3$g1$t1756858172$j58$l0$h0";
+
+const axiosInstance = axios.create({
+    headers: {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+        'Cookie': cookieString
+    }
+});
+
+function encodeDownloadUrl(url) {
+    if (!url) return url;
+    return url.replace(/ /g, '%20');
+}
+
+function detectUrlType(url) {
+    if (url.includes('/song/')) {
+        return 'song';
+    } else if (url.includes('/album/') && url.includes('?i=')) {
+        return 'song';
+    } else if (url.includes('/album/') && !url.includes('?i=')) {
+        return 'album';
+    } else {
+        return 'song';
+    }
+}
+
+async function apple(url) {
+    try {
+        const urlType = detectUrlType(url);
+
+        if (urlType === 'album') {
+            return await downloadAlbum(url);
+        } else {
+            return await downloadSong(url);
+        }
+    } catch (error) {
+        return {
+            author: "Herza",
+            status: 500,
+            source: "error",
+            data: {
+                error: error.message,
+                message: 'Download gagal dari aaplmusicdownloader'
+            }
+        };
+    }
+}
+
+async function downloadSong(url) {
+    await axiosInstance.get('https://aaplmusicdownloader.com/ifCaptcha.php');
+
+    const endpoint = url.includes('/song/') 
+        ? 'https://aaplmusicdownloader.com/api/song_url.php'
+        : 'https://aaplmusicdownloader.com/api/applesearch.php';
+
+    const searchResponse = await axiosInstance.get(`${endpoint}?url=${encodeURIComponent(url)}`, {
+        headers: {
+            'Accept': 'application/json, text/javascript, */*; q=0.01',
+            'X-Requested-With': 'XMLHttpRequest',
+            'Referer': 'https://aaplmusicdownloader.com/'
+        }
+    });
+
+    const searchData = searchResponse.data;
+
+    await axiosInstance.get('https://aaplmusicdownloader.com/song.php', {
+        headers: {
+            'Referer': 'https://aaplmusicdownloader.com/'
+        }
+    });
+
+    await axiosInstance.get('https://aaplmusicdownloader.com/ifCaptcha.php', {
+        headers: {
+            'Referer': 'https://aaplmusicdownloader.com/song.php'
+        }
+    });
+
+    const formData = `song_name=${encodeURIComponent(searchData.name)}&artist_name=${encodeURIComponent(searchData.artist)}&url=${encodeURIComponent(url)}&token=none&zip_download=false&quality=m4a`;
+
+    const downloadResponse = await axiosInstance.post('https://aaplmusicdownloader.com/api/composer/swd.php', formData, {
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+            'Accept': 'application/json, text/javascript, */*; q=0.01',
+            'X-Requested-With': 'XMLHttpRequest',
+            'Referer': 'https://aaplmusicdownloader.com/song.php'
+        }
+    });
+
+    const downloadData = downloadResponse.data;
+    const downloadLink = downloadData.dlink || downloadData.wmcode;
+
+    return {
+        author: "Herza",
+        status: 200,
+        source: "aaplmusicdownloader",
+        type: "song",
+        data: {
+            name: searchData.name,
+            albumname: searchData.albumname,
+            artist: searchData.artist,
+            thumb: searchData.thumb,
+            duration: searchData.duration,
+            downloadLink: encodeDownloadUrl(downloadLink),
+            status: downloadData.status
+        }
+    };
+}
+
+async function downloadAlbum(url) {
+    await axiosInstance.get('https://aaplmusicdownloader.com/ifCaptcha.php');
+
+    const playlistResponse = await axiosInstance.get(`https://aaplmusicdownloader.com/api/pl.php?url=${encodeURIComponent(url)}`, {
+        headers: {
+            'Accept': 'application/json, text/javascript, */*; q=0.01',
+            'X-Requested-With': 'XMLHttpRequest',
+            'Referer': 'https://aaplmusicdownloader.com/'
+        }
+    });
+
+    const albumData = playlistResponse.data.album_details;
+    const firstSong = albumData[0];
+
+    await axiosInstance.get('https://aaplmusicdownloader.com/album.php', {
+        headers: {
+            'Referer': 'https://aaplmusicdownloader.com/'
+        }
+    });
+
+    await axiosInstance.get('https://aaplmusicdownloader.com/ifCaptcha.php', {
+        headers: {
+            'Referer': 'https://aaplmusicdownloader.com/album.php'
+        }
+    });
+
+    const formData = `song_name=${encodeURIComponent(firstSong.name)}&artist_name=${encodeURIComponent(firstSong.artist.replace(/&/g, '&'))}&url=${encodeURIComponent(firstSong.link)}&token=na&zip_download=false&quality=m4a`;
+
+    const downloadResponse = await axiosInstance.post('https://aaplmusicdownloader.com/api/composer/swd.php', formData, {
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+            'Accept': 'application/json, text/javascript, */*; q=0.01',
+            'X-Requested-With': 'XMLHttpRequest',
+            'Referer': 'https://aaplmusicdownloader.com/album.php'
+        }
+    });
+
+    const downloadData = downloadResponse.data;
+    const downloadLink = downloadData.dlink || downloadData.wmcode;
+
+    return {
+        author: "Herza",
+        status: 200,
+        source: "aaplmusicdownloader",
+        type: "album",
+        data: {
+            name: firstSong.name,
+            albumname: firstSong.album,
+            artist: firstSong.artist.replace(/&/g, '&'),
+            thumb: firstSong.thumb,
+            duration: firstSong.duration,
+            downloadLink: encodeDownloadUrl(downloadLink),
+            status: downloadData.status
+        }
+    };
+}
+
+const handler = async (req, res) => {
+  try {
+    const { url } = req.query;
+
+    if (!url) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: url'
+      });
+    }
+
+    const result = await apple(url);
+
+    if (result.status === 500) {
+      return res.status(500).json({
+        success: false,
+        error: result.data.error,
+        message: result.data.message
+      });
+    }
+
+    res.json({
+      author: "Herza",
+      success: true,
+      msg: result.data
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Apple Music DL',
+  description: 'Download Apple Music Song or Album',
+  type: 'GET',
+  routes: ['api/download/applemusic'],
+  tags: ['downloader', 'tools', 'misc'],
+  parameters: ['url', 'key'],
+  enabled: true,
+  main: ['Downloader'],
+  handler
+}

plugins/brat.js

@@ -0,0 +1,61 @@
+const axios = require('axios');
+const FormData = require('form-data');
+
+const handler = async (req, res) => {
+  try {
+    const { text } = req.query;
+
+    if (!text) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: text'
+      });
+    }
+
+    const imageUrl = `https://api.siputzx.my.id/api/m/brat?text=${encodeURIComponent(text)}&isAnimated=false&delay=500`;
+
+    const imageResponse = await axios.get(imageUrl, {
+      responseType: 'arraybuffer'
+    });
+
+    const formData = new FormData();
+    formData.append('file', Buffer.from(imageResponse.data), {
+      filename: 'image.jpg',
+      contentType: imageResponse.headers['content-type'] || 'image/jpeg'
+    });
+
+    const uploadResponse = await axios.post(
+      'https://cdnme.idnet.my.id/upload',
+      formData,
+      {
+        headers: {
+          ...formData.getHeaders()
+        }
+      }
+    );
+
+    res.json({
+      author: "Herza",
+      success: true,
+      url: uploadResponse.data.url
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Brat Image Generator',
+  description: 'Generate brat style image and upload to CDN',
+  type: 'GET',
+  routes: ['api/maker/bratgen'],
+  tags: ['tools', 'image', 'generator'],
+  parameters: ['text'],
+  enabled: true,
+  main: ['Maker'],
+  handler
+};

plugins/cloudflare-bypass.js

@@ -0,0 +1,148 @@
+const BASE_URL = 'https://shannz.zone.id';
+
+async function callBypassAPI(endpoint, data = {}) {
+    const validEndpoints = ['stats', 'waf-session', 'solve-turnstile-min', 'solve-turnstile-max', 'get-source'];
+    if (!validEndpoints.includes(endpoint)) {
+        throw new Error(`Endpoint tidak valid: ${endpoint}`);
+    }
+
+    const url = `${BASE_URL}/api/${endpoint}`;
+    let options = {
+        headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json'
+        }
+    };
+
+    if (endpoint === 'stats') {
+        options.method = 'GET';
+    } else {
+        options.method = 'POST';
+        if (Object.keys(data).length > 0) {
+            options.body = JSON.stringify(data);
+        }
+    }
+
+    try {
+        const response = await fetch(url, options);
+        const json = await response.json();
+
+        if (json.success === true) {
+            return json.data;
+        }
+
+        const errorMessage = json.error || `Error API pada endpoint /api/${endpoint}`;
+        throw new Error(errorMessage);
+
+    } catch (error) {
+        throw error;
+    }
+}
+
+const handler = async (req, res) => {
+    try {
+        const { url, sitekey, key, mode } = req.query;
+
+        if (!url) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing required parameter: url'
+            });
+        }
+
+        if (!key) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing required parameter: key'
+            });
+        }
+
+        const validModes = ['turnstile-min', 'turnstile-max', 'waf-session', 'source', 'stats'];
+        const selectedMode = mode || 'turnstile-min';
+
+        if (!validModes.includes(selectedMode)) {
+            return res.status(400).json({
+                success: false,
+                error: `Invalid mode. Valid modes: ${validModes.join(', ')}`
+            });
+        }
+
+        let endpoint;
+        let data = { url };
+
+        switch(selectedMode) {
+            case 'turnstile-min':
+                if (!sitekey) {
+                    return res.status(400).json({
+                        success: false,
+                        error: 'Parameter sitekey required for turnstile-min mode'
+                    });
+                }
+                endpoint = 'solve-turnstile-min';
+                data.siteKey = sitekey;
+                break;
+            case 'turnstile-max':
+                endpoint = 'solve-turnstile-max';
+                break;
+            case 'waf-session':
+                endpoint = 'waf-session';
+                break;
+            case 'source':
+                endpoint = 'get-source';
+                break;
+            case 'stats':
+                endpoint = 'stats';
+                data = {};
+                break;
+            default:
+                endpoint = 'solve-turnstile-min';
+                if (sitekey) {
+                    data.siteKey = sitekey;
+                }
+        }
+
+        const result = await callBypassAPI(endpoint, data);
+
+        return res.json({
+            author: "Herza",
+            success: true,
+            data: {
+                result: result,
+                url: url,
+                sitekey: sitekey || null,
+                mode: selectedMode,
+                solvedAt: new Date().toISOString()
+            },
+            timestamp: new Date().toISOString()
+        });
+
+    } catch (error) {
+        res.status(500).json({
+            success: false,
+            error: error.message,
+            timestamp: new Date().toISOString()
+        });
+    }
+};
+
+const shannz = {
+    stats: () => callBypassAPI('stats'),
+    wafSession: (url, proxy) => callBypassAPI('waf-session', { url, proxy }),
+    turnstileMin: (url, siteKey, proxy) => callBypassAPI('solve-turnstile-min', { url, siteKey, proxy }),
+    turnstileMax: (url, proxy) => callBypassAPI('solve-turnstile-max', { url, proxy }),
+    source: (url, proxy) => callBypassAPI('get-source', { url, proxy })
+};
+
+module.exports = {
+    name: 'Cloudflare Bypass',
+    description: 'Bypass Cloudflare Turnstile protection',
+    type: 'GET',
+    routes: ['api/tools/bypass'],
+    tags: ['security', 'bypass', 'turnstile'],
+    parameters: ['url', 'sitekey', 'key', 'mode'],
+    limit: 8,
+    enabled: true,
+    main: ['tools'],
+    handler,
+    shannz
+};

plugins/deepseek.js

@@ -0,0 +1,52 @@
+const Groq = require('groq-sdk');
+
+const handler = async (req, res) => {
+  try {
+    const { text } = req.query;
+
+    if (!text) {
+      return res.status(400).json({
+        author: 'Herza',
+        success: false,
+        msg: 'Missing required parameter: text'
+      });
+    }
+
+    const client = new Groq({
+      apiKey: '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',
+    });
+
+    const chatCompletion = await client.chat.completions.create({
+      messages: [{ role: 'user', content: text }],
+      model: 'deepseek-r1-distill-llama-70b',
+    });
+
+    const result = chatCompletion.choices[0]?.message?.content || 'Maaf, saya tidak bisa menjawab itu.';
+
+    res.json({
+      author: 'Herza',
+      success: true,
+      msg: result
+    });
+
+  } catch (error) {
+    console.error('Error fetching from Deepseek:', error);
+    res.status(500).json({
+      author: 'Herza',
+      success: false,
+      msg: 'Terjadi kesalahan saat menghubungi AI.'
+    });
+  }
+};
+
+module.exports = {
+  name: 'DeepSeek AI',
+  description: 'Generate responses using DeepSeek AI via Groq',
+  type: 'GET',
+  routes: ['api/AI/deepseek'],
+  tags: ['ai', 'deepseek', 'groq'],
+  parameters: ['text', 'key'],
+  enabled: true,
+  main: ['AI'],
+  handler
+};

plugins/douyin.js

@@ -0,0 +1,70 @@
+const axios = require('axios');
+
+async function douyin(url) {
+  if (!url) {
+    return {
+      author: "Herza",
+      success: false,
+      error: "URL is required"
+    };
+  }
+
+  try {
+    const response = await axios.post("https://snapdouyin.app/wp-json/mx-downloader/video-data/", 
+      { url },
+      {
+        headers: {
+          "Content-Type": "application/json",
+          "Origin": "https://snapdouyin.app",
+          "Referer": "https://snapdouyin.app/"
+        }
+      }
+    );
+
+    return {
+      author: "Herza",
+      success: true,
+      data: response.data
+    };
+  } catch (error) {
+    return {
+      author: "Herza",
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+const handler = async (req, res) => {
+  try {
+    const { url } = req.query;
+
+    if (!url) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: url'
+      });
+    }
+
+    const result = await douyin(url);
+    res.json(result);
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Douyin DL',
+  description: 'Download Douyin Video',
+  type: 'GET',
+  routes: ['api/download/douyin'],
+  tags: ['downloader', 'tools', 'misc'],
+  parameters: ['url', 'key'],
+  enabled: true,
+  main: ['Downloader'],
+  handler
+};

plugins/fbdl.js

@@ -0,0 +1,110 @@
+const axios = require('axios');
+
+async function fbdl(url) {
+  if (!url) {
+    return {
+      author: "Herza",
+      success: false,
+      error: "URL is required"
+    };
+  }
+
+  try {
+    const verifyResponse = await axios.post('https://fdownloader.net/api/userverify', 
+      `url=${encodeURIComponent(url)}`,
+      {
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+          'Accept': '*/*',
+          'X-Requested-With': 'XMLHttpRequest'
+        }
+      }
+    );
+
+    if (!verifyResponse.data.success) {
+      return {
+        author: "Herza",
+        success: false,
+        error: 'User verification failed'
+      };
+    }
+
+    const token = verifyResponse.data.token;
+    const currentTime = Math.floor(Date.now() / 1000);
+    const k_exp = currentTime + 300;
+
+    const searchResponse = await axios.post('https://v3.fdownloader.net/api/ajaxSearch',
+      `k_exp=${k_exp}&k_token=${token.split('.')[2]}&q=${encodeURIComponent(url)}&lang=en&web=fdownloader.net&v=v2&w=&cftoken=${token}`,
+      {
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+          'Accept': '*/*'
+        }
+      }
+    );
+
+    const htmlData = searchResponse.data.data;
+    const titleMatch = htmlData.match(/<h3>(.+?)<\/h3>/);
+    const durationMatch = htmlData.match(/<p>(\d+:\d+)<\/p>/);
+    const thumbnailMatch = htmlData.match(/src="(https:\/\/scontent[^"]+)"/);
+
+    const hdMatch = htmlData.match(/href="(https:\/\/dl\.snapcdn\.app\/download\?token=[^"]+)"[^>]*title="Download 720p \(HD\)"/);
+    const sdMatch = htmlData.match(/href="(https:\/\/dl\.snapcdn\.app\/download\?token=[^"]+)"[^>]*title="Download 360p \(SD\)"/);
+
+    return {
+      author: 'Herza',
+      success: true,
+      data: {
+        title: titleMatch ? titleMatch[1] : 'Facebook Video',
+        duration: durationMatch ? durationMatch[1] : '0:00',
+        thumbnail: thumbnailMatch ? thumbnailMatch[1].replace(/&amp;/g, '&') : null,
+        downloads: {
+          hd: hdMatch ? hdMatch[1] : null,
+          sd: sdMatch ? sdMatch[1] : null
+        }
+      }
+    };
+  } catch (error) {
+    return {
+      author: 'Herza',
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+const handler = async (req, res) => {
+  try {
+    const { url } = req.query;
+
+    if (!url) {
+      return res.status(400).json({
+        author: "Herza",
+        success: false,
+        error: 'Missing required parameter: url'
+      });
+    }
+
+    const result = await fbdl(url);
+    res.json(result);
+
+  } catch (error) {
+    res.status(500).json({
+      author: "Herza",
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Facebook DL',
+  description: 'Download Facebook Video',
+  type: 'GET',
+  routes: ['api/download/fbdl'],
+  tags: ['downloader', 'tools', 'misc'],
+  parameters: ['url', 'key'],
+  enabled: true,
+  main: ['Downloader'],
+  handler
+};

plugins/google.js

@@ -0,0 +1,40 @@
+const { googleit } = require('notmebotz-tools');
+
+const handler = async (req, res) => {
+  try {
+    const { text } = req.query;
+
+    if (!text) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: text'
+      });
+    }
+
+    const results = await googleit(text);
+
+    res.json({
+      author: 'Herza',
+      success: true,
+      data: results.data
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Google Search',
+  description: 'Search Google by keyword',
+  type: 'GET',
+  routes: ['api/search/google'],
+  tags: ['search', 'google', 'tools'],
+  parameters: ['text'],
+  enabled: true,
+  main: ['Search'],
+  handler
+};

plugins/ig.js

@@ -0,0 +1,39 @@
+const { instagram } = require('notmebotz-tools');
+
+const handler = async (req, res) => {
+  try {
+    const { url } = req.query;
+
+    if (!url) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: url'
+      });
+    }
+
+    const result = await instagram(url);
+    res.json({
+      author: "Herza",
+      success: true,
+      data: result.data
+  });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Instagram DL',
+  description: 'Download Instagram Video Without WM',
+  type: 'GET',
+  routes: ['api/download/instagram'],
+  tags: ['downloader', 'tools', 'misc'],
+  parameters: ['url', 'key'],
+  enabled: true,
+  main: ['Downloader'],
+  handler
+}

plugins/igstalk.js

@@ -0,0 +1,111 @@
+const axios = require('axios');
+
+async function igstalk(user) {
+  try {
+    const profileResponse = await axios.post(
+      'https://api.boostfluence.com/api/instagram-profile-v2',
+      { username: user },
+      { headers: { 'Content-Type': 'application/json' } }
+    );
+
+    const profile = profileResponse.data;
+
+    let postsData = null;
+    try {
+      const initialPostsResponse = await axios.post(
+        'https://api.boostfluence.com/api/instagram-viewer-v2-2',
+        { username: user, type: 'photo', pagination_token: null },
+        { headers: { 'Content-Type': 'application/json' } }
+      );
+
+      if (initialPostsResponse.data.error === 'COMPUTE_REQUIRED') {
+        const { timestamp, expectedCompute } = initialPostsResponse.data.challenge;
+
+        const verifiedPostsResponse = await axios.post(
+          'https://api.boostfluence.com/api/instagram-viewer-v2-2',
+          { username: user, type: 'photo', pagination_token: null },
+          {
+            headers: {
+              'Content-Type': 'application/json',
+              'X-Compute': expectedCompute.toString(),
+              'X-Timestamp': timestamp.toString()
+            }
+          }
+        );
+
+        postsData = verifiedPostsResponse.data;
+      } else {
+        postsData = initialPostsResponse.data;
+      }
+    } catch (postsError) {
+      console.error('Error fetching posts:', postsError.message);
+    }
+
+    return {
+      profile: {
+        username: profile.username,
+        full_name: profile.full_name,
+        biography: profile.biography,
+        follower_count: profile.follower_count,
+        following_count: profile.following_count,
+        media_count: profile.media_count,
+        profile_pic_url: profile.profile_pic_url,
+        profile_pic_url_hd: profile.profile_pic_url_hd,
+        is_verified: profile.is_verified,
+        is_private: profile.is_private,
+        external_url: profile.external_url,
+        category: profile.category
+      }
+    };
+  } catch (error) {
+    throw new Error(`Failed to fetch Instagram data: ${error.message}`);
+  }
+}
+
+const handler = async (req, res) => {
+    try {
+        const { username } = req.query;
+
+        if (!username) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing required parameter: username'
+            });
+        }
+
+        const usernameRegex = /^[a-zA-Z0-9._]{1,30}$/;
+        if (!usernameRegex.test(username)) {
+            return res.status(400).json({
+                success: false,
+                error: 'Invalid username format'
+            });
+        }
+
+        const result = await igstalk(username);
+
+        res.json({
+            author: "Herza",
+            success: true,
+            data: result
+        });
+
+    } catch (error) {
+        res.status(500).json({
+            author: "Herza",
+            success: false,
+            error: error.message
+        });
+    }
+};
+
+module.exports = {
+    name: 'Instagram Stalk',
+    description: 'Get Instagram user profile information including stats, bio, and posts',
+    type: 'GET',
+    routes: ['api/stalk/instagram'],
+    tags: ['social', 'instagram', 'stalk', 'profile'],
+    parameters: ['username', 'key'],
+    enabled: true,
+    main: ['Stalk'],
+    handler
+};

plugins/likee.js

@@ -0,0 +1,88 @@
+const axios = require('axios');
+
+async function likee(url) {
+  try {
+    const apiResponse = await axios.post(
+      'https://steptodown.com/wp-json/aio-dl/video-data/',
+      { url: url },
+      {
+        headers: {
+          'Content-Type': 'application/json',
+          'Origin': 'https://steptodown.com',
+          'Referer': 'https://steptodown.com/',
+          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+          'Accept': 'application/json, text/plain, */*',
+          'Accept-Language': 'en-US,en;q=0.9',
+          'Sec-Fetch-Dest': 'empty',
+          'Sec-Fetch-Mode': 'cors',
+          'Sec-Fetch-Site': 'same-origin'
+        },
+        timeout: 15000
+      }
+    );
+
+    const apiData = apiResponse.data;
+
+    return {
+      url: apiData.url || url,
+      title: apiData.title || null,
+      thumbnail: apiData.thumbnail || null,
+      duration: apiData.duration || null,
+      source: apiData.source || 'likee',
+      medias: apiData.medias || [],
+      sid: apiData.sid || null
+    };
+  } catch (error) {
+    throw new Error(error.message);
+  }
+}
+
+const handler = async (req, res) => {
+  try {
+    const { url } = req.query;
+
+    if (!url) {
+      return res.status(400).json({
+        author: 'Herza',
+        success: false,
+        error: 'Missing required parameter: url',
+        message: 'Please provide a Likee video URL'
+      });
+    }
+
+    if (!url.includes('likee.video') && !url.includes('likee.com')) {
+      return res.status(400).json({
+        author: 'Herza',
+        success: false,
+        error: 'Invalid URL',
+        message: 'Please provide a valid Likee video URL'
+      });
+    }
+
+    const result = await likee(url);
+
+    res.json({
+      author: 'Herza',
+      success: true,
+      data: result
+    });
+  } catch (error) {
+    res.status(500).json({
+      author: 'Herza',
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Likee Downloader',
+  description: 'Download Likee videos without watermark using steptodown API',
+  type: 'GET',
+  routes: ['api/download/likee'],
+  tags: ['tools', 'likee', 'downloader', 'social-media'],
+  main: ['Downloader'],
+  parameters: ['url', 'key'],
+  enabled: true,
+  handler
+};

plugins/mcstalk.js

@@ -0,0 +1,39 @@
+const { mcstalk } = require('notmebotz-tools');
+
+const handler = async (req, res) => {
+  try {
+    const { text } = req.query;
+
+    if (!text) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: text'
+      });
+    }
+
+    const result = await mcstalk(text);
+    res.json({
+      author: "Herza",
+      success: true,
+      data: result.data
+  });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Minecraft Stalk',
+  description: 'Stalk someone Minecraft account with username',
+  type: 'GET',
+  routes: ['api/stalk/minecraft'],
+  tags: ['stalk', 'tools', 'misc'],
+  parameters: ['text', 'key'],
+  enabled: true,
+  main: ['Stalk'],
+  handler
+}

plugins/nnbana.js

@@ -0,0 +1,91 @@
+const axios = require("axios");
+
+async function NanoBanana(prompt, imageUrl, cookie) {
+  try {
+    const api = `https://anabot.my.id/api/ai/geminiOption?prompt=${encodeURIComponent(prompt)}&type=NanoBanana&imageUrl=${encodeURIComponent(imageUrl)}&imageUrl2=&imageUrl3=&imageUrl4=&cookie=${encodeURIComponent(cookie)}&apikey=freeApikey`;
+
+    const response = await axios.get(api, {
+      headers: { 'Accept': 'application/json' }
+    });
+
+    if (response.data && response.data.data && response.data.data.result) {
+      return {
+        success: true,
+        url: response.data.data.result.url,
+        prompt: prompt
+      };
+    }
+
+    throw new Error('Gagal memproses gambar');
+  } catch (err) {
+    throw new Error(err.response?.data?.message || err.message);
+  }
+}
+
+const handler = async (req, res) => {
+  try {
+    const { prompt, imageUrl, cookie, key } = req.query;
+
+    if (!key) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: key'
+      });
+    }
+
+    if (!prompt) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: prompt'
+      });
+    }
+
+    if (!imageUrl) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: imageUrl'
+      });
+    }
+
+    if (!cookie) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: cookie'
+      });
+    }
+
+    const result = await NanoBanana(prompt, imageUrl, cookie);
+
+    return res.json({
+      author: "Herza",
+      success: true,
+      data: {
+        prompt: result.prompt,
+        image_url: result.url,
+        original_url: imageUrl
+      },
+      timestamp: new Date().toISOString()
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message,
+      timestamp: new Date().toISOString()
+    });
+  }
+};
+
+module.exports = {
+  name: 'Nano Banana',
+  description: 'AI Image Editing using Gemini - Edit images with text prompts',
+  type: 'GET',
+  routes: ['api/AI/nanobanana'],
+  tags: ['ai', 'image', 'editing', 'gemini', 'nanobanana'],
+  parameters: ['prompt', 'imageUrl', 'cookie', 'key'],
+  limit: 5,
+  enabled: true,
+  main: ['AI'],
+  handler,
+  NanoBanana
+};

plugins/openai.js

@@ -0,0 +1,39 @@
+const { openai } = require('notmebotz-tools');
+
+const handler = async (req, res) => {
+  try {
+    const { text } = req.query;
+
+    if (!text) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: text'
+      });
+    }
+
+    const result = await openai(text);
+    res.json({
+      author: "Herza",
+      success: true,
+      msg: result.msg 
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'ChatGPT AI',
+  description: 'Generate responses using OpenAI ChatGPT',
+  type: 'GET',
+  routes: ['api/AI/chatgpt'],
+  tags: ['ai', 'chatgpt', 'openai'],
+  main: ['AI'],
+  parameters: ['text', 'key'],
+  enabled: true,
+  handler
+};

plugins/perplexity.js

@@ -0,0 +1,39 @@
+const { perplexity } = require('notmebotz-tools');
+
+const handler = async (req, res) => {
+  try {
+    const { text } = req.query;
+
+    if (!text) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: text'
+      });
+    }
+
+    const result = await perplexity(text);
+    res.json({
+      author: "Herza",
+      success: true,
+      msg: result.msg 
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Perplexity AI',
+  description: 'Generate responses using Perplexity AI',
+  type: 'GET',
+  routes: ['api/AI/perplexity'],
+  tags: ['ai', 'perplexity'],
+  parameters: ['text', 'key'],
+  enabled: true,
+  main: ['AI'],
+  handler
+};

plugins/pinterest.js

@@ -0,0 +1,40 @@
+const { pinsearch } = require('notmebotz-tools');
+
+const handler = async (req, res) => {
+  try {
+    const { text } = req.query;
+
+    if (!text) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: text'
+      });
+    }
+
+    const results = await pinsearch(text);
+
+    res.json({
+      author: 'Herza',
+      success: true,
+      data: results.results
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Pinterest Search',
+  description: 'Search Pinterest images by keyword',
+  type: 'GET',
+  routes: ['api/search/pinsearch'],
+  tags: ['search', 'pinterest', 'tools'],
+  parameters: ['text'],
+  enabled: true,
+  main: ['Search'],
+  handler
+};

plugins/qr-generator.js

@@ -0,0 +1,60 @@
+const handler = async (req, res) => {
+  try {
+      const { text, size = 200, format = 'png' } = req.query;
+
+      if (!text) {
+          return res.status(400).json({
+              success: false,
+              error: 'Missing required parameter: text'
+          });
+      }
+
+const validSizes = [100, 150, 200, 250, 300, 400, 500];
+      const validFormats = ['png', 'svg'];
+
+      if (!validSizes.includes(parseInt(size))) {
+          return res.status(400).json({
+              success: false,
+              error: 'Invalid size. Valid sizes: ' + validSizes.join(', ')
+          });
+      }
+
+      if (!validFormats.includes(format.toLowerCase())) {
+          return res.status(400).json({
+              success: false,
+              error: 'Invalid format. Valid formats: ' + validFormats.join(', ')
+          });
+      }
+
+      const qrApiUrl = `https://api.qrserver.com/v1/create-qr-code/?size=${size}x${size}&data=${encodeURIComponent(text)}&format=${format}`;
+
+      res.json({
+          success: true,
+          data: {
+              text,
+              size: parseInt(size),
+              format,
+              qr_url: qrApiUrl,
+              download_url: qrApiUrl + '&download=1'
+          }
+      });
+
+  } catch (error) {
+      res.status(500).json({
+          success: false,
+          error: error.message
+      });
+  }
+};
+
+module.exports = {
+  name: 'QR Code Generator',
+  description: 'Generate QR codes for text, URLs, and more with custom sizes',
+  type: 'GET',
+  routes: ['api/tools/qr/generate'],
+  tags: ['utility', 'qr', 'generator'],
+  parameters: ['text', 'size', 'format', 'key'],
+  enabled: true,
+  main: ['tools'],
+  handler
+};

plugins/random-generator.js

@@ -0,0 +1,201 @@
+const crypto = require('crypto');
+
+const WORD_LISTS = {
+  lorem: [
+    'lorem', 'ipsum', 'dolor', 'sit', 'amet', 'consectetur', 'adipiscing', 'elit',
+    'sed', 'do', 'eiusmod', 'tempor', 'incididunt', 'ut', 'labore', 'et', 'dolore',
+    'magna', 'aliqua', 'enim', 'ad', 'minim', 'veniam', 'quis', 'nostrud',
+    'exercitation', 'ullamco', 'laboris', 'nisi', 'aliquip', 'ex', 'ea', 'commodo',
+    'consequat', 'duis', 'aute', 'irure', 'in', 'reprehenderit', 'voluptate',
+    'velit', 'esse', 'cillum', 'fugiat', 'nulla', 'pariatur', 'excepteur', 'sint',
+    'occaecat', 'cupidatat', 'non', 'proident', 'sunt', 'culpa', 'qui', 'officia',
+    'deserunt', 'mollit', 'anim', 'id', 'est', 'laborum'
+  ],
+  english: [
+    'the', 'quick', 'brown', 'fox', 'jumps', 'over', 'lazy', 'dog', 'and', 'runs',
+    'through', 'forest', 'while', 'birds', 'sing', 'beautiful', 'songs', 'under',
+    'bright', 'sunny', 'sky', 'with', 'clouds', 'floating', 'peacefully', 'above',
+    'green', 'trees', 'beside', 'flowing', 'river', 'where', 'fish', 'swim',
+    'quietly', 'among', 'rocks', 'covered', 'moss', 'creating', 'natural', 'harmony'
+  ],
+  tech: [
+    'algorithm', 'database', 'framework', 'library', 'function', 'variable', 'array',
+    'object', 'method', 'class', 'interface', 'component', 'module', 'package',
+    'deployment', 'server', 'client', 'backend', 'frontend', 'fullstack', 'api',
+    'endpoint', 'authentication', 'authorization', 'encryption', 'decryption',
+    'blockchain', 'machine', 'learning', 'artificial', 'intelligence', 'neural',
+    'network', 'deep', 'learning', 'data', 'science', 'analytics', 'visualization'
+  ]
+};
+
+const CHARACTERS = {
+  lowercase: 'abcdefghijklmnopqrstuvwxyz',
+  uppercase: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+  numbers: '0123456789',
+  symbols: '!@#$%^&*()_+-=[]{}|;:,.<>?',
+  special: '!@#$%^&*'
+};
+
+const generateRandomWords = (count, wordList) => {
+  const words = [];
+  for (let i = 0; i < count; i++) {
+    const randomIndex = Math.floor(Math.random() * wordList.length);
+    words.push(wordList[randomIndex]);
+  }
+  return words.join(' ');
+};
+
+const generateRandomString = (length, charset) => {
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    result += charset.charAt(Math.floor(Math.random() * charset.length));
+  }
+  return result;
+};
+
+const generatePassword = (length, options) => {
+  let charset = '';
+  if (options.lowercase) charset += CHARACTERS.lowercase;
+  if (options.uppercase) charset += CHARACTERS.uppercase;
+  if (options.numbers) charset += CHARACTERS.numbers;
+  if (options.symbols) charset += CHARACTERS.symbols;
+
+  if (!charset) charset = CHARACTERS.lowercase + CHARACTERS.uppercase + CHARACTERS.numbers;
+
+  return generateRandomString(length, charset);
+};
+
+const generateSentences = (count, wordList, minWords = 5, maxWords = 15) => {
+  const sentences = [];
+  for (let i = 0; i < count; i++) {
+    const wordCount = Math.floor(Math.random() * (maxWords - minWords + 1)) + minWords;
+    const words = [];
+    for (let j = 0; j < wordCount; j++) {
+      const randomIndex = Math.floor(Math.random() * wordList.length);
+      words.push(wordList[randomIndex]);
+    }
+    let sentence = words.join(' ');
+    sentence = sentence.charAt(0).toUpperCase() + sentence.slice(1) + '.';
+    sentences.push(sentence);
+  }
+  return sentences.join(' ');
+};
+
+const handler = async (req, res) => {
+  try {
+    const { 
+      type = 'words', 
+      count = 10, 
+      length = 12,
+      wordType = 'lorem',
+      includeNumbers = true,
+      includeUppercase = true,
+      includeLowercase = true,
+      includeSymbols = false,
+      minWords = 5,
+      maxWords = 15
+    } = req.query;
+
+    const validTypes = ['words', 'sentences', 'paragraphs', 'password', 'string', 'uuid'];
+    const validWordTypes = Object.keys(WORD_LISTS);
+
+    if (!validTypes.includes(type)) {
+      return res.status(400).json({
+        success: false,
+        error: `Invalid type. Valid types: ${validTypes.join(', ')}`
+      });
+    }
+
+    if (!validWordTypes.includes(wordType) && ['words', 'sentences', 'paragraphs'].includes(type)) {
+      return res.status(400).json({
+        success: false,
+        error: `Invalid wordType. Valid wordTypes: ${validWordTypes.join(', ')}`
+      });
+    }
+
+    let result = '';
+    const wordList = WORD_LISTS[wordType] || WORD_LISTS.lorem;
+
+    switch (type) {
+      case 'words':
+        result = generateRandomWords(parseInt(count), wordList);
+        break;
+
+      case 'sentences':
+        result = generateSentences(parseInt(count), wordList, parseInt(minWords), parseInt(maxWords));
+        break;
+
+      case 'paragraphs':
+        const paragraphs = [];
+        for (let i = 0; i < parseInt(count); i++) {
+          const sentenceCount = Math.floor(Math.random() * 6) + 3;
+          paragraphs.push(generateSentences(sentenceCount, wordList, parseInt(minWords), parseInt(maxWords)));
+        }
+        result = paragraphs.join('\n\n');
+        break;
+
+      case 'password':
+        const passwordOptions = {
+          lowercase: includeLowercase === 'true',
+          uppercase: includeUppercase === 'true',
+          numbers: includeNumbers === 'true',
+          symbols: includeSymbols === 'true'
+        };
+        result = generatePassword(parseInt(length), passwordOptions);
+        break;
+
+      case 'string':
+        let charset = '';
+        if (includeLowercase === 'true') charset += CHARACTERS.lowercase;
+        if (includeUppercase === 'true') charset += CHARACTERS.uppercase;
+        if (includeNumbers === 'true') charset += CHARACTERS.numbers;
+        if (includeSymbols === 'true') charset += CHARACTERS.symbols;
+        if (!charset) charset = CHARACTERS.lowercase + CHARACTERS.numbers;
+        result = generateRandomString(parseInt(length), charset);
+        break;
+
+      case 'uuid':
+        result = crypto.randomUUID();
+        break;
+    }
+
+    res.json({
+      success: true,
+      data: {
+        type,
+        result,
+        length: result.length,
+        word_count: result.split(' ').length,
+        generated_at: new Date().toISOString(),
+        parameters: {
+          type,
+          count: parseInt(count),
+          length: parseInt(length),
+          wordType,
+          includeNumbers: includeNumbers === 'true',
+          includeUppercase: includeUppercase === 'true',
+          includeLowercase: includeLowercase === 'true',
+          includeSymbols: includeSymbols === 'true'
+        }
+      }
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Random Text Generator',
+  description: 'Generate random text, words, sentences, passwords, and UUIDs',
+  type: 'GET',
+  routes: ['api/tools/random/text'],
+  tags: ['utility', 'random', 'generator', 'text'],
+  parameters: ['type', 'count', 'length', 'wordType', 'includeNumbers', 'includeUppercase', 'includeLowercase', 'includeSymbols'],
+  enabled: true,
+  main: ['tools'],
+  handler
+};

plugins/sc.js

@@ -0,0 +1,39 @@
+const { soundcloud } = require('notmebotz-tools');
+
+const handler = async (req, res) => {
+  try {
+    const { url } = req.query;
+
+    if (!url) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: url'
+      });
+    }
+
+    const result = await soundcloud(url);
+    res.json({
+      author: "Herza",
+      success: true,
+      data: result.data
+  });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'SoundCloud DL',
+  description: 'Download Soundcloud Music from our server',
+  type: 'GET',
+  routes: ['api/download/soundcloud'],
+  tags: ['downloader', 'tools', 'misc'],
+  parameters: ['url', 'key'],
+  enabled: true,
+  main: ['Downloader'],
+  handler
+}

plugins/spotifydl.js

@@ -0,0 +1,39 @@
+const { spotydl } = require('notmebotz-tools');
+
+const handler = async (req, res) => {
+  try {
+    const { url } = req.query;
+
+    if (!url) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: url'
+      });
+    }
+
+    const result = await spotydl(url);
+    res.json({
+      author: "Herza",
+      success: true,
+      msg: result.data
+  });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Spotify DL',
+  description: 'Download Spotify Music Without Effort',
+  type: 'GET',
+  routes: ['api/download/spotifydl'],
+  tags: ['downloader', 'tools', 'misc'],
+  parameters: ['url', 'key'],
+  enabled: true,
+  main: ['Downloader'],
+  handler
+}

plugins/spotifysearch.js

@@ -0,0 +1,39 @@
+const { spotifysearch } = require('notmebotz-tools');
+
+const handler = async (req, res) => {
+  try {
+    const { text } = req.query;
+
+    if (!text) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: text'
+      });
+    }
+
+    const result = await spotifysearch(text);
+    res.json({
+      author: "Herza",
+      success: true,
+      data: result.results 
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Spotify Search',
+  description: 'Generate responses using OpenAI ChatGPT',
+  type: 'GET',
+  routes: ['api/search/spotify'],
+  tags: ['tools', 'spotify', 'downloader'],
+  main: ['Search'],
+  parameters: ['text', 'key'],
+  enabled: true,
+  handler
+};

plugins/subdo.js

@@ -0,0 +1,174 @@
+const { shannz: cf } = require('bycf');
+
+async function getTurnstileToken() {
+    try {
+        const token = await cf.turnstileMin(
+            "https://www.subdomainfinder.in",
+            "0x4AAAAAAAj7jyMV3Zv9ZMN-",
+            "host:port"
+        );
+        return token;
+    } catch (error) {
+        throw new Error("Gagal mendapatkan Turnstile token: " + error.message);
+    }
+}
+
+async function findSubdomains(domain, token) {
+    const response = await fetch(`https://api.subdomainfinder.in/?domain=${domain}`, {
+        method: 'GET',
+        headers: {
+            'X-Secure-Token': token,
+            'X-Referer': 'https://www.google.com/',
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        }
+    });
+
+    if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    return await response.json();
+}
+
+async function resolveDNS(subdomain) {
+    const response = await fetch(`https://lookup.subdomainfinder.in/resolve?name=${subdomain}&rd=1`, {
+        method: 'GET',
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        }
+    });
+
+    if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    return await response.json();
+}
+
+async function getIPInfo(ip) {
+    const response = await fetch(`https://ipresolver.subdomainfinder.in/${ip}`, {
+        method: 'GET',
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        }
+    });
+
+    if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    return await response.json();
+}
+
+function extractIPFromDNS(dnsData) {
+    if (!dnsData || !dnsData.Answer) return null;
+
+    for (const answer of dnsData.Answer) {
+        if (answer.type === 1 && answer.data) {
+            return answer.data;
+        }
+    }
+    return null;
+}
+
+async function subdo(domain) {
+    const token = await getTurnstileToken();
+
+    const subdomainData = await findSubdomains(domain, token);
+
+    const results = [];
+
+    for (const sub of subdomainData.data) {
+        try {
+            const dnsData = await resolveDNS(sub.subdomain);
+
+            const ip = extractIPFromDNS(dnsData);
+
+            let result = {
+                subdomain: sub.subdomain,
+                ip: ip || 'N/A',
+                cloudflare: sub.cloudflare,
+                dnsStatus: dnsData.Status
+            };
+
+            if (ip) {
+                try {
+                    const ipInfo = await getIPInfo(ip);
+                    if (ipInfo.success && ipInfo.result && ipInfo.result.ip) {
+                        result.ipInfo = {
+                            location: ipInfo.result.ip.locationName,
+                            asn: ipInfo.result.ip.asnName,
+                            country: ipInfo.result.ip.location,
+                            flag: ipInfo.result.ip.flag
+                        };
+                    }
+                } catch (e) {
+                    result.ipInfo = null;
+                }
+            }
+
+            results.push(result);
+        } catch (error) {
+            results.push({
+                subdomain: sub.subdomain,
+                error: error.message
+            });
+        }
+    }
+
+    return {
+        domain: domain,
+        count: subdomainData.count,
+        data: results
+    };
+}
+
+const handler = async (req, res) => {
+    try {
+        const { domain } = req.query;
+
+        if (!domain) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing required parameter: domain'
+            });
+        }
+
+        const domainRegex = /^[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9]?\.([a-zA-Z]{2,}\.?)+$/;
+        if (!domainRegex.test(domain)) {
+            return res.status(400).json({
+                success: false,
+                error: 'Invalid domain format'
+            });
+        }
+
+        const result = await subdo(domain);
+
+        res.json({
+            success: true,
+            data: {
+                domain: result.domain,
+                total_subdomains: result.count,
+                subdomains: result.data
+            }
+        });
+
+    } catch (error) {
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+};
+
+module.exports = {
+    name: 'Subdomain Finder',
+    description: 'Find subdomains with IP addresses and location information',
+    type: 'GET',
+    routes: ['api/tools/subdomain/finder'],
+    tags: ['security', 'subdomain', 'dns', 'recon'],
+    parameters: ['domain', 'key'],
+    enabled: true,
+    main: ['tools', "Search"],
+    handler
+};

plugins/suno.js

@@ -0,0 +1,263 @@
+const axios = require('axios');
+const { v4: uuidv4 } = require('uuid');
+const readline = require('readline');
+
+const sonu = {
+  api: {
+    base: 'https://musicai.apihub.today/api/v1',
+    endpoints: {
+      register: '/users',
+      create: '/song/create',
+      checkStatus: '/song/user'
+    }
+  },
+
+  headers: {
+    'user-agent': 'NB Android/1.0.0',
+    'content-type': 'application/json',
+    'accept': 'application/json',
+    'x-platform': 'android',
+    'x-app-version': '1.0.0',
+    'x-country': 'ID',
+    'accept-language': 'id-ID',
+    'x-client-timezone': 'Asia/Jakarta'
+  },
+
+  deviceId: uuidv4(),
+  userId: null,
+  fcmToken: 'eqnTqlxMTSKQL5NQz6r5aP:APA91bHa3CvL5Nlcqx2yzqTDAeqxm_L_vIYxXqehkgmTsCXrV29eAak6_jqXv5v1mQrdw4BGMLXl_BFNrJ67Em0vmdr3hQPVAYF8kR7RDtTRHQ08F3jLRRI',
+
+  register: async () => {
+    const msgId = uuidv4();
+    const time = Date.now().toString();
+    const header = {
+      ...sonu.headers,
+      'x-device-id': sonu.deviceId,
+      'x-request-id': msgId,
+      'x-message-id': msgId,
+      'x-request-time': time
+    };
+
+    try {
+      const response = await axios.put(
+        `${sonu.api.base}${sonu.api.endpoints.register}`,
+        {
+          deviceId: sonu.deviceId,
+          fcmToken: sonu.fcmToken
+        },
+        { headers: header }
+      );
+      sonu.userId = response.data.id;
+      return {
+        success: true,
+        code: 200,
+        result: { userId: sonu.userId }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        code: err.response?.status || 500,
+        result: { error: err.message }
+      };
+    }
+  },
+
+  create: async ({ title, mood, genre, lyrics, gender }) => {
+    if (!title || title.trim() === '') {
+      return {
+        success: false,
+        code: 400,
+        result: { error: "Judul lagunya kagak boleh kosong bree 😂" }
+      };
+    }
+    if (!lyrics || lyrics.trim() === '') {
+      return {
+        success: false,
+        code: 400,
+        result: { error: "Lirik lagunya mana? Mau generate lagu kan? Yaa mana liriknya 😂" }
+      };
+    }
+    if (lyrics.length > 1500) {
+      return {
+        success: false,
+        code: 400,
+        result: { error: "Lirik lagu kagak boleh lebih dari 1500 karakter yak bree 🗿"}
+      };
+    }
+
+    const msgId = uuidv4();
+    const time = Date.now().toString();
+    const header = {
+      ...sonu.headers,
+      'x-device-id': sonu.deviceId,
+      'x-client-id': sonu.userId,
+      'x-request-id': msgId,
+      'x-message-id': msgId,
+      'x-request-time': time
+    };
+
+    const body = {
+      type: 'lyrics',
+      name: title,
+      lyrics
+    };
+    if (mood && mood.trim() !== '') body.mood = mood;
+    if (genre && genre.trim() !== '') body.genre = genre;
+    if (gender && gender.trim() !== '') body.gender = gender;
+
+    try {
+      const response = await axios.post(
+        `${sonu.api.base}${sonu.api.endpoints.create}`,
+        body,
+        { headers: header }
+      );
+
+      return {
+        success: true,
+        code: 200,
+        result: { songId: response.data.id }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        code: err.response?.status || 500,
+        result: { error: err.message }
+      };
+    }
+  },
+
+  task: async (songId) => {
+    const header = {
+      ...sonu.headers,
+      'x-client-id': sonu.userId
+    };
+
+    const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+    try {
+      let attempt = 0;
+      let found = null;
+
+      while (true) {
+        const response = await axios.get(
+          `${sonu.api.base}${sonu.api.endpoints.checkStatus}`,
+          {
+            params: {
+              userId: sonu.userId,
+              isFavorite: false,
+              page: 1,
+              searchText: ''
+            },
+            headers: header
+          }
+        );
+
+        found = response.data.datas.find(song => song.id === songId);
+        if (!found) {
+          return {
+            success: false,
+            code: 404,
+            result: { error: "Lagunya belum jadi keknya bree, soalnya kagak ada 😂" }
+          };
+        }
+
+        attempt++;
+
+        if (found.url) {
+          return {
+            success: true,
+            code: 200,
+            result: {
+              status: found.status,
+              songId: found.id,
+              title: found.name,
+              username: found.username,
+              url: found.url,
+              thumbnail: found.thumbnail_url
+            }
+          };
+        }
+
+        await delay(3000);
+      }
+    } catch (err) {
+      return {
+        success: false,
+        code: err.response?.status || 500,
+        result: { error: err.message }
+      };
+    }
+  }
+};
+
+const handler = async (req, res) => {
+  try {
+    const { title, mood, genre, lyrics, gender } = req.query;
+
+    if (!title) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: title'
+      });
+    }
+
+    if (!lyrics) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: lyrics'
+      });
+    }
+
+    const registerResult = await sonu.register();
+    if (!registerResult.success) {
+      return res.status(registerResult.code).json({
+        author: "Herza",
+        success: false,
+        error: registerResult.result.error
+      });
+    }
+
+    const createResult = await sonu.create({ title, mood, genre, lyrics, gender });
+    if (!createResult.success) {
+      return res.status(createResult.code).json({
+        author: "Herza",
+        success: false,
+        error: createResult.result.error
+      });
+    }
+
+    const taskResult = await sonu.task(createResult.result.songId);
+    if (!taskResult.success) {
+      return res.status(taskResult.code).json({
+        author: "Herza",
+        success: false,
+        error: taskResult.result.error
+      });
+    }
+
+    res.json({
+      author: "Herza",
+      success: true,
+      result: taskResult.result
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Suno AI Music Generator',
+  description: 'Generate music using Suno AI with custom lyrics',
+  type: 'GET',
+  routes: ['api/AI/sunov1'],
+  tags: ['ai', 'music', 'suno', 'generator'],
+  main: ['AI'],
+  limit: 6,
+  parameters: ['title', 'lyrics', 'mood', 'genre', 'gender', 'key'],
+  enabled: true,
+  handler
+};

plugins/sunov2.js

@@ -0,0 +1,198 @@
+const axios = require('axios');
+const { shannz: cf } = require('bycf');
+
+class YesChatMusicGenerator {
+  constructor() {
+    this.userAgent = "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Mobile Safari/537.36";
+  }
+
+  async getBypassToken() {
+    try {
+      const token = await cf.turnstileMin(
+        "https://www.yeschat.ai/",
+        "0x4AAAAAAATOXAtQtziH-Rwq"
+      );
+      return token;
+    } catch (error) {
+      throw new Error(`Failed to get bypass token: ${error.message}`);
+    }
+  }
+
+  async generateSongLyrics({
+    prompt,
+    title = "Tanpa Judul",
+    style = "Happy",
+    instrumental = false,
+    customMode = true,
+  }) {
+    const token = await this.getBypassToken();
+    if (!token || typeof token !== "string") {
+      throw new Error("Failed to get bypass token.");
+    }
+
+    const res = await axios.post(
+      "https://aiarticle.erweima.ai/api/v1/secondary-page/api/create",
+      {
+        prompt,
+        channel: "MUSIC",
+        id: 1018,
+        type: "features",
+        source: "yeschat.ai",
+        style,
+        title,
+        customMode,
+        instrumental,
+      },
+      {
+        headers: {
+          authority: "aiarticle.erweima.ai",
+          accept: "application/json, text/plain, */*",
+          "accept-language": "ms-MY,ms;q=0.9,en-US;q=0.8,en;q=0.7,id;q=0.6",
+          origin: "https://www.yeschat.ai",
+          referer: "https://www.yeschat.ai/",
+          "sec-ch-ua": '"Not A(Brand";v="8", "Chromium";v="132"',
+          "sec-ch-ua-mobile": "?1",
+          "sec-ch-ua-platform": '"Android"',
+          "sec-fetch-dest": "empty",
+          "sec-fetch-mode": "cors",
+          "sec-fetch-site": "cross-site",
+          "user-agent": this.userAgent,
+          uniqueid: Date.now(),
+          verify: token,
+        },
+      }
+    );
+
+    if (res.data.code !== 200) {
+      throw new Error(res.data.msg || "Failed to generate lyrics");
+    }
+
+    const recordId = res.data?.data?.recordId;
+    return this.pollGeneratedResult(recordId);
+  }
+
+  pollGeneratedResult(recordId, interval = 5000) {
+    return new Promise((resolve, reject) => {
+      const url = `https://aiarticle.erweima.ai/api/v1/secondary-page/api/${recordId}`;
+      const timer = setInterval(async () => {
+        try {
+          const { data } = await axios.get(url, {
+            headers: {
+              authority: "aiarticle.erweima.ai",
+              accept: "application/json, text/plain, */*",
+              "accept-language": "ms-MY,ms;q=0.9,en-US;q=0.8,en;q=0.7,id;q=0.6",
+              origin: "https://www.yeschat.ai",
+              referer: "https://www.yeschat.ai/",
+              "sec-ch-ua": '"Not A(Brand";v="8", "Chromium";v="132"',
+              "sec-ch-ua-mobile": "?1",
+              "sec-ch-ua-platform": '"Android"',
+              "sec-fetch-dest": "empty",
+              "sec-fetch-mode": "cors",
+              "sec-fetch-site": "cross-site",
+              "user-agent": this.userAgent,
+            },
+          });
+
+          if (data.code !== 200) {
+            clearInterval(timer);
+            return reject(new Error(data.msg || "Unexpected error"));
+          }
+
+          if (data.data?.failCode && data.data?.failMsg) {
+            clearInterval(timer);
+            return reject(new Error(data.data.failMsg));
+          }
+
+          if (data.data?.state && data.data.completeData) {
+            clearInterval(timer);
+            return resolve(JSON.parse(data.data.completeData));
+          }
+        } catch (err) {
+          clearInterval(timer);
+          return reject(err);
+        }
+      }, interval);
+    });
+  }
+}
+
+const handler = async (req, res) => {
+  try {
+    const { mode, prompt, lyrics, title, style, instrumental } = req.query;
+
+    if (!mode) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: mode (custom/ai)'
+      });
+    }
+
+    const modeNormalized = mode.toLowerCase();
+
+    if (modeNormalized !== 'custom' && modeNormalized !== 'ai') {
+      return res.status(400).json({
+        success: false,
+        error: 'Invalid mode. Use "custom" for Custom Lyrics or "ai" for AI Lyrics'
+      });
+    }
+
+    let finalPrompt;
+    let customMode;
+
+    if (modeNormalized === 'custom') {
+      if (!lyrics) {
+        return res.status(400).json({
+          success: false,
+          error: 'Missing required parameter: lyrics (required for Custom Lyrics mode)'
+        });
+      }
+      finalPrompt = lyrics;
+      customMode = true;
+    } else {
+      if (!prompt) {
+        return res.status(400).json({
+          success: false,
+          error: 'Missing required parameter: prompt (required for AI Lyrics mode)'
+        });
+      }
+      finalPrompt = prompt;
+      customMode = false;
+    }
+
+    const generator = new YesChatMusicGenerator();
+
+    const result = await generator.generateSongLyrics({
+      prompt: finalPrompt,
+      title: title || "Tanpa Judul",
+      style: style || "Happy",
+      instrumental: instrumental === 'true',
+      customMode: customMode
+    });
+
+    res.json({
+      author: "Herza",
+      success: true,
+      mode: modeNormalized === 'custom' ? 'Custom Lyrics' : 'AI Lyrics',
+      result: result
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'SunoV2 Music Generator',
+  description: 'Generate music using YesChat AI with custom lyrics or AI-generated lyrics',
+  type: 'GET',
+  routes: ['api/AI/sunov2'],
+  tags: ['ai', 'music', 'yeschat', 'generator'],
+  main: ['AI'],
+  limit: 12,
+  parameters: ['mode', 'prompt', 'lyrics', 'title', 'style', 'instrumental', 'key'],
+  enabled: true,
+  handler
+};

plugins/sunov3.js

@@ -0,0 +1,254 @@
+const axios = require("axios");
+const { v4: uuidv4 } = require("uuid");
+
+function randomHex(length) {
+  const chars = "abcdef0123456789";
+  return Array.from({ length }, () => chars[Math.floor(Math.random() * chars.length)]).join("");
+}
+
+function gieneticTrace() {
+  return `${randomHex(32)}-${randomHex(16)}`;
+}
+
+async function login(deviceId) {
+  const res = await axios.post(
+    "https://api.sunora.mavtao.com/api/auth/login",
+    { device_id: deviceId },
+    {
+      headers: {
+        "user-agent": "Dart/3.4 (gienetic_build)",
+        "version": "2.2.2",
+        "accept-encoding": "gzip",
+        "content-type": "application/json",
+        "buildnumber": "105",
+        "platform": "android",
+        "sentry-trace": gieneticTrace()
+      }
+    }
+  );
+  return res.data?.data?.token || null;
+}
+
+async function polllll(xAuth, maxAttempts = 30, delayMs = 30000) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const res = await axios.get(
+        "https://api.sunora.mavtao.com/api/music/music_page?page=1&pagesize=50",
+        {
+          headers: {
+            "user-agent": "Dart/3.4 (gienetic_build)",
+            "version": "2.2.2",
+            "accept-encoding": "gzip",
+            "x-auth": xAuth,
+            "buildnumber": "105",
+            "platform": "android",
+            "sentry-trace": gieneticTrace()
+          }
+        }
+      );
+
+      const records = res.data?.data?.records || [];
+      const doneSongs = records.filter(r => r.status === "complete");
+
+      if (doneSongs.length > 0) {
+        return doneSongs.map(r => ({
+          id: r.song_id,
+          title: r.title || "Sniff By: Gienetic",
+          tags: r.meta_tags,
+          prompt: r.meta_prompt,
+          audioUrl: r.audio_url,
+          videoUrl: r.video_url,
+          imageUrl: r.image_url,
+          model: r.model_name
+        }));
+      }
+    } catch (err) {
+      console.error("⚠️ Polling error:", err.response?.data || err.message);
+    }
+    await new Promise(r => setTimeout(r, delayMs));
+  }
+  return [];
+}
+
+async function generateNormal(description) {
+  const deviceId = uuidv4();
+  const token = await login(deviceId);
+  if (!token) throw new Error("⚠️ Error: gagal login (makanya tag author ny kalau recode :v)");
+
+  await axios.post(
+    "https://api.sunora.mavtao.com/api/music/advanced_custom_generate",
+    {
+      continue_at: null,
+      continue_clip_id: null,
+      mv: null,
+      description,
+      title: "",
+      mood: "",
+      music_style: "",
+      instrumental_only: false
+    },
+    {
+      headers: {
+        "user-agent": "Dart/3.4 (gienetic_build)",
+        "version": "2.2.2",
+        "accept-encoding": "gzip",
+        "x-auth": token,
+        "content-type": "application/json",
+        "buildnumber": "105",
+        "platform": "android",
+        "sentry-trace": gieneticTrace()
+      }
+    }
+  );
+
+  return await polllll(token);
+}
+
+async function generateCustom({ title, style, lyrics }) {
+  const deviceId = uuidv4();
+  const token = await login(deviceId);
+  if (!token) throw new Error("⚠️ Error: gagal login (makanya tag author ny kalau recode :v)");
+
+  await axios.post(
+    "https://api.sunora.mavtao.com/api/music/custom_generate",
+    {
+      continue_at: null,
+      continue_clip_id: null,
+      mv: null,
+      prompt: lyrics,
+      title,
+      tags: style
+    },
+    {
+      headers: {
+        "user-agent": "Dart/3.4 (gienetic_build)",
+        "version": "2.2.2",
+        "accept-encoding": "gzip",
+        "x-auth": token,
+        "content-type": "application/json",
+        "buildnumber": "105",
+        "platform": "android",
+        "sentry-trace": gieneticTrace()
+      }
+    }
+  );
+
+  return await polllll(token);
+}
+
+async function generateInstrumental(description) {
+  const deviceId = uuidv4();
+  const token = await login(deviceId);
+  if (!token) throw new Error("⚠️ Error: gagal login (makanya tag author ny kalau recode :v)");
+
+  await axios.post(
+    "https://api.sunora.mavtao.com/api/music/advanced_custom_generate",
+    {
+      continue_at: null,
+      continue_clip_id: null,
+      mv: null,
+      description,
+      title: "",
+      mood: "",
+      music_style: "",
+      instrumental_only: true
+    },
+    {
+      headers: {
+        "user-agent": "Dart/3.4 (gienetic_build)",
+        "version": "2.2.2",
+        "accept-encoding": "gzip",
+        "x-auth": token,
+        "content-type": "application/json",
+        "buildnumber": "105",
+        "platform": "android",
+        "sentry-trace": gieneticTrace()
+      }
+    }
+  );
+
+  return await polllll(token);
+}
+
+const handler = async (req, res) => {
+  try {
+    const { mode, description, title, style, lyrics } = req.query;
+
+    if (!mode) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: mode (normal/custom/instrumental)'
+      });
+    }
+
+    const modeNormalized = mode.toLowerCase();
+
+    if (!['normal', 'custom', 'instrumental'].includes(modeNormalized)) {
+      return res.status(400).json({
+        success: false,
+        error: 'Invalid mode. Use "normal", "custom", or "instrumental"'
+      });
+    }
+
+    let result;
+
+    if (modeNormalized === 'normal') {
+      if (!description) {
+        return res.status(400).json({
+          success: false,
+          error: 'Missing required parameter: description (required for normal mode)'
+        });
+      }
+      result = await generateNormal(description);
+    } else if (modeNormalized === 'custom') {
+      if (!title || !style || !lyrics) {
+        return res.status(400).json({
+          success: false,
+          error: 'Missing required parameters: title, style, lyrics (required for custom mode)'
+        });
+      }
+      result = await generateCustom({ title, style, lyrics });
+    } else if (modeNormalized === 'instrumental') {
+      if (!description) {
+        return res.status(400).json({
+          success: false,
+          error: 'Missing required parameter: description (required for instrumental mode)'
+        });
+      }
+      result = await generateInstrumental(description);
+    }
+
+    if (!result || result.length === 0) {
+      return res.status(500).json({
+        success: false,
+        error: 'Failed to generate music or timeout'
+      });
+    }
+
+    res.json({
+      author: "Herza",
+      success: true,
+      mode: modeNormalized,
+      result: result
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Suno V3 Music Generator',
+  description: 'Generate music using Suno V3 AI with multiple modes',
+  type: 'GET',
+  routes: ['api/AI/sunov3'],
+  tags: ['ai', 'music', 'suno', 'generator'],
+  main: ['AI'],
+  parameters: ['mode', 'description', 'title', 'style', 'lyrics', 'key'],
+  enabled: true,
+  limit: 15,
+  handler
+};

plugins/terabox.js

@@ -0,0 +1,52 @@
+const axios = require('axios');
+
+const handler = async (req, res) => {
+  try {
+    const { url } = req.query;
+
+    if (!url) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: url'
+      });
+    }
+
+    const match = url.match(/\/s\/([^/?#]+)/);
+    if (!match || !match[1]) {
+      return res.status(400).json({
+        success: false,
+        error: 'Invalid URL format'
+      });
+    }
+
+    const id = match[1];
+    const { data } = await axios.get(`https://tera2.sylyt93.workers.dev/info?s=${id}`);
+
+    res.json({
+      author: "Herza",
+      success: data.status === 'ok',
+      data: data.status === 'ok' ? {
+        file: data.file,
+        dlink: data.dlink
+      } : {}
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'TeraBox DL',
+  description: 'Auto extract ID and get file info from TeraBox URL',
+  type: 'GET',
+  routes: ['api/download/terabox'],
+  tags: ['downloader', 'tools', 'misc'],
+  parameters: ['url', 'key'],
+  enabled: true,
+  main: ['Downloader'],
+  handler
+};

plugins/text2img.js

@@ -0,0 +1,60 @@
+const axios = require('axios')
+const FormData = require('form-data')
+const fetch = require('node-fetch')
+
+const handler = async (req, res) => {
+  try {
+    const { text } = req.query;
+
+    if (!text) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: text'
+      });
+    }
+
+    let result = await axios.get(`https://ab-text-toimgfast.abrahamdw882.workers.dev/?text=${encodeURIComponent(text)}`, {
+      responseType: 'arraybuffer'
+    })
+
+    let buffer = Buffer.from(result.data)
+
+    let form = new FormData()
+    form.append('file', buffer, {
+      filename: 'image.webp',
+      contentType: 'image/webp'
+    })
+
+    let uploadRes = await fetch('https://tmpfiles.org/api/v1/upload', {
+      method: 'POST',
+      body: form
+    })
+
+    let uploadData = await uploadRes.json()
+    let fileUrl = uploadData.data.url.replace('tmpfiles.org/', 'tmpfiles.org/dl/')
+
+    res.json({
+      author: "Herza",
+      success: true,
+      url: fileUrl
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Text2IMG AI',
+  description: 'Generate Image using OpenAI ChatGPT',
+  type: 'GET',
+  routes: ['api/AI/text2img'],
+  tags: ['ai', 'text2img', 'openai'],
+  main: ['AI'],
+  parameters: ['text'],
+  enabled: true,
+  handler
+};

plugins/text2video.js

@@ -0,0 +1,296 @@
+const axios = require('axios');
+const FormData = require('form-data');
+
+const aiLabs = {
+  api: {
+    base: 'https://text2video.aritek.app',
+    endpoints: {
+      text2img: '/text2img',
+      generate: '/txt2videov3',
+      video: '/video'
+    }
+  },
+
+  headers: {
+    'user-agent': 'NB Android/1.0.0',
+    'accept-encoding': 'gzip',
+    'content-type': 'application/json',
+    authorization: ''
+  },
+
+  state: {
+    token: null
+  },
+
+  setup: {
+    cipher: 'hbMcgZLlzvghRlLbPcTbCpfcQKM0PcU0zhPcTlOFMxBZ1oLmruzlVp9remPgi0QWP0QW',
+    shiftValue: 3,
+
+    dec(text, shift) {
+      return [...text].map(c =>
+        /[a-z]/.test(c)
+          ? String.fromCharCode((c.charCodeAt(0) - 97 - shift + 26) % 26 + 97)
+          : /[A-Z]/.test(c)
+          ? String.fromCharCode((c.charCodeAt(0) - 65 - shift + 26) % 26 + 65)
+          : c
+      ).join('');
+    },
+
+    decrypt: async () => {
+      if (aiLabs.state.token) return aiLabs.state.token;
+
+      const input = aiLabs.setup.cipher;
+      const shift = aiLabs.setup.shiftValue;
+      const decrypted = aiLabs.setup.dec(input, shift);
+
+      aiLabs.state.token = decrypted;
+      aiLabs.headers.authorization = decrypted;
+      return decrypted;
+    }
+  },
+
+  deviceId() {
+    return Array.from({ length: 16 }, () =>
+      Math.floor(Math.random() * 16).toString(16)
+    ).join('');
+  },
+
+  text2img: async (prompt) => {
+    if (!prompt?.trim()) {
+      return {
+        success: false,
+        code: 400,
+        result: { 
+          error: 'Yang bener aja anjirr, inputnya kosong begitu 🗿'
+        }
+      };
+    }
+
+    const token = await aiLabs.setup.decrypt();
+    const form = new FormData();
+    form.append('prompt', prompt);
+    form.append('token', token);
+
+    try {
+      const url = aiLabs.api.base + aiLabs.api.endpoints.text2img;
+      const res = await axios.post(url, form, {
+        headers: {
+          ...aiLabs.headers,
+          ...form.getHeaders()
+        }
+      });
+
+      const { code, url: imageUrl } = res.data;
+      if (code !== 0 || !imageUrl) {
+        return {
+          success: false,
+          code: res.status,
+          result: { 
+            error: 'Error bree 😂'
+          }
+        };
+      }
+
+      return {
+        success: true,
+        code: res.status,
+        result: {
+          url: imageUrl.trim(),
+          prompt
+        }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        code: err.response?.status || 500,
+        result: {
+          error: err.message || 'Error bree 😂'
+        }
+      };
+    }
+  },
+
+  generate: async ({ prompt = '', type = 'video', isPremium = 1 } = {}) => {
+    if (!prompt?.trim() || !/^[a-zA-Z0-9\s.,!?'-]+$/.test(prompt)) {
+      return {
+        success: false,
+        code: 400,
+        result: { 
+          error: 'Promptnya kagak boleh kosong bree.. apalagi ada karakternya aneh begitu :v kagak boleh yak 😂'
+        }
+      };
+    }
+
+    if (!/^(image|video)$/.test(type)) {
+      return {
+        success: false,
+        code: 400,
+        result: {
+          error: 'Tipenya kagak valid.. lu bisa pake image atau video yak.. ☺️'
+        }
+      };
+    }
+
+    if (type === 'image') {
+      return await aiLabs.text2img(prompt);
+    } else {
+      await aiLabs.setup.decrypt();
+      const payload = {
+        deviceID: aiLabs.deviceId(),
+        isPremium,
+        prompt,
+        used: [],
+        versionCode: 59
+      };
+
+      try {
+        const url = aiLabs.api.base + aiLabs.api.endpoints.generate;
+        const res = await axios.post(url, payload, { headers: aiLabs.headers });
+
+        const { code, key } = res.data;
+        if (code !== 0 || !key || typeof key !== 'string') {
+          return {
+            success: false,
+            code: res.status,
+            result: { 
+              error: 'Heumm.. Gagal bree ngambil Keynya 🫵🏻🐷' 
+            }
+          };
+        }
+        return await aiLabs.video(key);
+      } catch (err) {
+        return {
+          success: false,
+          code: err.response?.status || 500,
+          result: {
+            error: err.message || 'Error bree... 😂'
+          }
+        };
+      }
+    }
+  },
+
+  video: async (key) => {
+    if (!key || typeof key !== 'string') {
+      return {
+        success: false,
+        code: 400,
+        result: { 
+          error: 'Keynya kagak valid bree... 😏😂'
+        }
+      };
+    }
+
+    await aiLabs.setup.decrypt();
+    const payload = { keys: [key] };
+    const url = aiLabs.api.base + aiLabs.api.endpoints.video;
+    const maxAttempts = 100;
+    const delay = 2000;
+    let attempt = 0;
+
+    while (attempt < maxAttempts) {
+      attempt++;
+      try {
+        const res = await axios.post(url, payload, {
+          headers: aiLabs.headers,
+          timeout: 15000
+        });
+
+        const { code, datas } = res.data;
+        if (code === 0 && Array.isArray(datas) && datas.length > 0) {
+          const data = datas[0];
+          if (!data.url || data.url.trim() === '') {
+            await new Promise(r => setTimeout(r, delay));
+            continue;
+          }
+
+          return {
+            success: true,
+            code: res.status,
+            result: {
+              url: data.url.trim(),
+              safe: data.safe === 'true',
+              key: data.key,
+              progress: '100%'
+            }
+          };
+        }
+      } catch (err) {
+        const retry = ['ECONNRESET', 'ECONNABORTED', 'ETIMEDOUT'].includes(err.code);
+        if (retry && attempt < maxAttempts) {
+          await new Promise(r => setTimeout(r, delay));
+          continue;
+        }
+
+        return {
+          success: false,
+          code: err.response?.status || 500,
+          result: {
+            error: 'Error bree...',
+            attempt
+          }
+        };
+      }
+    }
+
+    return {
+      success: false,
+      code: 504,
+      result: {
+        error: 'Proses videonya kelamaan, keknya lagi ngambek tuh Server AI nya wkwk... ',
+        attempt
+      }
+    };
+  }
+};
+
+const handler = async (req, res) => {
+  try {
+    const { prompt } = req.query;
+
+    if (!prompt) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: prompt'
+      });
+    }
+
+    const result = await aiLabs.generate({
+      prompt: prompt,
+      type: 'video',
+      isPremium: 1
+    });
+
+    if (!result.success) {
+      return res.status(result.code).json({
+        author: "Herza",
+        success: false,
+        error: result.result.error
+      });
+    }
+
+    res.json({
+      author: "Herza",
+      success: true,
+      result: result.result
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'AI Labs Text to Video',
+  description: 'Generate video from text prompt using AI Labs',
+  type: 'GET',
+  routes: ['api/AI/text2video'],
+  tags: ['ai', 'video', 'text-to-video', 'generator'],
+  main: ['AI'],
+  parameters: ['prompt', 'key'],
+  enabled: true,
+  handler
+};

plugins/threads.js

@@ -0,0 +1,93 @@
+const axios = require('axios');
+
+async function threads(url) {
+  try {
+    const response = await axios.get('https://api.threadsphotodownloader.com/v2/media', {
+      params: {
+        url: url
+      },
+      headers: {
+        'Accept': '*/*',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+      }
+    });
+
+    const data = response.data;
+
+    if (!data.image_urls && !data.video_urls) {
+      return {
+        author: 'Herza',
+        status: 400,
+        data: {
+          error: true,
+          message: 'No media found'
+        }
+      };
+    }
+
+    return {
+      author: 'Herza',
+      status: 200,
+      data: {
+        images: data.image_urls || [],
+        videos: data.video_urls || []
+      }
+    };
+
+  } catch (error) {
+    return {
+      author: 'Herza',
+      status: 500,
+      data: {
+        error: true,
+        message: error.message
+      }
+    };
+  }
+}
+
+const handler = async (req, res) => {
+  try {
+    const { url } = req.query;
+
+    if (!url) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: url'
+      });
+    }
+
+    const result = await threads(url);
+
+    if (result.status !== 200) {
+      return res.status(result.status).json({
+        success: false,
+        error: result.data.message
+      });
+    }
+
+    res.json({
+      author: "Herza",
+      success: true,
+      msg: result.data
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Threads DL',
+  description: 'Download Threads Media',
+  type: 'GET',
+  routes: ['api/download/threads'],
+  tags: ['downloader', 'tools', 'misc'],
+  parameters: ['url', 'key'],
+  enabled: true,
+  main: ['Downloader'],
+  handler
+}

plugins/tiktok.js

@@ -0,0 +1,39 @@
+const { tiktok } = require('notmebotz-tools');
+
+const handler = async (req, res) => {
+  try {
+    const { url } = req.query;
+
+    if (!url) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: url'
+      });
+    }
+
+    const result = await tiktok(url);
+    res.json({
+      author: "Herza",
+      success: true,
+      msg: result.data
+  });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'TikTok DL',
+  description: 'Download TikTok Video Without WM',
+  type: 'GET',
+  routes: ['api/download/tiktok'],
+  tags: ['downloader', 'tools', 'misc'],
+  parameters: ['url', 'key'],
+  enabled: true,
+  main: ['Downloader'],
+  handler
+}

plugins/ttstalk.js

@@ -0,0 +1,131 @@
+const axios = require('axios');
+const cheerio = require('cheerio');
+const { shannz: cf } = require('bycf');
+
+async function getTurnstileToken() {
+    try {
+        const token = await cf.turnstileMin(
+            "https://claptools.com/tiktok-profile-viewer/",
+            "0x4AAAAAAA0aU62HwPRV0j1U"
+        );
+        return token;
+    } catch (error) {
+        throw new Error("Gagal mendapatkan Turnstile token: " + error.message);
+    }
+}
+
+async function getNonce() {
+    const response = await axios.get('https://claptools.com/tiktok-profile-viewer/', {
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        }
+    });
+
+    const $ = cheerio.load(response.data);
+    const nonce = $('input[name="tt_nonce"]').val();
+    return nonce;
+}
+
+async function tiktokStalk(username) {
+    const token = await getTurnstileToken();
+    const nonce = await getNonce();
+
+    const formData = new URLSearchParams();
+    formData.append('username', username);
+    formData.append('tt_nonce', nonce);
+    formData.append('cf-turnstile-response', token);
+
+    const response = await axios.post('https://claptools.com/tiktok-profile-viewer/', formData, {
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+            'Referer': 'https://claptools.com/tiktok-profile-viewer/',
+            'Origin': 'https://claptools.com'
+        }
+    });
+
+    const $ = cheerio.load(response.data);
+
+    const avatar = $('.profile img').attr('src');
+    const fullText = $('.profile-details h2').text().trim();
+    const bio = $('.profile-details p').text().trim();
+
+    const nameMatch = fullText.match(/^(.+?)\s*\(@(.+?)\)$/);
+    const nickname = nameMatch ? nameMatch[1].trim() : '';
+    const usernameFromPage = nameMatch ? nameMatch[2].trim() : username;
+
+    const followers = $('.stats .box').eq(0).find('.number').text().trim();
+    const likes = $('.stats .box').eq(1).find('.number').text().trim();
+    const videos = $('.stats .box').eq(2).find('.number').text().trim();
+
+    const videoList = [];
+    $('.thumb').each((i, elem) => {
+        const thumbnail = $(elem).find('img').attr('src');
+        if (thumbnail) {
+            videoList.push({
+                thumbnail: thumbnail
+            });
+        }
+    });
+
+    return {
+        username: usernameFromPage,
+        nickname: nickname,
+        bio: bio,
+        avatar: avatar,
+        stats: {
+            followers: followers,
+            likes: likes,
+            videos: videos
+        },
+        videoList: videoList
+    };
+}
+
+const handler = async (req, res) => {
+    try {
+        const { username } = req.query;
+
+        if (!username) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing required parameter: username'
+            });
+        }
+
+        const usernameRegex = /^[a-zA-Z0-9._]{1,24}$/;
+        if (!usernameRegex.test(username)) {
+            return res.status(400).json({
+                success: false,
+                error: 'Invalid username format'
+            });
+        }
+
+        const result = await tiktokStalk(username);
+
+        res.json({
+            author: "Herza",
+            success: true,
+            data: result
+        });
+
+    } catch (error) {
+        res.status(500).json({
+            author: "Herza",
+            success: false,
+            error: error.message
+        });
+    }
+};
+
+module.exports = {
+    name: 'TikTok Stalk',
+    description: 'Get TikTok user profile information including stats and avatar',
+    type: 'GET',
+    routes: ['api/stalk/tiktok'],
+    tags: ['social', 'tiktok', 'stalk', 'profile'],
+    parameters: ['username', 'key'],
+    enabled: true,
+    main: ['Stalk'],
+    handler
+};

plugins/twitter.js

@@ -0,0 +1,103 @@
+const axios = require('axios');
+const cheerio = require('cheerio');
+const crypto = require('crypto');
+
+async function twitterDownloader(url) {
+  try {
+    const urlParams = new URLSearchParams(url.split('?')[1]);
+    const tweetUrl = urlParams.get('url') || url;
+    const decodedUrl = decodeURIComponent(tweetUrl);
+
+    const timestamp = Math.floor(Date.now() / 1000);
+    const hash = crypto.createHash('md5');
+    hash.update(timestamp.toString() + 'ssstwitter');
+    const tt = hash.digest('hex');
+
+    const postData = new URLSearchParams({
+      'id': decodedUrl,
+      'locale': 'en',
+      'tt': tt,
+      'ts': timestamp.toString(),
+      'source': 'form'
+    });
+
+    const { data: html } = await axios.post('https://ssstwitter.com/', postData, {
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+        'HX-Request': 'true',
+        'HX-Target': 'target',
+        'HX-Current-URL': 'https://ssstwitter.com/en-2',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Origin': 'https://ssstwitter.com',
+        'Referer': 'https://ssstwitter.com/en-2'
+      }
+    });
+
+    const $ = cheerio.load(html);
+    const title = $('h2').first().text().trim();
+    const downloads = [];
+
+    $('.download-btn').each((i, elem) => {
+      const $elem = $(elem);
+      const downloadUrl = $elem.attr('href');
+      const qualityText = $elem.find('span').text().trim();
+      const quality = qualityText.replace('Download', '').trim();
+
+      if (downloadUrl && downloadUrl.startsWith('http')) {
+        downloads.push({
+          quality: quality,
+          url: downloadUrl
+        });
+      }
+    });
+
+    const mediaType = downloads.length > 0 ? 'video' : 'unknown';
+    const hdDownload = downloads.find(d => d.quality.includes('HD')) || downloads[0];
+
+    return {
+      title: title || 'Twitter Media',
+      mediaType: mediaType,
+      downloads: downloads,
+      hdUrl: hdDownload ? hdDownload.url : null,
+      hdQuality: hdDownload ? hdDownload.quality : null
+    };
+
+  } catch (error) {
+    throw new Error(error.message);
+  }
+}
+
+const handler = async (req, res) => {
+  try {
+    const { url } = req.query;
+    if (!url) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: url'
+      });
+    }
+    const result = await twitterDownloader(url);
+    res.json({
+      author: "Herza",
+      success: true,
+      msg: result
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Twitter DL',
+  description: 'Download Twitter/X Video and Images',
+  type: 'GET',
+  routes: ['api/download/twitter'],
+  tags: ['downloader', 'tools', 'misc'],
+  parameters: ['url', 'key'],
+  enabled: true,
+  main: ['Downloader'],
+  handler
+};

plugins/twitters.js

@@ -0,0 +1,147 @@
+const axios = require('axios');
+
+async function twitterStalk(username) {
+  try {
+    const profileResponse = await axios.get(
+      `https://www.archivlyx.com/api/x/user?username=${username}`,
+      {
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+          'Accept': 'application/json'
+        }
+      }
+    );
+
+    if (!profileResponse.data.success) {
+      throw new Error('Failed to fetch profile data');
+    }
+
+    const profile = profileResponse.data.data;
+
+    const tweetsResponse = await axios.get(
+      `https://www.archivlyx.com/api/x/user-tweets?user=${profile.restId}&cursor=`,
+      {
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+          'Accept': 'application/json'
+        }
+      }
+    );
+
+    if (!tweetsResponse.data.success) {
+      throw new Error('Failed to fetch tweets data');
+    }
+
+    const tweetsData = tweetsResponse.data.data;
+
+    return {
+      profile: {
+        display_name: profile.displayName,
+        handle: profile.handle,
+        bio: profile.bio,
+        avatar: profile.avatar,
+        banner: profile.banner || null,
+        is_verified: profile.isVerified,
+        is_protected: profile.protected,
+        rest_id: profile.restId,
+        stats: {
+          tweets: profile.tweetsCount,
+          followers: profile.followersCount,
+          following: profile.followingCount
+        },
+        website: profile.website || null,
+        location: profile.location || null,
+        join_date: profile.joinDate
+      },
+      tweets: tweetsData.tweets.map(tweet => ({
+        id: tweet.id,
+        text: tweet.text,
+        created_at: tweet.createdAt,
+        author: {
+          id: tweet.author.id,
+          display_name: tweet.author.displayName,
+          handle: tweet.author.handle,
+          avatar: tweet.author.avatar,
+          banner: tweet.author.bannerProfile || null,
+          is_verified: tweet.author.isVerified
+        },
+        stats: {
+          likes: tweet.stats.likes,
+          retweets: tweet.stats.retweets,
+          replies: tweet.stats.replies,
+          quotes: tweet.stats.quotes,
+          views: tweet.stats.views,
+          bookmarks: tweet.stats.bookmarks
+        },
+        media: tweet.media.map(m => ({
+          type: m.type,
+          url: m.url,
+          media_key: m.mediaKey,
+          video_url: m.videoUrl || null
+        })),
+        is_quote: tweet.isQuote,
+        is_retweet: tweet.isRetweet,
+        quoted_tweet: tweet.quotedTweet,
+        retweeted_tweet: tweet.retweetedTweet
+      })),
+      pagination: {
+        next_cursor: tweetsData.pagination.nextCursor,
+        prev_cursor: tweetsData.pagination.prevCursor,
+        has_more: tweetsData.pagination.hasMore
+      }
+    };
+  } catch (error) {
+    if (error.response) {
+      throw new Error(`API Error: ${error.response.status} - ${error.response.statusText}`);
+    }
+    throw new Error(`Failed to fetch Twitter data: ${error.message}`);
+  }
+}
+
+const handler = async (req, res) => {
+    try {
+        const { username } = req.query;
+
+        if (!username) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing required parameter: username'
+            });
+        }
+
+        const usernameRegex = /^[a-zA-Z0-9_]{1,15}$/;
+        if (!usernameRegex.test(username)) {
+            return res.status(400).json({
+                success: false,
+                error: 'Invalid username format'
+            });
+        }
+
+        const result = await twitterStalk(username);
+
+        res.json({
+            author: "Herza",
+            success: true,
+            data: result
+        });
+
+    } catch (error) {
+        res.status(500).json({
+            author: "Herza",
+            success: false,
+            error: error.message
+        });
+    }
+};
+
+module.exports = {
+    name: 'Twitter Stalk',
+    description: 'Get Twitter/X user profile information including stats, bio, and recent tweets',
+    type: 'GET',
+    routes: ['api/stalk/twitter'],
+    tags: ['social', 'twitter', 'x', 'stalk', 'profile'],
+    parameters: ['username', 'key'],
+    enabled: true,
+    main: ['Stalk'],
+    handler
+};

plugins/xbox.js

@@ -0,0 +1,39 @@
+const { sxbox } = require('notmebotz-tools');
+
+const handler = async (req, res) => {
+  try {
+    const { text } = req.query;
+
+    if (!text) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: text'
+      });
+    }
+
+    const result = await sxbox(text);
+    res.json({
+      author: "Herza",
+      success: true,
+      data: result.data
+  });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Xbox Stalk',
+  description: 'Stalk someone Xbox account with username',
+  type: 'GET',
+  routes: ['api/stalk/xbox'],
+  tags: ['stalk', 'tools', 'misc'],
+  parameters: ['text', 'key'],
+  enabled: true,
+  main: ['Stalk'],
+  handler
+}

plugins/ytdl.js

@@ -0,0 +1,105 @@
+const { youtube } = require('notmebotz-tools');
+
+const handler = async (req, res) => {
+  try {
+    const { url, type, quality } = req.query;
+
+    if (!url) {
+      return res.status(400).json({
+        author: "Herza",
+        success: false,
+        error: 'Missing required parameter: url'
+      });
+    }
+
+    if (!type) {
+      return res.status(400).json({
+        author: "Herza",
+        success: false,
+        error: 'Missing required parameter: type'
+      });
+    }
+
+    const validTypes = ['mp3', 'mp4'];
+    if (!validTypes.includes(type.toLowerCase())) {
+      return res.status(400).json({
+        author: "Herza",
+        success: false,
+        error: `${type} is not available, only mp3 and mp4`
+      });
+    }
+
+    if (type.toLowerCase() === 'mp4') {
+      const validQualities = ['144', '240', '360', '480', '720', '1080'];
+
+      if (!quality) {
+        return res.status(400).json({
+          author: "Herza",
+          success: false,
+          error: 'Missing required parameter: quality',
+          formats: ['144', '240', '360', '480', '720', '1080']
+        });
+      }
+
+      if (!validQualities.includes(quality)) {
+        return res.status(400).json({
+          author: "Herza",
+          success: false,
+          error: `Quality ${quality} is not available`,
+          formats: ['144', '240', '360', '480', '720', '1080']
+        });
+      }
+
+      const result = await youtube(`yt${type.toLowerCase()}`, url, quality);
+
+      if (result.status !== 200) {
+        return res.status(result.status).json({
+          author: "Herza",
+          success: false,
+          error: result.data.message || 'Failed to download video'
+        });
+      }
+
+      return res.json({
+        author: "Herza",
+        success: true,
+        data: result.data
+      });
+    }
+
+    const result = await youtube(`yt${type.toLowerCase()}`, url);
+
+    if (result.status !== 200) {
+      return res.status(result.status).json({
+        author: "Herza",
+        success: false,
+        error: result.data.message || 'Failed to download audio'
+      });
+    }
+
+    res.json({
+      author: "Herza",
+      success: true,
+      data: result.data
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      author: "Herza",
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'YouTube DL',
+  description: 'Download YouTube Video/Audio',
+  type: 'GET',
+  routes: ['api/download/youtube'],
+  tags: ['downloader', 'tools', 'misc'],
+  parameters: ['url', 'type', 'quality', 'key'],
+  enabled: true,
+  main: ['Downloader'],
+  handler
+};

plugins/ytstalk.js

@@ -0,0 +1,39 @@
+const { ytstalk } = require('notmebotz-tools');
+
+const handler = async (req, res) => {
+  try {
+    const { text } = req.query;
+
+    if (!text) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: text'
+      });
+    }
+
+    const result = await ytstalk(text);
+    res.json({
+      author: "Herza",
+      success: true,
+      data: result.data
+  });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'YouTube Stalk',
+  description: 'Stalk someone YouTube account with username',
+  type: 'GET',
+  routes: ['api/stalk/youtube'],
+  tags: ['stalk', 'tools', 'misc'],
+  parameters: ['text', 'key'],
+  enabled: true,
+  main: ['Stalk'],
+  handler
+}