Upload 19 files

.dockerignore

@@ -0,0 +1,21 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.venv/
+env.bak/
+venv.bak/
+*.log
+logs/
+data/
+*.db
+.DS_Store
+.git/
+.gitignore
+.vscode/
+.idea/
+*.md
+docker-compose.override.yml

.env

@@ -0,0 +1,15 @@
+# Email configuration
+EMAIL=gi2h27@gmail.com
+
+# Faucet configuration
+MAX_CLAIMS=100000
+COOLDOWN_OVERRIDE=5
+
+# Proxy settings (jika perlu)
+HTTP_PROXY=
+HTTPS_PROXY=
+NO_PROXY=localhost,127.0.0.1
+
+# Solver settings
+SOLVER_URL=https://gi2h-xxx.hf.space
+SOLVER_KEY=00000000000000000000#0000000000000000000#000000000000000000#

Api/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Api/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/Api.md

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

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/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/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/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;

Api/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

Api/README.md

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

Api/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"
+}

Api/supervisord.conf

@@ -0,0 +1,42 @@
+[supervisord]
+nodaemon=true
+logfile=/var/log/supervisor/supervisord.log
+pidfile=/var/run/supervisord.pid
+childlogdir=/var/log/supervisor
+
+[program:xvfb]
+command=Xvfb :99 -screen 0 1024x768x24 -ac +extension GLX +render -noreset
+autostart=true
+autorestart=true
+priority=100
+stdout_logfile=/var/log/supervisor/xvfb.log
+stderr_logfile=/var/log/supervisor/xvfb.err
+
+[program:api]
+command=npm start
+directory=/app/api
+environment=DISPLAY=":99",NODE_ENV="production"
+autostart=true
+autorestart=true
+priority=200
+stdout_logfile=/var/log/supervisor/api.log
+stderr_logfile=/var/log/supervisor/api.err
+startretries=3
+
+[program:bot]
+command=gunicorn --bind 0.0.0.0:7861 --workers 1 --threads 2 --timeout 120 app:app
+directory=/app/bot
+environment=DISPLAY=":99",PYTHONUNBUFFERED="1"
+autostart=true
+autorestart=true
+priority=300
+stdout_logfile=/var/log/supervisor/bot.log
+stderr_logfile=/var/log/supervisor/bot.err
+
+[program:nginx]
+command=nginx -g 'daemon off;'
+autostart=true
+autorestart=true
+priority=400
+stdout_logfile=/var/log/supervisor/nginx.log
+stderr_logfile=/var/log/supervisor/nginx.err

Dockerfile

