Upload 56 files

plugins/aimodel.js

@@ -0,0 +1,91 @@
+const axios = require('axios');
+const { v4: uuidv4 } = require('uuid');
+
+const models = {
+    'gpt-4o-mini': '25865',
+    'gpt-5-nano': '25871',
+    'gemini': '25874',
+    'deepseek': '25873',
+    'claude': '25875',
+    'grok': '25872',
+    'meta-ai': '25870',
+    'qwen': '25869'
+};
+
+async function aichat(question, model) {
+    let { data: html } = await axios.get(`https://px.nekolabs.my.id/${encodeURIComponent('https://chatgptfree.ai/')}`);
+    
+    let nonce = html.data.content.match(/"nonce"\s*:\s*"([^&]+)"/);
+    if (!nonce) throw new Error('Nonce not found.');
+    
+    let { data } = await axios.post(`https://px.nekolabs.my.id/${encodeURIComponent('https://chatgptfree.ai/wp-admin/admin-ajax.php')}`, new URLSearchParams({
+        action: 'aipkit_frontend_chat_message',
+        _ajax_nonce: nonce[1],
+        bot_id: models[model],
+        session_id: uuidv4(),
+        conversation_uuid: uuidv4(),
+        post_id: '6',
+        message: question
+    }).toString(), {
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Origin': 'https://chatgptfree.ai',
+            'Referer': 'https://chatgptfree.ai/',
+            'User-Agent': 'Mozilla/5.0 (Linux; Android 15; SM-F958 Build/AP3A.240905.015) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.86 Mobile Safari/537.36'
+        }
+    });
+    
+    return data.data.content.data.reply;
+}
+
+const handler = async (req, res) => {
+    try {
+        const { text, model } = req.query;
+
+        if (!text) {
+            return res.status(400).json({
+                author: 'Herza',
+                success: false,
+                msg: 'Missing required parameter: text'
+            });
+        }
+
+        if (!model || !models[model]) {
+            return res.status(400).json({
+                author: 'Herza',
+                success: false,
+                msg: 'Invalid or missing model parameter',
+                available_models: Object.keys(models)
+            });
+        }
+
+        const result = await aichat(text, model);
+
+        res.json({
+            author: 'Herza',
+            success: true,
+            model: model,
+            msg: result.trim()
+        });
+
+    } catch (error) {
+        console.error('Error fetching from AI:', error);
+        res.status(500).json({
+            author: 'Herza',
+            success: false,
+            msg: error.message || 'Terjadi kesalahan saat menghubungi AI.'
+        });
+    }
+};
+
+module.exports = {
+    name: 'Model AI Chat',
+    description: 'Generate responses using multiple AI models, availabe models is Claude, gpt-4o-mini, gpt-5-nano, gemini, deepseek, grok, meta-ai, qwen',
+    type: 'GET',
+    routes: ['api/AI/chat'],
+    tags: ['ai', 'gpt', 'gemini', 'claude', 'deepseek'],
+    parameters: ['text', 'model', 'key'],
+    enabled: true,
+    main: ['AI'],
+    handler
+};

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/cloudflare-bypass.js

@@ -0,0 +1,79 @@
+const axios = require('axios');
+
+const handler = async (req, res) => {
+  try {
+    const { site_url, site_key, key } = req.query;
+
+    if (!site_url || !site_key || !key) {
+      return res.status(400).json({
+        author: 'Herza',
+        success: false,
+        error: 'Missing required parameters: site_url, site_key, or key'
+      });
+    }
+
+    const solverUrl = `https://herzaj-turnstile-solver.hf.space/turnstile?url=${encodeURIComponent(site_url)}&sitekey=${encodeURIComponent(site_key)}`;
+    
+    const firstResponse = await axios.get(solverUrl, {
+      timeout: 30000
+    });
+
+    const taskId = firstResponse.data?.task_id;
+    if (!taskId) {
+      return res.status(400).json({
+        author: 'Herza',
+        success: false,
+        error: 'Failed to obtain task_id from solver service'
+      });
+    }
+
+    await new Promise(resolve => setTimeout(resolve, 8000));
+
+    const resultUrl = `https://herzaj-turnstile-solver.hf.space/result?id=${encodeURIComponent(taskId)}`;
+    
+    const secondResponse = await axios.get(resultUrl, {
+      timeout: 30000
+    });
+
+    const { elapsed_time, value } = secondResponse.data;
+
+    if (!value) {
+      return res.status(400).json({
+        author: 'Herza',
+        success: false,
+        error: 'Failed to retrieve token value from solver service'
+      });
+    }
+
+    return res.json({
+      author: 'Herza',
+      success: true,
+      data: {
+        elapsed_time,
+        value,
+        site_url,
+        site_key
+      }
+    });
+
+  } catch (error) {
+    return res.status(500).json({
+      author: 'Herza',
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Cloudflare Turnstile Bypass',
+  description: 'Generate Cloudflare Turnstile tokens with custom site URL and site key',
+  type: 'GET',
+  routes: ['api/tools/bypasscf'],
+  tags: ['utility', 'turnstile', 'solver'],
+  parameters: ['site_url', 'site_key', 'key'],
+  enabled: true,
+  main: ['tools'],
+  limit: 8,
+  handler
+};

plugins/copilot-think.js

@@ -0,0 +1,110 @@
+const WebSocket = require('ws')
+const axios = require('axios')
+
+class CopilotThink {
+    constructor() {
+        this.conversationId = null
+        this.headers = {
+            origin: 'https://copilot.microsoft.com',
+            'user-agent': 'Mozilla/5.0 (Linux; Android 15; SM-F958 Build/AP3A.240905.015) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.86 Mobile Safari/537.36'
+        }
+    }
+
+    async createConversation() {
+        let { data } = await axios.post('https://copilot.microsoft.com/c/api/conversations', null, { headers: this.headers })
+        this.conversationId = data.id
+        return this.conversationId
+    }
+
+    async chat(message) {
+        if (!this.conversationId) await this.createConversation()
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(`wss://copilot.microsoft.com/c/api/chat?api-version=2&features=-,ncedge,edgepagecontext&setflight=-,ncedge,edgepagecontext&ncedge=1`, { headers: this.headers })
+            const response = { text: '', citations: [] }
+            ws.on('open', () => {
+                ws.send(JSON.stringify({
+                    event: 'setOptions',
+                    supportedFeatures: ['partial-generated-images'],
+                    supportedCards: ['weather', 'local', 'image', 'sports', 'video', 'ads', 'safetyHelpline', 'quiz', 'finance', 'recipe'],
+                    ads: { supportedTypes: ['text', 'product', 'multimedia', 'tourActivity', 'propertyPromotion'] }
+                }))
+                ws.send(JSON.stringify({
+                    event: 'send',
+                    mode: 'reasoning',
+                    conversationId: this.conversationId,
+                    content: [{ type: 'text', text: message }],
+                    context: {}
+                }))
+            })
+            ws.on('message', (chunk) => {
+                try {
+                    const parsed = JSON.parse(chunk.toString())
+                    switch (parsed.event) {
+                        case 'appendText':
+                            response.text += parsed.text || ''
+                            break
+                        case 'citation':
+                            response.citations.push({ title: parsed.title, icon: parsed.iconUrl, url: parsed.url })
+                            break
+                        case 'done':
+                            resolve(response)
+                            ws.close()
+                            break
+                        case 'error':
+                            reject(new Error(parsed.message))
+                            ws.close()
+                            break
+                    }
+                } catch (error) {
+                    reject(error.message)
+                }
+            })
+            ws.on('error', reject)
+        })
+    }
+}
+
+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 copilot = new CopilotThink()
+        const result = await copilot.chat(text)
+
+        res.json({
+            author: 'Herza',
+            success: true,
+            model: 'copilot-think',
+            msg: result.text.trim(),
+            citations: result.citations
+        })
+
+    } catch (error) {
+        console.error('Error fetching from Copilot Think:', error)
+        res.status(500).json({
+            author: 'Herza',
+            success: false,
+            msg: 'Terjadi kesalahan saat menghubungi AI.'
+        })
+    }
+}
+
+module.exports = {
+    name: 'Copilot Think AI',
+    description: 'Generate responses using Microsoft Copilot with Reasoning/Think Deeper',
+    type: 'GET',
+    routes: ['api/AI/copilot-think'],
+    tags: ['ai', 'copilot', 'reasoning', 'think-deeper'],
+    parameters: ['text'],
+    enabled: true,
+    main: ['AI'],
+    handler
+}

plugins/copilot.js

@@ -0,0 +1,110 @@
+const WebSocket = require('ws')
+const axios = require('axios')
+
+class Copilot {
+    constructor() {
+        this.conversationId = null
+        this.headers = {
+            origin: 'https://copilot.microsoft.com',
+            'user-agent': 'Mozilla/5.0 (Linux; Android 15; SM-F958 Build/AP3A.240905.015) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.86 Mobile Safari/537.36'
+        }
+    }
+
+    async createConversation() {
+        let { data } = await axios.post('https://copilot.microsoft.com/c/api/conversations', null, { headers: this.headers })
+        this.conversationId = data.id
+        return this.conversationId
+    }
+
+    async chat(message) {
+        if (!this.conversationId) await this.createConversation()
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(`wss://copilot.microsoft.com/c/api/chat?api-version=2&features=-,ncedge,edgepagecontext&setflight=-,ncedge,edgepagecontext&ncedge=1`, { headers: this.headers })
+            const response = { text: '', citations: [] }
+            ws.on('open', () => {
+                ws.send(JSON.stringify({
+                    event: 'setOptions',
+                    supportedFeatures: ['partial-generated-images'],
+                    supportedCards: ['weather', 'local', 'image', 'sports', 'video', 'ads', 'safetyHelpline', 'quiz', 'finance', 'recipe'],
+                    ads: { supportedTypes: ['text', 'product', 'multimedia', 'tourActivity', 'propertyPromotion'] }
+                }))
+                ws.send(JSON.stringify({
+                    event: 'send',
+                    mode: 'chat',
+                    conversationId: this.conversationId,
+                    content: [{ type: 'text', text: message }],
+                    context: {}
+                }))
+            })
+            ws.on('message', (chunk) => {
+                try {
+                    const parsed = JSON.parse(chunk.toString())
+                    switch (parsed.event) {
+                        case 'appendText':
+                            response.text += parsed.text || ''
+                            break
+                        case 'citation':
+                            response.citations.push({ title: parsed.title, icon: parsed.iconUrl, url: parsed.url })
+                            break
+                        case 'done':
+                            resolve(response)
+                            ws.close()
+                            break
+                        case 'error':
+                            reject(new Error(parsed.message))
+                            ws.close()
+                            break
+                    }
+                } catch (error) {
+                    reject(error.message)
+                }
+            })
+            ws.on('error', reject)
+        })
+    }
+}
+
+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 copilot = new Copilot()
+        const result = await copilot.chat(text)
+
+        res.json({
+            author: 'Herza',
+            success: true,
+            model: 'copilot',
+            msg: result.text.trim(),
+            citations: result.citations
+        })
+
+    } catch (error) {
+        console.error('Error fetching from Copilot:', error)
+        res.status(500).json({
+            author: 'Herza',
+            success: false,
+            msg: 'Terjadi kesalahan saat menghubungi AI.'
+        })
+    }
+}
+
+module.exports = {
+    name: 'Copilot AI',
+    description: 'Generate responses using Microsoft Copilot',
+    type: 'GET',
+    routes: ['api/AI/copilot'],
+    tags: ['ai', 'copilot'],
+    parameters: ['text'],
+    enabled: true,
+    main: ['AI'],
+    handler
+}

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/faceswap.js

