feat(browser-agent): Centralize browser launch config for password manager support

guyernest · claude · guyernest · commit 4e67962dbdd3 · 2025-11-28T19:49:16.000-08:00
New browser_launch_config.py module: - Centralized configuration for all browser launch arguments - get_launch_options() returns consistent options across all entry points - Conditional --no-sandbox (only in containerized environments) - Environment detection via is_containerized_environment() - Support for BROWSER_LAUNCH_ARGS env var for custom args Key browser argument changes: - REMOVE --enable-automation: Hides "controlled by automation" bar, enables password save prompts and autofill - REMOVE --disable-component-extensions-with-background-pages: Enables password manager popup UI (critical for built-in and third-party managers) - ADD --disable-blink-features=AutomationControlled: Only for ephemeral sessions (hides navigator.webdriver flag) - ADD --no-sandbox: Only in Docker/container environments (security) Fixed computer_agent_wrapper.py: - Profile resolution now uses resolve_profile() for tag-based fallback - If profile_name not found, falls back to matching required_tags - setup_login now uses shared launch config for password manager support Updated openai_playwright_executor.py: - _init_browser() now uses shared get_launch_options() - Consistent arguments with profile setup and other entry points - Logs launch configuration for debugging 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
diff --git a/lambda/tools/local-browser-agent/python/browser_launch_config.py b/lambda/tools/local-browser-agent/python/browser_launch_config.py
@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""
+Browser Launch Configuration
+
+Centralized configuration for Playwright browser launch arguments.
+Ensures consistent browser behavior across all entry points:
+- Profile setup (setup_login)
+- Script execution (openai_playwright_executor, computer_agent_wrapper)
+- Testing
+
+Key Goals:
+1. Enable password manager functionality (both built-in and third-party)
+2. Remove "controlled by automation software" infobar
+3. Support containerized environments (Docker, etc.)
+4. Maintain security while enabling usability
+
+Reference: Nova Act SDK implementation
+"""
+
+import os
+import sys
+import platform
+from typing import List, Dict, Any, Optional
+
+
+def is_containerized_environment() -> bool:
+    """
+    Detect if running in a containerized environment (Docker, Kubernetes, etc.)
+
+    Returns:
+        True if running in a container, False otherwise
+    """
+    # Check for Docker
+    if os.path.exists("/.dockerenv"):
+        return True
+
+    # Check for environment variable
+    if os.environ.get("DOCKER_CONTAINER") or os.environ.get("CONTAINER"):
+        return True
+
+    # Check cgroup for container indicators
+    try:
+        with open("/proc/1/cgroup", "r") as f:
+            content = f.read()
+            if "docker" in content or "kubepods" in content or "containerd" in content:
+                return True
+    except (FileNotFoundError, PermissionError):
+        pass
+
+    return False
+
+
+def get_base_browser_args(
+    is_persistent_context: bool = True,
+    window_size: Optional[tuple] = None,
+    extra_args: Optional[List[str]] = None
+) -> List[str]:
+    """
+    Get base browser arguments that should be used for all launches.
+
+    Args:
+        is_persistent_context: Whether using persistent context (profile-based)
+        window_size: Optional (width, height) tuple for window size
+        extra_args: Additional custom arguments to include
+
+    Returns:
+        List of browser arguments
+    """
+    args = [
+        # Prevent /dev/shm OOM issues in containers and memory-constrained environments
+        "--disable-dev-shm-usage",
+    ]
+
+    # Add window size if specified
+    if window_size:
+        args.append(f"--window-size={window_size[0]},{window_size[1]}")
+
+    # Only add AutomationControlled flag for ephemeral (non-persistent) sessions
+    # For persistent sessions, we want the browser to behave normally
+    # This helps websites detect automation, but it's a tradeoff for profile stability
+    if not is_persistent_context:
+        args.append("--disable-blink-features=AutomationControlled")
+
+    # Cleaner debugging output (from Nova Act SDK)
+    args.append("--silent-debugger-extension-api")
+
+    # Allow Chrome DevTools remote connections (useful for debugging)
+    args.append("--remote-allow-origins=https://chrome-devtools-frontend.appspot.com")
+
+    # Add --no-sandbox only in containerized environments
+    # Security: --no-sandbox reduces Chrome's security on non-containerized systems
+    if is_containerized_environment():
+        args.append("--no-sandbox")
+        print("[INFO] Containerized environment detected, adding --no-sandbox", file=sys.stderr)
+
+    # Add user-provided extra arguments
+    if extra_args:
+        args.extend(extra_args)
+
+    # Add environment variable arguments (similar to Nova Act's NOVA_ACT_BROWSER_ARGS)
+    env_args = os.environ.get("BROWSER_LAUNCH_ARGS", "").strip()
+    if env_args:
+        args.extend(env_args.split())
+        print(f"[INFO] Added browser args from BROWSER_LAUNCH_ARGS: {env_args}", file=sys.stderr)
+
+    return args
+
+
+def get_ignore_default_args() -> List[str]:
+    """
+    Get list of default Playwright arguments to ignore/remove.
+
+    These are removed to enable password manager functionality:
+    - --enable-automation: When set, shows "controlled by automation" infobar
+      and disables some password manager features
+    - --disable-component-extensions-with-background-pages: When set, disables
+      background extension pages which breaks password manager popup UI
+    - --hide-scrollbars: Playwright hides scrollbars by default in headless,
+      but we want them visible for better UX in screenshots
+
+    Returns:
+        List of argument names to ignore
+    """
+    return [
+        # Remove automation flag to:
+        # 1. Hide "Chrome is being controlled by automated test software" infobar
+        # 2. Enable password manager save prompts
+        # 3. Enable password autofill on subsequent visits
+        "--enable-automation",
+
+        # Remove to enable password manager extension UI
+        # This is CRITICAL for password managers that use popups/bubbles
+        "--disable-component-extensions-with-background-pages",
+
+        # Show scrollbars for better UX (Nova Act SDK does this too)
+        "--hide-scrollbars",
+    ]
+
+
+def get_launch_options(
+    headless: bool = False,
+    browser_channel: Optional[str] = None,
+    is_persistent_context: bool = True,
+    window_size: Optional[tuple] = None,
+    ignore_https_errors: bool = True,
+    extra_args: Optional[List[str]] = None
+) -> Dict[str, Any]:
+    """
+    Get complete launch options for Playwright browser launch.
+
+    This is the main function to use for consistent browser launches.
+
+    Args:
+        headless: Whether to run in headless mode
+        browser_channel: Browser channel ('chrome', 'msedge', 'chromium', etc.)
+        is_persistent_context: Whether using persistent context
+        window_size: Optional (width, height) tuple
+        ignore_https_errors: Whether to ignore HTTPS certificate errors
+        extra_args: Additional custom arguments
+
+    Returns:
+        Dictionary of launch options for Playwright
+
+    Example:
+        ```python
+        from browser_launch_config import get_launch_options
+
+        options = get_launch_options(
+            headless=False,
+            browser_channel='msedge',
+            is_persistent_context=True
+        )
+
+        context = p.chromium.launch_persistent_context(
+            user_data_dir,
+            **options
+        )
+        ```
+    """
+    options = {
+        "headless": headless,
+        "args": get_base_browser_args(
+            is_persistent_context=is_persistent_context,
+            window_size=window_size,
+            extra_args=extra_args
+        ),
+        "ignore_default_args": get_ignore_default_args(),
+    }
+
+    # Add browser channel if specified (and not 'chromium' which is the default)
+    if browser_channel and browser_channel.lower() != "chromium":
+        options["channel"] = browser_channel
+
+    # Add HTTPS error handling
+    if ignore_https_errors:
+        options["ignore_https_errors"] = True
+
+    return options
+
+
+def get_default_browser_channel() -> str:
+    """
+    Get the default browser channel for the current platform.
+
+    Returns:
+        'msedge' on Windows, 'chrome' on other platforms
+    """
+    if platform.system() == "Windows":
+        return "msedge"
+    return "chrome"
+
+
+def log_launch_config(options: Dict[str, Any], context_type: str = "launch") -> None:
+    """
+    Log the browser launch configuration for debugging.
+
+    Args:
+        options: Launch options dictionary
+        context_type: Description of launch context (e.g., "profile_setup", "script_execution")
+    """
+    print(f"\n{'='*60}", file=sys.stderr)
+    print(f"Browser Launch Configuration ({context_type})", file=sys.stderr)
+    print(f"{'='*60}", file=sys.stderr)
+    print(f"  Headless: {options.get('headless', False)}", file=sys.stderr)
+    print(f"  Channel: {options.get('channel', 'chromium (default)')}", file=sys.stderr)
+    print(f"  Args: {options.get('args', [])}", file=sys.stderr)
+    print(f"  Ignored defaults: {options.get('ignore_default_args', [])}", file=sys.stderr)
+    print(f"  Container mode: {is_containerized_environment()}", file=sys.stderr)
+    print(f"{'='*60}\n", file=sys.stderr)
+
+
+# Convenience constants for common configurations
+PROFILE_SETUP_OPTIONS = {
+    "headless": False,  # Must be visible for manual login
+    "is_persistent_context": True,
+    "ignore_https_errors": True,
+}
+
+SCRIPT_EXECUTION_OPTIONS = {
+    "headless": False,  # Default to visible, can be overridden
+    "is_persistent_context": True,
+    "ignore_https_errors": True,
+}
+
+EPHEMERAL_SESSION_OPTIONS = {
+    "headless": False,
+    "is_persistent_context": False,  # Adds AutomationControlled flag
+    "ignore_https_errors": True,
+}
+
+
+if __name__ == "__main__":
+    # Test/demo the configuration
+    print("Browser Launch Configuration Demo")
+    print("-" * 40)
+
+    print("\n1. Profile Setup Options:")
+    options = get_launch_options(**PROFILE_SETUP_OPTIONS, browser_channel="msedge")
+    log_launch_config(options, "profile_setup")
+
+    print("\n2. Script Execution Options:")
+    options = get_launch_options(**SCRIPT_EXECUTION_OPTIONS, browser_channel="chrome")
+    log_launch_config(options, "script_execution")
+
+    print("\n3. Ephemeral Session Options:")
+    options = get_launch_options(**EPHEMERAL_SESSION_OPTIONS)
+    log_launch_config(options, "ephemeral")
+
+    print("\n4. Container Detection:")
+    print(f"  Is containerized: {is_containerized_environment()}")
diff --git a/lambda/tools/local-browser-agent/python/computer_agent_wrapper.py b/lambda/tools/local-browser-agent/python/computer_agent_wrapper.py
@@ -316,17 +316,35 @@ def execute_script(command: Dict[str, Any]) -> Dict[str, Any]:
             if not browser_channel:
                 browser_channel = 'msedge' if platform.system() == 'Windows' else 'chrome'
 
-            # Resolve profile if specified
+            # Resolve profile using tag-based resolution
+            # Priority: profile_name (exact match) -> required_tags (AND logic) -> temp profile -> error
             user_data_dir = None
             session_config = command.get('session', {})
             if session_config and isinstance(session_config, dict):
-                profile_name = session_config.get('profile_name')
-                if profile_name:
-                    profile_manager = ProfileManager()
-                    clone_for_parallel = session_config.get('clone_for_parallel', False)
-                    profile_config = profile_manager.get_nova_act_config(profile_name, clone_for_parallel=clone_for_parallel)
-                    user_data_dir = profile_config["user_data_dir"]
-                    print(f"[INFO] Using profile '{profile_name}' with user_data_dir: {user_data_dir}", file=sys.stderr)
+                profile_manager = ProfileManager()
+
+                # Use resolve_profile for tag-based resolution with fallback
+                try:
+                    resolved_profile = profile_manager.resolve_profile(session_config, verbose=True)
+
+                    if resolved_profile:
+                        # Successfully resolved a named profile
+                        clone_for_parallel = session_config.get('clone_for_parallel', False)
+                        profile_config = profile_manager.get_nova_act_config(
+                            resolved_profile["name"],
+                            clone_for_parallel=clone_for_parallel
+                        )
+                        user_data_dir = profile_config["user_data_dir"]
+                        print(f"[INFO] Resolved profile '{resolved_profile['name']}' (tags: {resolved_profile.get('tags', [])})", file=sys.stderr)
+                        print(f"[INFO] Using user_data_dir: {user_data_dir}", file=sys.stderr)
+                    else:
+                        # Using temporary profile (allow_temp_profile was True)
+                        print(f"[INFO] Using temporary profile (no persistent session)", file=sys.stderr)
+
+                except ValueError as e:
+                    # Profile resolution failed and temp not allowed
+                    print(f"[ERROR] Profile resolution failed: {e}", file=sys.stderr)
+                    raise
 
             # Create executor
             executor = OpenAIPlaywrightExecutor(
@@ -491,32 +509,29 @@ def setup_login(command: Dict[str, Any]) -> Dict[str, Any]:
         # We don't need LLM for manual login, so no API key required
         import time
         from playwright.sync_api import sync_playwright
+        from browser_launch_config import get_launch_options, log_launch_config
 
         print(f"Opening browser for manual login (no API key required)...", file=sys.stderr)
 
+        # Get consistent launch options for profile setup
+        # Key features:
+        # - Removes --enable-automation (hides "controlled by automation" bar)
+        # - Removes --disable-component-extensions-with-background-pages (enables password manager UI)
+        # - Adds --no-sandbox in containerized environments
+        launch_options = get_launch_options(
+            headless=False,  # Must be visible for manual login
+            browser_channel=browser_channel,
+            is_persistent_context=True,
+        )
+        log_launch_config(launch_options, "profile_setup")
+
         with sync_playwright() as p:
             # Launch browser with user_data_dir for session persistence
-            # Note: user_data_dir must be passed to launch_persistent_context, not to launch + new_context
-            if browser_channel == 'msedge':
-                context = p.chromium.launch_persistent_context(
-                    user_data_dir,
-                    channel='msedge',
-                    headless=False,
-                    ignore_https_errors=True,
-                )
-            elif browser_channel == 'chrome':
-                context = p.chromium.launch_persistent_context(
-                    user_data_dir,
-                    channel='chrome',
-                    headless=False,
-                    ignore_https_errors=True,
-                )
-            else:
-                context = p.chromium.launch_persistent_context(
-                    user_data_dir,
-                    headless=False,
-                    ignore_https_errors=True,
-                )
+            # Using shared launch configuration for password manager support
+            context = p.chromium.launch_persistent_context(
+                user_data_dir,
+                **launch_options
+            )
 
             # Create page and navigate
             page = context.new_page()
diff --git a/lambda/tools/local-browser-agent/python/openai_playwright_executor.py b/lambda/tools/local-browser-agent/python/openai_playwright_executor.py
