Update solver.py

solver.py

@@ -1,193 +1,329 @@
 import time
 import json
 import logging
-from selenium import webdriver
-from selenium.webdriver.common.by import By
-from selenium.webdriver.support.ui import WebDriverWait
-from selenium.webdriver.support import expected_conditions as EC
-from selenium.webdriver.chrome.options import Options
-from selenium.webdriver.chrome.service import Service
+import random
+import math
+from camoufox.sync_api import Camoufox
+from playwright.sync_api import sync_playwright
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
+class HumanMouseMovement:
+    @staticmethod
+    def bezier_curve(start, end, steps=50):
+        points = []
+        control1 = (
+            start[0] + random.randint(-100, 100),
+            start[1] + random.randint(-100, 100)
+        )
+        control2 = (
+            end[0] + random.randint(-100, 100),
+            end[1] + random.randint(-100, 100)
+        )
+        
+        for i in range(steps + 1):
+            t = i / steps
+            x = (1-t)**3 * start[0] + 3*(1-t)**2*t * control1[0] + 3*(1-t)*t**2 * control2[0] + t**3 * end[0]
+            y = (1-t)**3 * start[1] + 3*(1-t)**2*t * control1[1] + 3*(1-t)*t**2 * control2[1] + t**3 * end[1]
+            
+            shake_x = random.uniform(-2, 2)
+            shake_y = random.uniform(-2, 2)
+            
+            points.append((x + shake_x, y + shake_y))
+        
+        return points
+    
+    @staticmethod
+    def add_micro_movements(x, y):
+        micro_x = x + random.uniform(-1, 1)
+        micro_y = y + random.uniform(-1, 1)
+        return micro_x, micro_y
+
 class HCaptchaSolver:
     def __init__(self):
-        self.driver = None
-        self.wait = None
-        self.setup_driver()
-        
-    def setup_driver(self):
-        chrome_options = Options()
-        chrome_options.binary_location = '/usr/bin/chromium'
-        chrome_options.add_argument('--no-sandbox')
-        chrome_options.add_argument('--disable-dev-shm-usage')
-        chrome_options.add_argument('--disable-gpu')
-        chrome_options.add_argument('--disable-software-rasterizer')
-        chrome_options.add_argument('--disable-dev-tools')
-        chrome_options.add_argument('--no-zygote')
-        chrome_options.add_argument('--single-process')
-        chrome_options.add_argument('--window-size=1920,1080')
-        chrome_options.add_argument('--headless=new')
-        chrome_options.add_argument('--disable-blink-features=AutomationControlled')
-        chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
-        chrome_options.add_experimental_option('useAutomationExtension', False)
-        chrome_options.add_argument('user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36')
-        
-        service = Service('/usr/bin/chromedriver')
-        self.driver = webdriver.Chrome(service=service, options=chrome_options)
-        self.wait = WebDriverWait(self.driver, 30)
-        
-        self.driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
-            'source': '''
-                Object.defineProperty(navigator, 'webdriver', {get: () => undefined});
-                Object.defineProperty(navigator, 'plugins', {get: () => [1, 2, 3, 4, 5]});
-                Object.defineProperty(navigator, 'languages', {get: () => ['en-US', 'en']});
-                window.chrome = {runtime: {}};
-            '''
-        })
-        
-        logger.info("Chrome driver setup complete")
+        self.browser = None
+        self.page = None
+        self.context = None
+        
+    def setup_browser(self):
+        logger.info("Setting up Camoufox browser...")
+        
+        self.browser = Camoufox(
+            headless=True,
+            humanize=True,
+            geoip=True,
+            exclude_addons=['uBlock0@raymondhill.net']
+        )
+        
+        self.context = 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/120.0.0.0 Safari/537.36',
+            locale='en-US',
+            timezone_id='America/New_York'
+        )
+        
+        self.page = self.context.new_page()
+        
+        self.page.add_init_script("""
+            Object.defineProperty(navigator, 'webdriver', {
+                get: () => undefined
+            });
+            
+            window.chrome = {
+                runtime: {},
+            };
+            
+            Object.defineProperty(navigator, 'plugins', {
+                get: () => [1, 2, 3, 4, 5],
+            });
+        """)
+        
+        logger.info("Camoufox browser setup complete")
+        
+    def human_mouse_move(self, target_x, target_y):
+        current_pos = self.page.evaluate("""
+            () => ({x: window.mouseX || 0, y: window.mouseY || 0})
+        """)
+        
+        start = (current_pos['x'], current_pos['y'])
+        end = (target_x, target_y)
+        
+        points = HumanMouseMovement.bezier_curve(start, end, steps=random.randint(30, 60))
+        
+        for x, y in points:
+            micro_x, micro_y = HumanMouseMovement.add_micro_movements(x, y)
+            self.page.mouse.move(micro_x, micro_y)
+            time.sleep(random.uniform(0.001, 0.005))
+        
+        self.page.evaluate(f"window.mouseX = {target_x}; window.mouseY = {target_y};")
+        
+    def human_click(self, selector=None, x=None, y=None):
+        if selector:
+            element = self.page.locator(selector)
+            box = element.bounding_box()
+            if box:
+                click_x = box['x'] + box['width'] / 2 + random.uniform(-5, 5)
+                click_y = box['y'] + box['height'] / 2 + random.uniform(-5, 5)
+            else:
+                return False
+        else:
+            click_x = x
+            click_y = y
+        
+        self.human_mouse_move(click_x, click_y)
+        
+        time.sleep(random.uniform(0.05, 0.15))
+        
+        for _ in range(random.randint(1, 3)):
+            offset_x = random.uniform(-1, 1)
+            offset_y = random.uniform(-1, 1)
+            self.page.mouse.move(click_x + offset_x, click_y + offset_y)
+            time.sleep(random.uniform(0.01, 0.03))
+        
+        self.page.mouse.down()
+        time.sleep(random.uniform(0.05, 0.12))
+        self.page.mouse.up()
+        
+        time.sleep(random.uniform(0.1, 0.3))
+        
+        return True
         
     def open_page(self):
         logger.info("Opening bylo.ai...")
-        self.driver.get("https://bylo.ai/features/sora-2")
-        time.sleep(3)
+        self.page.goto("https://bylo.ai/features/sora-2", wait_until="networkidle")
+        time.sleep(random.uniform(2, 4))
         
     def click_login_button(self):
-        logger.info("Clicking login button...")
-        login_btn = self.wait.until(
-            EC.element_to_be_clickable((By.CSS_SELECTOR, 'button.flex.items-center.gap-3'))
-        )
-        login_btn.click()
-        time.sleep(2)
+        logger.info("Looking for login button...")
+        try:
+            self.page.wait_for_selector('button.flex.items-center.gap-3', timeout=10000)
+            self.human_click('button.flex.items-center.gap-3')
+            logger.info("Login button clicked")
+            time.sleep(random.uniform(1.5, 2.5))
+            return True
+        except Exception as e:
+            logger.error(f"Error clicking login: {e}")
+            return False
         
     def click_signup(self):
-        logger.info("Clicking Sign Up...")
-        signup = self.wait.until(
-            EC.element_to_be_clickable((By.XPATH, "//span[text()='Sign Up']"))
-        )
-        signup.click()
-        time.sleep(2)
+        logger.info("Looking for Sign Up...")
+        try:
+            self.page.wait_for_selector("//span[text()='Sign Up']", timeout=10000)
+            self.human_click("//span[text()='Sign Up']")
+            logger.info("Sign Up clicked")
+            time.sleep(random.uniform(1.5, 2.5))
+            return True
+        except Exception as e:
+            logger.error(f"Error clicking signup: {e}")
+            return False
         
     def fill_email(self, email):
         logger.info(f"Filling email: {email}")
-        email_input = self.wait.until(
-            EC.presence_of_element_located((By.CSS_SELECTOR, 'input[name="email"]'))
-        )
-        email_input.clear()
-        email_input.send_keys(email)
-        time.sleep(1)
+        try:
+            self.page.wait_for_selector('input[name="email"]', timeout=10000)
+            
+            email_input = self.page.locator('input[name="email"]')
+            box = email_input.bounding_box()
+            
+            if box:
+                click_x = box['x'] + box['width'] / 2
+                click_y = box['y'] + box['height'] / 2
+                self.human_mouse_move(click_x, click_y)
+                self.page.mouse.click(click_x, click_y)
+            
+            time.sleep(random.uniform(0.3, 0.6))
+            
+            for char in email:
+                self.page.keyboard.type(char)
+                time.sleep(random.uniform(0.08, 0.25))
+            
+            logger.info("Email filled")
+            time.sleep(random.uniform(0.5, 1))
+            return True
+        except Exception as e:
+            logger.error(f"Error filling email: {e}")
+            return False
         
     def click_get_code(self):
         logger.info("Clicking Get Code...")
-        get_code = self.wait.until(
-            EC.element_to_be_clickable((By.XPATH, "//button[text()='Get Code']"))
-        )
-        get_code.click()
-        time.sleep(3)
-        
-    def solve_hcaptcha_auto(self):
-        logger.info("Starting hCaptcha auto solve...")
-        
-        time.sleep(3)
+        try:
+            self.page.wait_for_selector("//button[text()='Get Code']", timeout=10000)
+            self.human_click("//button[text()='Get Code']")
+            logger.info("Get Code clicked")
+            time.sleep(random.uniform(2, 3))
+            return True
+        except Exception as e:
+            logger.error(f"Error clicking get code: {e}")
+            return False
         
-        iframes = self.driver.find_elements(By.TAG_NAME, 'iframe')
-        logger.info(f"Found {len(iframes)} iframes")
+    def solve_hcaptcha(self):
+        logger.info("="*60)
+        logger.info("Starting hCaptcha solving process...")
+        logger.info("="*60)
         
-        for idx, iframe in enumerate(iframes):
-            try:
-                iframe_src = iframe.get_attribute('src')
-                
-                if iframe_src and 'hcaptcha.com/captcha' in iframe_src:
-                    logger.info(f"Found hCaptcha iframe at index {idx}")
+        try:
+            time.sleep(3)
+            
+            logger.info("Looking for hCaptcha iframe...")
+            
+            frames = self.page.frames
+            logger.info(f"Found {len(frames)} frames")
+            
+            hcaptcha_frame = None
+            for frame in frames:
+                try:
+                    frame_url = frame.url
+                    logger.info(f"Frame URL: {frame_url[:100]}")
                     
-                    self.driver.switch_to.frame(iframe)
+                    if 'hcaptcha.com/captcha' in frame_url:
+                        logger.info("Found hCaptcha checkbox frame!")
+                        hcaptcha_frame = frame
+                        break
+                except:
+                    continue
+            
+            if not hcaptcha_frame:
+                logger.warning("hCaptcha frame not found, trying alternative methods...")
+                
+                for i in range(5):
+                    logger.info(f"Waiting for hCaptcha to load... attempt {i+1}/5")
                     time.sleep(2)
                     
-                    try:
-                        checkbox = self.wait.until(
-                            EC.element_to_be_clickable((By.CSS_SELECTOR, '#checkbox'))
-                        )
-                        logger.info("Clicking checkbox...")
-                        checkbox.click()
-                        time.sleep(3)
+                    frames = self.page.frames
+                    for frame in frames:
+                        try:
+                            if 'hcaptcha.com/captcha' in frame.url:
+                                hcaptcha_frame = frame
+                                break
+                        except:
+                            continue
+                    
+                    if hcaptcha_frame:
+                        break
+            
+            if hcaptcha_frame:
+                logger.info("Attempting to click hCaptcha checkbox...")
+                
+                try:
+                    checkbox = hcaptcha_frame.locator('#checkbox')
+                    
+                    checkbox.wait_for(timeout=5000)
+                    
+                    box = checkbox.bounding_box()
+                    if box:
+                        click_x = box['x'] + box['width'] / 2 + random.uniform(-3, 3)
+                        click_y = box['y'] + box['height'] / 2 + random.uniform(-3, 3)
                         
-                        self.driver.switch_to.default_content()
-                        time.sleep(3)
+                        self.human_mouse_move(click_x, click_y)
                         
-                        token = self.get_hcaptcha_token()
-                        if token:
-                            return token
-                            
-                    except Exception as e:
-                        logger.warning(f"Checkbox not found in this iframe: {e}")
-                        self.driver.switch_to.default_content()
+                        time.sleep(random.uniform(0.5, 1))
                         
-            except Exception as e:
-                logger.warning(f"Error processing iframe {idx}: {e}")
-                self.driver.switch_to.default_content()
-        
-        logger.info("Trying JavaScript bypass...")
-        
-        bypass_script = """
-            var response = document.querySelector('[name="h-captcha-response"]');
-            if (response && response.value) {
-                return response.value;
-            }
+                        for _ in range(random.randint(2, 4)):
+                            micro_x = click_x + random.uniform(-2, 2)
+                            micro_y = click_y + random.uniform(-2, 2)
+                            self.page.mouse.move(micro_x, micro_y)
+                            time.sleep(random.uniform(0.02, 0.05))
+                        
+                        self.page.mouse.down()
+                        time.sleep(random.uniform(0.08, 0.15))
+                        self.page.mouse.up()
+                        
+                        logger.info("Checkbox clicked!")
+                        
+                        time.sleep(random.uniform(2, 4))
+                        
+                except Exception as e:
+                    logger.error(f"Error clicking checkbox: {e}")
             
-            if (window.hcaptcha) {
-                try {
-                    var widgetID = window.hcaptcha.render(document.querySelector('.h-captcha'));
-                    window.hcaptcha.execute(widgetID);
-                } catch(e) {}
-            }
+            logger.info("Waiting for hCaptcha token...")
             
-            return null;
-        """
-        
-        for attempt in range(15):
-            result = self.driver.execute_script(bypass_script)
-            if result:
-                logger.info("Token obtained from JavaScript bypass!")
-                return result
+            for attempt in range(40):
+                token = self.get_hcaptcha_token()
+                if token:
+                    return token
                 