@@ -0,0 +1,109 @@
+# ============================================
+# DOCKERFILE FAUCET BOT - FULL FIX
+# ============================================
+FROM python:3.9-slim
+
+# -------------------------------
+# 1. Install system dependencies + Xvfb
+# -------------------------------
+RUN apt-get update && apt-get install -y \
+    curl \
+    wget \
+    gnupg \
+    ca-certificates \
+    xz-utils \
+    xvfb \
+    fonts-liberation \
+    libnss3 \
+    libatk-bridge2.0-0 \
+    libx11-xcb1 \
+    libxcb-dri3-0 \
+    libxcomposite1 \
+    libxdamage1 \
+    libxrandr2 \
+    libgbm1 \
+    libasound2 \
+    libatk1.0-0 \
+    libgtk-3-0 \
+    libxshmfence1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# -------------------------------
+# 2. Install Google Chrome
+# -------------------------------
+RUN mkdir -p /etc/apt/keyrings \
+    && wget -q -O - https://dl.google.com/linux/linux_signing_key.pub > /tmp/google.pub \
+    && gpg --dearmor < /tmp/google.pub > /etc/apt/keyrings/google-chrome.gpg \
+    && echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/google-chrome.gpg] http://dl.google.com/linux/chrome/deb/ stable main" > /etc/apt/sources.list.d/google-chrome.list \
+    && apt-get update \
+    && apt-get install -y google-chrome-stable \
+    && rm -rf /var/lib/apt/lists/* \
+    && rm /tmp/google.pub
+
+WORKDIR /app
+
+# -------------------------------
+# 3. Install Python dependencies
+# -------------------------------
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# -------------------------------
+# 4. Install Node.js 20
+# -------------------------------
+RUN mkdir -p /etc/apt/keyrings \
+    && curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg \
+    && echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_20.x nodistro main" > /etc/apt/sources.list.d/nodesource.list \
+    && apt-get update \
+    && apt-get install -y nodejs \
+    && rm -rf /var/lib/apt/lists/*
+
+# -------------------------------
+# 5. Copy API
+# -------------------------------
+COPY Api/ /app/Api/
+WORKDIR /app/Api
+RUN npm install --omit=dev
+
+WORKDIR /app
+
+# -------------------------------
+# 6. Copy Python bot
+# -------------------------------
+COPY app.py .
+
+# -------------------------------
+# 7. Startup Script
+# -------------------------------
+RUN echo '#!/bin/bash\n\
+echo "🤖 STARTING FAUCET BOT"\n\
+echo "======================"\n\
+\n\
+echo "Starting Node.js API..."\n\
+cd /app/Api\n\
+node Api.js &\n\
+\n\
+echo "Waiting for API to start..."\n\
+sleep 5\n\
+\n\
+echo "Starting Python Bot..."\n\
+cd /app\n\
+xvfb-run -a python3 app.py\n\
+' > /start.sh && chmod +x /start.sh
+
+# -------------------------------
+# 8. Healthcheck
+# -------------------------------
+HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
+    CMD curl -f http://localhost:3000/ || exit 1
+
+# -------------------------------
+# 9. Expose API port
+# -------------------------------
+EXPOSE 3000
+
+# -------------------------------
+# 10. Start container
+# -------------------------------
+CMD ["/start.sh"]

README.md

@@ -1,8 +1,8 @@
 ---
-title: Drtrx
-emoji: 🦀
-colorFrom: blue
-colorTo: indigo
+title: Auto
+emoji: 📉
+colorFrom: pink
+colorTo: gray
 sdk: docker
 pinned: false
 ---

app.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+import asyncio, json, os, re, aiohttp
+from bs4 import BeautifulSoup
+from datetime import datetime
+from yarl import URL
+
+BASE = "https://driptrx.fun"
+URL_FAUCET = BASE + "/faucet.php"
+URL_LUCKY  = BASE + "/lucky.php"
+URL_SPIN   = BASE + "/lucky.php?spin=1"
+
+EMAILS = [
+    "qnita989@gmail.com","gadisk820@gmail.com","jokondeso53@gmail.com","gadis0469@gmail.com",
+    "aldoaldo254535@gmail.com","queenitanita27@gmail.com","qoniytata@gmail.com","gi2h27013@gmail.com",
+    "gi2h27012@gmail.com","gi2h2720@gmail.com","gi2h27010@gmail.com","cleopard438@gmail.com",
+    "jndeso64@gmail.com","monross254535@gmail.com","gi2h2706@gmail.com","gi2h2709@gmail.com",
+    "gi2h27018@gmail.com","gigihlazim1@gmail.com","gigihlazim7@gmail.com","gigihlazim8@gmail.com",
+    "gigihlazim9@gmail.com","qoniq65@gmail.com","bosocksock@gmail.com","chusmyoh@gmail.com",
+    "gi2h370@gmail.com","aldi254535@gmail.com","monnavaldemar11@gmail.com","exelsnoxyti@gmail.com",
+    "toxicnozle@gmail.com","ydahross@gmail.com","gi2h37@gmail.com","gi2h27@gmail.com",
+    "gi2h270@gmail.com","gi2h2701@gmail.com","gi2h2702@gmail.com","gi2h2703@gmail.com",
+    "gi2h2704@gmail.com","gi2h2705@gmail.com","gi2h27015@gmail.com"
+]
+
+GREEN = "\033[92m"
+RESET = "\033[0m"
+
+TOTAL_SUCCESS = 0
+TOTAL_LOCK = asyncio.Lock()
+
+COOK_DIR = "drptrx21"
+os.makedirs(COOK_DIR, exist_ok=True)
+
+HEADERS = {
+    "user-agent": "Mozilla/5.0 (Linux; Android 12; SM-A537F) Chrome/140 Mobile"
+}
+
+def safe(email):
+    return email.replace("@","_at_").replace(".","_")
+
+def load_cookies(email):
+    fn = f"{COOK_DIR}/cookies_{safe(email)}.json"
+    if os.path.exists(fn):
+        try:
+            with open(fn) as f:
+                return json.load(f)
+        except:
+            return None
+    return None
+
+def save_cookies(email, jar):
+    fn = f"{COOK_DIR}/cookies_{safe(email)}.json"
+    with open(fn,"w") as f:
+        json.dump(jar, f)
+
+async def fetch(session, url):
+    async with session.get(url, timeout=30) as r:
+        return await r.text()
+
+async def post(session, url, data):
+    async with session.post(url, data=data, timeout=30) as r:
+        return await r.text()
+
+def parse(html):
+    soup = BeautifulSoup(html, "html.parser")
+
+    success = soup.find("div", class_=re.compile("alert.*success"))
+    msg = success.get_text(strip=True) if success else None
+
+    cd = soup.find(id="countdown-text")
+    sec = None
+    if cd:
+        m = re.search(r"(\d+)", cd.get_text(strip=True))
+        if m:
+            sec = int(m.group(1))
+
+    has_address = soup.find("input", {"name": "address"}) is not None
+    has_verify = soup.find("input", {"name": "verify"}) is not None
+
+    return msg, sec, has_address, has_verify
+
+def parse_spin(html):
+    soup = BeautifulSoup(html, "html.parser")
+
+    b = soup.find("b")
+    if b and b.get_text(strip=True).isdigit():
+        return ("reward", int(b.get_text(strip=True)))
+
+    txt = soup.get_text(" ", strip=True)
+
+    r = re.search(r"You won\s+(\d+)\s+satoshi", txt, re.I)
+    if r:
+        return ("reward", int(r.group(1)))
+
+    cd = re.search(r"(\d+)m\s*(\d+)s", txt)
+    if cd:
+        return ("cooldown", int(cd.group(1))*60 + int(cd.group(2)))
+
+    js = re.search(r"remaining\s*=\s*(\d+)", html)
+    if js:
+        return ("cooldown", int(js.group(1)))
+
+    return ("unknown", None)
+
+def get_spin_token(html):
+    soup = BeautifulSoup(html, "html.parser")
+    token_input = soup.find("input", {"name": "token"})
+
+    if token_input:
+        return token_input.get("value")
+    else:
+        return "50000"  # default token agar tidak error
+
+
+async def worker(email):
+    global TOTAL_SUCCESS
+    print(f"[START] {email}")
+
+    async with aiohttp.ClientSession(
+        headers=HEADERS,
+        cookie_jar=aiohttp.CookieJar()
+    ) as session:
+
+        ck = load_cookies(email)
+        if ck:
+            session.cookie_jar.update_cookies(ck)
+
+        success_count = 0
+
+        while True:
+            try:
+                now = datetime.now().strftime("%H:%M:%S")
+                html = await fetch(session, URL_FAUCET + "?after_verify=1")
+                msg, sec, has_address, has_verify = parse(html)
+
+                if msg and ("sent" in msg.lower()):
+                    success_count += 1
+                    async with TOTAL_LOCK:
+                        TOTAL_SUCCESS += 1
+                        global_total = TOTAL_SUCCESS
+
+                    print(f"[{now}] {email} → {GREEN}{msg}{RESET} "
+                          f"+ Timer {sec or 0}s "
+                          f"(Email: {success_count} | Global: {global_total})")
+
+                    cookies = session.cookie_jar.filter_cookies(URL(BASE))
+                    save_cookies(email, {k: v.value for k, v in cookies.items()})
+
+                   
+
+                    await asyncio.sleep((sec or 2) + 2)
+                    continue
+
+                if has_address:
+                    print(f"[{now}] {email} → Session expired → STEP 1")
+                    await post(session, URL_FAUCET, {"address": email})
+                    await asyncio.sleep(1)
+                    continue
+
+                if has_verify:
+                    print(f"[{now}] {email} → Server minta verify → STEP 2")
+                    await post(session, URL_FAUCET, {"verify": "1"})
+                    await asyncio.sleep(1)
+                    continue
+
+                if sec and sec > 0:
+                    print(f"[{now}] {email} → Timer {sec}s")
+                    await asyncio.sleep(sec + 2)
+                    continue
+
+                print(f"[{now}] {email} → Claiming...")
+                html = await post(session,
+                                  URL_FAUCET + "?after_verify=1",
+                                  {"verify": "1"})
+                msg, sec, _, _ = parse(html)
+                sec = sec or 0
+
+                print(f"[{now}] {email} → {GREEN}{msg}{RESET} + Timer {sec}s")
+
+                cookies = session.cookie_jar.filter_cookies(URL(BASE))
+                save_cookies(email, {k: v.value for k, v in cookies.items()})
+
+                await asyncio.sleep(3)
+
+            except Exception as e:
+                print(f"{email} ERROR: {e}")
+                await asyncio.sleep(5)
+
+async def main():
+    tasks = [asyncio.create_task(worker(email)) for email in EMAILS]
+    await asyncio.gather(*tasks)
+
+if __name__ == "__main__":
+    asyncio.run(main())

docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  multi-coin-bot:
+    build: .
+    container_name: multi-coin-faucet-bot
+    restart: unless-stopped
+    volumes:
+      - ./logs:/app/logs
+      - ./data:/app/data
+    environment:
+      - TZ=Asia/Jakarta
+      - EMAIL=gi2h27@gmail.com
+      - MAX_CYCLES=100000
+      - SOLVER_URL=https://gi2h-xxx.hf.space
+      - SOLVER_KEY=00000000000000000000#0000000000000000000#000000000000000000#
+      - PYTHONUNBUFFERED=1
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"

requirements.txt

@@ -0,0 +1,5 @@
+requests==2.31.0
+colorama==0.4.6
+python-dotenv==1.0.0
+aiohttp
+beautifulsoup4