upload

Dockerfile

@@ -0,0 +1,33 @@
+FROM node:20-bullseye
+
+# Install ALL dependencies untuk OpenCV + Chrome
+RUN apt update && apt install -y \
+    wget gnupg ca-certificates xvfb \
+    fonts-liberation libappindicator3-1 libasound2 libatk-bridge2.0-0 \
+    libatk1.0-0 libxss1 libnss3 libxcomposite1 libxdamage1 libxrandr2 libgbm1 \
+    python3 make g++ pkg-config cmake \
+    libcairo2-dev libjpeg-dev libpng-dev libgif-dev librsvg2-dev \
+    libopencv-dev \
+    && wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb \
+    && apt install -y ./google-chrome-stable_current_amd64.deb \
+    && rm google-chrome-stable_current_amd64.deb \
+    && apt clean
+
+WORKDIR /app
+
+RUN mkdir -p /app/endpoints && \
+    mkdir -p /app/cache
+
+COPY package*.json ./
+
+# Install OpenCV dengan build from source
+RUN npm install
+
+COPY . .
+
+EXPOSE 7860
+
+CMD rm -f /tmp/.X99-lock && \
+    Xvfb :99 -screen 0 1024x768x24 & \
+    export DISPLAY=:99 && \
+    npm start

README.md

@@ -3,10 +3,8 @@ title: Antibot3
 emoji: 👁
 colorFrom: blue
 colorTo: yellow
-sdk: gradio
+sdk: docker
 sdk_version: 6.0.0
-app_file: app.py
-pinned: false
 license: apache-2.0
 short_description: antibot ai
 ---

api_test.py

@@ -0,0 +1,26 @@
+import asyncio
+import httpx
+
+async def main():
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        resp1 = await client.post(
+            "http://localhost:8080/cloudflare",
+            json={
+                "domain": "https://olamovies.watch/generate",
+                "mode": "iuam",
+            },
+        )
+        print(resp1.json())
+
+        resp2 = await client.post(
+            "http://localhost:8080/cloudflare",
+            json={
+                "domain": "https://lksfy.com/",
+                "siteKey": "0x4AAAAAAA49NnPZwQijgRoi",
+                "mode": "turnstile",
+            },
+        )
+        print(resp2.json())
+
+if __name__ == "__main__":
+    asyncio.run(main())

cache/cache.json

@@ -0,0 +1,10 @@
+{
+  "{\"domain\":\"https://v2links.org\",\"mode\":\"iuam\"}": {
+    "timestamp": 1758616160392,
+    "value": {
+      "cf_clearance": "qqs5f4MpFMgA0v78Qmh_HYDWoKhbwqlQ57bTW5KeIr8-1758616161-1.2.1.1-D5PdpmheHl.26ssIRKQBsXzPtPPkSXntEZ_H9FUJVt7MMTS_BEE8iH.E48MDzKtFBLwZqRYxE_1GLo1gj3ChXrwatOGEJcmGRUwavy2qvGgUPizn7qufd.sW0ULfhaRO7Gz_H_eO1TU3iEqCzltEUDNk0SviKRFkF8ozbvJ91MW_qmO.qrjQorbu_jxcgJv5BHs6rTNOitWtVDAmYMDukASq0viHXIUAIvTM.LIfQ88",
+      "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
+      "elapsed_time": 5.028
+    }
+  }
+}

endpoints/antibot.js

