add browser-use agent run

Author: vvincent1234

src/agent/deep_research_agent.py renamed to src/agent/deep_research/deep_research_agent.py

@@ -9,11 +9,23 @@
     Playwright,
     async_playwright,
 )
-from browser_use.browser.browser import Browser
+from browser_use.browser.browser import Browser, IN_DOCKER
 from browser_use.browser.context import BrowserContext, BrowserContextConfig
 from playwright.async_api import BrowserContext as PlaywrightBrowserContext
 import logging
 
+from browser_use.browser.chrome import (
+	CHROME_ARGS,
+	CHROME_DETERMINISTIC_RENDERING_ARGS,
+	CHROME_DISABLE_SECURITY_ARGS,
+	CHROME_DOCKER_ARGS,
+	CHROME_HEADLESS_ARGS,
+)
+from browser_use.browser.context import BrowserContext, BrowserContextConfig
+from browser_use.browser.utils.screen_resolution import get_screen_resolution, get_window_adjustments
+from browser_use.utils import time_execution_async
+import socket
+
 from .custom_context import CustomBrowserContext
 
 logger = logging.getLogger(__name__)
@@ -26,3 +38,62 @@ async def new_context(
             config: BrowserContextConfig = BrowserContextConfig()
     ) -> CustomBrowserContext:
         return CustomBrowserContext(config=config, browser=self)
+
+    async def _setup_builtin_browser(self, playwright: Playwright) -> PlaywrightBrowser:
+        """Sets up and returns a Playwright Browser instance with anti-detection measures."""
+        assert self.config.browser_binary_path is None, 'browser_binary_path should be None if trying to use the builtin browsers'
+
+        if self.config.headless:
+            screen_size = {'width': 1920, 'height': 1080}
+            offset_x, offset_y = 0, 0
+        else:
+            screen_size = get_screen_resolution()
+            offset_x, offset_y = get_window_adjustments()
+
+        chrome_args = {
+            *CHROME_ARGS,
+            *(CHROME_DOCKER_ARGS if IN_DOCKER else []),
+            *(CHROME_HEADLESS_ARGS if self.config.headless else []),
+            *(CHROME_DISABLE_SECURITY_ARGS if self.config.disable_security else []),
+            *(CHROME_DETERMINISTIC_RENDERING_ARGS if self.config.deterministic_rendering else []),
+            f'--window-position={offset_x},{offset_y}',
+            *self.config.extra_browser_args,
+        }
+        contain_window_size = False
+        for arg in self.config.extra_browser_args:
+            if "--window-size" in arg:
+                contain_window_size = True
+                break
+        if not contain_window_size:
+            chrome_args.add(f'--window-size={screen_size["width"]},{screen_size["height"]}')
+
+        # check if port 9222 is already taken, if so remove the remote-debugging-port arg to prevent conflicts
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            if s.connect_ex(('localhost', 9222)) == 0:
+                chrome_args.remove('--remote-debugging-port=9222')
+
+        browser_class = getattr(playwright, self.config.browser_class)
+        args = {
+            'chromium': list(chrome_args),
+            'firefox': [
+                *{
+                    '-no-remote',
+                    *self.config.extra_browser_args,
+                }
+            ],
+            'webkit': [
+                *{
+                    '--no-startup-window',
+                    *self.config.extra_browser_args,
+                }
+            ],
+        }
+
+        browser = await browser_class.launch(
+            headless=self.config.headless,
+            args=args[self.config.browser_class],
+            proxy=self.config.proxy.model_dump() if self.config.proxy else None,
+            handle_sigterm=False,
+            handle_sigint=False,
+        )
+        return browser

src/browser/custom_browser.py

@@ -2,18 +2,112 @@
 import logging
 import os
 
-from browser_use.browser.browser import Browser
+from browser_use.browser.browser import Browser, IN_DOCKER
 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 CustomBrowserContextConfig(BrowserContextConfig):
+    force_new_context: bool = False  # force to create new context
+
+
 class CustomBrowserContext(BrowserContext):
     def __init__(
             self,
             browser: "Browser",
-            config: BrowserContextConfig = BrowserContextConfig()
+            config: CustomBrowserContextConfig = CustomBrowserContextConfig(),
     ):
         super(CustomBrowserContext, self).__init__(browser=browser, config=config)