-            time.sleep(2)
-            logger.info(f"Bypass attempt {attempt + 1}/15")
-        
-        logger.info("Waiting for token to appear...")
-        for i in range(40):
-            token = self.get_hcaptcha_token()
-            if token:
-                return token
-            time.sleep(1)
+                time.sleep(1)
+                
+                if attempt % 5 == 0:
+                    logger.info(f"Still waiting for token... {attempt}s")
             
-        return None
+            logger.warning("Token not found after waiting")
+            return None
+            
+        except Exception as e:
+            logger.error(f"Error solving hCaptcha: {e}")
+            return None
         
     def get_hcaptcha_token(self):
         try:
-            token = self.driver.execute_script("""
-                var elements = [
-                    document.querySelector('textarea[name="h-captcha-response"]'),
-                    document.querySelector('[data-hcaptcha-response]'),
-                    document.querySelector('input[name="h-captcha-response"]')
-                ];
-                
-                for (var el of elements) {
-                    if (el && el.value) {
-                        return el.value;
-                    }
-                    if (el && el.getAttribute('data-hcaptcha-response')) {
-                        return el.getAttribute('data-hcaptcha-response');
+            token = self.page.evaluate("""
+                () => {
+                    const elements = [
+                        document.querySelector('textarea[name="h-captcha-response"]'),
+                        document.querySelector('[data-hcaptcha-response]'),
+                        document.querySelector('input[name="h-captcha-response"]')
+                    ];
+                    
+                    for (let el of elements) {
+                        if (el && el.value && el.value.length > 10) {
+                            return el.value;
+                        }
+                        if (el && el.getAttribute('data-hcaptcha-response')) {
+                            return el.getAttribute('data-hcaptcha-response');
+                        }
                     }
+                    
+                    return null;
                 }
-                
-                return null;
             """)
             
             if token and len(token) > 10:
-                logger.info(f"TOKEN FOUND: {token[:50]}...")
-                logger.info(f"Token length: {len(token)}")
+                logger.info("="*60)
+                logger.info("TOKEN FOUND!")
+                logger.info(f"Token: {token[:50]}...")
+                logger.info(f"Length: {len(token)}")
+                logger.info("="*60)
                 return token
                 
         except Exception as e:
@@ -197,13 +333,22 @@ class HCaptchaSolver:
         
     def run(self, email="herzfnf@gmail.com"):
         try:
+            self.setup_browser()
             self.open_page()
-            self.click_login_button()
-            self.click_signup()
-            self.fill_email(email)
-            self.click_get_code()
             
-            token = self.solve_hcaptcha_auto()
+            if not self.click_login_button():
+                raise Exception("Failed to click login button")
+            
+            if not self.click_signup():
+                raise Exception("Failed to click signup")
+            
+            if not self.fill_email(email):
+                raise Exception("Failed to fill email")
+            
+            if not self.click_get_code():
+                raise Exception("Failed to click get code")
+            
+            token = self.solve_hcaptcha()
             
             if token:
                 logger.info("SUCCESS! Token retrieved")
@@ -225,19 +370,18 @@ class HCaptchaSolver:
                 "success": False,
                 "error": str(e)
             }
+        finally:
+            self.cleanup()
             
     def cleanup(self):
-        if self.driver:
-            self.driver.quit()
+        if self.browser:
+            self.browser.close()
             logger.info("Browser closed")
 
 if __name__ == "__main__":
     solver = HCaptchaSolver()
-    try:
-        result = solver.run("herzfnf@gmail.com")
-        print("\n" + "="*60)
-        print("RESULT:")
-        print(json.dumps(result, indent=2))
-        print("="*60)
-    finally:
-        solver.cleanup()
+    result = solver.run("herzfnf@gmail.com")
+    print("\n" + "="*60)
+    print("FINAL RESULT:")
+    print(json.dumps(result, indent=2))
+    print("="*60)