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: '270'
-emoji: 📚
-colorFrom: indigo
-colorTo: yellow
+title: Auto
+emoji: 📉
+colorFrom: pink
+colorTo: gray
 sdk: docker
 pinned: false
 ---

app.py

@@ -0,0 +1,934 @@
+#!/usr/bin/env python3
+"""
+MULTI-COIN FAUCET BOT - INDEPENDENT THREADS
+Auto claim untuk 3 coin: LTC, DOGE, TRUMP
+Setiap coin berjalan di thread terpisah dengan cooldown sendiri
+"""
+
+import requests
+import json
+import time
+import re
+import sys
+import os
+import threading
+from datetime import datetime, timedelta
+
+class Color:
+    """Class untuk warna terminal"""
+    PURPLE = '\033[95m'
+    CYAN = '\033[96m'
+    BLUE = '\033[94m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    RED = '\033[91m'
+    BOLD = '\033[1m'
+    END = '\033[0m'
+
+class IndependentMultiCoinFaucetBot:
+    def __init__(self, email):
+        self.email = email
+        self.base_url = "https://litecoin.freepepecoin.com"
+        self.solver_url = "https://gi2h-xxx.hf.space"
+        self.solver_key = "00000000000000000000#0000000000000000000#000000000000000000#"
+        
+        # File cookies per coin
+        self.cookies_files = {
+            'LTC': "cookies_ltc.json",
+            'DOGE': "cookies_doge.json", 
+            'TRUMP': "cookies_trump.json"
+        }
+        
+        # Konfigurasi coin dengan thread control
+        self.coins = {
+            'LTC': {
+                'name': 'Litecoin',
+                'url_path': '/faucet/LTC',
+                'default_cooldown': 180,  # 3 menit
+                'cooldown': 180,
+                'last_claim': 0,
+                'success_count': 0,
+                'total_claims': 0,
+                'total_rewards': 0,
+                'session': requests.Session(),
+                'running': True,
+                'last_login_time': 0,
+                'thread': None
+            },
+            'DOGE': {
+                'name': 'Dogecoin',
+                'url_path': '/faucet/DOGE',
+                'default_cooldown': 30,   # 30 detik
+                'cooldown': 30,
+                'last_claim': 0,
+                'success_count': 0,
+                'total_claims': 0,
+                'total_rewards': 0,
+                'session': requests.Session(),
+                'running': True,
+                'last_login_time': 0,
+                'thread': None
+            },
+            'TRUMP': {
+                'name': 'Trumpcoin',
+                'url_path': '/faucet/TRUMP',
+                'default_cooldown': 10,   # 10 detik
+                'cooldown': 10,
+                'last_claim': 0,
+                'success_count': 0,
+                'total_claims': 0,
+                'total_rewards': 0,
+                'session': requests.Session(),
+                'running': True,
+                'last_login_time': 0,
+                'thread': None
+            }
+        }
+        
+        # Setup headers untuk setiap session
+        for coin_symbol, coin_data in self.coins.items():
+            self.setup_headers(coin_data['session'])
+        
+        # Statistik global
+        self.total_cycles = 0
+        self.stats_file = "stats_independent.json"
+        self.load_stats()
+        
+        # Logging
+        self.log_dir = "logs"
+        os.makedirs(self.log_dir, exist_ok=True)
+        
+        # Lock untuk print output agar tidak tercampur
+        self.print_lock = threading.Lock()
+        
+        # Main running flag
+        self.running = True
+    
+    def setup_headers(self, session):
+        """Set headers untuk meniru browser"""
+        session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+            'Accept-Language': 'id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7',
+            'Accept-Encoding': 'gzip, deflate, br',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1',
+            'sec-ch-ua': '"Not(A:Brand";v="8", "Chromium";v="144", "Google Chrome";v="144"',
+            'sec-ch-ua-mobile': '?0',
+            'sec-ch-ua-platform': '"Windows"',
+        })
+    
+    def save_cookies(self, coin_symbol):
+        """Simpan cookies ke file untuk coin tertentu"""
+        try:
+            coin_data = self.coins[coin_symbol]
+            cookies_dict = requests.utils.dict_from_cookiejar(coin_data['session'].cookies)
+            
+            with open(self.cookies_files[coin_symbol], 'w') as f:
+                json.dump({
+                    'cookies': cookies_dict,
+                    'saved_at': datetime.now().isoformat(),
+                    'email': self.email,
+                    'last_login_time': coin_data['last_login_time']
+                }, f, indent=2)
+            
+            with self.print_lock:
+                print(f"{Color.GREEN}✓ [{coin_symbol}] Cookies disimpan{Color.END}")
+            return True
+        except Exception as e:
+            with self.print_lock:
+                print(f"{Color.YELLOW}⚠️  [{coin_symbol}] Gagal menyimpan cookies: {e}{Color.END}")
+            return False
+    
+    def load_cookies(self, coin_symbol):
+        """Load cookies dari file untuk coin tertentu"""
+        try:
+            if os.path.exists(self.cookies_files[coin_symbol]):
+                with open(self.cookies_files[coin_symbol], 'r') as f:
+                    data = json.load(f)
+                    cookies_dict = data.get('cookies', {})
+                    
+                    # Buat cookies jar dari dictionary
+                    cookies_jar = requests.utils.cookiejar_from_dict(cookies_dict)
+                    self.coins[coin_symbol]['session'].cookies = cookies_jar
+                    
+                    # Update last login time
+                    saved_time = data.get('saved_at')
+                    if saved_time:
+                        try:
+                            saved_dt = datetime.fromisoformat(saved_time)
+                            self.coins[coin_symbol]['last_login_time'] = saved_dt.timestamp()
+                        except:
+                            self.coins[coin_symbol]['last_login_time'] = time.time()
+                    else:
+                        self.coins[coin_symbol]['last_login_time'] = time.time()
+                    
+                    with self.print_lock:
+                        print(f"{Color.GREEN}✓ [{coin_symbol}] Cookies dimuat{Color.END}")
+                    return True
+            else:
+                with self.print_lock:
+                    print(f"{Color.YELLOW}⚠️  [{coin_symbol}] File cookies tidak ditemukan{Color.END}")
+                return False
+        except Exception as e:
+            with self.print_lock:
+                print(f"{Color.YELLOW}⚠️  [{coin_symbol}] Gagal memuat cookies: {e}{Color.END}")
+            return False
+    
+    def check_login_status(self, coin_symbol):
+        """Cek status login dengan cookies untuk coin tertentu"""
+        coin_data = self.coins[coin_symbol]
+        
+        try:
+            response = coin_data['session'].get(
+                f'{self.base_url}/dashboard',
+                timeout=30,
+                allow_redirects=True
+            )
+            
+            if response.status_code == 200 and f"Welcome, <b>{self.email}</b>" in response.text:
+                with self.print_lock:
+                    print(f"{Color.GREEN}✅ [{coin_symbol}] Login status valid{Color.END}")
+                return True
+            else:
+                with self.print_lock:
+                    print(f"{Color.YELLOW}⚠️  [{coin_symbol}] Cookies expired atau login diperlukan{Color.END}")
+                return False
+        except Exception as e:
+            with self.print_lock:
+                print(f"{Color.YELLOW}⚠️  [{coin_symbol}] Error cek login status: {e}{Color.END}")
+            return False
+    
+    def need_relogin(self, coin_symbol):
+        """Cek apakah perlu relogin (setiap 6 jam) untuk coin tertentu"""
+        coin_data = self.coins[coin_symbol]
+        current_time = time.time()
+        
+        if coin_data['last_login_time'] == 0:
+            return True
+        
+        time_since_login = current_time - coin_data['last_login_time']
+        if time_since_login >= (6 * 3600):  # 6 jam
+            hours = int(time_since_login // 3600)
+            minutes = int((time_since_login % 3600) // 60)
+            with self.print_lock:
+                print(f"{Color.YELLOW}⏰ [{coin_symbol}] Sudah {hours} jam {minutes} menit sejak login terakhir{Color.END}")
+            return True
+        
+        return False
+    
+    def print_banner(self):
+        """Menampilkan banner"""
+        banner = f"""
+{Color.PURPLE}{Color.BOLD}
+╔══════════════════════════════════════════════════════════════╗
+║         INDEPENDENT MULTI-COIN FAUCET BOT V3.0               ║
+║       (Setiap coin berjalan di thread terpisah)              ║
+╚══════════════════════════════════════════════════════════════╝
+{Color.END}
+{Color.CYAN}Email: {self.email}{Color.END}
+{Color.CYAN}Base URL: {self.base_url}{Color.END}
+{Color.CYAN}Total Coins: {len(self.coins)} (LTC, DOGE, TRUMP){Color.END}
+{Color.CYAN}Mode: INDEPENDENT THREADS - Tidak saling menunggu{Color.END}
+"""
+        print(banner)
+        self.print_coin_status_table()
+    
+    def print_coin_status_table(self):
+        """Print tabel status semua coin"""
+        print(f"{Color.BLUE}╔══════════════════════════════════════════════════════════════╗{Color.END}")
+        print(f"{Color.BLUE}║                     COIN STATUS TABLE                        ║{Color.END}")
+        print(f"{Color.BLUE}╠═══════════╦══════════╦══════════���══════════════╦══════════════╣{Color.END}")
+        print(f"{Color.BLUE}║   Coin    ║ Cooldown ║  Status  ║ Last Claim   ║  Next Claim  ║{Color.END}")
+        print(f"{Color.BLUE}╠═══════════╬══════════╬══════════╬══════════════╬══════════════╣{Color.END}")
+        
+        for coin_symbol, coin_data in self.coins.items():
+            current_time = time.time()
+            time_since_last = current_time - coin_data['last_claim']
+            remaining = coin_data['cooldown'] - time_since_last
+            
+            if coin_data['last_claim'] == 0:
+                status = f"{Color.GREEN}READY{Color.END}"
+                last_claim_str = "Never"
+                next_claim_str = "NOW"
+            elif remaining <= 0:
+                status = f"{Color.GREEN}READY{Color.END}"
+                last_claim_str = time.strftime("%H:%M:%S", time.localtime(coin_data['last_claim']))
+                next_claim_str = "NOW"
+            else:
+                mins = int(remaining // 60)
+                secs = int(remaining % 60)
+                status = f"{Color.YELLOW}WAIT {mins:02d}:{secs:02d}{Color.END}"
+                last_claim_str = time.strftime("%H:%M:%S", time.localtime(coin_data['last_claim']))
+                next_claim_time = coin_data['last_claim'] + coin_data['cooldown']
+                next_claim_str = time.strftime("%H:%M:%S", time.localtime(next_claim_time))
+            
+            print(f"║ {coin_symbol:^9} ║ {coin_data['cooldown']:^8} ║ {status:^8} ║ {last_claim_str:^12} ║ {next_claim_str:^12} ║")
+        
+        print(f"{Color.BLUE}╚═══════════╩══════════╩══════════╩══════════════╩══════════════╝{Color.END}")
+        print()
+    
+    def save_stats(self):
+        """Simpan statistik ke file"""
+        stats = {
+            'last_update': datetime.now().isoformat(),
+            'total_cycles': self.total_cycles,
+            'coins': {},
+            'email': self.email
+        }
+        
+        for coin_symbol, coin_data in self.coins.items():
+            stats['coins'][coin_symbol] = {
+                'last_claim': coin_data['last_claim'],
+                'success_count': coin_data['success_count'],
+                'total_claims': coin_data['total_claims'],
+                'total_rewards': coin_data['total_rewards'],
+                'cooldown': coin_data['cooldown'],
+                'last_login_time': coin_data['last_login_time']
+            }
+        
+        try:
+            with open(self.stats_file, 'w') as f:
+                json.dump(stats, f, indent=2)
+        except Exception as e:
+            with self.print_lock:
+                print(f"{Color.YELLOW}⚠️  Gagal menyimpan statistik: {e}{Color.END}")
+    
+    def load_stats(self):
+        """Load statistik dari file"""
+        try:
+            if os.path.exists(self.stats_file):
+                with open(self.stats_file, 'r') as f:
+                    stats = json.load(f)
+                    self.total_cycles = stats.get('total_cycles', 0)
+                    
+                    saved_coins = stats.get('coins', {})
+                    for coin_symbol in self.coins.keys():
+                        if coin_symbol in saved_coins:
+                            for key in ['last_claim', 'success_count', 'total_claims', 
+                                       'total_rewards', 'cooldown', 'last_login_time']:
+                                if key in saved_coins[coin_symbol]:
+                                    self.coins[coin_symbol][key] = saved_coins[coin_symbol][key]
+                            
+        except Exception as e:
+            with self.print_lock:
+                print(f"{Color.YELLOW}⚠️  Gagal load statistik: {e}{Color.END}")
+    
+    def get_recaptcha_token(self, coin_symbol):
+        """Mendapatkan token reCAPTCHA dari solver"""
+        with self.print_lock:
+            print(f"{Color.CYAN}[{coin_symbol}] [1/3] Meminta token reCAPTCHA...{Color.END}")
+        
+        headers = {
+            "Content-Type": "application/json",
+            "key": self.solver_key
+        }
+        
+        data = {
+            "type": "recaptcha3",
+            "domain": self.base_url,
+            "siteKey": "6LcbMB0sAAAAAAxsy76NqLNBhHfzZO8E4jLJ8XNl"
+        }
+        
+        try:
+            # Submit task
+            response = requests.post(
+                f"{self.solver_url}/solve",
+                headers=headers,
+                json=data,
+                timeout=30
+            )
+            
+            result = response.json()
+            if "taskId" not in result:
+                with self.print_lock:
+                    print(f"{Color.RED}❌ [{coin_symbol}] Gagal mendapatkan Task ID{Color.END}")
+                return None
+                
+            task_id = result["taskId"]
+            with self.print_lock:
+                print(f"{Color.GREEN}✓ [{coin_symbol}] Task ID: {task_id}{Color.END}")
+            
+            # Polling untuk hasil
+            for i in range(30):
+                time.sleep(2)
+                
+                poll_data = {"taskId": task_id}
+                poll_response = requests.post(
+                    f"{self.solver_url}/solve",
+                    headers=headers,
+                    json=poll_data,
+                    timeout=30
+                )
+                
+                poll_result = poll_response.json()
+                
+                if poll_result.get("status") == "done":
+                    with self.print_lock:
+                        print(f"{Color.GREEN}✓ [{coin_symbol}] reCAPTCHA solved!{Color.END}")
+                    token = poll_result.get("token") or poll_result.get("solution", {}).get("token")
+                    if token:
+                        return token
+                
+                elif poll_result.get("status") == "error":
+                    with self.print_lock:
+                        print(f"{Color.RED}❌ [{coin_symbol}] Error dari solver{Color.END}")
+                    return None
+            
+            with self.print_lock:
+                print(f"{Color.RED}❌ [{coin_symbol}] Timeout{Color.END}")
+            return None
+            
+        except Exception as e:
+            with self.print_lock:
+                print(f"{Color.RED}❌ [{coin_symbol}] Error: {e}{Color.END}")
+            return None
+    
+    def login(self, coin_symbol):
+        """Login ke website untuk mendapatkan cookies untuk coin tertentu"""
+        coin_data = self.coins[coin_symbol]
+        
+        with self.print_lock:
+            print(f"{Color.CYAN}[{coin_symbol}] [1/4] Login process...{Color.END}")
+        
+        # Dapatkan token reCAPTCHA untuk login
+        recaptcha_token = self.get_recaptcha_token(coin_symbol)
+        if not recaptcha_token:
+            with self.print_lock:
+                print(f"{Color.RED}❌ [{coin_symbol}] Gagal mendapatkan token reCAPTCHA untuk login{Color.END}")
+            return False
+        
+        # Persiapkan data login
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Origin': self.base_url,
+            'Referer': f'{self.base_url}/',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
+        }
+        
+        data = {
+            'address': self.email,
+            'g-recaptcha-response': recaptcha_token
+        }
+        
+        try:
+            with self.print_lock:
+                print(f"{Color.CYAN}[{coin_symbol}] [2/4] Mengirim data login...{Color.END}")
+            
+            response = coin_data['session'].post(
+                f'{self.base_url}/',
+                headers=headers,
+                data=data,
+                timeout=30,
+                allow_redirects=True
+            )
+            
+            with self.print_lock:
+                print(f"{Color.CYAN}✓ [{coin_symbol}] Response status: {response.status_code}{Color.END}")
+            
+            # Cek apakah login berhasil
+            if f"Welcome, <b>{self.email}</b>" in response.text:
+                with self.print_lock:
+                    print(f"{Color.GREEN}✅ [{coin_symbol}] Login berhasil!{Color.END}")
+                
+                # Update waktu login terakhir
+                coin_data['last_login_time'] = time.time()
+                
+                # Simpan cookies
+                self.save_cookies(coin_symbol)
+                
+                return True
+            else:
+                with self.print_lock:
+                    print(f"{Color.RED}❌ [{coin_symbol}] Login gagal!{Color.END}")
+                return False
+                
+        except Exception as e:
+            with self.print_lock:
+                print(f"{Color.RED}❌ [{coin_symbol}] Error login: {e}{Color.END}")
+            return False
+    
+    def relogin_if_needed(self, coin_symbol):
+        """Relogin jika diperlukan (setiap 6 jam) untuk coin tertentu"""
+        if self.need_relogin(coin_symbol):
+            with self.print_lock:
+                print(f"{Color.YELLOW}🔄 [{coin_symbol}] Waktunya relogin (setiap 6 jam)...{Color.END}")
+            return self.login(coin_symbol)
+        return True
+    
+    def get_csrf_token(self, coin_symbol):
+        """Ambil CSRF token dari halaman faucet untuk coin tertentu"""
+        coin_data = self.coins[coin_symbol]
+        
+        with self.print_lock:
+            print(f"{Color.CYAN}[{coin_symbol}] [2/4] Mengambil CSRF token...{Color.END}")
+        
+        headers = {
+            'Referer': f'{self.base_url}/dashboard',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
+        }
+        
+        try:
+            # Batasi redirects
+            coin_data['session'].max_redirects = 5
+            
+            response = coin_data['session'].get(
+                f'{self.base_url}{coin_data["url_path"]}',
+                headers=headers,
+                timeout=30,
+                allow_redirects=True
+            )
+            
+            with self.print_lock:
+                print(f"{Color.CYAN}✓ [{coin_symbol}] Response status: {response.status_code}{Color.END}")
+            
+            if response.status_code != 200:
+                with self.print_lock:
+                    print(f"{Color.RED}❌ [{coin_symbol}] Gagal akses faucet: {response.status_code}{Color.END}")
+                return None
+            
+            # Cari CSRF token dengan regex
+            csrf_pattern = r'name="csrf_token" value="([a-f0-9]{64})"'
+            match = re.search(csrf_pattern, response.text)
+            
+            if match:
+                csrf_token = match.group(1)
+                with self.print_lock:
+                    print(f"{Color.GREEN}✓ [{coin_symbol}] CSRF token ditemukan: {csrf_token[:16]}...{Color.END}")
+                return csrf_token
+            else:
+                with self.print_lock:
+                    print(f"{Color.RED}❌ [{coin_symbol}] CSRF token tidak ditemukan{Color.END}")
+                return None
+                
+        except requests.exceptions.TooManyRedirects:
+            with self.print_lock:
+                print(f"{Color.RED}❌ [{coin_symbol}] Redirect loop terdeteksi!{Color.END}")
+            return None
+        except Exception as e:
+            with self.print_lock:
+                print(f"{Color.RED}❌ [{coin_symbol}] Error: {e}{Color.END}")
+            return None
+    
+    def extract_cooldown_from_response(self, coin_symbol, response_text):
+        """Ekstrak waktu cooldown dari HTML response"""
+        try:
+            # Pola pencarian cooldown
+            patterns = [
+                r'cooldown.*?(\d+)\s*(minute|min|second|sec|hour|hr)',
+                r'wait.*?(\d+)\s*(minute|min|second|sec|hour|hr)',
+                r'timer.*?(\d+)\s*(minute|min|second|sec|hour|hr)',
+                r'(\d+)\s*(minute|min|second|sec|hour|hr).*?cooldown',
+                r'(\d+)\s*(minute|min|second|sec|hour|hr).*?wait'
+            ]
+            
+            for pattern in patterns:
+                matches = re.findall(pattern, response_text, re.IGNORECASE)
+                if matches:
+                    for match in matches:
+                        value = int(match[0])
+                        unit = match[1].lower()
+                        
+                        # Konversi ke detik
+                        if 'hour' in unit or 'hr' in unit:
+                            return value * 3600
+                        elif 'minute' in unit or 'min' in unit:
+                            return value * 60
+                        elif 'second' in unit or 'sec' in unit:
+                            return value
+            
+            return None  # Tidak ditemukan cooldown
+            
+        except Exception as e:
+            with self.print_lock:
+                print(f"{Color.YELLOW}⚠️  [{coin_symbol}] Error extracting cooldown: {e}{Color.END}")
+            return None
+    
+    def claim_coin(self, coin_symbol):
+        """Klaim faucet untuk coin tertentu"""
+        coin_data = self.coins[coin_symbol]
+        
+        with self.print_lock:
+            print(f"\n{Color.BLUE}{'═' * 50}{Color.END}")
+            print(f"{Color.BOLD}🪙 [{coin_symbol}] CLAIMING {coin_data['name']}{Color.END}")
+            print(f"{Color.BLUE}{'═' * 50}{Color.END}")
+        
+        # 1. Ambil CSRF token
+        csrf_token = self.get_csrf_token(coin_symbol)
+        if not csrf_token:
+            with self.print_lock:
+                print(f"{Color.RED}❌ [{coin_symbol}] Gagal mendapatkan CSRF token{Color.END}")
+            return False, None
+        
+        # 2. Dapatkan token reCAPTCHA untuk claim
+        with self.print_lock:
+            print(f"{Color.CYAN}[{coin_symbol}] [3/4] Meminta token reCAPTCHA untuk claim...{Color.END}")
+        
+        recaptcha_token = self.get_recaptcha_token(coin_symbol)
+        if not recaptcha_token:
+            with self.print_lock:
+                print(f"{Color.RED}❌ [{coin_symbol}] Gagal mendapatkan token reCAPTCHA untuk claim{Color.END}")
+            return False, None
+        
+        # 3. Persiapkan data claim
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Origin': self.base_url,
+            'Referer': f'{self.base_url}{coin_data["url_path"]}',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
+        }
+        
+        data = {
+            'currency': coin_symbol,
+            'csrf_token': csrf_token,
+            'g-recaptcha-response': recaptcha_token,
+            'claim': ''
+        }
+        
+        try:
+            with self.print_lock:
+                print(f"{Color.CYAN}[{coin_symbol}] [4/4] Mengirim claim...{Color.END}")
+            
+            response = coin_data['session'].post(
+                f'{self.base_url}{coin_data["url_path"]}',
+                headers=headers,
+                data=data,
+                timeout=30,
+                allow_redirects=True
+            )
+            
+            with self.print_lock:
+                print(f"{Color.CYAN}✓ [{coin_symbol}] Response status: {response.status_code}{Color.END}")
+            
+            # Cek apakah claim berhasil
+            success_keywords = [
+                'successfully', 'claimed', 'reward', 
+                'thank you', 'you received', 'has been added',
+                'congratulation'
+            ]
+            
+            response_lower = response.text.lower()
+            success = any(keyword in response_lower for keyword in success_keywords)
+            
+            if success:
+                with self.print_lock:
+                    print(f"{Color.GREEN}✅ [{coin_symbol}] Claim berhasil!{Color.END}")
+                
+                # Cari jumlah reward
+                reward_patterns = [
+                    r'(\d+\.?\d*)\s*' + re.escape(coin_symbol),
+                    r'claimed\s*:\s*(\d+\.?\d*)',
+                    r'reward\s*:\s*(\d+\.?\d*)',
+                    r'you received.*?(\d+\.?\d*)',
+                    r'(\d+\.?\d*)\s*coins?'
+                ]
+                
+                reward_found = 0
+                for pattern in reward_patterns:
+                    match = re.search(pattern, response.text, re.IGNORECASE)
+                    if match:
+                        reward_found = float(match.group(1))
+                        coin_data['total_rewards'] += reward_found
+                        with self.print_lock:
+                            print(f"{Color.GREEN}💰 [{coin_symbol}] Reward: {reward_found} {coin_symbol}{Color.END}")
+                        break
+                
+                # Update statistik
+                coin_data['success_count'] += 1
+                
+                # Update cookies setelah claim sukses
+                self.save_cookies(coin_symbol)
+                
+            else:
+                with self.print_lock:
+                    print(f"{Color.RED}❌ [{coin_symbol}] Claim gagal!{Color.END}")
+                
+                # Cek error message
+                error_keywords = ['error', 'failed', 'try again', 'cooldown', 'already claimed', 'wait']
+                for keyword in error_keywords:
+                    if keyword in response_lower:
+                        with self.print_lock:
+                            print(f"{Color.YELLOW}⚠️  [{coin_symbol}] Pesan: {keyword}{Color.END}")
+                        break
+            
+            # Update total claims
+            coin_data['total_claims'] += 1
+            coin_data['last_claim'] = time.time()
+            
+            # Ekstrak cooldown dari response
+            extracted_cooldown = self.extract_cooldown_from_response(coin_symbol, response.text)
+            if extracted_cooldown:
+                coin_data['cooldown'] = extracted_cooldown
+                with self.print_lock:
+                    print(f"{Color.CYAN}⏰ [{coin_symbol}] Cooldown terdeteksi: {extracted_cooldown} detik{Color.END}")
+            else:
+                # Gunakan default cooldown
+                coin_data['cooldown'] = coin_data['default_cooldown']
+                with self.print_lock:
+                    print(f"{Color.CYAN}⏰ [{coin_symbol}] Menggunakan default cooldown: {coin_data['default_cooldown']} detik{Color.END}")
+            
+            # Simpan statistik
+            self.save_stats()
+            
+            return success, response.text
+            
+        except Exception as e:
+            with self.print_lock:
+                print(f"{Color.RED}❌ [{coin_symbol}] Error saat claim: {e}{Color.END}")
+            return False, str(e)
+    
+    def coin_worker(self, coin_symbol):
+        """Worker thread untuk setiap coin - BERJALAN INDEPENDEN"""
+        coin_data = self.coins[coin_symbol]
+        
+        with self.print_lock:
+            print(f"{Color.CYAN}🚀 [{coin_symbol}] Thread dimulai!{Color.END}")
+        
+        # Cek cookies terlebih dahulu
+        if self.load_cookies(coin_symbol):
+            if not self.check_login_status(coin_symbol):
+                with self.print_lock:
+                    print(f"{Color.YELLOW}⚠️  [{coin_symbol}] Cookies tidak valid, melakukan login...{Color.END}")
+                if not self.login(coin_symbol):
+                    with self.print_lock:
+                        print(f"{Color.RED}❌ [{coin_symbol}] Gagal login!{Color.END}")
+                    return
+        else:
+            # Jika tidak ada cookies, lakukan login
+            with self.print_lock:
+                print(f"{Color.YELLOW}⚠️  [{coin_symbol}] Melakukan login...{Color.END}")
+            if not self.login(coin_symbol):
+                with self.print_lock:
+                    print(f"{Color.RED}❌ [{coin_symbol}] Gagal login!{Color.END}")
+                return
+        
+        # Main loop untuk coin ini
+        while self.running and coin_data['running']:
+            try:
+                current_time = time.time()
+                time_since_last = current_time - coin_data['last_claim']
+                
+                # Jika belum pernah di-claim atau cooldown sudah selesai
+                if coin_data['last_claim'] == 0 or time_since_last >= coin_data['cooldown']:
+                    # Cek apakah perlu relogin
+                    if not self.relogin_if_needed(coin_symbol):
+                        with self.print_lock:
+                            print(f"{Color.YELLOW}⚠️  [{coin_symbol}] Relogin gagal, tunggu 60 detik...{Color.END}")
+                        time.sleep(60)
+                        continue
+                    
+                    # Lakukan claim
+                    success, _ = self.claim_coin(coin_symbol)
+                    
+                    if not success:
+                        with self.print_lock:
+                            print(f"{Color.YELLOW}⚠️  [{coin_symbol}] Claim gagal, coba login ulang dalam 10 detik...{Color.END}")
+                        time.sleep(10)
+                        
+                        # Coba login ulang
+                        if not self.login(coin_symbol):
+                            with self.print_lock:
+                                print(f"{Color.RED}❌ [{coin_symbol}] Gagal login ulang, tunggu 60 detik...{Color.END}")
+                            time.sleep(60)
+                else:
+                    # Hitung waktu tunggu
+                    wait_time = coin_data['cooldown'] - time_since_last
+                    
+                    # Update status setiap 10 detik jika dalam cooldown
+                    if wait_time > 10:
+                        remaining = int(wait_time)
+                        with self.print_lock:
+                            print(f"{Color.YELLOW}⏳ [{coin_symbol}] Cooldown: {remaining} detik tersisa...{Color.END}")
+                        
+                        # Sleep dengan interval 1 detik untuk bisa di-interrupt
+                        for _ in range(min(remaining, 10)):
+                            if not self.running or not coin_data['running']:
+                                break
+                            time.sleep(1)
+                    else:
+                        time.sleep(1)
+                
+            except Exception as e:
+                with self.print_lock:
+                    print(f"{Color.RED}❌ [{coin_symbol}] Error dalam worker thread: {e}{Color.END}")
+                time.sleep(10)
+        
+        with self.print_lock:
+            print(f"{Color.YELLOW}🛑 [{coin_symbol}] Thread dihentikan{Color.END}")
+    
+    def print_statistics(self):
+        """Tampilkan statistik semua coin"""
+        with self.print_lock:
+            print(f"\n{Color.PURPLE}{Color.BOLD}📊 STATISTIK SEMUA COIN{Color.END}")
+            print(f"{Color.BLUE}╔═══════════╦══════════╦══════════╦══════════╦══════════════╗{Color.END}")
+            print(f"{Color.BLUE}║   Coin    ║  Claims  ║  Success ║  Reward  ║  Success Rate║{Color.END}")
+            print(f"{Color.BLUE}╠═══════════╬══════════╬══════════╬══════════╬══════════════╣{Color.END}")
+        
+        total_claims = 0
+        total_success = 0
+        total_rewards = 0
+        
+        for coin_symbol, coin_data in self.coins.items():
+            claims = coin_data['total_claims']
+            success = coin_data['success_count']
+            rewards = coin_data['total_rewards']
+            
+            if claims > 0:
+                success_rate = (success / claims) * 100
+                rate_str = f"{success_rate:.1f}%"
+            else:
+                rate_str = "0%"
+            
+            with self.print_lock:
+                print(f"║ {coin_symbol:^9} ║ {claims:^8} ║ {success:^8} ║ {rewards:^8.4f} ║ {rate_str:^12} ║")
+            
+            total_claims += claims
+            total_success += success
+            total_rewards += rewards
+        
+        with self.print_lock:
+            print(f"{Color.BLUE}╠═══════════╬══════════╬══════════╬══════════╬══════════════╣{Color.END}")
+        
+            if total_claims > 0:
+                overall_rate = (total_success / total_claims) * 100
+                rate_str = f"{overall_rate:.1f}%"
+            else:
+                rate_str = "0%"
+            
+            print(f"║ {Color.BOLD}TOTAL{Color.END:^9} ║ {total_claims:^8} ║ {total_success:^8} ║ {total_rewards:^8.4f} ║ {rate_str:^12} ║")
+            print(f"{Color.BLUE}╚═══════════╩══════════╩══════════╩══════════╩══════════════╝{Color.END}")
+            
+            # Tampilkan waktu sekarang
+            print(f"{Color.CYAN}🕐 Waktu Sekarang: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}{Color.END}")
+            print()
+    
+    def run(self, max_cycles=100000):
+        """Jalankan semua coin di thread terpisah"""
+        self.print_banner()
+        
+        with self.print_lock:
+            print(f"{Color.GREEN}{'='*60}{Color.END}")
+            print(f"{Color.BOLD}🚀 MEMULAI INDEPENDENT THREADS UNTUK 3 COIN{Color.END}")
+            print(f"{Color.GREEN}{'='*60}{Color.END}")
+        
+        # Buat thread untuk setiap coin
+        threads = []
+        for coin_symbol in self.coins.keys():
+            thread = threading.Thread(
+                target=self.coin_worker,
+                args=(coin_symbol,),
+                name=f"Thread-{coin_symbol}",
+                daemon=True
+            )
+            thread.start()
+            self.coins[coin_symbol]['thread'] = thread
+            threads.append(thread)
+        
+        # Thread untuk update statistik periodik
+        def stats_updater():
+            while self.running:
+                time.sleep(60)  # Update setiap 1 menit
+                if self.running:
+                    self.print_statistics()
+                    self.print_coin_status_table()
+                    self.save_stats()
+        
+        stats_thread = threading.Thread(target=stats_updater, daemon=True)
+        stats_thread.start()
+        
+        try:
+            # Keep main thread alive
+            while self.running:
+                # Tampilkan status setiap 5 menit
+                time.sleep(300)
+                
+        except KeyboardInterrupt:
+            with self.print_lock:
+                print(f"\n\n{Color.YELLOW}⚠️  Keyboard interrupt diterima, menghentikan semua thread...{Color.END}")
+            
+            self.running = False
+            
+            # Beri waktu untuk thread berhenti
+            with self.print_lock:
+                print(f"{Color.YELLOW}⏳ Menunggu thread berhenti...{Color.END}")
+            
+            time.sleep(5)
+            
+        finally:
+            # Hentikan semua thread
+            self.running = False
+            for coin_symbol, coin_data in self.coins.items():
+                coin_data['running'] = False
+            
+            # Tunggu semua thread selesai
+            for thread in threads:
+                if thread.is_alive():
+                    thread.join(timeout=10)
+            
+            # Tampilkan statistik akhir
+            with self.print_lock:
+                print(f"\n{Color.PURPLE}{'='*60}{Color.END}")
+                print(f"{Color.BOLD}🏁 STATISTIK AKHIR{Color.END}")
+                print(f"{Color.PURPLE}{'='*60}{Color.END}")
+            
+            self.print_statistics()
+            self.save_stats()
+            
+            with self.print_lock:
+                print(f"{Color.GREEN}✅ Semua thread dihentikan{Color.END}")
+
+def main():
+    """Fungsi utama dengan infinite loop untuk Docker"""
+    print(f"{Color.CYAN}🚀 Starting Independent Multi-Coin Faucet Bot{Color.END}")
+    
+    # Konfigurasi dari environment variables atau default
+    EMAIL = os.getenv('EMAIL', 'gi2h2705@gmail.com')
+    
+    print(f"{Color.CYAN}📧 Email: {EMAIL}{Color.END}")
+    print(f"{Color.CYAN}⚡ Mode: INDEPENDENT THREADS (3 coin terpisah){Color.END}")
+    print(f"{Color.CYAN}⏰ Timezone: {os.getenv('TZ', 'Asia/Jakarta')}{Color.END}")
+    print(f"{Color.CYAN}🍪 Cookies Management: Per-coin cookies{Color.END}")
+    print(f"{Color.CYAN}🔄 Relogin Interval: Every 6 hours per coin{Color.END}\n")
+    
+    consecutive_failures = 0
+    max_consecutive_failures = 3
+    
+    while True:
+        try:
+            bot = IndependentMultiCoinFaucetBot(EMAIL)
+            bot.run()
+            
+            consecutive_failures = 0
+            print(f"{Color.GREEN}✅ All threads completed{Color.END}")
+            
+        except KeyboardInterrupt:
+            print(f"\n{Color.YELLOW}👋 Bot stopped by user{Color.END}")
+            break
+        except Exception as e:
+            consecutive_failures += 1
+            print(f"{Color.RED}⚠️  Unexpected error: {e}{Color.END}")
+            
+            if consecutive_failures >= max_consecutive_failures:
+                print(f"{Color.RED}⚠️  Too many consecutive failures, waiting 5 minutes...{Color.END}")
+                time.sleep(300)  # Tunggu 5 menit
+                consecutive_failures = 0
+            else:
+                print(f"{Color.CYAN}⏳ Restarting in 30 seconds...{Color.END}")
+                time.sleep(30)
+
+if __name__ == "__main__":
+    # Install dependencies jika diperlukan
+    try:
+        import requests
+    except ImportError:
+        print("Menginstall requests...")
+        import subprocess
+        subprocess.check_call(["pip", "install", "requests"])
+    
+    # Jalankan
+    try:
+        main()
+    except KeyboardInterrupt:
+        print(f"\n\n{Color.YELLOW}👋 Sampai jumpa!{Color.END}")
+    except Exception as e:
+        print(f"\n{Color.RED}❌ Error: {e}{Color.END}")

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,3 @@
+requests==2.31.0
+colorama==0.4.6
+python-dotenv==1.0.0