Spaces:

XORE21
/

M3M3K3

Sleeping

App Files Files Community

XORE21 commited on Dec 9, 2025

Commit

0554a46

verified ·

1 Parent(s): f154f4a

Update index.js

Browse files

Files changed (1) hide show

index.js +76 -72

index.js CHANGED Viewed

@@ -1,52 +1,21 @@
 const express = require('express');
 const cors = require('cors');
 const { connect } = require("puppeteer-real-browser");
-const fs = require('fs');
 const path = require('path');
 const app = express();
 app.use(cors());
 app.use(express.json());
 const PORT = process.env.PORT || 7860;
-const MAX_CONCURRENT_BROWSERS = Number(process.env.MAX_BROWSERS) || 5;
 let activeBrowsers = 0;
-const CACHE_DIR = path.join(__dirname, "cache");
-const CACHE_FILE = path.join(CACHE_DIR, "cache.json");
-const CACHE_TTL = 30 * 60 * 1000;
-function getCache(key) {
-    if (!fs.existsSync(CACHE_FILE)) return null;
-    try {
-        const data = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
-        if (data[key] && Date.now() - data[key].timestamp < CACHE_TTL) {
-            return data[key].value;
-        }
-    } catch (e) { return null; }
-    return null;
-}
-function setCache(key, value) {
-    try {
-        if (!fs.existsSync(CACHE_DIR)) {
-            fs.mkdirSync(CACHE_DIR, { recursive: true });
-        }
-        let data = {};
-        if (fs.existsSync(CACHE_FILE)) {
-            data = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
-        }
-        data[key] = { timestamp: Date.now(), value };
-        fs.writeFileSync(CACHE_FILE, JSON.stringify(data, null, 2));
-    } catch (e) { console.error("Cache Error : ", e); }
-}
 async function createBrowser(proxy = null) {
     const options = {
         headless: false,
         turnstile: true,
-        executablePath: process.env.CHROME_PATH,
         args: [
             '--no-sandbox',
             '--disable-setuid-sandbox',
@@ -54,8 +23,10 @@ async function createBrowser(proxy = null) {
             '--disable-accelerated-2d-canvas',
             '--no-first-run',
             '--no-zygote',
-            '--disable-gpu'
         ],
         customConfig: {},
         connectOption: { defaultViewport: null }
     };
@@ -73,72 +44,105 @@ async function createBrowser(proxy = null) {
     return { browser, page };
 }
-const handleCloudflare = require('./endpoints/cloudflare');
-const handleTurnstile = require('./endpoints/turnstile');
 app.post('/bypass', async (req, res) => {
     const { url, mode, siteKey, proxy } = req.body;
-    if (!url || !mode) {
-        return res.status(400).json({ status: "error", message: "URL and Mode are required" });
-    }
     if (activeBrowsers >= MAX_CONCURRENT_BROWSERS) {
-        return res.status(429).json({ status: "busy", message: "Server is busy, please try again later" });
     }
-    const cacheKey = JSON.stringify({ url, mode, siteKey });
-    const cached = getCache(cacheKey);
-    if (cached) return res.json({ status: "success", cached: true, ...cached });
     activeBrowsers++;
     let browserInstance = null;
     try {
         const { browser, page } = await createBrowser(proxy);
         browserInstance = browser;
         let result;
-        if (mode === 'cloudflare') {
-            result = await handleCloudflare(page, url);
-        } else if (mode === 'turnstile') {
-            if (!siteKey) throw new Error("Sitekey is required for Turnstile mode");
             result = await handleTurnstile(page, url, siteKey);
         } else {
-            throw new Error("Unrecognized mode (use : cloudflare / turnstile)");
         }
-        if (result) setCache(cacheKey, result);
         res.json({ status: "success", ...result });
     } catch (error) {
-        console.error("Error Processing : ", error.message);
-        res.status(500).json({ status: "error", message: error.message });
     } finally {
         if (browserInstance) {
-            try { await browserInstance.close(); } catch (e) {}
         }
         activeBrowsers--;
     }
 });
-app.get('/', (req, res) => {
-    res.json({
-        status: "Running",
-        active_browsers: activeBrowsers,
-        max_browsers: MAX_CONCURRENT_BROWSERS,
-        usage: {
-            method: "POST",
-            endpoint: "/bypass",
-            body: {
-                url: "https://target.com",
-                mode: "cloudflare | turnstile",
-                siteKey: "0x4AAAA... (only for turnstile)",
-                proxy: { hostname: "...", port: "...", username: "...", password: "..." }
-            }
-        }
-    });
-});
-app.listen(PORT, () => console.log(`Server running on port ${PORT}`));

 const express = require('express');
 const cors = require('cors');
 const { connect } = require("puppeteer-real-browser");
 const path = require('path');
+const fs = require('fs');
 const app = express();
 app.use(cors());
 app.use(express.json());
 const PORT = process.env.PORT || 7860;
+const MAX_CONCURRENT_BROWSERS = 3;
 let activeBrowsers = 0;
 async function createBrowser(proxy = null) {
     const options = {
         headless: false,
         turnstile: true,
         args: [
             '--no-sandbox',
             '--disable-setuid-sandbox',
             '--disable-accelerated-2d-canvas',
             '--no-first-run',
             '--no-zygote',
+            '--disable-gpu',
+            '--window-size=1280,720'
         ],
+        executablePath: process.env.CHROME_PATH || "/usr/bin/google-chrome-stable",
         customConfig: {},
         connectOption: { defaultViewport: null }
     };
     return { browser, page };
 }
+async function handleTurnstile(page, url, siteKey) {
+    return new Promise(async (resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error("Timeout waiting for Turnstile token")), 45000);
+        try {
+            const htmlContent = `
+                <!DOCTYPE html>
+                <html>
+                <head><title>Turnstile</title></head>
+                <body>
+                    <div class="cf-turnstile" data-sitekey="${siteKey}" data-callback="turnstileCallback"></div>
+                    <script src="https://challenges.cloudflare.com/turnstile/v0/api.js" async defer></script>
+                    <script>
+                        function turnstileCallback(token) {
+                            console.log("Token received");
+                            window.cf_token = token;
+                        }
+                    </script>
+                </body>
+                </html>
+            `;
+            await page.setRequestInterception(true);
+            page.once('request', request => {
+                request.respond({
+                    status: 200,
+                    contentType: 'text/html',
+                    body: htmlContent
+                });
+            });
+            console.log(`[Turnstile] Navigating to ${url}`);
+            await page.goto(url, { waitUntil: "domcontentloaded" });
+            const checkToken = setInterval(async () => {
+                try {
+                    const token = await page.evaluate(() => window.cf_token);
+                    if (token) {
+                        clearInterval(checkToken);
+                        clearTimeout(timeout);
+                        resolve({ token: token });
+                    }
+                } catch (e) {
+                }
+            }, 500);
+        } catch (e) {
+            clearTimeout(timeout);
+            reject(e);
+        }
+    });
+}
 app.post('/bypass', async (req, res) => {
     const { url, mode, siteKey, proxy } = req.body;
+    if (!url || !mode) return res.status(400).json({ status: "error", message: "Missing url or mode" });
     if (activeBrowsers >= MAX_CONCURRENT_BROWSERS) {
+        return res.status(429).json({ status: "busy", message: "Server busy, try again in 5 seconds" });
     }
     activeBrowsers++;
     let browserInstance = null;
     try {
+        console.log(`[REQ] Processing: ${url} | Mode: ${mode}`);
         const { browser, page } = await createBrowser(proxy);
         browserInstance = browser;
         let result;
+        if (mode === 'turnstile') {
+            if (!siteKey) throw new Error("siteKey required for turnstile");
             result = await handleTurnstile(page, url, siteKey);
         } else {
+            throw new Error("Only 'turnstile' mode supported in this fix version");
         }
+        console.log(`[SUCCESS] Token obtained for ${url}`);
         res.json({ status: "success", ...result });
     } catch (error) {
+        console.error(`[CRITICAL ERROR]`, error);
+        res.status(500).json({
+            status: "error",
+            message: error.message,
+            stack: error.stack
+        });
     } finally {
         if (browserInstance) {
+            try { await browserInstance.close(); } catch {}
         }
         activeBrowsers--;
     }
 });
+app.get('/', (req, res) => res.send("M3M3K3 Server Running. Use POST /bypass"));
+app.listen(PORT, () => console.log(`Server listening on port ${PORT}`));