Spaces:

lordofc
/

bycf

Sleeping

App Files Files Community

lordofc commited on Nov 2

Commit

1f72a3b

verified ·

1 Parent(s): b02912d

Upload 3 files

Browse files

Files changed (3) hide show

lib/BypassService.js +233 -0
lib/browser.js +270 -0
lib/logger.js +33 -0

lib/BypassService.js ADDED Viewed

	@@ -0,0 +1,233 @@

+const { Logger } = require("./logger");
+const { BrowserService } = require("./browser");
+const fs = require("fs");
+const path = require("path");
+class BypassService {
+    constructor() {
+        this.logger = new Logger("Bypass");
+        this.browserService = new BrowserService();
+        this.fakePageContent = "";
+        this.loadFakePage();
+    }
+    loadFakePage() {
+        try {
+            let fakePagePath = path.join(process.cwd(), "assets", "fakePage.html");
+            if (!fs.existsSync(fakePagePath)) {
+                fakePagePath = path.join(process.cwd(), "fakePage.html");
+            }
+            const assetsDir = path.dirname(fakePagePath);
+            if (!fs.existsSync(assetsDir)) {
+                fs.mkdirSync(assetsDir, { recursive: true });
+            }
+            if (!fs.existsSync(fakePagePath)) {
+                this.fakePageContent = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title></title>
+</head>
+<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: '<site-key>',
+                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>`;
+                fs.writeFileSync(fakePagePath, this.fakePageContent);
+            } else {
+                this.fakePageContent = fs.readFileSync(fakePagePath, "utf-8");
+            }
+            this.logger.success("Fake page loaded successfully");
+        } catch (error) {
+            this.logger.error("Failed to load fake page:", error);
+            this.fakePageContent = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title></title>
+</head>
+<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: '<site-key>',
+                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>`;
+        }
+    }
+    async solveTurnstileMin(url, siteKey, proxy, timeout = 60000) {
+        const startTime = Date.now();
+        try {
+            if (!url || !siteKey) throw new Error("Missing url or siteKey parameter");
+            const token = await this.browserService.withBrowserContext(async (context) => {
+                const page = await context.newPage();
+                if (proxy?.username && proxy?.password) {
+                    await page.authenticate({
+                        username: proxy.username,
+                        password: proxy.password,
+                    });
+                }
+                await page.setRequestInterception(true);
+                page.on("request", async (request) => {
+                    if ([url, url + "/"].includes(request.url()) && request.resourceType() === "document") {
+                        await request.respond({
+                            status: 200,
+                            contentType: "text/html",
+                            body: this.fakePageContent.replace(/<site-key>/g, siteKey),
+                        });
+                    } else {
+                        await request.continue();
+                    }
+                });
+                await page.goto(url, { waitUntil: "domcontentloaded" });
+                await page.waitForSelector('[name="cf-response"]', { timeout });
+                return page.evaluate(() => {
+                    try {
+                        const input = document.querySelector('[name="cf-response"]');
+                        return input ? input.value : null;
+                    } catch {
+                        return null;
+                    }
+                });
+            });
+            if (!token || token.length < 10) throw new Error("Failed to get token");
+            return {
+                success: true,
+                creator: "LoRDx",
+                data: token,
+                duration: Date.now() - startTime,
+            };
+        } catch (error) {
+            this.logger.error("Turnstile min solve error:", error);
+            return {
+                success: false,
+                error: error.message || "Unknown error",
+                duration: Date.now() - startTime,
+            };
+        }
+    }
+    async getSource(url, proxy, timeout = 60000) {
+        const startTime = Date.now();
+        try {
+            if (!url) throw new Error("Missing url parameter");
+            const result = await this.browserService.withBrowserContext(async (context) => {
+                const page = await context.newPage();
+                await page.setDefaultTimeout(30000);
+                await page.setDefaultNavigationTimeout(30000);
+                if (proxy?.username && proxy?.password) {
+                    await page.authenticate({
+                        username: proxy.username,
+                        password: proxy.password,
+                    });
+                }
+                await page.setRequestInterception(true);
+                let resolved = false;
+                return new Promise((resolve, reject) => {
+                    const timeoutHandler = setTimeout(() => {
+                        if (!resolved) {
+                            resolved = true;
+                            reject(new Error("Timeout Error"));
+                        }
+                    }, timeout);
+                    page.on("request", async (request) => {
+                        try {
+                            await request.continue();
+                        } catch { }
+                    });
+                    page.on("response", async (res) => {
+                        try {
+                            if (!resolved && [200, 302].includes(res.status()) && [url, url + "/"].includes(res.url())) {
+                                await page.waitForNavigation({ waitUntil: "load", timeout: 5000 }).catch(() => { });
+                                const html = await page.content();
+                                resolved = true;
+                                clearTimeout(timeoutHandler);
+                                resolve(html);
+                            }
+                        } catch (error) {
+                            if (!resolved) {
+                                resolved = true;
+                                clearTimeout(timeoutHandler);
+                                reject(error);
+                            }
+                        }
+                    });
+                    page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 }).catch((error) => {
+                        if (!resolved) {
+                            resolved = true;
+                            clearTimeout(timeoutHandler);
+                            reject(error);
+                        }
+                    });
+                });
+            });
+            return {
+                success: true,
+                creator: "LoRDx",
+                data: result,
+                duration: Date.now() - startTime,
+            };
+        } catch (error) {
+            this.logger.error("Get source error:", error);
+            return {
+                success: false,
+                error: error.message || "Unknown error",
+                duration: Date.now() - startTime,
+            };
+        }
+    }
+    async findAcceptLanguage(page) {
+        try {
+            return await page.evaluate(async () => {
+                try {
+                    const res = await fetch("https://httpbin.org/get");
+                    const json = await res.json();
+                    return json.headers["Accept-Language"] || json.headers["accept-language"] || null;
+                } catch {
+                    return null;
+                }
+            });
+        } catch {
+            return "en-US,en;q=0.9";
+        }
+    }
+    getStats() {
+        return this.browserService.getBrowserStats();
+    }
+}
+module.exports = { BypassService };

