Upload 3 files

src/custom_browser.py

@@ -0,0 +1,120 @@
+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

src/custom_context.py

@@ -0,0 +1,88 @@
+import json
+import logging
+import os
+
+from browser_use.browser.browser import Browser
+from browser_use.browser.context import BrowserContext, BrowserContextConfig
+from playwright.async_api import Browser as PlaywrightBrowser
+from playwright.async_api import BrowserContext as PlaywrightBrowserContext
+
+logger = logging.getLogger(__name__)
+
+
+class CustomBrowserContext(BrowserContext):
+    def __init__(
+        self,
+        browser: "Browser",
+        config: BrowserContextConfig = BrowserContextConfig()
+    ):
+        super(CustomBrowserContext, self).__init__(browser=browser, config=config)
+
+    async def _create_context(self, browser: PlaywrightBrowser) -> PlaywrightBrowserContext:
+        """Creates a new browser context with anti-detection measures and loads cookies if available."""
+        # If we have a context, return it directly
+
+        # Check if we should use existing context for persistence
+        if self.browser.config.chrome_instance_path and len(browser.contexts) > 0:
+            # Connect to existing Chrome instance instead of creating new one
+            context = browser.contexts[0]
+        else:
+            # Original code for creating new context
+            context = await browser.new_context(
+                viewport=self.config.browser_window_size,
+                no_viewport=False,
+                user_agent=(
+                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+                    "(KHTML, like Gecko) Chrome/85.0.4183.102 Safari/537.36"
+                ),
+                java_script_enabled=True,
+                bypass_csp=self.config.disable_security,
+                ignore_https_errors=self.config.disable_security,
+                record_video_dir=self.config.save_recording_path,
+                record_video_size=self.config.browser_window_size,
+            )
+
+        if self.config.trace_path:
+            await context.tracing.start(screenshots=True, snapshots=True, sources=True)
+
+        # Load cookies if they exist
+        if self.config.cookies_file and os.path.exists(self.config.cookies_file):
+            with open(self.config.cookies_file, "r") as f:
+                cookies = json.load(f)
+                logger.info(
+                    f"Loaded {len(cookies)} cookies from {self.config.cookies_file}"
+                )
+                await context.add_cookies(cookies)
+
+        # Expose anti-detection scripts
+        await context.add_init_script(
+            """
+            // Webdriver property
+            Object.defineProperty(navigator, 'webdriver', {
+                get: () => undefined
+            });
+
+            // Languages
+            Object.defineProperty(navigator, 'languages', {
+                get: () => ['en-US', 'en']
+            });
+
+            // Plugins
+            Object.defineProperty(navigator, 'plugins', {
+                get: () => [1, 2, 3, 4, 5]
+            });
+
+            // Chrome runtime
+            window.chrome = { runtime: {} };
+
+            // Permissions
+            const originalQuery = window.navigator.permissions.query;
+            window.navigator.permissions.query = (parameters) => (
+                parameters.name === 'notifications' ?
+                    Promise.resolve({ state: Notification.permission }) :
+                    originalQuery(parameters)
+            );
+            """
+        )
+
+        return context