@@ -0,0 +1,99 @@
+const axios = require('axios');
+const upload = require('../lib/uploadImage');
+
+async function faceSwap(img_url1, img_url2) {
+  try {
+    const response1 = await axios.get(img_url1, { responseType: 'arraybuffer' });
+    const base64_1 = Buffer.from(response1.data).toString('base64');
+    
+    const response2 = await axios.get(img_url2, { responseType: 'arraybuffer' });
+    const base64_2 = Buffer.from(response2.data).toString('base64');
+
+    const swapResponse = await axios.post('https://api.faceswapper.ai/swap', {
+      target: base64_1,
+      source: base64_2,
+      type: 'invisible',
+      id: 'faceswapper'
+    }, {
+      headers: {
+        'Accept': 'application/json, text/plain, */*',
+        'Content-Type': 'application/json',
+        'type': 'rapid'
+      }
+    });
+
+    const base64Data = swapResponse.data.result.replace(/^data:image\/\w+;base64,/, '');
+    const buffer = Buffer.from(base64Data, 'base64');
+    
+    const imageUrl = await upload(buffer);
+
+    return {
+      success: true,
+      elapsedTime: swapResponse.data.elapsedTime,
+      result: swapResponse.data.result,
+      url: imageUrl
+    };
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+const handler = async (req, res) => {
+    try {
+        const { img, img2, key } = req.query;
+
+        if (!img) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing required parameter: img'
+            });
+        }
+
+        if (!img2) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing required parameter: img2'
+            });
+        }
+
+        if (!key) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing required parameter: key'
+            });
+        }
+
+        const result = await faceSwap(img, img2);
+
+        return res.json({
+            author: "Herza",
+            success: true,
+            data: {
+                elapsedTime: result.elapsedTime,
+                result: result.result,
+                url: result.url
+            }
+        });
+
+    } catch (error) {
+        res.status(500).json({
+            success: false,
+            error: error.message,
+            timestamp: new Date().toISOString()
+        });
+    }
+};
+
+module.exports = {
+    name: 'Face Swap',
+    description: 'Swap faces between two images using AI',
+    type: 'GET',
+    routes: ['api/AI/faceswap'],
+    tags: ['AI', 'tools'],
+    parameters: ['img', 'img2', 'key'],
+    limit: 3,
+    enabled: true,
+    main: ['AI', 'tools'],
+    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/flixer.js

@@ -0,0 +1,158 @@
+const puppeteer = require('puppeteer');
+
+const scrapeFlixer = async (searchQuery) => {
+  const browser = await puppeteer.launch({ 
+    headless: true,
+    args: [
+      '--no-sandbox',
+      '--disable-setuid-sandbox',
+      '--disable-dev-shm-usage',
+      '--disable-gpu'
+    ]
+  });
+  
+  const page = await browser.newPage();
+  
+  await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36');
+  
+  const searchUrl = `https://flixer.sh/search?q=${encodeURIComponent(searchQuery)}`;
+  await page.goto(searchUrl, { waitUntil: 'networkidle0', timeout: 30000 });
+  
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  const searchResults = await page.evaluate(() => {
+    const results = [];
+    const images = document.querySelectorAll('img[alt]');
+    
+    images.forEach(img => {
+      const link = img.closest('a');
+      if (link && img.alt) {
+        results.push({
+          title: img.alt,
+          image: img.src,
+          url: link.href
+        });
+      }
+    });
+    
+    return results;
+  });
+
+  if (searchResults.length === 0) {
+    await browser.close();
+    throw new Error('No results found');
+  }
+
+  const movieUrl = searchResults[0].url;
+  await page.goto(movieUrl, { waitUntil: 'networkidle0', timeout: 30000 });
+  
+  await new Promise(resolve => setTimeout(resolve, 3000));
+
+  const servers = await page.evaluate(() => {
+    const serverList = [];
+    const buttons = document.querySelectorAll('button');
+    
+    buttons.forEach(btn => {
+      const nameEl = btn.querySelector('.font-medium');
+      const statusEl = btn.querySelector('.text-green-400');
+      
+      if (nameEl && statusEl && statusEl.textContent.includes('AVAILABLE')) {
+        serverList.push({
+          name: nameEl.textContent.trim(),
+          available: true
+        });
+      }
+    });
+    
+    return serverList;
+  });
+
+  let videoUrl = null;
+  
+  page.on('response', async response => {
+    const url = response.url();
+    if (url.includes('.m3u8') || url.includes('.mp4') || url.includes('stream')) {
+      videoUrl = url;
+    }
+  });
+
+  for (const server of servers) {
+    try {
+      await page.evaluate((serverName) => {
+        const buttons = Array.from(document.querySelectorAll('button'));
+        const btn = buttons.find(b => {
+          const nameEl = b.querySelector('.font-medium');
+          return nameEl && nameEl.textContent.trim() === serverName;
+        });
+        if (btn) btn.click();
+      }, server.name);
+
+      await new Promise(resolve => setTimeout(resolve, 5000));
+
+      const currentVideoUrl = await page.evaluate(() => {
+        const video = document.querySelector('video');
+        return video ? video.src : null;
+      });
+
+      if (currentVideoUrl && !currentVideoUrl.startsWith('blob:')) {
+        videoUrl = currentVideoUrl;
+        break;
+      }
+
+      if (videoUrl && !videoUrl.startsWith('blob:')) {
+        break;
+      }
+    } catch (e) {
+      continue;
+    }
+  }
+
+  await browser.close();
+  
+  return {
+    title: searchResults[0].title,
+    image: searchResults[0].image,
+    movieUrl: movieUrl,
+    servers: servers,
+    videoUrl: videoUrl,
+    allResults: searchResults
+  };
+};
+
+const handler = async (req, res) => {
+  try {
+    const { q } = req.query;
+
+    if (!q) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: q'
+      });
+    }
+
+    const result = await scrapeFlixer(q);
+    res.json({
+      author: "Herza",
+      success: true,
+      msg: result
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Flixer Search',
+  description: 'Search and get video from Flixer',
+  type: 'GET',
+  routes: ['api/search/flixer'],
+  tags: ['search', 'movie', 'tools'],
+  parameters: ['q', 'key'],
+  enabled: true,
+  main: ['Downloader', 'Search'],
+  handler
+};

plugins/flux.js

@@ -0,0 +1,138 @@
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
+
+async function fluxImage(prompt, width = 1024, height = 1024, server = "Azure Lite Supercomputer Server") {
+  try {
+    const { data: init } = await axios.post(
+      "https://nihalgazi-flux-unlimited.hf.space/gradio_api/call/generate_image",
+      { data: [prompt, width, height, 3, true, server] },
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Origin: "https://chrunos.com",
+          Referer: "https://chrunos.com/",
+        },
+      }
+    );
+
+    const eventId = init.event_id;
+    if (!eventId) throw new Error("Failed to obtain event_id.");
+
+    const streamUrl = `https://nihalgazi-flux-unlimited.hf.space/gradio_api/call/generate_image/${eventId}`;
+    let imageUrl = null;
+
+    for (let i = 0; i < 15; i++) {
+      const { data } = await axios.get(streamUrl, {
+        headers: { Accept: "text/event-stream" },
+      });
+
+      const match = data.match(/"url":\s*"([^"]+)"/);
+      if (match) {
+        imageUrl = match[1];
+        break;
+      }
+
+      await new Promise(r => setTimeout(r, 2000));
+    }
+
+    if (!imageUrl) throw new Error("Failed to retrieve image URL from stream.");
+    return imageUrl;
+  } catch (err) {
+    throw new Error(`fluxImage error: ${err.message}`);
+  }
+}
+
+async function downloadAndSaveImage(imageUrl, fileId) {
+  const tmpDir = path.join(process.cwd(), 'tmp');
+  
+  if (!fs.existsSync(tmpDir)) {
+    fs.mkdirSync(tmpDir, { recursive: true });
+  }
+
+  const filePath = path.join(tmpDir, `flux-${fileId}.webp`);
+
+  const response = await axios.get(imageUrl, {
+    responseType: 'arraybuffer',
+    timeout: 30000
+  });
+
+  fs.writeFileSync(filePath, Buffer.from(response.data));
+
+  setTimeout(() => {
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+    }
+  }, 60000);
+
+  return `flux-${fileId}.webp`;
+}
+
+const handler = async (req, res) => {
+  try {
+    const { prompt, key, width, height, server } = req.query;
+
+    if (!prompt) {
+      return res.status(400).json({
+        author: "Herza",
+        success: false,
+        error: 'Missing required parameter: prompt'
+      });
+    }
+
+    if (!key) {
+      return res.status(400).json({
+        author: "Herza",
+        success: false,
+        error: 'Missing required parameter: key'
+      });
+    }
+
+    const imgWidth = width ? parseInt(width) : 1024;
+    const imgHeight = height ? parseInt(height) : 1024;
+    const selectedServer = server || "NSFW-Core: Uncensored Server 2";
+
+    const imageUrl = await fluxImage(prompt, imgWidth, imgHeight, selectedServer);
+    
+    if (!imageUrl) {
+      return res.status(500).json({
+        author: "Herza",
+        success: false,
+        error: 'Failed to generate image'
+      });
+    }
+
+    const fileId = Date.now() + '_' + Math.random().toString(36).substring(7);
+    const filename = await downloadAndSaveImage(imageUrl, fileId);
+
+    const baseUrl = `${req.protocol}://${req.get('host')}`;
+    const localUrl = `${baseUrl}/tmp/${filename}`;
+
+    res.json({
+      author: "Herza",
+      success: true,
+      data: {
+        result: localUrl
+      }
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      author: "Herza",
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Flux Image Generator',
+  description: 'Generate images using Flux AI model',
+  type: 'GET',
+  routes: ['api/AI/Flux'],
+  tags: ['ai', 'image', 'flux', 'generator'],
+  main: ['AI'],
+  parameters: ['prompt', 'key', 'width', 'height', 'server'],
+  enabled: true,
+  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/gpt-5.js

@@ -0,0 +1,110 @@
+const WebSocket = require('ws')
+const axios = require('axios')
+
+class GPT5 {
+    constructor() {
+        this.conversationId = null
+        this.headers = {
+            origin: 'https://copilot.microsoft.com',
+            'user-agent': 'Mozilla/5.0 (Linux; Android 15; SM-F958 Build/AP3A.240905.015) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.86 Mobile Safari/537.36'
+        }
+    }
+
+    async createConversation() {
+        let { data } = await axios.post('https://copilot.microsoft.com/c/api/conversations', null, { headers: this.headers })
+        this.conversationId = data.id
+        return this.conversationId
+    }
+
+    async chat(message) {
+        if (!this.conversationId) await this.createConversation()
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(`wss://copilot.microsoft.com/c/api/chat?api-version=2&features=-,ncedge,edgepagecontext&setflight=-,ncedge,edgepagecontext&ncedge=1`, { headers: this.headers })
+            const response = { text: '', citations: [] }
+            ws.on('open', () => {
+                ws.send(JSON.stringify({
+                    event: 'setOptions',
+                    supportedFeatures: ['partial-generated-images'],
+                    supportedCards: ['weather', 'local', 'image', 'sports', 'video', 'ads', 'safetyHelpline', 'quiz', 'finance', 'recipe'],
+                    ads: { supportedTypes: ['text', 'product', 'multimedia', 'tourActivity', 'propertyPromotion'] }
+                }))
+                ws.send(JSON.stringify({
+                    event: 'send',
+                    mode: 'smart',
+                    conversationId: this.conversationId,
+                    content: [{ type: 'text', text: message }],
+                    context: {}
+                }))
+            })
+            ws.on('message', (chunk) => {
+                try {
+                    const parsed = JSON.parse(chunk.toString())
+                    switch (parsed.event) {
+                        case 'appendText':
+                            response.text += parsed.text || ''
+                            break
+                        case 'citation':
+                            response.citations.push({ title: parsed.title, icon: parsed.iconUrl, url: parsed.url })
+                            break
+                        case 'done':
+                            resolve(response)
+                            ws.close()
+                            break
+                        case 'error':
+                            reject(new Error(parsed.message))
+                            ws.close()
+                            break
+                    }
+                } catch (error) {
+                    reject(error.message)
+                }
+            })
+            ws.on('error', reject)
+        })
+    }
+}
+
+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 gpt5 = new GPT5()
+        const result = await gpt5.chat(text)
+
+        res.json({
+            author: 'Herza',
+            success: true,
+            model: 'gpt-5',
+            msg: result.text.trim(),
+            citations: result.citations
+        })
+
+    } catch (error) {
+        console.error('Error fetching from GPT-5:', error)
+        res.status(500).json({
+            author: 'Herza',
+            success: false,
+            msg: 'Terjadi kesalahan saat menghubungi AI.'
+        })
+    }
+}
+
+module.exports = {
+    name: 'GPT-5 AI',
+    description: 'Generate responses using GPT-5 Smart Model via Copilot',
+    type: 'GET',
+    routes: ['api/AI/gpt-5'],
+    tags: ['ai', 'gpt-5', 'smart'],
+    parameters: ['text'],
+    enabled: true,
+    main: ['AI'],
+    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/img2pixel.js

@@ -0,0 +1,163 @@
+const axios = require('axios');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+async function img2pixel(imgUrl) {
+  let tempFilePath = null;
+
+  try {
+    const response = await axios.get(imgUrl, { 
+      responseType: 'arraybuffer',
+      timeout: 30000
+    });
+    
+    const imageBuffer = Buffer.from(response.data);
+    
+    const tempFileName = `img2pixel_${Date.now()}_${Math.random().toString(36).substring(7)}.jpg`;
+    tempFilePath = path.join(os.tmpdir(), tempFileName);
+    fs.writeFileSync(tempFilePath, imageBuffer);
+
+    const filename = imgUrl.split('/').pop().split('?')[0] || tempFileName;
+    const contentType = 'image/jpeg';
+
+    const presignedResponse = await axios.post(
+      'https://pixelartgenerator.app/api/upload/presigned-url',
+      {
+        filename: filename,
+        contentType: contentType,
+        type: 'pixel-art-source'
+      },
+      {
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      }
+    );
+
+    const { uploadUrl, key, publicUrl } = presignedResponse.data.data;
+
+    await axios.put(uploadUrl, imageBuffer, {
+      headers: {
+        'Content-Type': contentType
+      }
+    });
+
+    if (tempFilePath && fs.existsSync(tempFilePath)) {
+      fs.unlinkSync(tempFilePath);
+      tempFilePath = null;
+    }
+
+    const generateResponse = await axios.post(
+      'https://pixelartgenerator.app/api/pixel/generate',
+      {
+        size: '1:1',
+        type: 'image',
+        imageKey: key,
+        prompt: ''
+      },
+      {
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      }
+    );
+
+    const { taskId } = generateResponse.data.data;
+
+    let attempts = 0;
+    const maxAttempts = 60;
+
+    while (attempts < maxAttempts) {
+      const statusResponse = await axios.get(
+        `https://pixelartgenerator.app/api/pixel/status?taskId=${taskId}`
+      );
+
+      const { status, progress, images, error } = statusResponse.data.data;
+
+      if (status === 'SUCCESS' && images.length > 0) {
+        return images[0];
+      }
+
+      if (error) {
+        throw new Error(`Generation failed: ${error}`);
+      }
+
+      attempts++;
+      await new Promise(resolve => setTimeout(resolve, 3000));
+    }
+
+    throw new Error('Timeout: Generation took too long');
+
+  } catch (error) {
+    if (tempFilePath && fs.existsSync(tempFilePath)) {
+      try {
+        fs.unlinkSync(tempFilePath);
+      } catch (cleanupError) {
+        console.error('Failed to cleanup temp file:', cleanupError);
+      }
+    }
+    throw new Error(`img2pixel error: ${error.message}`);
+  }
+}
+
+const handler = async (req, res) => {
+  try {
+    const { img, key } = req.query;
+
+    if (!img) {
+      return res.status(400).json({
+        author: "Herza",
+        success: false,
+        error: 'Missing required parameter: img (image URL)'
+      });
+    }
+
+    if (!key) {
+      return res.status(400).json({
+        author: "Herza",
+        success: false,
+        error: 'Missing required parameter: key'
+      });
+    }
+
+    try {
+      new URL(img);
+    } catch (e) {
+      return res.status(400).json({
+        author: "Herza",
+        success: false,
+        error: 'Invalid image URL format'
+      });
+    }
+
+    const result = await img2pixel(img);
+    
+    res.json({
+      author: "Herza",
+      success: true,
+      data: {
+        result: result
+      }
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      author: "Herza",
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Image to Pixel Art',
+  description: 'Convert image to pixel art style',
+  type: 'GET',
+  routes: ['api/AI/img2pixel'],
+  tags: ['ai', 'image', 'pixel-art'],
+  main: ['AI'],
+  parameters: ['img', 'key'],
+  enabled: true,
+  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/lyrics.js

@@ -0,0 +1,40 @@
+const axios = require('axios');
+
+const handler = async (req, res) => {
+  try {
+    const { query } = req.query;
+
+    if (!query) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: query'
+      });
+    }
+
+    let result = await axios.get(`https://lyrics.lewdhutao.my.eu.org/v2/youtube/lyrics?title=${encodeURIComponent(query)}`)
+    res.json({
+      author: "Herza",
+      success: true,
+      data: result.data.data
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Lyrics Search',
+  description: 'Input song name and system will get the lyrics for you',
+  type: 'GET',
+  routes: ['api/search/lyrics'],
+  tags: ['Youtube', 'Genius Lyrics', 'Lyrics'],
+  main: ['Search'],
+  parameters: ['query', 'key'],
+  enabled: true,
+  limit: 5,
+  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/mediafire.js

@@ -0,0 +1,48 @@
+const cheerio = require('cheerio');
+const { basename, extname } = require('path');
+
+async function mediafire(url) {
+    const $ = cheerio.load(await (await fetch(url.trim())).text())
+    const title = $("meta[property='og:title']").attr("content")?.trim() || "Unknown"
+    const size = /Download\s*\(([\d.]+\s*[KMGT]?B)\)/i.exec($.html())?.[1] || "Unknown"
+    const dl = $("a.popsok[href^='https://download']").attr("href")?.trim() || $("a.popsok:not([href^='javascript'])").attr("href")?.trim() || (() => { throw new Error("Download URL not found.") })()
+    return { name: title, filename: basename(dl), type: extname(dl), size, download: dl, link: url.trim() }
+}
+
+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 mediafire(url);
+    res.json({
+      author: "Herza",
+      success: true,
+      data: result
+  });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'MediaFire DL',
+  description: 'Download File From Mediafire',
+  type: 'GET',
+  routes: ['api/download/mediafire'],
+  tags: ['downloader', 'tools', 'misc'],
+  parameters: ['url', 'key'],
+  enabled: true,
+  main: ['Downloader'],
+  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/pinlens.js

@@ -0,0 +1,210 @@
+const axios = require('axios');
+const FormData = require('form-data');
+const crypto = require('crypto');
+// SCRAPE BY SIPUTZX
+class PinterestLensScraper {
+  constructor(authToken) {
+    this.authToken = authToken;
+  }
+
+  getRandomHeaders() {
+    const devices = [
+      { model: 'SM-G991B', manufacturer: 'samsung', name: 'Samsung Galaxy S21' },
+      { model: 'SM-A525F', manufacturer: 'samsung', name: 'Samsung Galaxy A52' },
+      { model: 'Pixel 6', manufacturer: 'Google', name: 'Google Pixel 6' },
+      { model: 'Pixel 7 Pro', manufacturer: 'Google', name: 'Google Pixel 7 Pro' },
+      { model: 'M2101K6G', manufacturer: 'Xiaomi', name: 'Xiaomi Redmi Note 10' },
+      { model: '2201117TG', manufacturer: 'Xiaomi', name: 'Xiaomi 11T' },
+      { model: 'CPH2121', manufacturer: 'OPPO', name: 'OPPO Reno5' },
+      { model: 'RMX3085', manufacturer: 'realme', name: 'realme 8 Pro' },
+      { model: 'itel S665L', manufacturer: 'ITEL', name: 'itel S665L' },
+      { model: 'TECNO KE5', manufacturer: 'TECNO', name: 'TECNO Spark 7' }
+    ];
+
+    const versions = ['13.36.2', '13.35.0', '13.34.1', '13.33.0', '13.32.1'];
+    const androidVersions = ['11', '12', '13'];
+    
+    const device = devices[Math.floor(Math.random() * devices.length)];
+    const version = versions[Math.floor(Math.random() * versions.length)];
+    const androidVer = androidVersions[Math.floor(Math.random() * androidVersions.length)];
+    const advertisingId = crypto.randomUUID();
+    const hardwareId = crypto.randomBytes(8).toString('hex');
+    const installId = crypto.randomBytes(16).toString('hex');
+
+    return {
+      'User-Agent': `Pinterest for Android/${version} (${device.model}; ${androidVer})`,
+      'accept-language': 'id-ID',
+      'x-pinterest-advertising-id': advertisingId,
+      'x-pinterest-app-type-detailed': '3',
+      'x-pinterest-device': device.model,
+      'x-pinterest-device-hardwareid': hardwareId,
+      'x-pinterest-device-manufacturer': device.manufacturer,
+      'x-pinterest-installid': installId,
+      'x-pinterest-webview-supported': 'false',
+      'x-pinterest-appstate': 'active',
+      'x-node-id': 'true',
+      'authorization': `Bearer ${this.authToken}`
+    };
+  }
+
+  async searchByImage(imageUrl, pageSize = 12) {
+    const data = new FormData();
+    data.append('camera_type', '0');
+    data.append('source_type', '1');
+    data.append('video_autoplay_disabled', '0');
+    data.append('fields', this.getFields());
+    data.append('page_size', pageSize.toString());
+    data.append('image_url', imageUrl);
+
+    const headers = this.getRandomHeaders();
+    const response = await axios.post(
+      'https://api.pinterest.com/v3/visual_search/lens/search/',
+      data,
+      { headers: { ...headers, ...data.getHeaders() } }
+    );
+
+    return this.parseResults(response.data);
+  }
+
+  async getMoreResults(bookmark, url, pageSize = 12) {
+    const params = new URLSearchParams({
+      bookmark,
+      camera_type: '0',
+      source_type: '1',
+      video_autoplay_disabled: '0',
+      fields: this.getFields(),
+      url,
+      page_size: pageSize.toString(),
+      view_type: '119',
+      view_parameter: '3064'
+    });
+
+    const headers = this.getRandomHeaders();
+    const response = await axios.get(
+      `https://api.pinterest.com/v3/visual_search/lens/search/?${params}`,
+      { headers }
+    );
+
+    return this.parseResults(response.data);
+  }
+
+  async scrapeAll(imageUrl, maxPages = 5) {
+    const allResults = [];
+    
+    const firstPage = await this.searchByImage(imageUrl);
+    allResults.push(...firstPage.pins);
+
+    let bookmark = firstPage.bookmark;
+    let url = firstPage.url;
+    let page = 2;
+
+    while (bookmark && page <= maxPages) {
+      const nextPage = await this.getMoreResults(bookmark, url);
+      allResults.push(...nextPage.pins);
+      bookmark = nextPage.bookmark;
+      page++;
+      await this.delay(100);
+    }
+
+    return {
+      total: allResults.length,
+      pins: allResults,
+      visualObjects: firstPage.visualObjects,
+      searchIdentifier: firstPage.searchIdentifier
+    };
+  }
+
+  parseResults(response) {
+    const pins = response.data.map(pin => ({
+      id: pin.id,
+      title: pin.title || '',
+      description: pin.description || '',
+      imageUrl: pin.images?.['736x']?.url || pin.images?.originals?.url,
+      thumbnailUrl: pin.images?.['236x']?.url,
+      dominantColor: pin.dominant_color,
+      creator: {
+        id: pin.pinner?.id,
+        username: pin.pinner?.username,
+        fullName: pin.pinner?.full_name,
+        imageUrl: pin.pinner?.image_medium_url
+      },
+      board: {
+        id: pin.board?.id,
+        name: pin.board?.name,
+        url: pin.board?.url
+      },
+      stats: {
+        saves: pin.aggregated_pin_data?.aggregated_stats?.saves || 0,
+        comments: pin.comment_count || 0
+      },
+      createdAt: pin.created_at,
+      isVideo: pin.is_video || false,
+      link: pin.link,
+      domain: pin.domain
+    }));
+
+    return {
+      pins,
+      bookmark: response.bookmark,
+      url: response.url,
+      visualObjects: response.visual_objects,
+      searchIdentifier: response.search_identifier
+    };
+  }
+
+  getFields() {
+    return 'pin.{id,title,description,images[736x,236x],dominant_color,pinner(),board(),aggregated_pin_data(),comment_count,created_at,is_video,link,domain},user.{id,username,full_name,image_medium_url},board.{id,name,url},aggregatedpindata.{aggregated_stats}';
+  }
+
+  delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+const handler = async (req, res) => {
+  try {
+    const { imageUrl, token, maxPages = 5, key } = req.query;
+
+    if (!imageUrl) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: imageUrl'
+      });
+    }
+
+    if (!token) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: token'
+      });
+    }
+
+    const scraper = new PinterestLensScraper(token);
+    const results = await scraper.scrapeAll(imageUrl, parseInt(maxPages));
+
+    res.json({
+      author: 'siputzx',
+      success: true,
+      data: results
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Pinterest Lens Scraper',
+  description: 'Scrape Pinterest pins using image search with lens',
+  type: 'GET',
+  routes: ['api/tools/pinlens'],
+  tags: ['tools', 'pinterest', 'image-search'],
+  main: ['tools', 'Search'],
+  parameters: ['imageUrl', 'token', 'maxPages', 'key'],
+  enabled: true,
+  limit: 10,
+  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/removebg.js

@@ -0,0 +1,85 @@
+const axios = require('axios');
+
+async function removebg(img_url) {
+  const uploadResponse = await axios.get('https://aibackgroundremover.org/api/get-upload-url');
+  const { uploadUrl, publicUrl } = uploadResponse.data;
+
+  const imageResponse = await axios.get(img_url, { responseType: 'arraybuffer' });
+  
+  await axios.put(uploadUrl, imageResponse.data, {
+    headers: {
+      'Content-Type': 'image/png',
+      'Referer': 'https://aibackgroundremover.org/?utm_source=chatgpt.com'
+    }
+  });
+
+  const removeBgResponse = await axios.post('https://aibackgroundremover.org/api/remove-bg', {
+    image: publicUrl
+  }, {
+    headers: {
+      'Content-Type': 'application/json',
+      'Referer': 'https://aibackgroundremover.org/?utm_source=chatgpt.com'
+    }
+  });
+
+  const { id } = removeBgResponse.data;
+
+  while (true) {
+    const statusResponse = await axios.get(`https://aibackgroundremover.org/api/check-status?id=${id}`, {
+      headers: {
+        'Referer': 'https://aibackgroundremover.org/?utm_source=chatgpt.com'
+      }
+    });
+
+    const { status, output, error } = statusResponse.data;
+
+    if (status === 'succeeded') {
+      return output;
+    } else if (status === 'failed') {
+      throw new Error(error || 'Background removal failed');
+    }
+
+    await new Promise(resolve => setTimeout(resolve, 2000));
+  }
+}
+
+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 removebg(url);
+
+    res.json({
+      success: true,
+      data: {
+        original_url: url,
+        output_url: result
+      }
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Background Remover',
+  description: 'Remove background from images using AI',
+  type: 'GET',
+  routes: ['api/tools/removebg'],
+  tags: ['image', 'ai', 'background'],
+  parameters: ['url', 'key'],
+  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/sora2-img2vid.js

@@ -0,0 +1,499 @@
+const axios = require('axios');
+const dns = require('dns').promises;
+
+const PROXY_URL = 'https://proxy-sigma-roan.vercel.app/api/proxy';
+
+dns.setServers(['1.1.1.1', '8.8.8.8', '8.8.4.4']);
+
+function generateUniqueId() {
+    return Array.from({ length: 32 }, () => 
+        Math.floor(Math.random() * 16).toString(16)
+    ).join('');
+}
+
+function generatePassword() {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let password = '';
+    for (let i = 0; i < 12; i++) {
+        password += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return password;
+}
+
+function randomDelay(min = 1000, max = 3000) {
+    const delay = Math.floor(Math.random() * (max - min + 1)) + min;
+    return new Promise(resolve => setTimeout(resolve, delay));
+}
+
+function generateRandomIP() {
+    return `${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}`;
+}
+
+async function proxyRequest(url, options = {}) {
+    const targetPath = url.startsWith('http') ? url : url;
+    const fakeIP = generateRandomIP();
+    
+    const headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        'Accept': 'application/json, text/plain, */*',
+        'X-Forwarded-For': fakeIP,
+        'X-Real-IP': fakeIP,
+        'X-Client-IP': fakeIP,
+        ...(options.headers || {})
+    };
+    
+    await randomDelay(500, 1500);
+    
+    const axiosConfig = {
+        method: options.method || 'GET',
+        headers: headers,
+        timeout: 30000,
+        params: { url: targetPath },
+        validateStatus: (status) => status >= 200 && status < 600
+    };
+    
+    if (options.data && (options.method === 'POST' || options.method === 'PUT')) {
+        axiosConfig.data = options.data;
+    }
+    
+    let lastError = null;
+    
+    for (let attempt = 1; attempt <= 3; attempt++) {
+        try {
+            axiosConfig.url = PROXY_URL;
+            const response = await axios(axiosConfig);
+            
+            console.log(`[Proxy] Status: ${response.status}, URL: ${targetPath}`);
+            
+            if (response.status === 500) {
+                console.error('[Proxy] 500 Error Details:', JSON.stringify(response.data));
+                throw new Error(`Proxy server error: ${JSON.stringify(response.data)}`);
+            }
+            
+            if (response.status === 403) {
+                await randomDelay(3000, 5000);
+                throw new Error('API Bylo returned 403 Forbidden');
+            }
+            
+            if (response.status === 429) {
+                await randomDelay(5000, 10000);
+                if (attempt < 3) continue;
+                throw new Error('Rate limit exceeded');
+            }
+            
+            if (response.status >= 200 && response.status < 300) {
+                if (!response.data) throw new Error('Empty response from proxy');
+                return response;
+            }
+            
+            if (response.status >= 400) {
+                const errorMsg = response.data?.msg || response.data?.message || 'Unknown error';
+                throw new Error(`API error (${response.status}): ${errorMsg}`);
+            }
+            
+            if (attempt < 3) await randomDelay(2000, 4000);
+            
+        } catch (error) {
+            console.error('[Proxy] Request failed:', {
+                url: targetPath,
+                status: error.response?.status,
+                data: error.response?.data,
+                message: error.message
+            });
+            lastError = error;
+            if (attempt < 3) {
+                const waitTime = 3000 * attempt;
+                await randomDelay(waitTime, waitTime + 2000);
+            }
+        }
+    }
+    
+    throw new Error(`Proxy request failed after 3 attempts: ${lastError?.message || 'Unknown error'}`);
+}
+
+async function createTempEmail() {
+    const { data } = await axios.post('https://api.internal.temp-mail.io/api/v3/email/new', {
+        min_name_length: 10,
+        max_name_length: 10
+    }, {
+        headers: {
+            'Content-Type': 'application/json',
+            'Application-Name': 'web',
+            'Application-Version': '4.0.0',
+            'X-CORS-Header': 'iaWg3pchvFx48fY'
+        },
+        timeout: 15000
+    });
+    return data;
+}
+
+async function getHcaptchaToken() {
+    const { data } = await axios.get(
+        'https://anabot.my.id/api/tools/bypass?url=https%3A%2F%2Fapi.hcaptcha.com&siteKey=6f70c0f2-3ef6-4972-9fb6-c0b4bade3af8&type=hcaptcha-invisible&apikey=freeApikey',
+        { timeout: 15000 }
+    );
+    
+    if (!data.success) throw new Error('Failed to get hCaptcha token');
+    return data.data.result.token;
+}
+
+async function sendVerificationEmail(email) {
+    await randomDelay(1000, 2000);
+    const hcaptchaToken = await getHcaptchaToken();
+    const encodedEmail = encodeURIComponent(email);
+    await randomDelay(500, 1000);
+    
+    const { data } = await proxyRequest(
+        `/api/auth/send-captcha?email=${encodedEmail}&type=register`,
+        {
+            method: 'GET',
+            headers: {
+                'Accept': 'application/json, text/plain, */*',
+                'hcaptcha-token': hcaptchaToken,
+                'uniqueId': generateUniqueId()
+            }
+        }
+    );
+    
+    if (data.code !== 200) {
+        throw new Error(`Failed to send verification email: ${data.msg || 'Unknown error'}`);
+    }
+    
+    await randomDelay(3000, 5000);
+    return true;
+}
+
+async function getVerificationCode(email) {
+    let attempts = 0;
+    const maxAttempts = 30;
+    
+    while (attempts < maxAttempts) {
+        try {
+            await new Promise(resolve => setTimeout(resolve, 5000));
+            
+            const { data } = await axios.get(
+                `https://api.internal.temp-mail.io/api/v3/email/${email}/messages`,
+                {
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Application-Name': 'web',
+                        'Application-Version': '4.0.0',
+                        'X-CORS-Header': 'iaWg3pchvFx48fY'
+                    },
+                    timeout: 10000
+                }
+            );
+            
+            if (data.length > 0) {
+                const bodyText = data[0].body_text;
+                const codeMatch = bodyText.match(/Verification Code:\s*(\d{6})/);
+                if (codeMatch) return codeMatch[1];
+            }
+            
+            attempts++;
+        } catch (error) {
+            attempts++;
+        }
+    }
+    
+    throw new Error('Verification code not received after 30 attempts');
+}
+
+async function registerAccount(email, password, verificationCode) {
+    const { data } = await proxyRequest('/api/auth/register', {
+        method: 'POST',
+        headers: {
+            'Accept': 'application/json, text/plain, */*',
+            'Content-Type': 'application/json',
+            'uniqueId': generateUniqueId()
+        },
+        data: {
+            email: email,
+            password: password,
+            confirmPassword: password,
+            verificationCode: verificationCode,
+            referDomain: ''
+        }
+    });
+    
+    if (data.code !== 200) {
+        throw new Error(`Registration failed: ${data.msg || 'Unknown error'}`);
+    }
+    
+    return data.data.token;
+}
+
+async function createVideoFromImage(prompt, imageUrl, ratio, duration, authToken, email) {
+    await randomDelay(2000, 3000);
+    
+    const payloadVariants = [
+        {
+            prompt: prompt,
+            channel: 'SORA2',
+            pageId: 536,
+            source: 'bylo.ai',
+            watermarkFlag: false,
+            privateFlag: false,
+            isTemp: true,
+            model: 'sora_video2',
+            videoType: 'image-to-video',
+            duration: duration.toString(),
+            aspectRatio: ratio,
+            imageUrls: [imageUrl],
+            email: email
+        },
+        {
+            prompt: prompt,
+            channel: 'SORA2',
+            pageId: 536,
+            source: 'bylo.ai',
+            watermarkFlag: false,
+            privateFlag: false,
+            isTemp: true,
+            model: 'sora_video2',
+            videoType: 'image-to-video',
+            duration: duration.toString(),
+            aspectRatio: ratio,
+            imageUrl: imageUrl,
+            email: email
+        },
+        {
+            prompt: prompt,
+            channel: 'SORA2',
+            pageId: 536,
+            source: 'bylo.ai',
+            watermarkFlag: false,
+            privateFlag: false,
+            isTemp: true,
+            model: 'sora_video2',
+            videoType: 'image-to-video',
+            duration: duration.toString(),
+            aspectRatio: ratio,
+            image: imageUrl,
+            email: email
+        }
+    ];
+    
+    let lastError = null;
+    
+    for (let i = 0; i < payloadVariants.length; i++) {
+        try {
+            console.log(`[DEBUG] Trying payload variant ${i + 1}:`, JSON.stringify(payloadVariants[i], null, 2));
+            
+            const { data } = await proxyRequest('/aimodels/api/v1/ai/video/create', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'uniqueid': generateUniqueId(),
+                    'verify': '',
+                    'authorization': authToken
+                },
+                data: payloadVariants[i]
+            });
+            
+            console.log('[DEBUG] Response:', JSON.stringify(data, null, 2));
+            
+            if (data.code === 200) {
+                return data.data;
+            }
+            
+            lastError = new Error(`Failed with code ${data.code}: ${data.message || data.msg || 'Unknown error'}`);
+            
+        } catch (error) {
+            console.error(`[DEBUG] Payload variant ${i + 1} failed:`, error.message);
+            lastError = error;
+        }
+    }
+    
+    throw lastError || new Error('All payload variants failed');
+}
+
+async function getTaskStatus(taskId, authToken) {
+    const { data } = await proxyRequest(
+        `/aimodels/api/v1/ai/${taskId}?channel=SORA2`,
+        {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                'authorization': authToken
+            }
+        }
+    );
+    
+    if (!data || !data.data) {
+        throw new Error('Invalid response from task status API');
+    }
+    
+    return data.data;
+}
+
+async function waitForVideoCompletion(taskId, authToken) {
+    let attempts = 0;
+    const maxAttempts = 120;
+    
+    while (attempts < maxAttempts) {
+        await randomDelay(5000, 7000);
+        const taskData = await getTaskStatus(taskId, authToken);
+        
+        console.log(`[Progress] Attempt ${attempts + 1}/${maxAttempts} - State: ${taskData.state}`);
+        
+        if (taskData.state === 1 && taskData.completeData) {
+            const completeData = JSON.parse(taskData.completeData);
+            return completeData.data.result_urls[0];
+        }
+        
+        if (taskData.failMsg) {
+            throw new Error(`Video generation failed: ${taskData.failMsg}`);
+        }
+        
+        attempts++;
+    }
+    
+    throw new Error('Video generation timeout after 10 minutes');
+}
+
+async function sora2ImageToVideo(prompt, imageUrl, ratio = 'portrait', duration = 10) {
+    console.log('[1/6] Creating temporary email...');
+    const tempMail = await createTempEmail();
+    const email = tempMail.email;
+    const password = generatePassword();
+    console.log(`[Email] ${email}`);
+    
+    console.log('[2/6] Sending verification email...');
+    await sendVerificationEmail(email);
+    
+    console.log('[3/6] Waiting for verification code...');
+    const verificationCode = await getVerificationCode(email);
+    console.log(`[Code] ${verificationCode}`);
+    
+    console.log('[4/6] Registering account...');
+    const authToken = await registerAccount(email, password, verificationCode);
+    console.log('[Auth] Token received');
+    
+    console.log('[5/6] Creating video task...');
+    const taskId = await createVideoFromImage(prompt, imageUrl, ratio, duration, authToken, email);
+    console.log(`[Task ID] ${taskId}`);
+    
+    console.log('[6/6] Waiting for video completion...');
+    const videoUrl = await waitForVideoCompletion(taskId, authToken);
+    console.log(`[Video URL] ${videoUrl}`);
+    
+    return {
+        success: true,
+        email: email,
+        password: password,
+        videoUrl: videoUrl,
+        taskId: taskId
+    };
+}
+
+const handler = async (req, res) => {
+    const startTime = Date.now();
+    
+    try {
+        const { prompt, imageUrl, key, ratio = 'portrait' } = req.query;
+        
+        if (!prompt) {
+            return res.status(400).json({
+                author: 'Herza',
+                success: false,
+                msg: 'Missing required parameter: prompt',
+                usage: '/api/AI/sora2img2video?prompt=your_prompt&imageUrl=image_url&ratio=portrait&key=your_key'
+            });
+        }
+        
+        if (!imageUrl) {
+            return res.status(400).json({
+                author: 'Herza',
+                success: false,
+                msg: 'Missing required parameter: imageUrl'
+            });
+        }
+        
+        if (!key) {
+            return res.status(400).json({
+                author: 'Herza',
+                success: false,
+                msg: 'Missing required parameter: key'
+            });
+        }
+        
+        if (!['portrait', 'landscape'].includes(ratio)) {
+            return res.status(400).json({
+                author: 'Herza',
+                success: false,
+                msg: 'Invalid ratio. Use: portrait or landscape'
+            });
+        }
+        
+        console.log(`\n${'='.repeat(60)}`);
+        console.log('NEW IMAGE TO VIDEO REQUEST RECEIVED');
+        console.log(`Prompt: ${prompt}`);
+        console.log(`Image URL: ${imageUrl}`);
+        console.log(`Ratio: ${ratio}`);
+        console.log(`${'='.repeat(60)}\n`);
+        
+        const result = await sora2ImageToVideo(prompt, imageUrl, ratio, 10);
+        
+        const processingTime = ((Date.now() - startTime) / 1000).toFixed(2);
+        
+        console.log(`\n${'='.repeat(60)}`);
+        console.log('REQUEST COMPLETED');
+        console.log(`Duration: ${processingTime}s`);
+        console.log(`${'='.repeat(60)}\n`);
+        
+        res.json({
+            author: 'Herza',
+            success: true,
+            data: {
+                model: 'sora-video2',
+                prompt: prompt,
+                imageUrl: imageUrl,
+                ratio: ratio,
+                duration: '10s',
+                videoUrl: result.videoUrl,
+                taskId: result.taskId,
+                account: {
+                    email: result.email,
+                    password: result.password
+                },
+                processingTime: `${processingTime}s`
+            }
+        });
+    } catch (error) {
+        console.error('\n❌ ERROR:', error.message);
+        console.error('Stack:', error.stack);
+        
+        const processingTime = ((Date.now() - startTime) / 1000).toFixed(2);
+        
+        const errorMessage = error.response?.data?.error || 
+                            error.response?.data?.message || 
+                            error.message || 
+                            'Unknown error occurred';
+        
+        res.status(error.response?.status || 500).json({
+            author: 'Herza',
+            success: false,
+            msg: errorMessage,
+            processingTime: `${processingTime}s`,
+            error: {
+                code: error.code || 'UNKNOWN',
+                statusCode: error.response?.status,
+                details: error.response?.data || error.message
+            }
+        });
+    }
+}
+
+module.exports = {
+    name: 'Sora2 Image to Video Generator',
+    description: 'Generate videos from images using Sora2 AI model from Bylo.ai via Vercel Proxy',
+    type: 'GET',
+    routes: ['api/AI/sora2img2video'],
+    tags: ['AI', 'Sora', 'OpenAI', 'Video', 'Image to Video'],
+    parameters: ['prompt', 'imageUrl', 'ratio', 'key'],
+    enabled: true,
+    main: ['AI'],
+    limit: 13,
+    handler
+};

plugins/sora2.js

@@ -0,0 +1,472 @@
+const axios = require('axios');
+const dns = require('dns').promises;
+
+const PROXY_URL = 'https://proxy-sigma-roan.vercel.app/api/proxy';
+
+dns.setServers([
+    '1.1.1.1',
+    '8.8.8.8',
+    '8.8.4.4'
+]);
+
+function generateUniqueId() {
+    return Array.from({ length: 32 }, () => 
+        Math.floor(Math.random() * 16).toString(16)
+    ).join('');
+}
+
+function generatePassword() {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let password = '';
+    for (let i = 0; i < 12; i++) {
+        password += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return password;
+}
+
+function randomDelay(min = 1000, max = 3000) {
+    const delay = Math.floor(Math.random() * (max - min + 1)) + min;
+    return new Promise(resolve => setTimeout(resolve, delay));
+}
+
+function generateRandomIP() {
+    return `${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}`;
+}
+
+async function proxyRequest(url, options = {}) {
+    const targetPath = url.startsWith('http') ? url : url;
+    
+    const fakeIP = generateRandomIP();
+    
+    const headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        'Accept': 'application/json, text/plain, */*',
+        'X-Forwarded-For': fakeIP,
+        'X-Real-IP': fakeIP,
+        'X-Client-IP': fakeIP,
+        ...(options.headers || {})
+    };
+    
+    await randomDelay(500, 1500);
+    
+    const axiosConfig = {
+        method: options.method || 'GET',
+        headers: headers,
+        timeout: 30000,
+        params: {
+            url: targetPath
+        },
+        validateStatus: function (status) {
+            return status >= 200 && status < 600;
+        }
+    };
+    
+    if (options.data && (options.method === 'POST' || options.method === 'PUT')) {
+        axiosConfig.data = options.data;
+    }
+    
+    let lastError = null;
+    
+    for (let attempt = 1; attempt <= 3; attempt++) {
+        try {
+            axiosConfig.url = PROXY_URL;
+            console.log(`Attempt ${attempt}: ${PROXY_URL}?url=${targetPath}`);
+            
+            const response = await axios(axiosConfig);
+            
+            console.log(`Attempt ${attempt} got status ${response.status}`);
+            console.log(`Response data:`, JSON.stringify(response.data).substring(0, 200));
+            
+            if (response.status === 403) {
+                console.log('Got 403, waiting longer before retry...');
+                await randomDelay(3000, 5000);
+                throw new Error('API Bylo returned 403 Forbidden - possible rate limit or IP block');
+            }
+            
+            if (response.status === 429) {
+                console.log('Got 429 Too Many Requests, waiting...');
+                await randomDelay(5000, 10000);
+                if (attempt < 3) continue;
+                throw new Error('Rate limit exceeded');
+            }
+            
+            if (response.status >= 200 && response.status < 300) {
+                if (!response.data) {
+                    throw new Error('Empty response from proxy');
+                }
+                return response;
+            }
+            
+            if (response.status >= 400) {
+                const errorMsg = response.data?.msg || response.data?.message || response.data?.error || 'Unknown error';
+                throw new Error(`API error (${response.status}): ${errorMsg}`);
+            }
+            
+            if (attempt < 3) {
+                await randomDelay(2000, 4000);
+            }
+            
+        } catch (error) {
+            lastError = error;
+            console.error(`Attempt ${attempt} failed:`, error.message);
+            
+            if (error.response) {
+                console.error(`Response status: ${error.response.status}`);
+                console.error(`Response data:`, error.response.data);
+            }
+            
+            if (attempt < 3) {
+                const waitTime = 3000 * attempt;
+                console.log(`Retrying in ${waitTime/1000} seconds...`);
+                await randomDelay(waitTime, waitTime + 2000);
+            }
+        }
+    }
+    
+    throw new Error(`Proxy request failed after 3 attempts: ${lastError?.message || 'Unknown error'}`);
+}
+
+async function createTempEmail() {
+    console.log('Creating temporary email...');
+    const { data } = await axios.post('https://api.internal.temp-mail.io/api/v3/email/new', {
+        min_name_length: 10,
+        max_name_length: 10
+    }, {
+        headers: {
+            'Content-Type': 'application/json',
+            'Application-Name': 'web',
+            'Application-Version': '4.0.0',
+            'X-CORS-Header': 'iaWg3pchvFx48fY'
+        },
+        timeout: 15000
+    });
+    
+    console.log(`Email created: ${data.email}`);
+    return data;
+}
+
+async function getHcaptchaToken() {
+    console.log('Getting hCaptcha token...');
+    const { data } = await axios.get(
+        'https://anabot.my.id/api/tools/bypass?url=https%3A%2F%2Fapi.hcaptcha.com&siteKey=6f70c0f2-3ef6-4972-9fb6-c0b4bade3af8&type=hcaptcha-invisible&apikey=freeApikey',
+        {
+            timeout: 15000
+        }
+    );
+    
+    if (!data.success) {
+        throw new Error('Failed to get hCaptcha token');
+    }
+    
+    console.log('hCaptcha token obtained');
+    return data.data.result.token;
+}
+
+async function sendVerificationEmail(email) {
+    console.log(`Sending verification email to ${email}...`);
+    
+    await randomDelay(1000, 2000);
+    
+    const hcaptchaToken = await getHcaptchaToken();
+    const encodedEmail = encodeURIComponent(email);
+    
+    await randomDelay(500, 1000);
+    
+    const { data } = await proxyRequest(
+        `/api/auth/send-captcha?email=${encodedEmail}&type=register`,
+        {
+            method: 'GET',
+            headers: {
+                'Accept': 'application/json, text/plain, */*',
+                'hcaptcha-token': hcaptchaToken,
+                'uniqueId': generateUniqueId()
+            }
+        }
+    );
+    
+    if (data.code !== 200) {
+        throw new Error(`Failed to send verification email: ${data.msg || 'Unknown error'}`);
+    }
+    
+    console.log('Verification email sent successfully');
+    await randomDelay(3000, 5000);
+    return true;
+}
+
+async function getVerificationCode(email) {
+    console.log('Waiting for verification code...');
+    let attempts = 0;
+    const maxAttempts = 30;
+    
+    while (attempts < maxAttempts) {
+        try {
+            await new Promise(resolve => setTimeout(resolve, 5000));
+            
+            const { data } = await axios.get(
+                `https://api.internal.temp-mail.io/api/v3/email/${email}/messages`,
+                {
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Application-Name': 'web',
+                        'Application-Version': '4.0.0',
+                        'X-CORS-Header': 'iaWg3pchvFx48fY'
+                    },
+                    timeout: 10000
+                }
+            );
+            
+            if (data.length > 0) {
+                const bodyText = data[0].body_text;
+                const codeMatch = bodyText.match(/Verification Code:\s*(\d{6})/);
+                
+                if (codeMatch) {
+                    console.log(`Verification code received: ${codeMatch[1]}`);
+                    return codeMatch[1];
+                }
+            }
+            
+            attempts++;
+            console.log(`Checking for verification code... attempt ${attempts}/${maxAttempts}`);
+        } catch (error) {
+            console.log(`Email check attempt ${attempts} failed:`, error.message);
+            attempts++;
+        }
+    }
+    
+    throw new Error('Verification code not received after 30 attempts');
+}
+
+async function registerAccount(email, password, verificationCode) {
+    console.log('Registering account...');
+    const { data } = await proxyRequest('/api/auth/register', {
+        method: 'POST',
+        headers: {
+            'Accept': 'application/json, text/plain, */*',
+            'Content-Type': 'application/json',
+            'uniqueId': generateUniqueId()
+        },
+        data: {
+            email: email,
+            password: password,
+            confirmPassword: password,
+            verificationCode: verificationCode,
+            referDomain: ''
+        }
+    });
+    
+    if (data.code !== 200) {
+        throw new Error(`Registration failed: ${data.msg || 'Unknown error'}`);
+    }
+    
+    console.log('Account registered successfully');
+    return data.data.token;
+}
+
+async function createVideo(prompt, ratio, authToken, email) {
+    console.log('Creating video task...');
+    await randomDelay(2000, 3000);
+    
+    const { data } = await proxyRequest('/aimodels/api/v1/ai/video/create', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'uniqueid': generateUniqueId(),
+            'verify': '',
+            'authorization': authToken
+        },
+        data: {
+            prompt: prompt,
+            channel: 'SORA2',
+            pageId: 536,
+            source: 'bylo.ai',
+            watermarkFlag: false,
+            privateFlag: false,
+            isTemp: true,
+            model: 'sora_video2',
+            videoType: 'text-to-video',
+            duration: '10',
+            aspectRatio: ratio,
+            email: email
+        }
+    });
+    
+    if (data.code !== 200) {
+        throw new Error(`Failed to create video: ${data.message || 'Unknown error'}`);
+    }
+    
+    console.log(`Video task created with ID: ${data.data}`);
+    return data.data;
+}
+
+async function getTaskStatus(taskId, authToken) {
+    try {
+        const { data } = await proxyRequest(
+            `/aimodels/api/v1/ai/${taskId}?channel=SORA2`,
+            {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'authorization': authToken
+                }
+            }
+        );
+        
+        if (!data || !data.data) {
+            throw new Error('Invalid response from task status API');
+        }
+        
+        return data.data;
+    } catch (error) {
+        console.error('Error getting task status:', error.message);
+        throw error;
+    }
+}
+
+async function waitForVideoCompletion(taskId, authToken) {
+    console.log('Waiting for video generation...');
+    let attempts = 0;
+    const maxAttempts = 120;
+    
+    while (attempts < maxAttempts) {
+        await randomDelay(5000, 7000);
+        
+        const taskData = await getTaskStatus(taskId, authToken);
+        
+        console.log(`Video status check ${attempts + 1}/${maxAttempts} - State: ${taskData.state}`);
+        
+        if (taskData.state === 1 && taskData.completeData) {
+            const completeData = JSON.parse(taskData.completeData);
+            console.log('Video generation completed!');
+            return completeData.data.result_urls[0];
+        }
+        
+        if (taskData.failMsg) {
+            throw new Error(`Video generation failed: ${taskData.failMsg}`);
+        }
+        
+        attempts++;
+    }
+    
+    throw new Error('Video generation timeout after 10 minutes');
+}
+
+async function sora2(prompt, ratio = 'portrait') {
+    console.log('=== Starting Sora2 Video Generation ===');
+    console.log(`Prompt: ${prompt}`);
+    console.log(`Ratio: ${ratio}`);
+    
+    const tempMail = await createTempEmail();
+    const email = tempMail.email;
+    const password = generatePassword();
+    
+    await sendVerificationEmail(email);
+    const verificationCode = await getVerificationCode(email);
+    const authToken = await registerAccount(email, password, verificationCode);
+    const taskId = await createVideo(prompt, ratio, authToken, email);
+    const videoUrl = await waitForVideoCompletion(taskId, authToken);
+    
+    console.log('=== Video Generation Completed ===');
+    console.log(`Video URL: ${videoUrl}`);
+    
+    return {
+        success: true,
+        email: email,
+        password: password,
+        videoUrl: videoUrl,
+        taskId: taskId
+    };
+}
+
+const handler = async (req, res) => {
+    const startTime = Date.now();
+    
+    try {
+        const { prompt, key, ratio = 'portrait' } = req.query;
+        
+        if (!prompt) {
+            return res.status(400).json({
+                author: 'Herza',
+                success: false,
+                msg: 'Missing required parameter: prompt',
+                usage: '/api/AI/sora2?prompt=your_prompt&ratio=portrait&key=your_key'
+            });
+        }
+        
+        if (!key) {
+            return res.status(400).json({
+                author: 'Herza',
+                success: false,
+                msg: 'Missing required parameter: key'
+            });
+        }
+        
+        if (!['portrait', 'landscape', 'square'].includes(ratio)) {
+            return res.status(400).json({
+                author: 'Herza',
+                success: false,
+                msg: 'Invalid ratio. Use: portrait, landscape, or square'
+            });
+        }
+        
+        console.log(`\n${'='.repeat(60)}`);
+        console.log('NEW REQUEST RECEIVED');
+        console.log(`Prompt: ${prompt}`);
+        console.log(`Ratio: ${ratio}`);
+        console.log(`${'='.repeat(60)}\n`);
+        
+        const result = await sora2(prompt, ratio);
+        
+        const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+        
+        console.log(`\n${'='.repeat(60)}`);
+        console.log('REQUEST COMPLETED');
+        console.log(`Duration: ${duration}s`);
+        console.log(`${'='.repeat(60)}\n`);
+        
+        res.json({
+            author: 'Herza',
+            success: true,
+            data: {
+                model: 'sora-video2',
+                prompt: prompt,
+                ratio: ratio,
+                videoUrl: result.videoUrl,
+                taskId: result.taskId,
+                account: {
+                    email: result.email,
+                    password: result.password
+                },
+                processingTime: `${duration}s`
+            }
+        });
+    } catch (error) {
+        console.error('\n❌ ERROR:', error.message);
+        console.error('Stack:', error.stack);
+        
+        const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+        
+        res.status(500).json({
+            author: 'Herza',
+            success: false,
+            msg: error.message || 'Terjadi kesalahan saat generate video.',
+            processingTime: `${duration}s`,
+            error: {
+                code: error.code || 'UNKNOWN',
+                details: error.response?.data || null
+            }
+        });
+    }
+}
+
+module.exports = {
+    name: 'Sora2 Video Generator',
+    description: 'Generate videos using Sora2 AI model from Bylo.ai via Vercel Proxy',
+    type: 'GET',
+    routes: ['api/AI/sora2'],
+    tags: ['AI', 'Sora', 'OpenAI', 'Video'],
+    parameters: ['prompt', 'ratio', 'key'],
+    enabled: true,
+    main: ['AI'],
+    limit: 10,
+    handler
+};