lib/browser.js ADDED Viewed

	@@ -0,0 +1,270 @@

+const { Logger } = require("./logger");
+const { connect } = require("puppeteer-real-browser");
+const os = require("os");
+class BrowserService {
+    constructor() {
+        this.logger = new Logger("Browser");
+        this.browser = null;
+        this.browserContexts = new Set();
+        this.cleanupTimer = null;
+        this.isShuttingDown = false;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.cleanupInterval = 30000;
+        this.contextTimeout = 300000;
+        this.contextCreationTimes = new Map();
+        this.stats = {
+            totalContexts: 0,
+            activeContexts: 0,
+            memoryUsage: 0,
+            cpuUsage: 0,
+            lastCleanup: Date.now(),
+        };
+        const cpuCores = os.cpus().length;
+        this.contextLimit = Math.max(cpuCores * 4, 16);
+        this.logger.info(`Browser service initialized with context limit: ${this.contextLimit}`);
+        this.setupGracefulShutdown();
+        this.startPeriodicCleanup();
+    }
+    async initialize(options = {}) {
+        if (this.isShuttingDown) return;
+        try {
+            await this.closeBrowser();
+            this.logger.info("Launching browser...");
+            const defaultWidth = 1024;
+            const defaultHeight = 768;
+            const width = options.width || defaultWidth;
+            const height = options.height || defaultHeight;
+            const { browser } = await connect({
+                headless: false,
+                turnstile: true,
+                connectOption: {
+                    defaultViewport: { width, height },
+                    timeout: 120000,
+                    protocolTimeout: 300000,
+                    args: [
+                        `--window-size=${width},${height}`,
+                        "--no-sandbox",
+                        "--disable-setuid-sandbox",
+                        "--disable-dev-shm-usage",
+                        "--disable-gpu",
+                        "--no-first-run",
+                        "--disable-extensions",
+                        "--disable-sync",
+                        "--disable-translate",
+                        "--disable-web-security",
+                        "--disable-features=VizDisplayCompositor",
+                    ],
+                },
+                disableXvfb: false,
+            });
+            if (!browser) throw new Error("Failed to connect to browser");
+            this.browser = browser;
+            this.reconnectAttempts = 0;
+            this.setupBrowserEventHandlers();
+            this.wrapBrowserMethods();
+            this.logger.success("Browser launched successfully");
+        } catch (error) {
+            this.logger.error("Browser initialization failed:", error);
+            if (this.reconnectAttempts < this.maxReconnectAttempts && !this.isShuttingDown) {
+                this.reconnectAttempts++;
+                this.logger.warn(`Retrying browser initialization (${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+                await new Promise((resolve) => setTimeout(resolve, 5000 * this.reconnectAttempts));
+                return this.initialize(options);
+            }
+            throw error;
+        }
+    }
+    setupBrowserEventHandlers() {
+        if (!this.browser) return;
+        this.browser.on("disconnected", async () => {
+            if (this.isShuttingDown) return;
+            this.logger.warn("Browser disconnected, attempting to reconnect...");
+            await this.handleBrowserDisconnection();
+        });
+        this.browser.on("targetcreated", () => this.updateStats());
+        this.browser.on("targetdestroyed", () => this.updateStats());
+    }
+    wrapBrowserMethods() {
+        if (!this.browser) return;
+        const originalCreateContext = this.browser.createBrowserContext.bind(this.browser);
+        this.browser.createBrowserContext = async (...args) => {
+            if (this.browserContexts.size >= this.contextLimit) {
+                await this.forceCleanupOldContexts();
+                if (this.browserContexts.size >= this.contextLimit) {
+                    throw new Error(`Browser context limit reached (${this.contextLimit})`);
+                }
+            }
+            const context = await originalCreateContext(...args);
+            if (context) {
+                this.browserContexts.add(context);
+                this.contextCreationTimes.set(context, Date.now());
+                this.stats.totalContexts++;
+                const originalClose = context.close.bind(context);
+                context.close = async () => {
+                    try {
+                        await originalClose();
+                    } catch (error) {
+                        this.logger.warn("Error closing context:", error.message);
+                    } finally {
+                        this.browserContexts.delete(context);
+                        this.contextCreationTimes.delete(context);
+                        this.updateStats();
+                    }
+                };
+                setTimeout(async () => {
+                    if (this.browserContexts.has(context)) {
+                        this.logger.debug("Force closing expired context");
+                        try {
+                            await context.close();
+                        } catch { }
+                    }
+                }, this.contextTimeout);
+            }
+            this.updateStats();
+            return context;
+        };
+    }
+    async handleBrowserDisconnection() {
+        try {
+            const cleanupPromises = Array.from(this.browserContexts).map((context) => context.close().catch(() => { }));
+            await Promise.allSettled(cleanupPromises);
+            this.browserContexts.clear();
+            this.contextCreationTimes.clear();
+            if (this.reconnectAttempts < this.maxReconnectAttempts) {
+                await new Promise((resolve) => setTimeout(resolve, 5000));
+                await this.initialize();
+            } else {
+                this.logger.error("Max reconnection attempts reached");
+            }
+        } catch (error) {
+            this.logger.error("Error handling browser disconnection:", error);
+        }
+    }
+    startPeriodicCleanup() {
+        this.cleanupTimer = setInterval(async () => {
+            if (this.isShuttingDown) return;
+            try {
+                await this.performCleanup();
+                this.updateStats();
+            } catch (error) {
+                this.logger.error("Periodic cleanup error:", error);
+            }
+        }, this.cleanupInterval);
+    }
+    async performCleanup() {
+        const now = Date.now();
+        const contextsToCleanup = [];
+        for (const [context, creationTime] of this.contextCreationTimes.entries()) {
+            if (now - creationTime > this.contextTimeout) {
+                contextsToCleanup.push(context);
+            }
+        }
+        if (contextsToCleanup.length > 0) {
+            this.logger.debug(`Cleaning up ${contextsToCleanup.length} expired contexts`);
+            const cleanupPromises = contextsToCleanup.map((context) => context.close().catch(() => { }));
+            await Promise.allSettled(cleanupPromises);
+        }
+        if (this.browserContexts.size > this.contextLimit * 0.8) await this.forceCleanupOldContexts();
+        this.stats.lastCleanup = now;
+    }
+    async forceCleanupOldContexts() {
+        const contextsArray = Array.from(this.browserContexts);
+        const sortedContexts = contextsArray.sort((a, b) => {
+            const timeA = this.contextCreationTimes.get(a) || 0;
+            const timeB = this.contextCreationTimes.get(b) || 0;
+            return timeA - timeB;
+        });
+        const toCleanup = sortedContexts.slice(0, Math.floor(sortedContexts.length * 0.3));
+        if (toCleanup.length > 0) {
+            this.logger.warn(`Force cleaning up ${toCleanup.length} contexts due to limit`);
+            const cleanupPromises = toCleanup.map((context) => context.close().catch(() => { }));
+            await Promise.allSettled(cleanupPromises);
+        }
+    }
+    updateStats() {
+        this.stats.activeContexts = this.browserContexts.size;
+        this.stats.memoryUsage = process.memoryUsage().heapUsed;
+        const usage = process.cpuUsage();
+        this.stats.cpuUsage = (usage.user + usage.system) / 1000000;
+    }
+    async createContext(options = {}) {
+        if (!this.browser) await this.initialize();
+        if (!this.browser) throw new Error("Browser not available");
+        return await this.browser.createBrowserContext({
+            ...options,
+            ignoreHTTPSErrors: true,
+        });
+    }
+    async withBrowserContext(callback) {
+        let context = null;
+        try {
+            context = await this.createContext();
+            return await callback(context);
+        } finally {
+            if (context) {
+                try {
+                    await context.close();
+                } catch (error) {
+                    this.logger.warn(`Failed to close context: ${error.message}`);
+                }
+            }
+        }
+    }
+    getBrowserStats() {
+        return { ...this.stats };
+    }
+    isReady() {
+        return this.browser !== null && !this.isShuttingDown;
+    }
+    async closeBrowser() {
+        if (this.browser) {
+            try {
+                const cleanupPromises = Array.from(this.browserContexts).map((context) => context.close().catch(() => { }));
+                await Promise.allSettled(cleanupPromises);
+                this.browserContexts.clear();
+                this.contextCreationTimes.clear();
+                await this.browser.close();
+                this.logger.info("Browser closed successfully");
+            } catch (error) {
+                this.logger.error("Error closing browser:", error);
+            } finally {
+                this.browser = null;
+            }
+        }
+    }
+    setupGracefulShutdown() {
+        const gracefulShutdown = async (signal) => {
+            this.logger.warn(`Received ${signal}, shutting down browser service...`);
+            this.isShuttingDown = true;
+            if (this.cleanupTimer) clearInterval(this.cleanupTimer);
+            await this.closeBrowser();
+            this.logger.success("Browser service shutdown complete");
+        };
+        process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+        process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+    }
+    async shutdown() {
+        this.isShuttingDown = true;
+        if (this.cleanupTimer) clearInterval(this.cleanupTimer);
+        await this.closeBrowser();
+    }
+}
+module.exports = { BrowserService };

lib/logger.js ADDED Viewed

	@@ -0,0 +1,33 @@

+class Logger {
+  constructor(context) {
+    this.context = context;
+  }
+  getTimestamp() {
+    return new Date().toISOString().replace("T", " ").substring(0, 19);
+  }
+  info(message, ...args) {
+    console.log(`[INFO] [${this.getTimestamp()}] [${this.context}] | ${message}`, ...args);
+  }
+  warn(message, ...args) {
+    console.log(`[WARN] [${this.getTimestamp()}] [${this.context}] | ${message}`, ...args);
+  }
+  error(message, ...args) {
+    console.log(`[ERROR] [${this.getTimestamp()}] [${this.context}] | ${message}`, ...args);
+  }
+  success(message, ...args) {
+    console.log(`[SUCCESS] [${this.getTimestamp()}] [${this.context}] | ${message}`, ...args);
+  }
+  debug(message, ...args) {
+    if (process.env.NODE_ENV === "development") {
+      console.log(`[DEBUG] [${this.getTimestamp()}] [${this.context}] | ${message}`, ...args);
+    }
+  }
+}
+module.exports = { Logger };