Deploy to HF Space

Api.js

@@ -0,0 +1,205 @@
+/**
+ * API.js
+ */
+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;
+
+global.browserLimit = 100;
+global.timeOut = 300000;
+
+// cache 
+const CACHE_DIR = path.join(__dirname, "cache");
+const CACHE_FILE = path.join(CACHE_DIR, "cache.json");
+const CACHE_TTL = 5 * 60 * 1000;
+const CACHE_AUTOSAVE = process.env.CACHE_AUTOSAVE === "true";
+
+function readCache(type, taskId) {
+    const file = path.join(CACHE_DIR, type, `${taskId}.json`);
+    if (!fs.existsSync(file)) return null;
+
+    try {
+        const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        console.log(`cache check: ${type}:${taskId} => ${data ? "HIT" : "MISS"}`);
+        if (Date.now() - data.timestamp < CACHE_TTL) {
+            return data;
+        }
+        return null;
+    } catch {
+        return null;
+    }
+}
+
+function writeCache(type, taskId, value) {
+    const dir = path.join(CACHE_DIR, type);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+    const file = path.join(dir, `${taskId}.json`);
+    const data = { timestamp: Date.now(), ...value };
+
+    fs.writeFileSync(file, JSON.stringify(data, null, 2), 'utf-8');
+    console.log(`cache saved: ${type}:${taskId}`);
+}
+
+function cleanCache() {
+    const types = ["turnstile", "recaptcha3", "recaptcha2", "interstitial", "error"];
+    const now = Date.now();
+    const TTL = 60 * 60 * 1000;
+
+    types.forEach(type => {
+        const dir = path.join(CACHE_DIR, type);
+        if (!fs.existsSync(dir)) return;
+
+        fs.readdirSync(dir).forEach(file => {
+            const filePath = path.join(dir, file);
+            try {
+                const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                if (now - data.timestamp > TTL) {
+                    fs.unlinkSync(filePath);
+                    console.log(`cache expired: ${filePath}`);
+                }
+            } catch {
+                fs.unlinkSync(filePath);
+            }
+        });
+    });
+}
+
+setInterval(cleanCache, 600 * 1000);
+
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+const tasks = {};
+
+// Api_route
+app.get("/", (req, res) => {
+    const baseUrl = `${req.protocol}://${req.get('host')}`;
+    const uptime = process.uptime(); 
+    res.json({
+        message: "Welcome",
+        server: {
+            domain: baseUrl,
+            version: "7.3.0",
+            uptime: `${Math.floor(uptime)} seconds`,
+            limit: global.browserLimit,
+            timeout: global.timeOut,
+            status: "recently running"
+        },
+        solvers: ["turnstile", "recaptcha2", "recaptcha3", "interstitial"]
+    });
+});
+
+
+app.post('/solve', async (req, res) => {
+    const { type, domain, siteKey, taskId, action, proxy, isInvisible } = req.body;
+
+    if (taskId) {
+        const task = tasks[taskId];
+        if (!task) return res.status(404).json({ status: "error", message: "Task not found" });
+
+        if (task.status === "pending") {
+            return res.json({ status: "processing" });
+        }
+
+        return res.json(task);
+    }
+
+    const newTaskId = Date.now().toString(36);
+    tasks[newTaskId] = { status: "pending" };
+    console.log(`New : ${newTaskId}=${type}:${domain}`);
+
+    (async () => {
+        try {
+            const ctx = await init_browser(proxy?.server);
+            const page = ctx.page;
+            let result;
+
+            switch (type) {
+                case "turnstile":
+                    result = await turnstile({ domain, siteKey, action, proxy }, page);
+                    tasks[newTaskId] = { status: "done", ...result };
+                    console.log(`done: ${newTaskId}=${type}:${domain}`);
+                    if (CACHE_AUTOSAVE) writeCache("turnstile", newTaskId, tasks[newTaskId]);
+                    break;
+
+                case "interstitial":
+                    result = await interstitial({ domain, proxy }, page);
+                    tasks[newTaskId] = { status: "done", ...result };
+                    console.log(`done: ${newTaskId}=${type}:${domain}`);
+                    if (CACHE_AUTOSAVE) writeCache("interstitial", newTaskId, tasks[newTaskId]);
+                    break;
+
+                case "recaptcha2":
+                    result = await recaptchaV2({ domain, siteKey, action, isInvisible, proxy }, page);
+                    tasks[newTaskId] = { status: "done", ...result };
+                    console.log(`done: ${newTaskId}=${type}:${domain}`);
+                    if (CACHE_AUTOSAVE) writeCache("recaptcha2", newTaskId, tasks[newTaskId]);
+                    break;
+                    
+                case "recaptcha3":
+                    result = await recaptchaV3({ domain, siteKey, action, proxy }, page);
+                    tasks[newTaskId] = { status: "done", ...result };
+                    console.log(`done: ${newTaskId}=${type}:${domain}`);
+                    if (CACHE_AUTOSAVE) writeCache("recaptcha3", newTaskId, tasks[newTaskId]);
+                    break;
+
+                default:
+                    tasks[newTaskId] = { status: "error", message: "Invalid type" };
+            }
+
+            await ctx.browser.close();
+            console.log(`Browser closed ${newTaskId}`);
+        } catch (err) {
+            tasks[newTaskId] = { status: "error", message: "totally failed" };
+            console.error(`failed: ${newTaskId}=${type}:${domain}`);
+            console.error("Detailed error:", err);
+        }
+    })();
+
+    res.json({ taskId: newTaskId, status: "pending" });
+});
+
+// init_browser
+async function init_browser(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();
+    });
+    console.log(`initialized${proxyServer ? "proxy= " + proxyServer : ""}`);
+
+    return { browser, page };
+}
+
+
+const turnstile = require('./Api/turnstile');
+const interstitial = require('./Api/interstitial');
+const recaptchaV2 = require('./Api/recaptcha2');
+const recaptchaV3 = require('./Api/recaptcha3');
+
+app.use((req, res) => {
+    res.status(404).json({ message: 'Not Found' });
+    console.warn(`error: ${req.method} ${req.originalUrl}`);
+});
+
+app.listen(port, () => {
+    console.log(`Server running: http://localhost:${port}`);
+});

