Merge pull request #83 from vvincent1234/fix/own_browser_on_mac

Fix using own browser on mac

Author: warmshao

src/agent/custom_agent.py

@@ -9,6 +9,10 @@
 import pdb
 import traceback
 from typing import Optional, Type
+from PIL import Image, ImageDraw, ImageFont
+import os
+import base64
+import io
 
 from browser_use.agent.prompts import SystemPrompt
 from browser_use.agent.service import Agent
@@ -227,6 +231,119 @@ async def step(self, step_info: Optional[CustomAgentStepInfo] = None) -> None:
                     )
             if state:
                 self._make_history_item(model_output, state, result)
+    def create_history_gif(
+            self,
+            output_path: str = 'agent_history.gif',
+            duration: int = 3000,
+            show_goals: bool = True,
+            show_task: bool = True,
+            show_logo: bool = False,
+            font_size: int = 40,
+            title_font_size: int = 56,
+            goal_font_size: int = 44,
+            margin: int = 40,
+            line_spacing: float = 1.5,
+    ) -> None:
+        """Create a GIF from the agent's history with overlaid task and goal text."""
+        if not self.history.history:
+            logger.warning('No history to create GIF from')
+            return
+
+        images = []
+        # if history is empty or first screenshot is None, we can't create a gif
+        if not self.history.history or not self.history.history[0].state.screenshot:
+            logger.warning('No history or first screenshot to create GIF from')
+            return
+
+        # Try to load nicer fonts
+        try:
+            # Try different font options in order of preference
+            font_options = ['Helvetica', 'Arial', 'DejaVuSans', 'Verdana']
+            font_loaded = False
+
+            for font_name in font_options:
+                try:
+                    import platform
+                    if platform.system() == "Windows":
+                        # Need to specify the abs font path on Windows
+                        font_name = os.path.join(os.getenv("WIN_FONT_DIR", "C:\\Windows\\Fonts"), font_name + ".ttf")
+                    regular_font = ImageFont.truetype(font_name, font_size)
+                    title_font = ImageFont.truetype(font_name, title_font_size)
+                    goal_font = ImageFont.truetype(font_name, goal_font_size)
+                    font_loaded = True
+                    break
+                except OSError:
+                    continue
+
+            if not font_loaded:
+                raise OSError('No preferred fonts found')
+
+        except OSError:
+            regular_font = ImageFont.load_default()
+            title_font = ImageFont.load_default()
+
+            goal_font = regular_font
+
+        # Load logo if requested
+        logo = None
+        if show_logo:
+            try:
+                logo = Image.open('./static/browser-use.png')
+                # Resize logo to be small (e.g., 40px height)
+                logo_height = 150
+                aspect_ratio = logo.width / logo.height
+                logo_width = int(logo_height * aspect_ratio)
+                logo = logo.resize((logo_width, logo_height), Image.Resampling.LANCZOS)
+            except Exception as e:
+                logger.warning(f'Could not load logo: {e}')
+
+        # Create task frame if requested
+        if show_task and self.task:
+            task_frame = self._create_task_frame(
+                self.task,
+                self.history.history[0].state.screenshot,
+                title_font,
+                regular_font,
+                logo,
+                line_spacing,
+            )
+            images.append(task_frame)
+
+        # Process each history item
+        for i, item in enumerate(self.history.history, 1):
+            if not item.state.screenshot:
+                continue
+
+            # Convert base64 screenshot to PIL Image
+            img_data = base64.b64decode(item.state.screenshot)
+            image = Image.open(io.BytesIO(img_data))
+
+            if show_goals and item.model_output:
+                image = self._add_overlay_to_image(
+                    image=image,
+                    step_number=i,
+                    goal_text=item.model_output.current_state.thought,
+                    regular_font=regular_font,
+                    title_font=title_font,
+                    margin=margin,
+                    logo=logo,
+                )
+
+            images.append(image)
+
+        if images:
+            # Save the GIF
+            images[0].save(
+                output_path,
+                save_all=True,
+                append_images=images[1:],
+                duration=duration,
+                loop=0,
+                optimize=False,
+            )
+            logger.info(f'Created GIF at {output_path}')
+        else:
+            logger.warning('No images found in history to create GIF')
 
     async def run(self, max_steps: int = 100) -> AgentHistoryList:
         """Execute the task with maximum number of steps"""
@@ -283,3 +400,6 @@ async def run(self, max_steps: int = 100) -> AgentHistoryList:
 
             if not self.injected_browser and self.browser:
                 await self.browser.close()
+
+            if self.generate_gif:
+                self.create_history_gif()

src/browser/custom_browser.py

@@ -4,6 +4,16 @@
 # @ProjectName: browser-use-webui
 # @FileName: browser.py
 
+import asyncio
+
+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
@@ -15,36 +25,102 @@
 logger = logging.getLogger(__name__)
 
 class CustomBrowser(Browser):
-    _global_context = None
 
     async def new_context(
         self,
-        config: BrowserContextConfig = BrowserContextConfig(),
-        context: PlaywrightBrowserContext = None,
+        config: BrowserContextConfig = BrowserContextConfig()
     ) -> CustomBrowserContext:
-        """Create a browser context with persistence support"""
-        persistence_config = BrowserPersistenceConfig.from_env()
-        
-        if persistence_config.persistent_session:
-            if CustomBrowser._global_context is not None:
-                logger.info("Reusing existing persistent browser context")
-                return CustomBrowser._global_context
-            
-            context_instance = CustomBrowserContext(config=config, browser=self, context=context)
-            CustomBrowser._global_context = context_instance
-            logger.info("Created new persistent browser context")
-            return context_instance
-        
-        logger.info("Creating non-persistent browser context")
-        return CustomBrowserContext(config=config, browser=self, context=context)
-
-    async def close(self):
-        """Override close to respect persistence setting"""
-        persistence_config = BrowserPersistenceConfig.from_env()
-        if not persistence_config.persistent_session:
-            if CustomBrowser._global_context is not None:
-                await CustomBrowser._global_context.close()
-                CustomBrowser._global_context = None
-            await super().close()
+        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:
-            logger.info("Skipping browser close due to persistent session")
+            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/browser/custom_context.py

@@ -22,22 +22,17 @@ class CustomBrowserContext(BrowserContext):
     def __init__(
         self,
         browser: "Browser",
-        config: BrowserContextConfig = BrowserContextConfig(),
-        context: PlaywrightBrowserContext = None,
+        config: BrowserContextConfig = BrowserContextConfig()
     ):
         super(CustomBrowserContext, self).__init__(browser=browser, config=config)
-        self.context = context
-        self._persistence_config = BrowserPersistenceConfig.from_env()
 
     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
-        if self.context:
-            return self.context
 
         # Check if we should use existing context for persistence
-        if self._persistence_config.persistent_session and len(browser.contexts) > 0:
-            logger.info("Using existing persistent context")
+        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
@@ -99,8 +94,3 @@ async def _create_context(self, browser: PlaywrightBrowser) -> PlaywrightBrowser
         )
 
         return context
-
-    async def close(self):
-        """Override close to respect persistence setting"""
-        if not self._persistence_config.persistent_session:
-            await super().close()