Update src/browser/custom_browser.py

src/browser/custom_browser.py

@@ -1,120 +1,115 @@
-import asyncio
-import pdb
-
-from playwright.async_api import Browser as PlaywrightBrowser
-from playwright.async_api import (
-	BrowserContext as PlaywrightBrowserContext,
-)
-from playwright.async_api import (
-	Playwright,
-	async_playwright,
-)
-from browser_use.browser.browser import Browser
-from browser_use.browser.context import BrowserContext, BrowserContextConfig
-from playwright.async_api import BrowserContext as PlaywrightBrowserContext
-import logging
-
-from .custom_context import CustomBrowserContext
-
-logger = logging.getLogger(__name__)
-
-class CustomBrowser(Browser):
-
-    async def new_context(
-        self,
-        config: BrowserContextConfig = BrowserContextConfig()
-    ) -> CustomBrowserContext:
-        return CustomBrowserContext(config=config, browser=self)
-
-    async def _setup_browser(self, playwright: Playwright) -> PlaywrightBrowser:
-        """Sets up and returns a Playwright Browser instance with anti-detection measures."""
-        if self.config.wss_url:
-            browser = await playwright.chromium.connect(self.config.wss_url)
-            return browser
-        elif self.config.chrome_instance_path:
-            import subprocess
-
-            import requests
-
-            try:
-                # Check if browser is already running
-                response = requests.get('http://localhost:9222/json/version', timeout=2)
-                if response.status_code == 200:
-                    logger.info('Reusing existing Chrome instance')
-                    browser = await playwright.chromium.connect_over_cdp(
-                        endpoint_url='http://localhost:9222',
-                        timeout=20000,  # 20 second timeout for connection
-                    )
-                    return browser
-            except requests.ConnectionError:
-                logger.debug('No existing Chrome instance found, starting a new one')
-
-            # Start a new Chrome instance
-            subprocess.Popen(
-                [
-                    self.config.chrome_instance_path,
-                    '--remote-debugging-port=9222',
-                ],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-
-            # Attempt to connect again after starting a new instance
-            for _ in range(10):
-                try:
-                    response = requests.get('http://localhost:9222/json/version', timeout=2)
-                    if response.status_code == 200:
-                        break
-                except requests.ConnectionError:
-                    pass
-                await asyncio.sleep(1)
-
-            try:
-                browser = await playwright.chromium.connect_over_cdp(
-                    endpoint_url='http://localhost:9222',
-                    timeout=20000,  # 20 second timeout for connection
-                )
-                return browser
-            except Exception as e:
-                logger.error(f'Failed to start a new Chrome instance.: {str(e)}')
-                raise RuntimeError(
-                    ' To start chrome in Debug mode, you need to close all existing Chrome instances and try again otherwise we can not connect to the instance.'
-                )
-
-        else:
-            try:
-                disable_security_args = []
-                if self.config.disable_security:
-                    disable_security_args = [
-                        '--disable-web-security',
-                        '--disable-site-isolation-trials',
-                        '--disable-features=IsolateOrigins,site-per-process',
-                    ]
-
-                browser = await playwright.chromium.launch(
-                    headless=self.config.headless,
-                    args=[
-                             '--no-sandbox',
-                             '--disable-blink-features=AutomationControlled',
-                             '--disable-infobars',
-                             '--disable-background-timer-throttling',
-                             '--disable-popup-blocking',
-                             '--disable-backgrounding-occluded-windows',
-                             '--disable-renderer-backgrounding',
-                             '--disable-window-activation',
-                             '--disable-focus-on-load',
-                             '--no-first-run',
-                             '--no-default-browser-check',
-                             '--no-startup-window',
-                             '--window-position=0,0',
-                             # '--window-size=1280,1000',
-                         ]
-                         + disable_security_args
-                         + self.config.extra_chromium_args,
-                    proxy=self.config.proxy,
-                )
-
-                return browser
-            except Exception as e:
-                logger.error(f'Failed to initialize Playwright browser: {str(e)}')
-                raise
+import asyncio
+import logging
+import subprocess
+import requests
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.chrome.service import Service
+from webdriver_manager.chrome import ChromeDriverManager
+
+logger = logging.getLogger(__name__)
+
+class CustomBrowser:
+    def __init__(self, config=None):
+        self.config = config or {}
+        self.driver = None
+
+    async def new_context(self):
+        """Crea y retorna un nuevo contexto de navegador."""
+        return await self._setup_browser()
+
+    async def _setup_browser(self):
+        """Configura y retorna una instancia de Selenium WebDriver con medidas anti-detección."""
+        chrome_options = Options()
+
+        # Configuración para modo headless (sin interfaz gráfica)
+        if self.config.get("headless", True):
+            chrome_options.add_argument("--headless=new")
+
+        # Configuración de seguridad
+        if self.config.get("disable_security", False):
+            chrome_options.add_argument("--disable-web-security")
+            chrome_options.add_argument("--disable-site-isolation-trials")
+            chrome_options.add_argument("--disable-features=IsolateOrigins,site-per-process")
+
+        # Argumentos adicionales de Chromium
+        chrome_options.add_argument("--no-sandbox")
+        chrome_options.add_argument("--disable-blink-features=AutomationControlled")
+        chrome_options.add_argument("--disable-infobars")
+        chrome_options.add_argument("--disable-background-timer-throttling")
+        chrome_options.add_argument("--disable-popup-blocking")
+        chrome_options.add_argument("--disable-backgrounding-occluded-windows")
+        chrome_options.add_argument("--disable-renderer-backgrounding")
+        chrome_options.add_argument("--disable-window-activation")
+        chrome_options.add_argument("--disable-focus-on-load")
+        chrome_options.add_argument("--no-first-run")
+        chrome_options.add_argument("--no-default-browser-check")
+        chrome_options.add_argument("--no-startup-window")
+        chrome_options.add_argument("--window-position=0,0")
+
+        # Proxy (si está configurado)
+        if self.config.get("proxy"):
+            chrome_options.add_argument(f"--proxy-server={self.config['proxy']}")
+
+        # Conexión a una instancia de Chrome en ejecución (si se especifica)
+        if self.config.get("wss_url"):
+            chrome_options.debugger_address = self.config["wss_url"]
+            self.driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=chrome_options)
+            return self.driver
+
+        # Conexión a una instancia local de Chrome (debug mode)
+        elif self.config.get("chrome_instance_path"):
+            try:
+                # Verifica si Chrome ya está en ejecución
+                response = requests.get('http://localhost:9222/json/version', timeout=2)
+                if response.status_code == 200:
+                    logger.info('Reusing existing Chrome instance')
+                    chrome_options.debugger_address = "localhost:9222"
+                    self.driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=chrome_options)
+                    return self.driver
+            except requests.ConnectionError:
+                logger.debug('No existing Chrome instance found, starting a new one')
+
+            # Inicia una nueva instancia de Chrome
+            subprocess.Popen(
+                [
+                    self.config["chrome_instance_path"],
+                    '--remote-debugging-port=9222',
+                ],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+
+            # Intenta conectarse después de iniciar la instancia
+            for _ in range(10):
+                try:
+                    response = requests.get('http://localhost:9222/json/version', timeout=2)
+                    if response.status_code == 200:
+                        break
+                except requests.ConnectionError:
+                    pass
+                await asyncio.sleep(1)
+
+            try:
+                chrome_options.debugger_address = "localhost:9222"
+                self.driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=chrome_options)
+                return self.driver
+            except Exception as e:
+                logger.error(f'Failed to start a new Chrome instance: {str(e)}')
+                raise RuntimeError(
+                    'To start Chrome in Debug mode, close all existing Chrome instances and try again.'
+                )
+
+        # Inicia una nueva instancia de Chrome sin conexión a una instancia existente
+        else:
+            try:
+                self.driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=chrome_options)
+                return self.driver
+            except Exception as e:
+                logger.error(f'Failed to initialize Selenium browser: {str(e)}')
+                raise
+
+    async def close(self):
+        """Cierra el navegador."""
+        if self.driver:
+            self.driver.quit()