Api/Api.md

@@ -0,0 +1 @@
+Api

Api/interstitial.js

@@ -0,0 +1,82 @@
+/**
+ * INTERSTITIAL
+ */
+async function interstitial({ domain, proxy }, page) {
+    return new Promise(async (resolve, reject) => {
+        if (!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;
+                resolve({
+                    cf_clearance: null,
+                    cookies: null,
+                    user_agent: userAgent,
+                    type: 'interstitial'
+                });
+            }
+        }, 20000);
+
+        try {
+            if (proxy?.username && proxy?.password) {
+                await page.authenticate({
+                    username: proxy.username,
+                    password: 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 cookies = headers["set-cookie"];
+                            const match = cookies.match(/cf_clearance=([^;]+)/);
+                            if (match) {
+                                const cf_clearance = match[1];
+                                const userAgent = (await res.request().headers())["user-agent"];
+
+                                if (!isResolved) {
+                                    isResolved = true;
+                                    clearTimeout(cl);
+                                    resolve({
+                                        cf_clearance,
+                                        cookies,          // seluruh cookie string
+                                        user_agent: userAgent,
+                                        type: 'interstitial'
+                                    });
+                                }
+                            }
+                        }
+                    }
+                } catch (_) {}
+            });
+
+            await page.goto(domain, { waitUntil: "domcontentloaded" });
+            userAgent = await page.evaluate(() => navigator.userAgent);
+        } catch (err) {
+            if (!isResolved) {
+                isResolved = true;
+                clearTimeout(cl);
+                reject(err);
+            }
+        }
+    });
+}
+
+module.exports = interstitial;

Api/recaptcha2.js

@@ -0,0 +1,228 @@
+/**
+ * API_RECAPTCHA2
+ */
+async function recaptchaV2({ domain, siteKey, action = "submit", isInvisible = false, proxy }, page) {
+    if (!domain) throw new Error("Missing domain parameter");
+    if (!siteKey) throw new Error("Missing siteKey parameter");
+
+    const timeout = global.timeOut;
+
+    return new Promise(async (resolve, reject) => {
+        let isResolved = false;
+
+        const cl = setTimeout(() => {
+            if (!isResolved) {
+                isResolved = true;
+                reject(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">
+                <head>
+                    <meta charset="UTF-8">
+                    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                    <title>reCAPTCHA v2 Solver</title>
+                    <style>
+                        body {
+                            font-family: Arial, sans-serif;
+                            margin: 0;
+                            padding: 20px;
+                            background: #f5f5f5;
+                            display: flex;
+                            justify-content: center;
+                            align-items: center;
+                            min-height: 100vh;
+                        }
+                        .container {
+                            background: white;
+                            padding: 30px;
+                            border-radius: 10px;
+                            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+                            text-align: center;
+                        }
+                        .status {
+                            margin-top: 20px;
+                            padding: 10px;
+                            border-radius: 5px;
+                            background: #f8f9fa;
+                        }
+                        button {
+                            background: #007bff;
+                            color: white;
+                            border: none;
+                            padding: 10px 20px;
+                            border-radius: 5px;
+                            cursor: pointer;
+                            margin: 10px;
+                        }
+                        button:hover { background: #0056b3; }
+                    </style>
+                </head>
+                <body>
+                    <div class="container">
+                        <h2>reCAPTCHA v2 Solver</h2>
+                        <p>SiteKey: ${siteKey}</p>
+                        <div id="recaptcha-container">
+                            <div class="g-recaptcha"
+                                 data-sitekey="${siteKey}"
+                                 data-callback="recaptchaCallback"
+                                 data-expired-callback="recaptchaExpired"
+                                 data-error-callback="recaptchaError"
+                                 data-size="${isInvisible ? 'invisible' : 'normal'}"
+                                 data-theme="light"></div>
+                        </div>
+                        ${isInvisible ? '<button onclick="executeInvisible()">Execute reCAPTCHA</button>' : ''}
+                        <button onclick="checkToken()">Check Token</button>
+                        <div class="status" id="status">Waiting for reCAPTCHA...</div>
+                    </div>
+
+                    <script>
+                        window.recaptchaToken = null;
+                        window.recaptchaSolved = false;
+
+                        window.recaptchaCallback = function(token) {
+                            console.log('reCAPTCHA token received:', token);
+                            window.recaptchaToken = token;
+                            window.recaptchaSolved = true;
+
+                            document.getElementById('status').innerHTML =
+                                '✅ reCAPTCHA Solved! Token: ' + token.substring(0, 20) + '...';
+                            document.getElementById('status').style.background = '#d4edda';
+                            document.getElementById('status').style.color = '#155724';
+
+                            var input = document.createElement('input');
+                            input.type = 'hidden';
+                            input.name = 'g-recaptcha-response';
+                            input.value = token;
+                            input.id = 'recaptcha-token-input';
+                            document.body.appendChild(input);
+
+                            localStorage.setItem('recaptcha_token', token);
+                        };
+
+                        window.recaptchaExpired = function() {
+                            console.log('reCAPTCHA expired');
+                            window.recaptchaToken = null;
+                            window.recaptchaSolved = false;
+                            document.getElementById('status').innerHTML = '❌ reCAPTCHA Expired - Refreshing...';
+                            document.getElementById('status').style.background = '#fff3cd';
+                            document.getElementById('status').style.color = '#856404';
+
+                            var existing = document.getElementById('recaptcha-token-input');
+                            if (existing) existing.remove();
+
+                            setTimeout(() => { if (window.grecaptcha) grecaptcha.reset(); }, 1000);
+                        };
+
+                        window.recaptchaError = function() {
+                            console.log('reCAPTCHA error');
+                            document.getElementById('status').innerHTML = '❌ reCAPTCHA Error';
+                            document.getElementById('status').style.background = '#f8d7da';
+                            document.getElementById('status').style.color = '#721c24';
+                        };
+
+                        window.executeInvisible = function() {
+                            if (window.grecaptcha) grecaptcha.execute();
+                        };
+
+                        window.checkToken = function() {
+                            const token = window.recaptchaToken ||
+                                          document.getElementById('recaptcha-token-input')?.value;
+                            document.getElementById('status').innerHTML = token
+                                ? 'Token: ' + token
+                                : 'No token yet';
+                        };
+
+                        window.onload = function() {
+                            setTimeout(function() {
+                                if (${isInvisible} && window.grecaptcha) {
+                                    grecaptcha.execute();
+                                }
+                                if (!${isInvisible}) {
+                                    var iframe = document.querySelector('iframe[src*="recaptcha"]');
+                                    if (iframe) {
+                                        console.log('Attempting to interact with reCAPTCHA');
+                                        var rect = iframe.getBoundingClientRect();
+                                        var clickEvent = new MouseEvent('click', {
+                                            view: window, bubbles: true, cancelable: true,
+                                            clientX: rect.left + rect.width / 2,
+                                            clientY: rect.top + rect.height / 2
+                                        });
+                                        iframe.dispatchEvent(clickEvent);
+                                    }
+                                }
+                            }, 2000);
+                        };
+                    </script>
+
+                    <script src="https://www.google.com/recaptcha/api.js" async defer></script>
+                </body>
+                </html>
+            `;
+
+            await page.setRequestInterception(true);
+            page.removeAllListeners("request");
+            page.on("request", async (req) => {
+                const url = req.url();
+                if ([domain, domain + "/"].includes(url) && req.resourceType() === "document") {
+                    await req.respond({ status: 200, contentType: "text/html", body: htmlContent });
+                } else if (["image", "stylesheet", "font"].includes(req.resourceType())) {
+                    await req.abort();
+                } else {
+                    await req.continue();
+                }
+            });
+
+            await page.goto(domain, { waitUntil: "domcontentloaded", timeout });
+            await page.waitForSelector('.g-recaptcha', { timeout: 10000 });
+
+            const tokenHandle = await page.waitForFunction(() => {
+                const input = document.querySelector('#recaptcha-token-input');
+                if (input?.value?.length > 10) return input.value;
+                const stored = localStorage.getItem('recaptcha_token');
+                if (stored?.length > 10) return stored;
+                if (window.recaptchaToken?.length > 10) return window.recaptchaToken;
+                return null;
+            }, { timeout, polling: 100 });
+
+            const tokenValue = await tokenHandle.jsonValue();
+
+            isResolved = true;
+            clearTimeout(cl);
+
+            if (!tokenValue || tokenValue.length < 10) {
+                reject(new Error("Failed to get valid reCAPTCHA token"));
+            } else {
+                resolve({ token: tokenValue, type: 'recaptcha_v2' });
+            }
+        } catch (error) {
+            if (!isResolved) {
+                isResolved = true;
+                clearTimeout(cl);
+                try {
+                    const fallbackToken = await page.evaluate(() => {
+                        const input = document.querySelector('#recaptcha-token-input');
+                        return input ? input.value : null;
+                    });
+                    if (fallbackToken?.length > 10) {
+                        resolve({ token: fallbackToken, type: 'recaptcha_v2' });
+                        return;
+                    }
+                } catch {}
+                reject(new Error(`reCAPTCHA solving failed: ${error.message}`));
+            }
+        }
+    });
+}
+
+module.exports = recaptchaV2;

Api/recaptcha3.js

@@ -0,0 +1,54 @@
+/**
+ * recaptcha3.js
+ */
+async function recaptchaV3({ domain, siteKey, action, proxy }, page) {
+    if (!domain) throw new Error("Missing domain parameter");
+    if (!siteKey) throw new Error("Missing siteKey parameter");
+
+    const timeout = 120000;
+
+    return new Promise(async (resolve, reject) => {
+        let isResolved = false;
+
+        const cl = setTimeout(() => {
+            if (!isResolved) {
+                isResolved = true;
+                reject(new Error("Timeout Error"));
+            }
+        }, timeout);
+
+        try {
+            if (proxy?.username && proxy?.password) {
+                await page.authenticate({
+                    username: proxy.username,
+                    password: proxy.password,
+                });
+            }
+
+            await page.goto(domain, { waitUntil: "domcontentloaded" });
+
+            await page.addScriptTag({ url: "https://www.google.com/recaptcha/api.js?render=" + siteKey });
+
+            const token = await page.evaluate(async (siteKey, action) => {
+                return await grecaptcha.execute(siteKey, { action: action || "login" });
+            }, siteKey, action);
+
+            isResolved = true;
+            clearTimeout(cl);
+
+            if (!token || token.length < 10) {
+                reject(new Error("Failed to get token"));
+            } else {
+                resolve({ token: token, type: "recaptcha3" });
+            }
+        } catch (e) {
+            if (!isResolved) {
+                isResolved = true;
+                clearTimeout(cl);
+                reject(e);
+            }
+        }
+    });
+}
+
+module.exports = recaptchaV3;

Api/turnstile.js

@@ -0,0 +1,92 @@
+/**
+ * API_TURNSTILE
+ */
+async function turnstile({ domain, siteKey, action, proxy }, page) {
+    if (!domain) throw new Error("Missing domain parameter");
+    if (!siteKey) throw new Error("Missing siteKey parameter");
+
+    const timeout = global.timeOut;
+
+    return new Promise(async (resolve, reject) => {
+        let isResolved = false;
+
+        const cl = setTimeout(() => {
+            if (!isResolved) {
+                isResolved = true;
+                reject(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}',
+                                action: '${action || ""}',
+                                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(() => {
+                return document.querySelector('[name="cf-response"]').value;
+            });
+
+            isResolved = true;
+            clearTimeout(cl);
+
+            if (!token || token.length < 10) {
+                reject(new Error("Failed to get token"));
+            } else {
+                resolve({ token: token, type: 'turnstile' });
+            }
+        } catch (e) {
+            if (!isResolved) {
+                isResolved = true;
+                clearTimeout(cl);
+                reject(e);
+            }
+        }
+    });
+}
+
+module.exports = turnstile;

Dockerfile

@@ -0,0 +1,25 @@
+FROM node:20-slim
+
+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 \
+    && 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
+
+WORKDIR /A
+
+RUN mkdir -p /A/Api && mkdir -p /A/cache
+
+COPY package.json ./
+RUN npm install
+
+COPY . .
+
+EXPOSE 7860
+
+CMD rm -f /tmp/.X99-lock && \
+    Xvfb :99 -screen 0 1024x768x24 & \
+    export DISPLAY=:99 && \
+    npm start

README.md

@@ -1,11 +1,12 @@
 ---
-title: Apalah
-emoji: 😻
-colorFrom: green
-colorTo: indigo
+title: Api
+emoji: 🦀
+colorFrom: blue
+colorTo: yellow
 sdk: docker
 pinned: false
-short_description: Newbie
+license: mit
+short_description: Api
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

package.json

@@ -0,0 +1,17 @@
+{
+    "name": "api",
+    "version": "7.3.0",
+    "description": "gmxch_Api",
+    "scripts": {
+        "start": "node Api.js",
+        "dev": "nodemon Api.js"
+    },
+    "dependencies": {
+        "express": "^5.1.0",
+        "puppeteer-real-browser": "^1.4.0"
+    },
+    "devDependencies": {
+        "nodemon": "^3.1.10"
+    },
+    "license": "MIT"
+}