@@ -0,0 +1,277 @@
+const fs = require('fs');
+const path = require('path');
+const { extractTextFromImage } = require('./imageProcessor');
+
+function mapAnswer(soalArray, jawaban, botIndex) {
+  return jawaban;
+}
+
+function normalizeText(text) {
+  return text.toLowerCase().replace(/[^\w\s]/g, '').trim();
+}
+
+function isValueMatch(value, targetSoal) {
+  const numberMap = {
+    '0': 'zero', '1': 'one', '2': 'two', '3': 'three', '4': 'four',
+    '5': 'five', '6': 'six', '7': 'seven', '8': 'eight', '9': 'nine', '10': 'ten',
+    'zero': '0', 'one': '1', 'two': '2', 'three': '3', 'four': '4',
+    'five': '5', 'six': '6', 'seven': '7', 'eight': '8', 'nine': '9', 'ten': '10',
+    'I': '1', 'II': '2', 'III': '3', 'IV': '4', 'V': '5',
+    'VI': '6', 'VII': '7', 'VIII': '8', 'IX': '9', 'X': '10',
+    'slx': '6', 's1x': '6', 'six': '6',
+    'f0ur': '4', 'f0r': '4', 'fuor': '4',
+    'f1ve': '5', 'fiv': '5', 'f1v': '5',
+    'e1ght': '8', 'elght': '8', 'eight': '8',
+    'n1ne': '9', 'n1n': '9', 'nne': '9',
+    'se7en': '7', 'sven': '7', 'seven': '7',
+    'thre': '3', 'tree': '3', 'thr33': '3',
+    'tw0': '2', 'to': '2', 'tw': '2',
+    '0ne': '1', 'on': '1', 'oen': '1'
+  };
+
+  const leetMap = {
+    'O': '0', 'o': '0',
+    'I': '1', 'i': '1', 'l': '1',
+    'Z': '2', 'z': '2',
+    'E': '3', 'e': '3',
+    'A': '4', 'a': '4',
+    'S': '5', 's': '5',
+    'G': '6', 'g': '6',
+    'T': '7', 't': '7',
+    'B': '8', 'b': '8',
+    'Q': '9', 'q': '9',
+    'U': '4', 'u': '4',
+    'R': '2', 'r': '2',
+    'N': '9', 'n': '9',
+    'V': '7', 'v': '7'
+  };
+
+  const normalizedValue = normalizeText(value);
+  const normalizedSoal = normalizeText(targetSoal);
+
+  if (normalizedValue === normalizedSoal) {
+    return true;
+  }
+
+  const convertLeet = (text) => {
+    return text.split('').map(char => leetMap[char] || char).join('');
+  };
+
+  const leetValue = convertLeet(value);
+  const leetSoal = convertLeet(targetSoal);
+
+  if (leetValue === normalizedSoal) return true;
+  if (normalizedValue === leetSoal) return true;
+  if (leetValue === leetSoal) return true;
+
+  const mappedValue = numberMap[normalizedValue] || numberMap[value] || normalizedValue;
+  const mappedSoal = numberMap[normalizedSoal] || numberMap[targetSoal] || normalizedSoal;
+
+  if (mappedValue === normalizedSoal) return true;
+  if (normalizedValue === mappedSoal) return true;
+  if (mappedValue === mappedSoal) return true;
+
+  const similarity = calculateSimilarity(normalizedValue, normalizedSoal);
+  if (similarity >= 0.8) {
+    return true;
+  }
+
+  try {
+    const valueResult = evaluateSimpleMath(value);
+    const soalResult = evaluateSimpleMath(targetSoal);
+    if (valueResult !== null && soalResult !== null && valueResult === soalResult) {
+      return true;
+    }
+  } catch (e) {}
+
+  return false;
+}
+
+function calculateSimilarity(str1, str2) {
+  if (str1 === str2) return 1;
+  if (str1.length === 0 || str2.length === 0) return 0;
+  
+  const longer = str1.length > str2.length ? str1 : str2;
+  const shorter = str1.length > str2.length ? str2 : str1;
+  
+  if (longer.includes(shorter)) return shorter.length / longer.length;
+  
+  let matches = 0;
+  for (let i = 0; i < shorter.length; i++) {
+    if (shorter[i] === longer[i]) matches++;
+  }
+  
+  return matches / longer.length;
+}
+
+function evaluateSimpleMath(expression) {
+  if (!expression) return null;
+  const cleanExpr = expression.toString().replace(/[^\d+\-*/.()]/g, '');
+  if (!cleanExpr) return null;
+  try {
+    if (cleanExpr.length > 10) return null;
+    const result = Function(`"use strict"; return (${cleanExpr})`)();
+    return typeof result === 'number' ? result : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function parseSoalText(text) {
+  const delimiters = /[.,:;\\/\s]+/;
+  let parts = text.split(delimiters).filter(part => part.trim() !== '');
+  if (parts.length === 1) {
+    parts = text.split(/\s+/).filter(part => part.trim() !== '');
+  }
+  return parts;
+}
+
+async function antibot(data) {
+  try {
+    const { main, bots } = data;
+
+    const mainBuffer = Buffer.from(main, 'base64');
+    const mainText = await extractTextFromImage(mainBuffer);
+    
+    const soalArray = parseSoalText(mainText.response);
+    
+    if (soalArray.length === 0) {
+      throw new Error('Tidak ada soal yang terdeteksi');
+    }
+
+    const botResults = [];
+    
+    for (let i = 0; i < bots.length; i++) {
+      const bot = bots[i];
+      try {
+        const botBuffer = Buffer.from(bot.img, 'base64');
+        const botText = await extractTextFromImage(botBuffer);
+        const mappedValue = mapAnswer(soalArray, botText.response, i);
+        
+        botResults.push({
+          id: bot.id,
+          text: botText.response,
+          value: mappedValue,
+          normalized: normalizeText(botText.response)
+        });
+        
+      } catch (error) {
+        botResults.push({
+          id: bot.id,
+          text: '',
+          value: '',
+          normalized: '',
+          error: error.message
+        });
+      }
+    }
+
+    const result = [];
+    const usedIds = new Set();
+    let matchedCount = 0;
+
+    for (let i = 0; i < soalArray.length; i++) {
+      const targetSoal = soalArray[i];
+      let foundId = null;
+
+      for (const bot of botResults) {
+        if (!usedIds.has(bot.id) && bot.value && bot.value.trim() !== '' && 
+            isValueMatch(bot.value, targetSoal)) {
+          foundId = bot.id;
+          usedIds.add(bot.id);
+          matchedCount++;
+          break;
+        }
+      }
+
+      result.push({ 
+        id: foundId,
+        soal: targetSoal,
+        matchType: foundId ? 'exact' : 'none'
+      });
+    }
+
+    if (matchedCount < soalArray.length) {
+      for (let i = 0; i < result.length; i++) {
+        if (!result[i].id) {
+          const targetSoal = soalArray[i];
+          const normalizedSoal = normalizeText(targetSoal);
+          
+          for (const bot of botResults) {
+            if (!usedIds.has(bot.id) && bot.normalized && bot.normalized.trim() !== '') {
+              if (bot.normalized === normalizedSoal) {
+                result[i].id = bot.id;
+                result[i].matchType = 'normalized';
+                usedIds.add(bot.id);
+                matchedCount++;
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (matchedCount >= 2) {
+      for (let i = 0; i < result.length; i++) {
+        if (!result[i].id) {
+          for (const bot of botResults) {
+            if (!usedIds.has(bot.id) && bot.value && bot.value.trim() !== '') {
+              result[i].id = bot.id;
+              result[i].matchType = 'fallback';
+              usedIds.add(bot.id);
+              break;
+            }
+          }
+        }
+      }
+    } else if (matchedCount === 1) {
+      for (let i = 0; i < result.length; i++) {
+        if (!result[i].id) {
+          result[i].id = 'invalid';
+          result[i].matchType = 'invalid';
+        }
+      }
+    } else {
+      for (let i = 0; i < result.length; i++) {
+        result[i].id = 'invalid';
+        result[i].matchType = 'invalid';
+      }
+    }
+
+    for (let i = 0; i < result.length; i++) {
+      if (!result[i].id) {
+        result[i].id = 'invalid';
+        result[i].matchType = 'invalid';
+      }
+    }
+
+    return {
+      success: true,
+      data: {
+        soal: soalArray,
+        soalLeet: soalArray,
+        botResults: botResults,
+        result: result.map(r => ({ id: r.id })),
+        debug: {
+          parsedSoal: soalArray,
+          matches: result.map(r => ({ id: r.id, matchType: r.matchType, soal: r.soal })),
+          totalMatches: matchedCount
+        }
+      }
+    };
+
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message,
+      data: {
+        soal: [],
+        botResults: [],
+        result: []
+      }
+    };
+  }
+}
+
+module.exports = antibot;

endpoints/cloudflare.js

@@ -0,0 +1,79 @@
+async function cloudflare(data, page) {
+  return new Promise(async (resolve, reject) => {
+    if (!data.domain) return reject(new Error("Missing domain parameter"))
+
+    const startTime = Date.now()
+    let isResolved = false
+    let userAgent = null
+
+    const cl = setTimeout(() => {
+      if (!isResolved) {
+        isResolved = true
+        const elapsedTime = (Date.now() - startTime) / 1000
+        resolve({
+          cf_clearance: null,
+          user_agent: userAgent,
+          elapsed_time: elapsedTime,
+        })
+      }
+    }, 20000)
+
+    try {
+      if (data.proxy?.username && data.proxy?.password) {
+        await page.authenticate({
+          username: data.proxy.username,
+          password: data.proxy.password,
+        })
+      }
+
+      page.removeAllListeners("request")
+      page.removeAllListeners("response")
+      await page.setRequestInterception(true)
+
+      page.on("request", async (req) => {
+        try {
+          await req.continue()
+        } catch (_) {}
+      })
+
+      page.on("response", async (res) => {
+        try {
+          const url = res.url()
+          if (url.includes("/cdn-cgi/challenge-platform/")) {
+            const headers = res.headers()
+            if (headers["set-cookie"]) {
+              const match = headers["set-cookie"].match(/cf_clearance=([^;]+)/)
+              if (match) {
+                const cf_clearance = match[1]
+                const userAgent = (await res.request().headers())["user-agent"]
+                const elapsedTime = (Date.now() - startTime) / 1000
+
+                if (!isResolved) {
+                  isResolved = true
+                  clearTimeout(cl)
+
+                  resolve({
+                    cf_clearance,
+                    user_agent: userAgent,
+                    elapsed_time: elapsedTime,
+                  })
+                }
+              }
+            }
+          }
+        } catch (_) {}
+      })
+
+      await page.goto(data.domain, { waitUntil: "domcontentloaded" })
+      userAgent = await page.evaluate(() => navigator.userAgent)
+    } catch (err) {
+      if (!isResolved) {
+        isResolved = true
+        clearTimeout(cl)
+        reject(err)
+      }
+    }
+  })
+}
+
+module.exports = cloudflare

endpoints/imageProcessor

@@ -0,0 +1,181 @@
+const fs = require('fs');
+const https = require('https');
+
+// API Keys configuration
+const API_KEYS = [
+    "fw_3ZNhzPGSUhHBxTL5PuB5Cpkv",
+    "fw_3ZchAJSfZBupby3hnESzSkbk"
+];
+
+function getRandomApiKey() {
+    return API_KEYS[Math.floor(Math.random() * API_KEYS.length)];
+}
+
+async function extractTextFromImage(imagePath) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            // Baca file gambar dan encode ke base64
+            const imageBuffer = fs.readFileSync(imagePath);
+            const base64Image = imageBuffer.toString('base64');
+
+            // Dapatkan API key secara random
+            const apiKey = getRandomApiKey();
+
+            // Request payload untuk Fireworks.ai
+            const requestData = JSON.stringify({
+                model: "accounts/fireworks/models/llama4-maverick-instruct-basic",
+                max_tokens: 1024,
+                temperature: 0.1, // Temperature rendah untuk hasil yang lebih konsisten
+                messages: [
+                    {
+                        role: "user",
+                        content: [
+                            { 
+                                type: "text", 
+                                text: "Berikan text yang ada di gambar ini saja, tidak ada informasi lain cukup yang ada di gambar saja, jangan ada text lain kalo bukan dari gambar nya. dan ini adalah pembatas iya _ , : ; dan tolong tiap text berbeda beda kalo ada pembatas itu kirim satu kalimat saja" 
+                            },
+                            { 
+                                type: "image_url", 
+                                image_url: { 
+                                    url: `data:image/png;base64,${base64Image}` 
+                                } 
+                            }
+                        ]
+                    }
+                ]
+            });
+
+            const options = {
+                hostname: 'api.fireworks.ai',
+                path: '/inference/v1/chat/completions',
+                method: 'POST',
+                headers: {
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${apiKey}`,
+                    'Content-Length': Buffer.byteLength(requestData)
+                }
+            };
+
+            const req = https.request(options, (res) => {
+                let data = '';
+
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+
+                res.on('end', () => {
+                    try {
+                        const response = JSON.parse(data);
+                        
+                        if (response.choices && response.choices[0] && response.choices[0].message) {
+                            const text = response.choices[0].message.content;
+                            resolve({ status: true, response: text });
+                        } else {
+                            console.error('API Response structure unexpected:', response);
+                            resolve({ status: false, response: 'Struktur respons tidak sesuai' });
+                        }
+                    } catch (error) {
+                        console.error('Error parsing response:', error);
+                        reject(error);
+                    }
+                });
+            });
+
+            req.on('error', (error) => {
+                console.error('Request error:', error);
+                reject(error);
+            });
+
+            req.write(requestData);
+            req.end();
+
+        } catch (error) {
+            reject(error);
+        }
+    });
+}
+
+// Fungsi untuk upload gambar ke hosting (opsional)
+async function uploadImageToHosting(buffer) {
+    try {
+        // Karena kita menggunakan base64 langsung, fungsi ini mungkin tidak diperlukan
+        // Tapi tetap disediakan untuk kompatibilitas
+        return null;
+    } catch (error) {
+        console.error("Gagal mengunggah gambar:", error);
+        return null;
+    }
+}
+
+// Fungsi untuk analisis gambar yang lebih detail
+async function analyzeImage(imagePath) {
+    try {
+        const imageBuffer = fs.readFileSync(imagePath);
+        const base64Image = imageBuffer.toString('base64');
+        const apiKey = getRandomApiKey();
+        
+        const payload = {
+            model: "accounts/fireworks/models/llama4-maverick-instruct-basic",
+            max_tokens: 1024,
+            temperature: 0.6,
+            messages: [
+                {
+                    role: "user",
+                    content: [
+                        { type: "text", text: "Berikan text yang ada di gambar ini saja, tidak ada informasi lain cukup yang ada di gambar saja, jangan ada text lain kalo bukan dari gambar nya. dan ini adalah pembatas iya _ , : ; dan tolong tiap text berbeda beda kalo ada pembatas itu kirim satu kalimat saja" },
+                        { type: "image_url", image_url: { url: `data:image/jpeg;base64,${base64Image}` } }
+                    ]
+                }
+            ]
+        };
+
+        const response = await fetch("https://api.fireworks.ai/inference/v1/chat/completions", {
+            method: "POST",
+            headers: {
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${apiKey}`
+            },
+            body: JSON.stringify(payload)
+        });
+
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error("API Error response:", errorText);
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+
+        const data = await response.json();
+        return data.choices?.[0]?.message?.content || "Tidak bisa menganalisis gambar ini";
+    } catch (error) {
+        console.error("Error analyzing image:", error);
+        return "Error saat menganalisis gambar";
+    }
+}
+
+// Contoh penggunaan
+async function main() {
+    try {
+        const result = await extractTextFromImage('main_instruction.png');
+        if (result.status) {
+            console.log('Teks yang diekstrak:', result.response);
+        } else {
+            console.log('Gagal:', result.response);
+        }
+    } catch (error) {
+        console.error('Error:', error);
+    }
+}
+
+// Jalankan jika file dijalankan langsung
+if (require.main === module) {
+    main();
+}
+
+module.exports = { 
+    extractTextFromImage, 
+    uploadImageToHosting, 
+    analyzeImage,
+    getRandomApiKey 
+};

endpoints/turnstile.js

@@ -0,0 +1,84 @@
+async function turnstile({ domain, proxy, siteKey }, page) {
+  if (!domain) throw new Error("Missing domain parameter");
+  if (!siteKey) throw new Error("Missing siteKey parameter");
+
+  const timeout = global.timeOut || 60000;
+  let isResolved = false;
+
+  const cl = setTimeout(async () => {
+    if (!isResolved) {
+      throw new Error("Timeout Error");
+    }
+  }, timeout);
+
+  try {
+    if (proxy?.username && proxy?.password) {
+      await page.authenticate({
+        username: proxy.username,
+        password: proxy.password,
+      });
+    }
+
+    const htmlContent = `
+      <!DOCTYPE html>
+      <html lang="en">
+      <body>
+        <div class="turnstile"></div>
+        <script src="https://challenges.cloudflare.com/turnstile/v0/api.js?onload=onloadTurnstileCallback" defer></script>
+        <script>
+          window.onloadTurnstileCallback = function () {
+            turnstile.render('.turnstile', {
+              sitekey: '${siteKey}',
+              callback: function (token) {
+                var c = document.createElement('input');
+                c.type = 'hidden';
+                c.name = 'cf-response';
+                c.value = token;
+                document.body.appendChild(c);
+              },
+            });
+          };
+        </script>
+      </body>
+      </html>
+    `;
+
+    await page.setRequestInterception(true);
+    page.removeAllListeners("request");
+    page.on("request", async (request) => {
+      if ([domain, domain + "/"].includes(request.url()) && request.resourceType() === "document") {
+        await request.respond({
+          status: 200,
+          contentType: "text/html",
+          body: htmlContent,
+        });
+      } else {
+        await request.continue();
+      }
+    });
+
+    await page.goto(domain, { waitUntil: "domcontentloaded" });
+
+    await page.waitForSelector('[name="cf-response"]', { timeout });
+
+    const token = await page.evaluate(() => {
+      try {
+        return document.querySelector('[name="cf-response"]').value;
+      } catch {
+        return null;
+      }
+    });
+
+    isResolved = true;
+    clearTimeout(cl);
+
+    if (!token || token.length < 10) throw new Error("Failed to get token");
+    return token;
+
+  } catch (e) {
+    clearTimeout(cl);
+    throw e;
+  }
+}
+
+module.exports = turnstile;

index.js

@@ -0,0 +1,179 @@
+const express = require('express');
+const { connect } = require("puppeteer-real-browser");
+const fs = require('fs');
+const path = require('path');
+
+const app = express();
+const port = process.env.PORT || 7860;
+const authToken = process.env.authToken || null;
+const domain = process.env.DOMAIN || `https://fourstore-antibot3.hf.space`;
+
+global.browserLimit = Number(process.env.browserLimit) || 20;
+global.timeOut = Number(process.env.timeOut) || 60000;
+
+const CACHE_DIR = path.join(__dirname, "cache");
+const CACHE_FILE = path.join(CACHE_DIR, "cache.json");
+const CACHE_TTL = 5 * 60 * 1000;
+
+function loadCache() {
+  if (!fs.existsSync(CACHE_FILE)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveCache(cache) {
+  if (!fs.existsSync(CACHE_DIR)) {
+    fs.mkdirSync(CACHE_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2), 'utf-8');
+}
+
+function readCache(key) {
+  const cache = loadCache();
+  const entry = cache[key];
+  if (entry && Date.now() - entry.timestamp < CACHE_TTL) {
+    return entry.value;
+  }
+  return null;
+}
+
+function writeCache(key, value) {
+  const cache = loadCache();
+  cache[key] = { timestamp: Date.now(), value };
+  saveCache(cache);
+}
+
+app.use(express.json({ limit: "50mb" }));
+app.use(express.urlencoded({ extended: true, limit: "50mb" }));
+
+app.get("/", (req, res) => {
+  res.json({
+    message: "Server is running!",
+    domain: domain,
+    endpoints: {
+      cloudflare: `${domain}/cloudflare`,
+      antibot: `${domain}/antibot`
+    },
+    status: {
+      browserLimit: global.browserLimit,
+      timeOut: global.timeOut,
+      authRequired: authToken !== null
+    }
+  });
+});
+
+if (process.env.NODE_ENV !== 'development') {
+  let server = app.listen(port, () => {
+    console.log(`Server running on port ${port}`);
+    console.log(`Domain: ${domain}`);
+    console.log(`Auth required: ${authToken !== null}`);
+  });
+  try {
+    server.timeout = global.timeOut;
+  } catch {}
+}
+
+async function createBrowser(proxyServer = null) {
+  const connectOptions = {
+    headless: false,
+    turnstile: true,
+    connectOption: { defaultViewport: null },
+    disableXvfb: false,
+  };
+  if (proxyServer) connectOptions.args = [`--proxy-server=${proxyServer}`];
+
+  const { browser } = await connect(connectOptions);
+  const [page] = await browser.pages();
+
+  await page.goto('about:blank');
+  await page.setRequestInterception(true);
+  page.on('request', (req) => {
+    const type = req.resourceType();
+    if (["image", "stylesheet", "font", "media"].includes(type)) req.abort();
+    else req.continue();
+  });
+
+  return { browser, page };
+}
+
+const turnstile = require('./endpoints/turnstile');
+const cloudflare = require('./endpoints/cloudflare');
+const antibot = require('./endpoints/antibot');
+
+app.post('/cloudflare', async (req, res) => {
+  const data = req.body;
+  if (!data || typeof data.mode !== 'string')
+    return res.status(400).json({ message: 'Bad Request: missing or invalid mode' });
+
+  if (global.browserLimit <= 0)
+    return res.status(429).json({ message: 'Too Many Requests' });
+
+  let cacheKey, cached;
+  if (data.mode === "iuam") {
+    cacheKey = JSON.stringify(data);
+    cached = readCache(cacheKey);
+    if (cached) return res.status(200).json({ ...cached, cached: true });
+  }
+
+  global.browserLimit--;
+  let result, browser;
+
+  try {
+    const proxyServer = data.proxy ? `${data.proxy.hostname}:${data.proxy.port}` : null;
+    const ctx = await createBrowser(proxyServer);
+    browser = ctx.browser;
+    const page = ctx.page;
+
+    await page.goto('about:blank');
+
+    switch (data.mode) {
+      case "turnstile":
+        result = await turnstile(data, page).then(t => ({ token: t }));
+        break;
+
+      case "iuam":
+        result = await cloudflare(data, page).then(r => ({ ...r }));
+        writeCache(cacheKey, result);
+        break;
+
+      case "antibot":
+        result = await antibot(data);
+        break;
+
+      default:
+        result = { code: 400, message: 'Invalid mode' };
+    }
+  } catch (err) {
+    result = { code: 500, message: err.message };
+  } finally {
+    if (browser) try { await browser.close(); } catch {}
+    global.browserLimit++;
+  }
+
+  res.status(result.code ?? 200).json(result);
+});
+
+app.post("/antibot", async (req, res) => {
+  const data = req.body;
+
+  if (!data || !data.main || !Array.isArray(data.bots))
+    return res.status(400).json({ message: "Invalid body" });
+
+  try {
+    const result = await antibot(data);
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+});
+
+app.use((req, res) => {
+  res.status(404).json({ message: 'Not Found' });
+});
+
+if (process.env.NODE_ENV === 'development') {
+  module.exports = app;
+}

package.json

@@ -0,0 +1,22 @@
+{
+  "name": "cf-bypass",
+  "version": "1.0",
+  "description": "get the cf_clearance cookie from any website",
+  "scripts": {
+    "start": "node index.js",
+    "dev": "nodemon index.js"
+  },
+  "dependencies": {
+    "express": "^5.1.0",
+    "canvas": "^2.11.2",
+    "sharp": "^0.32.0",
+    "puppeteer-real-browser": "^1.4.0",
+    "axios": "^1.9.0",
+    "child_process": "*",
+    "tesseract.js": "^5.0.3",
+    "jimp": "^0.22.10"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.10"
+  }
+}