Upload 9 files

Dockerfile

@@ -1,13 +1,14 @@
 FROM mcr.microsoft.com/playwright/python:v1.42.0-jammy
 
-RUN useradd -m -u 1000 user
-USER user
-ENV HOME=/home/user \
-    PATH=/home/user/.local/bin:$PATH
+# Playwright image already has a default user "pwuser" with UID 1000, 
+# which is exactly what Hugging Face needs. We don't need to create one.
+USER pwuser
+ENV HOME=/home/pwuser \
+    PATH=/home/pwuser/.local/bin:$PATH
 
 WORKDIR $HOME/app
 
-COPY --chown=user . $HOME/app
+COPY --chown=pwuser . $HOME/app
 
 RUN pip install --no-cache-dir --upgrade pip && \
     pip install --no-cache-dir -r requirements.txt

bot.py

@@ -0,0 +1,319 @@
+import asyncio
+import logging
+from playwright.async_api import async_playwright
+from playwright_stealth import Stealth
+import os
+import json
+from dotenv import load_dotenv
+from datetime import datetime
+
+# Setup logging
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class AviatorBot:
+    def __init__(self, config):
+        self.config = config
+        self.browser = None
+        self.context = None
+        self.page = None
+        self.game_frame = None
+        self.is_running = False
+        self.dry_run = config.get('DRY_RUN', True) # Default to True for safety
+
+    async def setup(self):
+        """Initialize browser, stealth mode and session state"""
+        
+        # Performance/Server args
+        launch_args = ["--disable-web-security", "--disable-features=IsolateOrigins,site-per-process"]
+        
+        self.browser = await self.playwright.chromium.launch(
+            headless=True,
+            args=["--disable-blink-features=AutomationControlled"]
+        )
+        
+        # Load session state if exists
+        state_path = "state.json"
+        if os.path.exists(state_path):
+            logger.info("Loading existing session state from state.json")
+            self.context = await self.browser.new_context(
+                storage_state=state_path,
+                viewport={'width': 1920, 'height': 1080},
+                user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
+            )
+        else:
+            self.context = await self.browser.new_context(
+                viewport={'width': 1920, 'height': 1080},
+                user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
+            )
+            
+        self.page = await self.context.new_page()
+        try:
+            await Stealth().apply_stealth_async(self.page)
+            logger.info("Stealth applied.")
+        except Exception as e:
+            logger.warning(f"Stealth application failed: {e}")
+        logger.info("Browser setup complete.")
+
+    async def login(self):
+        """Use state.json if it exists, otherwise do fresh login via visible browser"""
+        if os.path.exists("state.json"):
+            logger.info("state.json found — checking session validity...")
+            # Navigate to site to verify session
+            await self.page.goto("https://luckyeie.com/", wait_until="domcontentloaded", timeout=60000)
+            await asyncio.sleep(3)
+            
+            # If Login button is still visible, session is invalid
+            login_btn = self.page.locator("button:visible:has-text('Log in'), button:visible:has-text('Login')").first
+            is_logged_out = await login_btn.count() > 0
+            
+            if is_logged_out:
+                logger.warning("Session is invalid (Login button visible). Re-logging in...")
+                if os.path.exists("state.json"): os.remove("state.json")
+                await self._do_login()
+            else:
+                logger.info("Session is valid. Proceeding to game.")
+            return
+
+        await self._do_login()
+
+    async def _do_login(self):
+        """Perform actual browser login and save HttpOnly cookies"""
+        logger.info("Opening login page in browser...")
+        await self.page.goto("https://luckyeie.com/", wait_until="domcontentloaded", timeout=60000)
+        await asyncio.sleep(2)
+
+        try:
+            # Click login button on header
+            logger.info("Step 1: Clicking header login button...")
+            login_btn = self.page.locator("button:visible:has-text('Log in'), button:visible:has-text('Login'), a:visible:has-text('Log in'), a:visible:has-text('Login')").first
+            await login_btn.click()
+            await asyncio.sleep(3)
+            await self.page.screenshot(path="login_step1_modal.png")
+            
+            # Switch to E-mail/Email tab in login modal
+            logger.info("Step 2: Switching to Email tab...")
+            # Use the specific data-test-id we found: signInByPhone-form-tab-email
+            email_tab = self.page.locator("[data-test-id*='tab-email'], button:has-text('Email'), [role='tab']:has-text('Email')").locator("visible=true").first
+            try:
+                await email_tab.wait_for(state='visible', timeout=7000)
+                await email_tab.click(force=True)
+                logger.info("Email tab clicked (force=True).")
+                await asyncio.sleep(2)
+                
+                # Double check if we switched - if not try clicking again or using dispatch_event
+                # Look for an email input to confirm switch
+                if await self.page.locator("input[type='email'], input[placeholder*='mail' i]").locator("visible=true").count() == 0:
+                    logger.warning("Email input not visible after click, trying dispatch_event('click')...")
+                    await email_tab.evaluate("el => el.click()")
+                    await asyncio.sleep(2)
+            except Exception as e:
+                logger.warning(f"Email tab switch failed: {e}")
+            await self.page.screenshot(path="login_step2_email_tab.png")
+
+            # Fill email
+            logger.info("Step 3: Filling email...")
+            email_input = self.page.locator("input[type='email'], input[name='email'], input[placeholder*='mail' i]").locator("visible=true").first
+            await email_input.wait_for(state='visible', timeout=10000)
+            await email_input.fill(self.config['EMAIL'])
+
+            # Fill password
+            logger.info("Step 4: Filling password...")
+            pass_input = self.page.locator("input[type='password'], input[name='password']").locator("visible=true").first
+            await pass_input.fill(self.config['PASSWORD'])
+            await self.page.screenshot(path="login_step3_filled.png")
+
+            # Submit login
+            logger.info("Step 5: Submitting login form...")
+            # Target the green 'Log in' button inside the modal specifically
+            submit_btn = self.page.locator("[class*='modal'] button:has-text('Log in'), [class*='modal'] button[type='submit']").locator("visible=true").first
+            await submit_btn.click()
+
+            logger.info("Credentials submitted. Waiting 15s for login to finalize and redirect...")
+            await asyncio.sleep(15) 
+            await self.page.screenshot(path="login_step4_after_submit.png")
+
+            # Save full state including HttpOnly cookies from Playwright context
+            await self.context.storage_state(path="state.json")
+            logger.info("SUCCESS: Full session saved to state.json (includes HttpOnly cookies)")
+
+        except Exception as e:
+            logger.error(f"Login error: {e}. Please login manually in the open browser window.")
+            logger.info("Waiting 30s for manual login...")
+            await asyncio.sleep(30)
+            await self.context.storage_state(path="state.json")
+            logger.info("Session saved after manual window.")
+
+    async def enter_game(self):
+        """Navigate to Aviator and find the game iframe"""
+        logger.info(f"Navigating to: {self.config['BASE_URL']}")
+        await self.page.goto(self.config['BASE_URL'], wait_until="domcontentloaded", timeout=60000)
+        logger.info("Game page loaded. Waiting 5s for game iframe to initialize...")
+        await asyncio.sleep(5)
+
+        try:
+            # Search all frames for any spribegaming/aviator URL
+            for f in self.page.frames:
+                logger.info(f"  Frame URL: {f.url}")
+                if any(k in f.url for k in ["spribegaming", "aviator", "launch.spribe"]):
+                    self.game_frame = f
+                    logger.info(f"✅ Aviator iframe found: {f.url}")
+                    return True
+
+            logger.error("❌ Could not find Aviator game iframe after scanning all frames.")
+            return False
+        except Exception as e:
+            logger.error(f"Error entering game: {e}")
+            return False
+
+    async def monitor_results(self):
+        """Monitor game events by polling the DOM inside the Aviator iframe"""
+        logger.info("Monitoring results started via DOM polling...")
+        
+        last_result = ""
+        last_active = ""
+
+        while self.is_running:
+            try:
+                if not self.game_frame:
+                    await asyncio.sleep(1)
+                    continue
+
+                # Execute JS inside the iframe to grab the current state
+                state = await self.game_frame.evaluate('''() => {
+                    let result = null;
+                    let active = null;
+                    
+                    // Historical payout bubbles (most recent is usually first or last depending on layout)
+                    let bubbles = Array.from(document.querySelectorAll('.payouts-block app-bubble-multiplier, .bubble-multiplier, app-bubble-multiplier, .payout'));
+                    if (bubbles.length > 0) {
+                        // Usually the first one in the list is the most recent completed
+                        result = bubbles[0].innerText.trim();
+                    }
+                    
+                    // The large active flying multiplier on screen
+                    let main_text = document.querySelector('.fliers-block .fliers-x, .current-multiplier, [class*="fliers-x"], app-multiplier');
+                    if (main_text) {
+                        active = main_text.innerText.trim();
+                    }
+                    
+                    return {result: result, active: active};
+                }''')
+
+                result = state.get('result')
+                active = state.get('active')
+
+                # Detect active flight (Round Start)
+                if active and active != last_active and "x" in active.lower() and "wait" not in active.lower():
+                    # We only log round start if it's a small multiplier indicating takeoff
+                    val_str = active.lower().replace("x", "").strip()
+                    try:
+                        if float(val_str) < 1.10 and last_active == "":
+                            logger.info(">>> NEW ROUND STARTING...")
+                            await self.on_round_start()
+                    except:
+                        pass
+                    last_active = active
+
+                # Detect when flight ends (active disappears or says 'flew away')
+                if not active and last_active:
+                    last_active = ""
+
+                # Detect new completed result
+                if result and result != last_result and "x" in result.lower():
+                    last_result = result
+                    logger.info(f">>> ROUND RESULT: {result}")
+                    self.log_result(result)
+
+                # Poll every 0.3 seconds
+                await asyncio.sleep(0.3)
+
+            except Exception as e:
+                # Ignore expected errors like frame detached during reload
+                if "Target page, context or browser has been closed" in str(e):
+                    break
+                await asyncio.sleep(1)
+
+    async def on_round_start(self):
+        """Logic to execute when a new round begins"""
+        if self.dry_run:
+            logger.info("[DRY-RUN] Round started. Skipping bet.")
+            return
+
+        # 1. Place Bet
+        bet_success = await self.place_bet(self.config['BASE_BET'])
+        if bet_success:
+            # 2. Start looking for target multiplier to Cash Out
+            asyncio.create_task(self.auto_cash_out())
+
+    async def place_bet(self, amount):
+        """Interact with the Bet button"""
+        if self.dry_run:
+            return False
+
+        try:
+            if self.game_frame:
+                # Set amount in input field first
+                # Selector: .input .bet-input
+                await self.game_frame.fill(".input .bet-input", str(amount))
+                
+                # Click 'BET' button
+                # Selector: button.bet-button.green
+                bet_btn = self.game_frame.locator("button.bet-button").first
+                await bet_btn.click()
+                logger.info(f"Bet placed: {amount}")
+                return True
+        except Exception as e:
+            logger.error(f"Failed to place bet: {e}")
+        return False
+
+    async def auto_cash_out(self):
+        """Monitor live multiplier and click Cash Out at target"""
+        if self.dry_run:
+            return
+
+        target = self.config['TARGET_MULTIPLIER']
+        logger.info(f"Waiting for {target}x to cash out...")
+        # ... logic for actual cashout ...
+
+    def log_result(self, result):
+        """Save multiplier results to a local file for strategy analysis"""
+        try:
+            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            # Check if file needs header
+            needs_header = not os.path.exists("game_history.csv")
+            with open("game_history.csv", "a") as f:
+                if needs_header:
+                    f.write("timestamp,multiplier\n")
+                f.write(f"{timestamp},{result}\n")
+            logger.info(f"Result logged: {result}")
+        except Exception as e:
+            logger.error(f"Failed to log result: {e}")
+
+    async def start(self):
+        self.is_running = True
+        
+        logger.info("[START] Initializing Playwright...")
+        async with async_playwright() as self.playwright:
+            await self.setup()
+            
+            await self.login()
+            if await self.enter_game():
+                logger.info("Game entered. Starting monitor loop...")
+                await self.monitor_results()
+
+async def main_bot():
+    load_dotenv()
+    config = {
+        "EMAIL": os.getenv("EMAIL"),
+        "PASSWORD": os.getenv("PASSWORD"),
+        "BASE_URL": os.getenv("BASE_URL"),
+        "DRY_RUN": os.getenv("DRY_RUN", "True").lower() == "true",
+        "BASE_BET": float(os.getenv("BASE_BET", 10.0)),
+        "TARGET_MULTIPLIER": float(os.getenv("TARGET_MULTIPLIER", 1.5))
+    }
+    bot = AviatorBot(config)
+    await bot.start()
+
+if __name__ == "__main__":
+    asyncio.run(main_bot())

game_history.csv

@@ -0,0 +1,54 @@
+4.70x
+2.38x
+5.79x
+1.90x
+1.17x
+1.29x
+48.88x
+4.14x
+8.15x
+1.06x
+1.31x
+8.16x
+1.07x
+5.23x
+1.36x
+3.51x
+1.21x
+2.97x
+1.07x
+2.54x
+1.41x
+1.32x
+2.39x
+2.17x
+1.00x
+1.92x
+1.11x
+1.09x
+17.63x
+232.59x
+2.45x
+4.16x
+1.00x
+1.04x
+1.43x
+2.41x
+3.57x
+2.09x
+1.41x
+28.05x
+1.03x
+1.15x
+3.60x
+1.78x
+1.21x
+1.79x
+8.77x
+4.94x
+2.38x
+1.00x
+1.83x
+751.99x
+3.80x
+1.72x

run_bot.py

@@ -1,7 +1,7 @@
 import asyncio
 import logging
 import os
-from src.bot import main_bot
+from bot import main_bot
 
 if __name__ == "__main__":
     try: