Upload 8 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#

Dockerfile

@@ -0,0 +1,79 @@
+# ============================================
+# DOCKERFILE YANG PASTI BERJALAN - TANPA APT-KEY
+# ============================================
+FROM python:3.9-slim
+
+# 1. Install system dependencies
+RUN apt-get update && apt-get install -y \
+    curl \
+    wget \
+    gnupg \
+    ca-certificates \
+    xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+
+# 2. Install Chrome tanpa apt-key (cara baru)
+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. Copy Python requirements
+COPY requirements.txt .
+
+# 4. Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# 5. Install Node.js
+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/*
+
+# 6. Copy Api folder dan install dependencies
+COPY Api/ /app/Api/
+WORKDIR /app/Api
+RUN npm install --omit=dev
+WORKDIR /app
+
+# 7. Copy Python aplikasi
+COPY app.py .
+
+# 8. Buat startup script yang sesuai dengan struktur
+RUN echo '#!/bin/bash\n\
+\n\
+echo "🤖 STARTING FAUCET BOT"\n\
+echo "======================"\n\
+\n\
+# Start API dari folder Api\n\
+echo "Starting Node.js API..."\n\
+cd /app/Api\n\
+node Api.js &\n\
+\n\
+# Wait for API to start\n\
+echo "Waiting for API to start..."\n\
+sleep 5\n\
+\n\
+# Start Python Bot\n\
+echo "Starting Python Bot..."\n\
+cd /app\n\
+python3 app.py\n\
+' > /start.sh && chmod +x /start.sh
+
+# 9. Health check untuk API (sesuaikan port dengan Api.js)
+HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
+    CMD curl -f http://localhost:3000/ || exit 1
+
+# 10. Expose port untuk API (sesuaikan dengan Api.js)
+EXPOSE 3000
+
+CMD ["/start.sh"]

README.md

@@ -1,8 +1,8 @@
 ---
-title: Gadis
-emoji: 😻
-colorFrom: green
-colorTo: red
+title: Auto
+emoji: 📉
+colorFrom: pink
+colorTo: gray
 sdk: docker
 pinned: false
 ---

app.py

@@ -0,0 +1,820 @@
+#!/usr/bin/env python3
+"""
+FAUCET BOT TRUMP COIN
+Auto claim untuk coin: TRUMP saja
+Dengan fitur cookies management dan relogin setiap 6 jam
+"""
+
+import requests
+import json
+import time
+import re
+import sys
+import os
+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 TrumpFaucetBot:
+    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
+        self.cookies_file = "cookies.json"
+        self.last_login_time = 0
+        self.relogin_interval = 6 * 3600  # 6 jam dalam detik
+        
+        # Konfigurasi coin - HANYA TRUMP
+        self.coins = {
+            '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
+            }
+        }
+        
+        self.session = requests.Session()
+        self.setup_headers()
+        
+        # Statistik
+        self.total_cycles = 0
+        self.stats_file = "stats.json"
+        self.load_stats()
+        
+        # Load cookies jika ada
+        self.load_cookies()
+        
+        # Logging
+        self.log_dir = "logs"
+        os.makedirs(self.log_dir, exist_ok=True)
+    
+    def setup_headers(self):
+        """Set headers untuk meniru browser"""
+        self.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):
+        """Simpan cookies ke file"""
+        try:
+            cookies_dict = requests.utils.dict_from_cookiejar(self.session.cookies)
+            with open(self.cookies_file, 'w') as f:
+                json.dump({
+                    'cookies': cookies_dict,
+                    'saved_at': datetime.now().isoformat(),
+                    'email': self.email
+                }, f, indent=2)
+            print(f"{Color.GREEN}✓ Cookies disimpan ke {self.cookies_file}{Color.END}")
+            return True
+        except Exception as e:
+            print(f"{Color.YELLOW}⚠️  Gagal menyimpan cookies: {e}{Color.END}")
+            return False
+    
+    def load_cookies(self):
+        """Load cookies dari file"""
+        try:
+            if os.path.exists(self.cookies_file):
+                with open(self.cookies_file, '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.session.cookies = cookies_jar
+                    
+                    print(f"{Color.GREEN}✓ Cookies dimuat dari {self.cookies_file}{Color.END}")
+                    print(f"{Color.CYAN}🍪 Jumlah cookies: {len(cookies_dict)}{Color.END}")
+                    
+                    # Update last login time
+                    saved_time = data.get('saved_at')
+                    if saved_time:
+                        try:
+                            saved_dt = datetime.fromisoformat(saved_time)
+                            self.last_login_time = saved_dt.timestamp()
+                        except:
+                            self.last_login_time = time.time()
+                    else:
+                        self.last_login_time = time.time()
+                        
+                    return True
+            else:
+                print(f"{Color.YELLOW}⚠️  File cookies tidak ditemukan{Color.END}")
+                return False
+        except Exception as e:
+            print(f"{Color.YELLOW}⚠️  Gagal memuat cookies: {e}{Color.END}")
+            return False
+    
+    def update_cookies(self):
+        """Update cookies setelah claim sukses"""
+        return self.save_cookies()
+    
+    def check_login_status(self):
+        """Cek status login dengan cookies"""
+        try:
+            response = self.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:
+                print(f"{Color.GREEN}✅ Login status valid dengan cookies{Color.END}")
+                return True
+            else:
+                print(f"{Color.YELLOW}⚠️  Cookies expired atau login diperlukan{Color.END}")
+                return False
+        except Exception as e:
+            print(f"{Color.YELLOW}⚠️  Error cek login status: {e}{Color.END}")
+            return False
+    
+    def need_relogin(self):
+        """Cek apakah perlu relogin (setiap 6 jam)"""
+        current_time = time.time()
+        if self.last_login_time == 0:
+            return True
+        
+        time_since_login = current_time - self.last_login_time
+        if time_since_login >= self.relogin_interval:
+            hours = int(time_since_login // 3600)
+            minutes = int((time_since_login % 3600) // 60)
+            print(f"{Color.YELLOW}⏰ Sudah {hours} jam {minutes} menit sejak login terakhir{Color.END}")
+            return True
+        
+        return False
+    
+    def print_banner(self):
+        """Menampilkan banner khusus TRUMP"""
+        banner = f"""
+{Color.PURPLE}{Color.BOLD}
+╔══════════════════════════════════════════════════════════════╗
+║               TRUMP FAUCET BOT V2.0                          ║
+║              (Dengan Cookies Management)                     ║
+╚══════════════════════════════════════════════════════════════╝
+{Color.END}
+{Color.CYAN}Email: {self.email}{Color.END}
+{Color.CYAN}Base URL: {self.base_url}{Color.END}
+{Color.CYAN}Coin: TRUMP (Trumpcoin){Color.END}
+{Color.CYAN}Relogin Interval: Setiap 6 jam{Color.END}
+"""
+        print(banner)
+        self.print_coin_table()
+    
+    def print_coin_table(self):
+        """Print tabel informasi coin (hanya TRUMP)"""
+        coin_symbol = 'TRUMP'
+        coin_data = self.coins[coin_symbol]
+        
+        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}"
+        elif remaining <= 0:
+            status = f"{Color.GREEN}READY{Color.END}"
+        else:
+            mins = int(remaining // 60)
+            secs = int(remaining % 60)
+            status = f"{Color.YELLOW}WAIT {mins:02d}:{secs:02d}{Color.END}"
+        
+        print(f"{Color.BLUE}╔══════════════════════════════════════════════════════════╗{Color.END}")
+        print(f"{Color.BLUE}║                     TRUMP STATUS                          ║{Color.END}")
+        print(f"{Color.BLUE}╠═══════════╦══════════════╦════════════════╦══════════════╣{Color.END}")
+        print(f"{Color.BLUE}║   Coin    ║   Default    ║    Current     ║    Status    ║{Color.END}")
+        print(f"{Color.BLUE}╠═══════════╬══════════════╬════════════════╬══════════════╣{Color.END}")
+        print(f"║ {coin_symbol:^9} ║ {coin_data['default_cooldown']:>6} sec  ║ {coin_data['cooldown']:>6} sec     ║ {status:^12} ║")
+        print(f"{Color.BLUE}╚═══════════╩══════════════╩════════════════╩══════════════╝{Color.END}")
+        print()
+    
+    def save_stats(self):
+        """Simpan statistik ke file"""
+        stats = {
+            'last_update': datetime.now().isoformat(),
+            'last_login_time': self.last_login_time,
+            'total_cycles': self.total_cycles,
+            'coins': self.coins,
+            'email': self.email
+        }
+        
+        try:
+            with open(self.stats_file, 'w') as f:
+                json.dump(stats, f, indent=2)
+        except Exception as e:
+            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)
+                    self.last_login_time = stats.get('last_login_time', 0)
+                    
+                    # Load data coin per coin
+                    saved_coins = stats.get('coins', {})
+                    for coin_symbol in self.coins.keys():
+                        if coin_symbol in saved_coins:
+                            self.coins[coin_symbol].update(saved_coins[coin_symbol])
+                            
+        except Exception as e:
+            print(f"{Color.YELLOW}⚠️  Gagal load statistik: {e}{Color.END}")
+    
+    def get_recaptcha_token(self):
+        """Mendapatkan token reCAPTCHA dari solver"""
+        print(f"{Color.CYAN}[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:
+                print(f"{Color.RED}❌ Gagal mendapatkan Task ID{Color.END}")
+                return None
+                
+            task_id = result["taskId"]
+            print(f"{Color.GREEN}✓ 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":
+                    print(f"{Color.GREEN}✓ 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":
+                    print(f"{Color.RED}❌ Error dari solver{Color.END}")
+                    return None
+            
+            print(f"{Color.RED}❌ Timeout{Color.END}")
+            return None
+            
+        except Exception as e:
+            print(f"{Color.RED}❌ Error: {e}{Color.END}")
+            return None
+    
+    def login(self):
+        """Login ke website untuk mendapatkan cookies"""
+        print(f"{Color.CYAN}[1/4] Login process...{Color.END}")
+        
+        # Dapatkan token reCAPTCHA untuk login
+        recaptcha_token = self.get_recaptcha_token()
+        if not recaptcha_token:
+            print(f"{Color.RED}❌ 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:
+            print(f"{Color.CYAN}[2/4] Mengirim data login...{Color.END}")
+            response = self.session.post(
+                f'{self.base_url}/',
+                headers=headers,
+                data=data,
+                timeout=30,
+                allow_redirects=True
+            )
+            
+            print(f"{Color.CYAN}✓ Response status: {response.status_code}{Color.END}")
+            
+            # Cek apakah login berhasil
+            if f"Welcome, <b>{self.email}</b>" in response.text:
+                print(f"{Color.GREEN}✅ Login berhasil!{Color.END}")
+                
+                # Update waktu login terakhir
+                self.last_login_time = time.time()
+                
+                # Simpan cookies
+                self.save_cookies()
+                
+                return True
+            else:
+                print(f"{Color.RED}❌ Login gagal!{Color.END}")
+                return False
+                
+        except Exception as e:
+            print(f"{Color.RED}❌ Error login: {e}{Color.END}")
+            return False
+    
+    def relogin_if_needed(self):
+        """Relogin jika diperlukan (setiap 6 jam)"""
+        if self.need_relogin():
+            print(f"{Color.YELLOW}🔄 Waktunya relogin (setiap 6 jam)...{Color.END}")
+            return self.login()
+        return True
+    
+    def get_csrf_token(self, coin_symbol):
+        """Ambil CSRF token dari halaman faucet untuk coin tertentu"""
+        coin_data = self.coins[coin_symbol]
+        print(f"{Color.CYAN}[2/4] Mengambil CSRF token untuk {coin_symbol}...{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
+            self.session.max_redirects = 5
+            
+            response = self.session.get(
+                f'{self.base_url}{coin_data["url_path"]}',
+                headers=headers,
+                timeout=30,
+                allow_redirects=True
+            )
+            
+            print(f"{Color.CYAN}✓ Response status: {response.status_code}{Color.END}")
+            
+            if response.status_code != 200:
+                print(f"{Color.RED}❌ Gagal akses faucet {coin_symbol}: {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)
+                print(f"{Color.GREEN}✓ CSRF token ditemukan: {csrf_token[:16]}...{Color.END}")
+                return csrf_token
+            else:
+                print(f"{Color.RED}❌ CSRF token tidak ditemukan{Color.END}")
+                return None
+                
+        except requests.exceptions.TooManyRedirects:
+            print(f"{Color.RED}❌ Redirect loop terdeteksi!{Color.END}")
+            print(f"{Color.YELLOW}⚠️  Mungkin session expired atau belum login{Color.END}")
+            return None
+        except Exception as e:
+            print(f"{Color.RED}❌ Error: {e}{Color.END}")
+            return None
+    
+    def extract_cooldown_from_response(self, 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:
+            print(f"{Color.YELLOW}⚠️  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]
+        
+        print(f"\n{Color.BLUE}{'═' * 50}{Color.END}")
+        print(f"{Color.BOLD}🪙 CLAIMING {coin_symbol} ({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:
+            print(f"{Color.RED}❌ Gagal mendapatkan CSRF token untuk {coin_symbol}{Color.END}")
+            return False, None
+        
+        # 2. Dapatkan token reCAPTCHA untuk claim
+        print(f"{Color.CYAN}[3/4] Meminta token reCAPTCHA untuk claim...{Color.END}")
+        recaptcha_token = self.get_recaptcha_token()
+        if not recaptcha_token:
+            print(f"{Color.RED}❌ 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:
+            print(f"{Color.CYAN}[4/4] Mengirim claim untuk {coin_symbol}...{Color.END}")
+            response = self.session.post(
+                f'{self.base_url}{coin_data["url_path"]}',
+                headers=headers,
+                data=data,
+                timeout=30,
+                allow_redirects=True
+            )
+            
+            print(f"{Color.CYAN}✓ 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:
+                print(f"{Color.GREEN}✅ Claim {coin_symbol} 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?'
+                ]
+                
+                for pattern in reward_patterns:
+                    match = re.search(pattern, response.text, re.IGNORECASE)
+                    if match:
+                        reward = float(match.group(1))
+                        coin_data['total_rewards'] += reward
+                        print(f"{Color.GREEN}💰 Reward: {reward} {coin_symbol}{Color.END}")
+                        break
+                
+                # Update statistik
+                coin_data['success_count'] += 1
+                
+                # Update cookies setelah claim sukses
+                self.update_cookies()
+                
+            else:
+                print(f"{Color.RED}❌ Claim {coin_symbol} 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:
+                        print(f"{Color.YELLOW}⚠️  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(response.text)
+            if extracted_cooldown:
+                coin_data['cooldown'] = extracted_cooldown
+                print(f"{Color.CYAN}⏰ Cooldown terdeteksi: {extracted_cooldown} detik{Color.END}")
+            else:
+                # Gunakan default cooldown
+                coin_data['cooldown'] = coin_data['default_cooldown']
+                print(f"{Color.CYAN}⏰ Menggunakan default cooldown: {coin_data['default_cooldown']} detik{Color.END}")
+            
+            # Simpan statistik
+            self.save_stats()
+            
+            return success, response.text
+            
+        except Exception as e:
+            print(f"{Color.RED}❌ Error saat claim {coin_symbol}: {e}{Color.END}")
+            return False, str(e)
+    
+    def show_cooldown_timer(self, seconds, coin_symbol):
+        """Tampilkan timer countdown untuk coin tertentu"""
+        print(f"\n{Color.YELLOW}⏰ Cooldown {coin_symbol}: {seconds} detik{Color.END}")
+        print(f"{Color.CYAN}{'─' * 50}{Color.END}")
+        
+        for i in range(seconds):
+            remaining = seconds - i
+            progress = int((i / seconds) * 50)
+            
+            # Format waktu
+            if remaining >= 3600:
+                time_str = f"{remaining//3600:02d}:{(remaining%3600)//60:02d}:{remaining%60:02d}"
+            elif remaining >= 60:
+                time_str = f"{remaining//60:02d}:{remaining%60:02d}"
+            else:
+                time_str = f"00:{remaining:02d}"
+            
+            # Progress bar
+            bar = '█' * progress + '░' * (50 - progress)
+            percent = (i / seconds) * 100
+            
+            sys.stdout.write(f'\r{Color.GREEN}[{bar}]{Color.END} {time_str} ({percent:.1f}%)')
+            sys.stdout.flush()
+            
+            # Check every second if we should interrupt
+            try:
+                time.sleep(1)
+            except KeyboardInterrupt:
+                print(f"\n\n{Color.YELLOW}⚠️  Timer dihentikan{Color.END}")
+                return
+        
+        print(f"\n{Color.GREEN}✅ Cooldown {coin_symbol} selesai!{Color.END}")
+    
+    def get_next_available_coin(self):
+        """Cari coin yang sudah siap di-claim (hanya TRUMP)"""
+        coin_symbol = 'TRUMP'
+        coin_data = self.coins[coin_symbol]
+        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']:
+            return coin_symbol, 0  # 0 detik waiting
+        
+        # Hitung waktu tunggu
+        wait_time = coin_data['cooldown'] - time_since_last
+        return coin_symbol, max(0, wait_time)
+    
+    def print_statistics(self):
+        """Tampilkan statistik khusus TRUMP"""
+        print(f"\n{Color.PURPLE}{Color.BOLD}📊 TRUMP STATISTIK LENGKAP{Color.END}")
+        
+        coin_symbol = 'TRUMP'
+        coin_data = self.coins[coin_symbol]
+        
+        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%"
+        
+        print(f"{Color.BLUE}╔══════════════════════════════════════════════════════════╗{Color.END}")
+        print(f"{Color.BLUE}║                     TRUMP STATS                           ║{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}")
+        print(f"║ {coin_symbol:^9} ║ {claims:^8} ║ {success:^8} ║ {rewards:^8.4f} ║ {rate_str:^12} ║")
+        print(f"{Color.BLUE}╚═══════════╩══════════╩══════════╩══════════╩══════════════╝{Color.END}")
+        
+        # Tampilkan info login
+        if self.last_login_time > 0:
+            last_login_dt = datetime.fromtimestamp(self.last_login_time)
+            time_since_login = time.time() - self.last_login_time
+            hours_since = int(time_since_login // 3600)
+            minutes_since = int((time_since_login % 3600) // 60)
+            
+            print(f"{Color.CYAN}🍪 Last Login: {last_login_dt.strftime('%Y-%m-%d %H:%M:%S')}{Color.END}")
+            print(f"{Color.CYAN}⏰ Since Login: {hours_since} jam {minutes_since} menit yang lalu{Color.END}")
+        
+        print(f"{Color.CYAN}🔄 Total Cycles: {self.total_cycles}{Color.END}")
+        print(f"{Color.CYAN}🕐 Waktu Sekarang: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}{Color.END}")
+    
+    def run(self, max_cycles=100000):
+        """Jalankan bot dengan infinite loop khusus TRUMP"""
+        self.print_banner()
+        
+        # Cek cookies terlebih dahulu
+        print(f"{Color.CYAN}[1/3] Memeriksa cookies...{Color.END}")
+        if self.load_cookies():
+            print(f"{Color.CYAN}[2/3] Memeriksa status login...{Color.END}")
+            if self.check_login_status():
+                print(f"{Color.GREEN}✅ Login valid dengan cookies yang ada{Color.END}")
+            else:
+                print(f"{Color.YELLOW}⚠️  Cookies tidak valid, melakukan login...{Color.END}")
+                if not self.login():
+                    print(f"{Color.RED}❌ Gagal login, coba lagi dalam 60 detik...{Color.END}")
+                    time.sleep(60)
+                    return
+        else:
+            # Jika tidak ada cookies, lakukan login
+            print(f"{Color.CYAN}[2/3] Melakukan login...{Color.END}")
+            if not self.login():
+                print(f"{Color.RED}❌ Gagal login, coba lagi dalam 60 detik...{Color.END}")
+                time.sleep(60)
+                return
+        
+        print(f"{Color.GREEN}{'='*60}{Color.END}")
+        print(f"{Color.BOLD}🚀 MEMULAI TRUMP FAUCET BOT DENGAN COOKIES{Color.END}")
+        print(f"{Color.GREEN}{'='*60}{Color.END}")
+        
+        try:
+            while self.total_cycles < max_cycles:
+                self.total_cycles += 1
+                
+                print(f"\n{Color.CYAN}{'═' * 60}{Color.END}")
+                print(f"{Color.BOLD}🔄 CYCLE #{self.total_cycles}{Color.END}")
+                print(f"{Color.CYAN}{'═' * 60}{Color.END}")
+                
+                # Cek apakah perlu relogin (setiap 6 jam)
+                if not self.relogin_if_needed():
+                    print(f"{Color.YELLOW}⚠️  Relogin gagal, tunggu 1 menit...{Color.END}")
+                    time.sleep(60)
+                    continue
+                
+                # Update tabel status coin
+                self.print_coin_table()
+                
+                # Cari coin yang siap di-claim (selalu TRUMP)
+                next_coin, wait_time = self.get_next_available_coin()
+                
+                if wait_time > 0:
+                    # Tunggu sampai coin siap
+                    print(f"{Color.YELLOW}⏳ TRUMP dalam cooldown...{Color.END}")
+                    print(f"{Color.YELLOW}⏳ Menunggu {wait_time:.0f} detik untuk {next_coin}...{Color.END}")
+                    
+                    # Countdown tunggu
+                    for i in range(int(wait_time)):
+                        if i % 10 == 0:  # Update setiap 10 detik
+                            remaining = wait_time - i
+                            mins = int(remaining // 60)
+                            secs = int(remaining % 60)
+                            sys.stdout.write(f'\r⏳ Menunggu: {mins:02d}:{secs:02d} ...')
+                            sys.stdout.flush()
+                        time.sleep(1)
+                    print()
+                
+                # Claim coin yang tersedia (selalu TRUMP)
+                success, response = self.claim_coin(next_coin)
+                
+                if not success:
+                    # Jika gagal, coba login ulang
+                    print(f"{Color.YELLOW}⚠️  Claim TRUMP gagal, coba login ulang...{Color.END}")
+                    if self.login():
+                        continue
+                    else:
+                        print(f"{Color.RED}❌ Gagal login ulang, tunggu 5 menit...{Color.END}")
+                        time.sleep(300)
+                
+                # Tampilkan statistik setelah setiap claim
+                self.print_statistics()
+                
+                # Simpan statistik
+                self.save_stats()
+                
+                # Tunggu sebentar sebelum cek coin berikutnya
+                time.sleep(2)
+                
+        except KeyboardInterrupt:
+            print(f"\n\n{Color.YELLOW}⚠️  Bot dihentikan oleh user{Color.END}")
+        except Exception as e:
+            print(f"\n{Color.RED}❌ Error tidak terduga: {e}{Color.END}")
+            print(f"{Color.YELLOW}⚠️  Restart dalam 30 detik...{Color.END}")
+            time.sleep(30)
+            return False
+        
+        finally:
+            # Tampilkan statistik akhir
+            print(f"\n{Color.PURPLE}{'='*60}{Color.END}")
+            print(f"{Color.BOLD}🏁 STATISTIK AKHIR TRUMP{Color.END}")
+            print(f"{Color.PURPLE}{'='*60}{Color.END}")
+            self.print_statistics()
+            self.save_stats()
+            
+        return True
+
+def main():
+    """Fungsi utama dengan infinite loop untuk Docker (khusus TRUMP)"""
+    print(f"{Color.CYAN}🚀 Starting TRUMP Faucet Bot with Cookies Management{Color.END}")
+    
+    # Konfigurasi dari environment variables atau default
+    EMAIL = os.getenv('EMAIL', 'gadisk820@gmail.com')
+    MAX_CYCLES = int(os.getenv('MAX_CYCLES', '100000'))
+    
+    print(f"{Color.CYAN}📧 Email: {EMAIL}{Color.END}")
+    print(f"{Color.CYAN}🔁 Max Cycles: {MAX_CYCLES}{Color.END}")
+    print(f"{Color.CYAN}⏰ Timezone: {os.getenv('TZ', 'Asia/Jakarta')}{Color.END}")
+    print(f"{Color.CYAN}🍪 Cookies Management: Enabled{Color.END}")
+    print(f"{Color.CYAN}🔄 Relogin Interval: Every 6 hours{Color.END}\n")
+    
+    consecutive_failures = 0
+    max_consecutive_failures = 5
+    
+    while True:
+        try:
+            bot = TrumpFaucetBot(EMAIL)
+            success = bot.run(max_cycles=MAX_CYCLES)
+            
+            if success:
+                consecutive_failures = 0
+                print(f"{Color.GREEN}✅ Cycle completed successfully{Color.END}")
+            else:
+                consecutive_failures += 1
+                print(f"{Color.RED}❌ Cycle failed ({consecutive_failures}/{max_consecutive_failures}){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
+            
+            # Tunggu sebentar sebelum restart cycle
+            print(f"{Color.CYAN}⏳ Restarting in 10 seconds...{Color.END}")
+            time.sleep(10)
+            
+        except KeyboardInterrupt:
+            print(f"\n{Color.YELLOW}👋 Bot stopped by user{Color.END}")
+            break
+        except Exception as e:
+            print(f"{Color.RED}⚠️  Unexpected error: {e}{Color.END}")
+            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