+
+    async def _create_context(self, browser: PlaywrightBrowser):
+        """Creates a new browser context with anti-detection measures and loads cookies if available."""
+        if not self.config.force_new_context and self.browser.config.cdp_url and len(browser.contexts) > 0:
+            context = browser.contexts[0]
+        elif not self.config.force_new_context and self.browser.config.browser_binary_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(
+                no_viewport=True,
+                user_agent=self.config.user_agent,
+                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.model_dump(),
+                record_har_path=self.config.save_har_path,
+                locale=self.config.locale,
+                http_credentials=self.config.http_credentials,
+                is_mobile=self.config.is_mobile,
+                has_touch=self.config.has_touch,
+                geolocation=self.config.geolocation,
+                permissions=self.config.permissions,
+                timezone_id=self.config.timezone_id,
+            )
+
+        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:
+                try:
+                    cookies = json.load(f)
+
+                    valid_same_site_values = ['Strict', 'Lax', 'None']
+                    for cookie in cookies:
+                        if 'sameSite' in cookie:
+                            if cookie['sameSite'] not in valid_same_site_values:
+                                logger.warning(
+                                    f"Fixed invalid sameSite value '{cookie['sameSite']}' to 'None' for cookie {cookie.get('name')}"
+                                )
+                                cookie['sameSite'] = 'None'
+                    logger.info(f'🍪  Loaded {len(cookies)} cookies from {self.config.cookies_file}')
+                    await context.add_cookies(cookies)
+
+                except json.JSONDecodeError as e:
+                    logger.error(f'Failed to parse cookies file: {str(e)}')
+
+        # 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']
+            });
+
+            // 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)
+            );
+            (function () {
+                const originalAttachShadow = Element.prototype.attachShadow;
+                Element.prototype.attachShadow = function attachShadow(options) {
+                    return originalAttachShadow.call(this, { ...options, mode: "open" });
+                };
+            })();
+            """
+        )
+
+        return context

src/browser/custom_context.py

@@ -48,28 +48,6 @@ def __init__(self, exclude_actions: list[str] = [],
         self.mcp_client = None
         self.mcp_server_config = None
 
-    async def setup_mcp_client(self, mcp_server_config: Optional[Dict[str, Any]] = None):
-        self.mcp_server_config = mcp_server_config
-        if self.mcp_server_config:
-            self.mcp_client = await setup_mcp_client_and_tools(self.mcp_server_config)
-            self.register_mcp_tools()
-
-    def register_mcp_tools(self):
-        """
-        Register the MCP tools used by this controller.
-        """
-        if self.mcp_client:
-            for server_name in self.mcp_client.server_name_to_tools:
-                for tool in self.mcp_client.server_name_to_tools[server_name]:
-                    tool_name = f"mcp.{server_name}.{tool.name}"
-                    self.registry.registry.actions[tool_name] = RegisteredAction(
-                        name=tool_name,
-                        description=tool.description,
-                        function=tool,
-                        param_model=create_tool_param_model(tool),
-                    )
-                    logger.info(f"Add mcp tool: {tool_name}")
-
     def _register_custom_actions(self):
         """Register all custom browser actions"""
 
@@ -173,6 +151,28 @@ async def act(
         except Exception as e:
             raise e
 
+    async def setup_mcp_client(self, mcp_server_config: Optional[Dict[str, Any]] = None):
+        self.mcp_server_config = mcp_server_config
+        if self.mcp_server_config:
+            self.mcp_client = await setup_mcp_client_and_tools(self.mcp_server_config)
+            self.register_mcp_tools()
+
+    def register_mcp_tools(self):
+        """
+        Register the MCP tools used by this controller.
+        """
+        if self.mcp_client:
+            for server_name in self.mcp_client.server_name_to_tools:
+                for tool in self.mcp_client.server_name_to_tools[server_name]:
+                    tool_name = f"mcp.{server_name}.{tool.name}"
+                    self.registry.registry.actions[tool_name] = RegisteredAction(
+                        name=tool_name,
+                        description=tool.description,
+                        function=tool,
+                        param_model=create_tool_param_model(tool),
+                    )
+                    logger.info(f"Add mcp tool: {tool_name}")
+
     async def close_mcp_client(self):
         if self.mcp_client:
             await self.mcp_client.__aexit__(None, None, None)

src/controller/custom_controller.py

@@ -40,7 +40,13 @@ async def setup_mcp_client_and_tools(mcp_server_config: Dict[str, Any]) -> Optio
 
     logger.info("Initializing MultiServerMCPClient...")
 
+    if not mcp_server_config:
+        logger.error("No MCP server configuration provided.")
+        return None
+
     try:
+        if "mcpServers" in mcp_server_config:
+            mcp_server_config = mcp_server_config["mcpServers"]
         client = MultiServerMCPClient(mcp_server_config)
         await client.__aenter__()
         return client