plugins/sora2nowm.js

@@ -0,0 +1,130 @@
+async function videoGenerator(prompt) {
+  if (!prompt) return { error: "Prompt tidak boleh kosong" };
+
+  const videoId = `video_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+  const apiUrl = "https://veo31.ai/api";
+
+  try {
+    const res = await fetch(`${apiUrl}/generate/stream`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        prompt,
+        aspectRatio: "9:16",
+        videoId,
+      }),
+    });
+
+    const data = await res.json();
+    if (!data.success) return { status: "failed", error: "Error generating video", detail: data };
+
+    await new Promise((r) => setTimeout(r, 120000));
+
+    while (true) {
+      const check = await fetch(`${apiUrl}/webhook?videoId=${videoId}`);
+      const status = await check.json();
+
+      if (status.status === "completed") {
+        return {
+          status: "completed",
+          videoUrl: status.videoUrl,
+          videoId,
+        };
+      } else if (status.status === "failed") {
+        return {
+          status: "failed",
+          error: status.error || "unknown",
+        };
+      } else {
+        await new Promise((r) => setTimeout(r, 60000));
+      }
+    }
+  } catch (err) {
+    return { status: "error", error: err.message };
+  }
+}
+
+const handler = async (req, res) => {
+  const startTime = Date.now();
+  
+  try {
+    const { prompt, key } = req.query;
+    
+    if (!prompt) {
+      return res.status(400).json({
+        author: 'Herza',
+        success: false,
+        msg: 'Missing required parameter: prompt',
+        usage: '/api/AI/sora2nowm?prompt=your_prompt&key=your_key'
+      });
+    }
+    
+    if (!key) {
+      return res.status(400).json({
+        author: 'Herza',
+        success: false,
+        msg: 'Missing required parameter: key'
+      });
+    }
+    
+    console.log(`\n${'='.repeat(60)}`);
+    console.log('NEW REQUEST RECEIVED');
+    console.log(`Prompt: ${prompt}`);
+    console.log(`${'='.repeat(60)}\n`);
+    
+    const result = await videoGenerator(prompt);
+    
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+    
+    if (result.status === "completed") {
+      console.log(`\n${'='.repeat(60)}`);
+      console.log('REQUEST COMPLETED');
+      console.log(`Duration: ${duration}s`);
+      console.log(`${'='.repeat(60)}\n`);
+      
+      res.json({
+        author: 'Herza',
+        success: true,
+        data: {
+          model: 'veo31-sora2',
+          prompt: prompt,
+          videoUrl: result.videoUrl,
+          videoId: result.videoId,
+          processingTime: `${duration}s`
+        }
+      });
+    } else {
+      throw new Error(result.error || 'Video generation failed');
+    }
+    
+  } catch (error) {
+    console.error('\n❌ ERROR:', error.message);
+    console.error('Stack:', error.stack);
+    
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+    
+    res.status(500).json({
+      author: 'Herza',
+      success: false,
+      msg: error.message || 'Terjadi kesalahan saat generate video.',
+      processingTime: `${duration}s`,
+      error: {
+        code: error.code || 'UNKNOWN',
+        details: error.response?.data || null
+      }
+    });
+  }
+}
+
+module.exports = {
+  name: 'Sora2 Video Generator No Watermark',
+  description: 'Generate videos using Sora2 AI model without watermark',
+  type: 'GET',
+  routes: ['api/AI/sora2nowm'],
+  tags: ['AI', 'Sora', 'Video', 'NoWatermark'],
+  parameters: ['prompt', 'key'],
+  enabled: true,
+  main: ['AI'],
+  limit: 15,
+  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,192 @@
+const TURNSTILE_SOLVER_URL = 'https://herzaj-turnstile-solver.hf.space';
+
+async function getTurnstileToken() {
+    try {
+        const params = new URLSearchParams({
+            url: 'https://www.subdomainfinder.in',
+            sitekey: '0x4AAAAAAAj7jyMV3Zv9ZMN-'
+        });
+
+        const submitResponse = await fetch(`${TURNSTILE_SOLVER_URL}/turnstile?${params}`, {
+            method: 'GET'
+        });
+
+        if (!submitResponse.ok) {
+            throw new Error(`Failed to submit task: ${submitResponse.status}`);
+        }
+
+        const taskData = await submitResponse.json();
+        const taskId = taskData.task_id;
+
+        await new Promise(resolve => setTimeout(resolve, 5000));
+
+        const resultResponse = await fetch(`${TURNSTILE_SOLVER_URL}/result?id=${taskId}`);
+
+        if (!resultResponse.ok) {
+            throw new Error(`Failed to get result: ${resultResponse.status}`);
+        }
+
+        const resultData = await resultResponse.json();
+        return resultData.value;
+
+    } 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/subdofinder'],
+    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/suno4.js

@@ -0,0 +1,469 @@
+const axios = require('axios');
+const crypto = require('crypto');
+const HttpProxyAgent = require('http-proxy-agent');
+const HttpsProxyAgent = require('https-proxy-agent');
+
+async function getRandomProxy() {
+  try {
+    const response = await axios.get('https://raw.githubusercontent.com/proxifly/free-proxy-list/refs/heads/main/proxies/protocols/https/data.json');
+    const proxies = response.data;
+    if (proxies.length === 0) return null;
+    return proxies[Math.floor(Math.random() * proxies.length)].proxy;
+  } catch (err) {
+    return null;
+  }
+}
+
+const aiMu = {
+  api: {
+    base: 'https://aimu.1010diy.com',
+    endpoint: {
+      credits: '/and/getUserActualCredits',
+      musicAI: '/music/MusicAI',
+      taskStatus: '/music/getTaskStatus',
+      generateList: '/and/data/generateList',
+      options: '/and/home/index',
+    },
+  },
+
+  headers: {
+    'user-agent': 'NB Android/1.0.0',
+    'accept-encoding': 'gzip',
+    'x-version-code': '27',
+    'x-token': '',
+  },
+
+  sid: null,
+
+  setDeviceId: (id) => {
+    aiMu.sid = id;
+  },
+
+  getDeviceId: () => {
+    if (!aiMu.sid) {
+      aiMu.sid = crypto.randomBytes(8).toString('hex');
+    }
+    return aiMu.sid;
+  },
+
+  opts: async () => {
+    try {
+      const proxyUrl = await getRandomProxy();
+      const axiosConfig = { headers: { ...aiMu.headers, 'x-device-id': aiMu.getDeviceId() } };
+      
+      if (proxyUrl) {
+        axiosConfig.httpAgent = new HttpProxyAgent(proxyUrl);
+        axiosConfig.httpsAgent = new HttpsProxyAgent(proxyUrl);
+      }
+
+      const res = await axios.get(
+        `${aiMu.api.base}${aiMu.api.endpoint.options}`,
+        axiosConfig
+      );
+      
+      const { code, msg, data } = res.data;
+      if (code !== 200) {
+        return {
+          success: false,
+          code,
+          author: 'Daffa ~',
+          team: 'NB Team',
+          result: { 
+            error: { msg }
+           }
+        };
+      }
+
+      const moods = [...(data.mood?.default || []), ...(data.mood?.more || [])].map(m => m.text);
+      const genres = [...(data.genre?.default || []), ...(data.genre?.more || [])].map(g => g.text);
+      const voices = ['female', 'male', 'random'];
+
+      return {
+        success: true,
+        code: 200,
+        author: 'Daffa ~',
+        team: 'NB Team',
+        result: { 
+            moods, 
+            genres, 
+            voices
+        }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        code: err.response?.status || 500,
+        author: 'Daffa ~',
+        team: 'NB Team',
+        result: { 
+            error: err.message
+         }
+      };
+    }
+  },
+
+  getCredits: async () => {
+    try {
+      const proxyUrl = await getRandomProxy();
+      const axiosConfig = { headers: { ...aiMu.headers, 'x-device-id': aiMu.getDeviceId() } };
+      
+      if (proxyUrl) {
+        axiosConfig.httpAgent = new HttpProxyAgent(proxyUrl);
+        axiosConfig.httpsAgent = new HttpsProxyAgent(proxyUrl);
+      }
+
+      const res = await axios.get(
+        `${aiMu.api.base}${aiMu.api.endpoint.credits}`,
+        axiosConfig
+      );
+      const { code, msg, data } = res.data;
+      if (code === 200) {
+        return {
+          success: true,
+          code: 200,
+          author: 'Daffa ~',
+          team: 'NB Team',
+          result: { 
+            ...data
+          }
+        };
+      }
+      return {
+        success: false,
+        code,
+        author: 'Daffa ~',
+        team: 'NB Team',
+        result: { 
+            error: msg
+        }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        code: err.response?.status || 500,
+        author: 'Daffa ~',
+        team: 'NB Team',
+        result: { 
+            error: err.message
+        }
+      };
+    }
+  },
+
+  generate: async (params) => {
+    let make_instrumental = params.make_instrumental ? 1 : 0;
+    let vocal_only = params.vocal_only ? 1 : 0;
+    if (make_instrumental === 1) vocal_only = 0;
+
+    const { lyrics = '', prompt = '' } = params;
+    if (!lyrics.trim() && !prompt.trim()) {
+      return {
+        success: false,
+        code: 400,
+        author: 'Daffa ~',
+        team: 'NB Team',
+        result: { 
+            error: 'Lu bisa pilih Lyric atau Prompt bree'
+         }
+      };
+    }
+
+    if (prompt && prompt.length > 1000) {
+      return {
+        success: false,
+        code: 400,
+        author: 'Daffa ~',
+        team: 'NB Team',
+        result: { 
+            error: 'Promptnya kepanjangan yak, max 1k karakter aja.. '
+         }
+      };
+    }
+
+    const payload = { make_instrumental, vocal_only, lyrics, prompt, ...params };
+
+    try {
+      const proxyUrl = await getRandomProxy();
+      const axiosConfig = {
+        headers: {
+          ...aiMu.headers,
+          'content-type': 'application/json',
+          'x-device-id': aiMu.getDeviceId(),
+        },
+      };
+
+      if (proxyUrl) {
+        axiosConfig.httpAgent = new HttpProxyAgent(proxyUrl);
+        axiosConfig.httpsAgent = new HttpsProxyAgent(proxyUrl);
+      }
+
+      const res = await axios.post(
+        `${aiMu.api.base}${aiMu.api.endpoint.musicAI}`,
+        payload,
+        axiosConfig
+      );
+      const { code, msg, data } = res.data;
+      if (code === 200) {
+        return {
+          success: true,
+          code: 200,
+          author: 'Daffa ~',
+          team: 'NB Team',
+          result: { 
+            taskId: data?.task_id, 
+            inputType: prompt ? 'prompt' : 'lyrics',
+            inputValue: prompt || lyrics
+          }
+        };
+      }
+      return {
+        success: false,
+        code,
+        author: 'Daffa ~',
+        team: 'NB Team',
+        result: { 
+            error: msg
+          }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        code: err.response?.status || 500,
+        author: 'Daffa ~',
+        team: 'NB Team',
+        result: { 
+            error: err.message
+        }
+      };
+    }
+  },
+
+  polling: async (taskId) => {
+    if (!String(taskId)?.trim()) {
+      return {
+        success: false,
+        code: 400,
+        author: 'Daffa ~',
+        team: 'NB Team',
+        result: { 
+            error: 'Task IDnya kagak boleh kosong bree... '
+         }
+      };
+    }
+    try {
+      const proxyUrl = await getRandomProxy();
+      const axiosConfig = {
+        params: { task_id: taskId },
+        headers: { ...aiMu.headers, 'x-device-id': aiMu.getDeviceId() },
+      };
+
+      if (proxyUrl) {
+        axiosConfig.httpAgent = new HttpProxyAgent(proxyUrl);
+        axiosConfig.httpsAgent = new HttpsProxyAgent(proxyUrl);
+      }
+
+      const res = await axios.get(
+        `${aiMu.api.base}${aiMu.api.endpoint.taskStatus}`,
+        axiosConfig
+      );
+      const { code, msg, data } = res.data;
+      if (code === 200) {
+        return {
+          success: true,
+          code: 200,
+          author: 'Daffa ~',
+          team: 'NB Team',
+          result: { 
+            status: data?.status, 
+          }
+        };
+      }
+      return {
+        success: false,
+        code,
+        author: 'Daffa ~',
+        team: 'NB Team',
+        result: { 
+            error: msg
+         }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        code: err.response?.status || 500,
+        author: 'Daffa ~',
+        team: 'NB Team',
+        result: { 
+            error: err.message
+         }
+      };
+    }
+  },
+
+  getGenerateList: async () => {
+    try {
+      const proxyUrl = await getRandomProxy();
+      const axiosConfig = { headers: { ...aiMu.headers, 'x-device-id': aiMu.getDeviceId() } };
+
+      if (proxyUrl) {
+        axiosConfig.httpAgent = new HttpProxyAgent(proxyUrl);
+        axiosConfig.httpsAgent = new HttpsProxyAgent(proxyUrl);
+      }
+
+      const res = await axios.get(
+        `${aiMu.api.base}${aiMu.api.endpoint.generateList}`,
+        axiosConfig
+      );
+      const { code, msg, data } = res.data;
+      if (code === 200) {
+        const results = (data || []).map((item) => ({
+          taskId: item.task_id,
+          title: item.title,
+          duration: item.duration,
+          mp3: item.conversion_path,
+          cover: item.album_cover_path,
+          input: item.lyrics, 
+          created_at: item.created_at,
+          updated_at: item.updated_at,
+        }));
+        return {
+          success: true,
+          code: 200,
+          author: 'Daffa ~',
+          team: 'NB Team',
+          result: { 
+            results
+          }
+        };
+      }
+      return {
+        success: false,
+        code,
+        author: 'Daffa ~',
+        team: 'NB Team',
+        result: { 
+            error: msg
+        }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        code: err.response?.status || 500,
+        author: 'Daffa ~',
+        team: 'NB Team',
+        result: { 
+            error: err.message
+         }
+      };
+    }
+  },
+
+  task: async (taskId, inputType, inputValue, intervalMs = 5000) => {
+    if (!String(taskId)?.trim()) {
+      return {
+        success: false,
+        code: 400,
+        author: 'Daffa ~',
+        team: 'NB Team',
+        result: { 
+            error: 'Task IDnya kagak boleh kosong bree... '
+        }
+      };
+    }
+
+    while (true) {
+      const resx = await aiMu.polling(taskId);
+      if (!resx.success) return resx;
+
+      if (resx.result.status === 'complete') {
+        const re = await aiMu.getGenerateList();
+        if (!re.success) return re;
+
+        const tracks = re.result.results.filter((r) => String(r.taskId) === String(taskId));
+
+        const avr = tracks.every((t) => t.mp3.includes('vocal-remover.s3.us-west-2.amazonaws.com'));
+
+        if (tracks.length > 0 && avr) {
+          return {
+            success: true,
+            code: 200,
+            author: 'Daffa ~',
+            team: 'NB Team',
+            result: {
+              taskId: String(taskId),
+              count: tracks.length,
+              tracks: tracks.map((t) => ({
+                title: t.title,
+                duration: t.duration,
+                audio: t.mp3,
+                cover: t.cover,
+                [inputType]: t.input,
+                created_at: t.created_at,
+                updated_at: t.updated_at,
+              })),
+              inputValue
+            }
+          };
+        }
+      }
+
+      await new Promise((r) => setTimeout(r, intervalMs));
+    }
+  },
+};
+
+const handler = async (req, res) => {
+  try {
+    const { prompt, lyrics, mood, genre, voice, key } = req.query;
+
+    if (!prompt && !lyrics) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: prompt or lyrics'
+      });
+    }
+
+    const params = {
+      prompt: prompt || '',
+      lyrics: lyrics || '',
+      mood: mood || '',
+      genre: genre || '',
+      voice: voice || 'random',
+      make_instrumental: 0,
+      vocal_only: 0
+    };
+
+    const genResult = await aiMu.generate(params);
+
+    if (!genResult.success) {
+      return res.status(400).json(genResult);
+    }
+
+    const taskId = genResult.result.taskId;
+    const inputType = genResult.result.inputType;
+    const inputValue = genResult.result.inputValue;
+
+    const taskResult = await aiMu.task(taskId, inputType, inputValue);
+
+    res.json(taskResult);
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+};
+
+module.exports = {
+  name: 'Sunov4 Music Generator',
+  description: 'Generate music using AiMu AI model',
+  type: 'GET',
+  routes: ['api/AI/suno4'],
+  tags: ['ai', 'music', 'aimu', 'suno'],
+  main: ['AI'],
+  parameters: ['prompt', 'lyrics', 'mood', 'genre', 'voice', 'key'],
+  enabled: true,
+  limit: 18,
+  handler
+};

plugins/sunov2.js

@@ -0,0 +1,207 @@
+const axios = require('axios');
+
+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 response = await axios.get('https://anabot.my.id/api/tools/bypass', {
+        params: {
+          url: 'https://www.yeschat.ai/',
+          siteKey: '0x4AAAAAAATOXAtQtziH-Rwq',
+          type: 'turnstile-min',
+          apikey: 'freeApikey'
+        },
+        headers: {
+          'accept': '*/*'
+        }
+      });
+
+      if (response.data.success && response.data.data?.result?.token) {
+        return response.data.data.result.token;
+      }
+      throw new Error('Failed to get token from response');
+    } 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',
+  type: 'GET',
+  routes: ['api/AI/sunov2'],
+  tags: ['ai', 'music', '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/upscale.js

@@ -0,0 +1,189 @@
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+const https = require('https');
+const FormData = require('form-data');
+
+const UPLOAD_URL = 'https://api.unblurimage.ai/api/common/upload/upload-image';
+const CREATE_JOB_URL = 'https://api.unblurimage.ai/api/imgupscaler/v1/ai-image-upscaler-v2/create-job';
+const PRODUCT_SERIAL = '79661c82d918475e7458944c2f66857e';
+const TMP_DIR = '/tmp/upscaler';
+
+const axiosInstance = axios.create({
+  timeout: 60000,
+  httpsAgent: new https.Agent({
+    rejectUnauthorized: false,
+  }),
+});
+
+function ensureTmpDir() {
+  if (!fs.existsSync(TMP_DIR)) {
+    fs.mkdirSync(TMP_DIR, { recursive: true });
+  }
+}
+
+async function downloadImage(imageUrl) {
+  const response = await axiosInstance.get(imageUrl, {
+    responseType: 'arraybuffer',
+  });
+  return Buffer.from(response.data);
+}
+
+function saveImageToTmp(imageBuffer) {
+  ensureTmpDir();
+  const fileName = `image_${Date.now()}_${Math.random().toString(36).substr(2, 9)}.jpg`;
+  const filePath = path.join(TMP_DIR, fileName);
+  fs.writeFileSync(filePath, imageBuffer);
+  return filePath;
+}
+
+function deleteFileAfterDelay(filePath, delayMs = 10000) {
+  setTimeout(() => {
+    try {
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    } catch (error) {
+      console.error(`Failed to delete file ${filePath}:`, error.message);
+    }
+  }, delayMs);
+}
+
+async function uploadImage(filePath) {
+  const imageBuffer = fs.readFileSync(filePath);
+  const fileName = path.basename(filePath);
+  const contentType = 'image/jpeg';
+  
+  const form = new FormData();
+  form.append('file_name', fileName);
+  form.append('file', imageBuffer, fileName);
+
+  const uploadResponse = await axiosInstance.post(UPLOAD_URL, form, {
+    headers: {
+      ...form.getHeaders(),
+      'User-Agent': 'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36',
+    },
+  });
+
+  if (uploadResponse.data.code !== 100000) {
+    throw new Error(`Upload failed: ${uploadResponse.data.message.en}`);
+  }
+
+  const uploadUrl = uploadResponse.data.result.url;
+
+  await axiosInstance.put(uploadUrl, imageBuffer, {
+    headers: {
+      'Content-Type': contentType,
+      'User-Agent': 'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36',
+    },
+  });
+
+  return {
+    url: uploadUrl.split('?')[0],
+  };
+}
+
+async function createJob(imageUrl, upscaleLevel) {
+  const form = new FormData();
+  form.append('original_image_url', imageUrl);
+  form.append('upscale_type', upscaleLevel.toString());
+
+  const response = await axiosInstance.post(CREATE_JOB_URL, form, {
+    headers: {
+      ...form.getHeaders(),
+      'Product-Serial': PRODUCT_SERIAL,
+      'User-Agent': 'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36',
+    },
+  });
+
+  if (response.data.code !== 100000) {
+    throw new Error(`Job creation failed: ${response.data.message.en}`);
+  }
+
+  return response.data.result;
+}
+
+async function upscaleImage(imageUrl, scaleNumber) {
+  let tmpFilePath = null;
+  
+  try {
+    if (!imageUrl) {
+      throw new Error('Image URL is required');
+    }
+
+    if (![2, 4, 8, 16].includes(scaleNumber)) {
+      throw new Error('Scale number must be 2, 4, 8, or 16');
+    }
+
+    const imageBuffer = await downloadImage(imageUrl);
+    tmpFilePath = saveImageToTmp(imageBuffer);
+    
+    const uploadResult = await uploadImage(tmpFilePath);
+    const result = await createJob(uploadResult.url, scaleNumber);
+    
+    deleteFileAfterDelay(tmpFilePath, 10000);
+    
+    return result;
+  } catch (error) {
+    if (tmpFilePath && fs.existsSync(tmpFilePath)) {
+      fs.unlinkSync(tmpFilePath);
+    }
+    throw error;
+  }
+}
+
+const handler = async (req, res) => {
+  try {
+    const { image_url, scale, key } = req.query;
+
+    if (!image_url) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: image_url'
+      });
+    }
+
+    if (!scale) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameter: scale'
+      });
+    }
+
+    const scaleNum = parseInt(scale);
+    if (![2, 4, 8, 16].includes(scaleNum)) {
+      return res.status(400).json({
+        success: false,
+        error: 'Scale must be 2, 4, 8, or 16'
+      });
+    }
+
+    const result = await upscaleImage(image_url, scaleNum);
+
+    return res.json({
+      author: "Herza",
+      success: true,
+      data: result
+    });
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message,
+      timestamp: new Date().toISOString()
+    });
+  }
+};
+
+module.exports = {
+  name: 'Image Upscaler',
+  description: 'Upscale images to 2x, 4x, 8x, or 16x resolution',
+  type: 'GET',
+  routes: ['api/tools/upscale'],
+  tags: ['image', 'upscale', 'enhancement'],
+  parameters: ['image_url', 'scale', 'key'],
+  limit: 5,
+  enabled: true,
+  main: ['tools'],
+  handler
+};