iflow-mcp_janspoerer-mcp_browser_use 0.1.0__py3-none-any.whl

mcp_browser_use/browser/chrome_launcher.py

@@ -0,0 +1,330 @@
+"""Chrome launch orchestration and command building."""
+
+import os
+import time
+import platform
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Tuple, Optional
+
+from .chrome_executable import get_chrome_binary_for_platform
+from .chrome_process import find_chrome_by_port, is_chrome_running_with_userdata
+
+# Import from sibling modules
+from .devtools import devtools_active_port_from_file, is_debugger_listening
+from .process import write_rendezvous, get_free_port
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+def build_chrome_command(
+    binary: str,
+    port: int,
+    user_data_dir: str,
+    profile_name: str,
+) -> list[str]:
+    """
+    Build Chrome command-line arguments for debugging.
+
+    Consolidates duplicated command building from 2 locations in start_or_attach_chrome_from_env.
+
+    Args:
+        binary: Path to Chrome executable
+        port: Remote debugging port
+        user_data_dir: Chrome user data directory
+        profile_name: Chrome profile name
+
+    Returns:
+        list[str]: Command-line arguments for Chrome
+    """
+    headless = os.getenv("MCP_HEADLESS", "0").strip()
+    is_headless = headless in ("1", "true", "True", "yes", "Yes")
+
+    cmd = [
+        binary,
+        f"--remote-debugging-port={port}",
+        f"--user-data-dir={user_data_dir}",
+        f"--profile-directory={profile_name}",
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--new-window",
+        "--disable-features=ProcessPerSite",
+        "--disable-gpu",
+        "--disable-dev-shm-usage",
+        "--disable-software-rasterizer",
+        "about:blank",
+    ]
+
+    if is_headless:
+        cmd.append("--headless=new")
+
+    # Load unpacked extensions from an external Extensions folder
+    # This prevents Chrome from auto-deleting extensions it doesn't recognize
+    enable_extensions = os.getenv("MCP_ENABLE_EXTENSIONS", "0").strip()
+
+    # Debug logging to file
+    debug_log_dir = Path(tempfile.gettempdir()) / "mcp_browser_logs"
+    debug_log_dir.mkdir(exist_ok=True)
+    debug_log_file = debug_log_dir / "extension_loading_debug.log"
+
+    with open(debug_log_file, "a") as f:
+        f.write(f"\n=== Extension Loading Debug {time.strftime('%Y-%m-%d %H:%M:%S')} ===\n")
+        f.write(f"MCP_ENABLE_EXTENSIONS env var: {enable_extensions}\n")
+        f.write(f"user_data_dir: {user_data_dir}\n")
+        f.write(f"profile_name: {profile_name}\n")
+
+    if enable_extensions in ("1", "true", "True", "yes", "Yes"):
+        # Load extensions from dedicated MCPExtensions folder
+        # This avoids conflicts with Chrome's internal extension management
+        if platform.system() == "Windows":
+            extensions_base_path = Path(os.path.expandvars(r"%USERPROFILE%\MCPExtensions"))
+        else:
+            extensions_base_path = Path(os.path.expanduser("~/MCPExtensions"))
+
+        with open(debug_log_file, "a") as f:
+            f.write(f"extensions_base_path: {extensions_base_path}\n")
+            f.write(f"extensions_base_path.exists(): {extensions_base_path.exists()}\n")
+
+        extension_paths = []
+        if extensions_base_path.exists():
+            # Scan all subdirectories in MCPExtensions for valid extensions
+            for extension_dir in extensions_base_path.iterdir():
+                if extension_dir.is_dir() and (extension_dir / "manifest.json").exists():
+                    extension_paths.append(str(extension_dir))
+
+        with open(debug_log_file, "a") as f:
+            f.write(f"Found {len(extension_paths)} extension(s)\n")
+            for path in extension_paths:
+                f.write(f"  - {path}\n")
+
+        if extension_paths:
+            # Join all extension paths with comma
+            load_ext_arg = f"--load-extension={','.join(extension_paths)}"
+            cmd.append(load_ext_arg)
+            logger.info(f"Loading {len(extension_paths)} extension(s): {extension_paths}")
+
+            with open(debug_log_file, "a") as f:
+                f.write(f"Added to command: {load_ext_arg}\n")
+                f.write(f"Full command: {' '.join(cmd)}\n")
+
+    return cmd
+
+
+def launch_chrome_process(
+    cmd: list[str],
+    port: int,
+) -> subprocess.Popen:
+    """
+    Launch Chrome process and verify it started.
+
+    Consolidates duplicated launch logic from 2 locations in start_or_attach_chrome_from_env.
+
+    Args:
+        cmd: Command-line arguments for Chrome
+        port: Remote debugging port (used for logging)
+
+    Returns:
+        subprocess.Popen: Chrome process
+
+    Note:
+        Does not raise if process exits immediately; caller should check proc.poll()
+    """
+    # Create error log file
+    log_dir = Path(tempfile.gettempdir()) / "mcp_browser_logs"
+    log_dir.mkdir(exist_ok=True)
+    error_log = log_dir / f"chrome_debug_{port}.log"
+
+    # Launch process
+    if platform.system() == "Windows":
+        proc = subprocess.Popen(
+            cmd,
+            creationflags=subprocess.CREATE_NO_WINDOW,
+            stdin=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL
+        )
+    else:
+        proc = subprocess.Popen(
+            cmd,
+            stdin=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL
+        )
+
+    # Verify Chrome started
+    time.sleep(2.0)
+    if proc.poll() is not None:
+        try:
+            with open(error_log, "r") as log:
+                error_content = log.read()
+                logger.error(f"Chrome failed to start. Exit code: {proc.returncode}. Log: {error_content}")
+        except Exception:
+            pass
+
+    return proc
+
+
+def wait_for_devtools_ready(
+    host: str,
+    port: int,
+    user_data_dir: str,
+    timeout_iterations: int = 100,
+) -> bool:
+    """
+    Wait for DevTools endpoint to become available.
+
+    Consolidates duplicated waiting logic from 2 locations in start_or_attach_chrome_from_env.
+
+    Args:
+        host: Debugger host (typically "127.0.0.1")
+        port: Remote debugging port
+        user_data_dir: Chrome user data directory (for error messages)
+        timeout_iterations: Number of 0.1s iterations to wait
+
+    Returns:
+        bool: True if endpoint is ready
+
+    Raises:
+        RuntimeError: If endpoint never appears with helpful diagnostic message
+    """
+    for _ in range(timeout_iterations):
+        if is_debugger_listening(host, port):
+            return True
+        time.sleep(0.1)
+
+    # If endpoint never appeared, provide helpful error
+    if is_chrome_running_with_userdata(user_data_dir):
+        raise RuntimeError(
+            "DevTools endpoint did not appear. Likely causes:\n"
+            " - Chrome refused remote debugging because the user-data-dir is a default channel directory.\n"
+            " - Another Chrome instance (started without --remote-debugging-port) is holding this user-data-dir.\n"
+            "Actions:\n"
+            f" - Use a separate automation dir (e.g., '{Path(user_data_dir).parent}/Chrome Beta MCP'), "
+            "optionally seeded from your profile, and try again.\n"
+            " - Or ensure all Chrome/Chrome Beta processes are fully quit before starting."
+        )
+
+    raise RuntimeError(f"Failed to start Chrome with remote debugging on {port}.")
+
+
+def try_attach_existing_chrome(
+    config: dict,
+    host: str,
+) -> Optional[Tuple[str, int, None]]:
+    """
+    Try to attach to existing Chrome instance via DevToolsActivePort.
+
+    Args:
+        config: Configuration dict with user_data_dir
+        host: Debugger host (typically "127.0.0.1")
+
+    Returns:
+        Optional[Tuple[str, int, None]]: (host, port, None) if successful, None otherwise
+    """
+    user_data_dir = config["user_data_dir"]
+
+    existing_port = devtools_active_port_from_file(user_data_dir)
+    if existing_port and is_debugger_listening(host, existing_port):
+        chrome_proc = find_chrome_by_port(existing_port)
+        write_rendezvous(config, existing_port, chrome_proc.pid if chrome_proc else os.getpid())
+        return host, existing_port, None
+
+    return None
+
+
+def launch_on_fixed_port(
+    config: dict,
+    host: str,
+    port: int,
+) -> Tuple[str, int, Optional[subprocess.Popen]]:
+    """
+    Launch Chrome on a fixed port or attach to existing instance.
+
+    Args:
+        config: Configuration dict with user_data_dir, profile_name
+        host: Debugger host (typically "127.0.0.1")
+        port: Fixed port to use
+
+    Returns:
+        Tuple[str, int, Optional[subprocess.Popen]]: (host, port, proc) where proc is None if attached to existing
+
+    Raises:
+        RuntimeError: If Chrome fails to start or DevTools endpoint doesn't appear
+    """
+    user_data_dir = config["user_data_dir"]
+    profile_name = config["profile_name"]
+
+    # Check if profile is already debuggable on a different port
+    existing_port = devtools_active_port_from_file(user_data_dir)
+    if existing_port and existing_port != port and is_debugger_listening(host, existing_port):
+        chrome_proc = find_chrome_by_port(existing_port)
+        write_rendezvous(config, existing_port, chrome_proc.pid if chrome_proc else os.getpid())
+        return host, existing_port, None
+
+    # Check if already listening on target port
+    if is_debugger_listening(host, port):
+        chrome_proc = find_chrome_by_port(port)
+        write_rendezvous(config, port, chrome_proc.pid if chrome_proc else os.getpid())
+        return host, port, None
+
+    # Launch Chrome on fixed port
+    binary = get_chrome_binary_for_platform(config)
+    cmd = build_chrome_command(binary, port, user_data_dir, profile_name)
+    proc = launch_chrome_process(cmd, port)
+
+    # Wait for DevTools
+    if wait_for_devtools_ready(host, port, user_data_dir):
+        chrome_proc = find_chrome_by_port(port)
+        write_rendezvous(config, port, chrome_proc.pid if chrome_proc else proc.pid)
+        return host, port, proc
+
+    raise RuntimeError(f"Failed to start Chrome with remote debugging on {port}.")
+
+
+def launch_on_dynamic_port(
+    config: dict,
+    host: str,
+) -> Tuple[str, int, subprocess.Popen]:
+    """
+    Launch Chrome on a dynamically assigned port.
+
+    Args:
+        config: Configuration dict with user_data_dir, profile_name
+        host: Debugger host (typically "127.0.0.1")
+
+    Returns:
+        Tuple[str, int, subprocess.Popen]: (host, port, proc)
+
+    Raises:
+        RuntimeError: If Chrome fails to start or DevTools endpoint doesn't appear
+    """
+    user_data_dir = config["user_data_dir"]
+    profile_name = config["profile_name"]
+
+    port = get_free_port()
+    binary = get_chrome_binary_for_platform(config)
+    cmd = build_chrome_command(binary, port, user_data_dir, profile_name)
+    proc = launch_chrome_process(cmd, port)
+
+    # Wait for DevTools
+    if wait_for_devtools_ready(host, port, user_data_dir):
+        chrome_proc = find_chrome_by_port(port)
+        if chrome_proc:
+            write_rendezvous(config, port, chrome_proc.pid)
+        else:
+            write_rendezvous(config, port, proc.pid)
+        return host, port, proc
+
+    raise RuntimeError("Failed to start Chrome with remote debugging; endpoint never came up.")
+
+
+__all__ = [
+    'build_chrome_command',
+    'launch_chrome_process',
+    'wait_for_devtools_ready',
+    'try_attach_existing_chrome',
+    'launch_on_fixed_port',
+    'launch_on_dynamic_port',
+]

mcp_browser_use/browser/chrome_process.py

@@ -0,0 +1,104 @@
+"""Chrome process discovery and management."""
+
+import time
+import subprocess
+from typing import Optional
+import psutil
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+def is_chrome_running_with_userdata(user_data_dir: str) -> bool:
+    """
+    Check if any Chrome process is running with the specified user-data-dir.
+
+    Args:
+        user_data_dir: Path to Chrome user data directory
+
+    Returns:
+        bool: True if a Chrome process is found with this user-data-dir
+    """
+    for p in psutil.process_iter(["name", "cmdline"]):
+        try:
+            if not p.info["name"] or "chrome" not in p.info["name"].lower():
+                continue
+            cmd = p.info.get("cmdline") or []
+            if any((arg or "").startswith("--user-data-dir=") and (arg.split("=", 1)[1].strip('"') == user_data_dir)
+                   for arg in cmd):
+                return True
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            continue
+    return False
+
+
+def find_chrome_by_port(port: int) -> Optional[psutil.Process]:
+    """
+    Find Chrome process listening on the specified debug port.
+
+    Args:
+        port: Remote debugging port number
+
+    Returns:
+        Optional[psutil.Process]: Chrome process if found, None otherwise
+    """
+    target = f"--remote-debugging-port={port}"
+    for p in psutil.process_iter(["name", "cmdline", "exe"]):
+        try:
+            if not p.info["name"]:
+                continue
+            if "chrome" not in p.info["name"].lower():
+                continue
+            cmd = p.info.get("cmdline") or []
+            if any(target in (arg or "") for arg in cmd):
+                return p
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            continue
+    return None
+
+
+def find_chrome_by_userdata(user_data_dir: str) -> Optional[psutil.Process]:
+    """
+    Find the first Chrome process using the specified user-data-dir.
+
+    Args:
+        user_data_dir: Path to Chrome user data directory
+
+    Returns:
+        Optional[psutil.Process]: Chrome process if found, None otherwise
+    """
+    for p in psutil.process_iter(["name", "cmdline"]):
+        try:
+            if not p.info["name"] or "chrome" not in p.info["name"].lower():
+                continue
+            cmd = p.info.get("cmdline") or []
+            if any((arg or "").startswith("--user-data-dir=") and
+                   (arg.split("=", 1)[1].strip('"') == user_data_dir)
+                   for arg in cmd):
+                return p
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            continue
+    return None
+
+
+def wait_for_process_stable(proc: subprocess.Popen, timeout: float = 2.0) -> bool:
+    """
+    Wait for process to stabilize and check if it's still running.
+
+    Args:
+        proc: Subprocess to check
+        timeout: Time to wait in seconds
+
+    Returns:
+        bool: True if process is running, False if it exited
+    """
+    time.sleep(timeout)
+    return proc.poll() is None
+
+
+__all__ = [
+    'is_chrome_running_with_userdata',
+    'find_chrome_by_port',
+    'find_chrome_by_userdata',
+    'wait_for_process_stable',
+]

mcp_browser_use/browser/devtools.py

@@ -0,0 +1,230 @@
+"""DevTools protocol operations."""
+
+import os
+import json
+import time
+import urllib.request
+from pathlib import Path
+from typing import Optional
+
+import logging
+logger = logging.getLogger(__name__)
+
+from ..context import get_context
+from ..constants import ALLOW_ATTACH_ANY
+
+
+def _read_devtools_active_port(user_data_dir: str) -> int | None:
+    """Read debug port from DevToolsActivePort file."""
+    p = Path(user_data_dir) / "DevToolsActivePort"
+    if not p.exists():
+        return None
+    try:
+        first = p.read_text().splitlines()[0].strip()
+        return int(first)
+    except Exception:
+        return None
+
+
+def _same_dir(a: str, b: str) -> bool:
+    """Check if two paths refer to the same directory."""
+    if not a or not b:
+        return False
+    try:
+        return Path(a).resolve() == Path(b).resolve()
+    except Exception:
+        return False
+
+
+def _devtools_user_data_dir(host: str, port: int, timeout: float = 1.5) -> str | None:
+    """Get user data directory from DevTools protocol."""
+    try:
+        with urllib.request.urlopen(f"http://{host}:{port}/json/version", timeout=timeout) as resp:
+            meta = json.load(resp)
+            return meta.get("userDataDir")
+    except Exception:
+        return None
+
+
+def _verify_port_matches_profile(host: str, port: int, expected_dir: str) -> bool:
+    """Verify that a debug port belongs to the expected profile."""
+    actual = _devtools_user_data_dir(host, port)
+    return _same_dir(actual, expected_dir)
+
+
+def is_debugger_listening(host: str, port: int, timeout: float = 3.0) -> bool:
+    """Check if Chrome DevTools debugger is listening on a port."""
+    try:
+        with urllib.request.urlopen(f"http://{host}:{port}/json/version", timeout=timeout) as resp:
+            return resp.status == 200
+    except Exception:
+        return False
+
+
+def devtools_active_port_from_file(user_data_dir: str) -> Optional[int]:
+    """
+    If Chrome is running this profile with remote debugging enabled,
+    it writes 'DevToolsActivePort' in the user-data-dir. Return that port if valid.
+    """
+    try:
+        p = Path(user_data_dir) / "DevToolsActivePort"
+        if not p.exists():
+            return None
+        lines = p.read_text().splitlines()
+        if not lines:
+            return None
+        first = lines[0].strip()
+        return int(first) if first.isdigit() else None
+    except Exception:
+        return None
+
+
+def _ensure_debugger_ready(cfg: dict, max_wait_secs: float | None = None) -> None:
+    """
+    Ensure a debuggable Chrome is running for the configured user-data-dir,
+    set debugger host/port in context.
+    """
+    from .process import _is_port_open
+    from .chrome import start_or_attach_chrome_from_env, _launch_chrome_with_debug
+
+    ctx = get_context()
+
+    try:
+        host, port, _ = start_or_attach_chrome_from_env(cfg)
+        if not (ALLOW_ATTACH_ANY or _verify_port_matches_profile(host, port, cfg["user_data_dir"])):
+            raise RuntimeError("DevTools port does not belong to the configured profile")
+        ctx.debugger_host = host
+        ctx.debugger_port = port
+        return
+    except Exception:
+        ctx.debugger_host = None
+        ctx.debugger_port = None
+
+    # Allow override by env; default to 10 seconds
+    try:
+        max_wait_secs = float(os.getenv("MCP_DEVTOOLS_MAX_WAIT_SECS", "10")) if max_wait_secs is None else float(max_wait_secs)
+    except Exception:
+        max_wait_secs = 10.0
+
+    udir = cfg["user_data_dir"]
+    env_port = os.getenv("CHROME_REMOTE_DEBUG_PORT")
+    try:
+        env_port = int(env_port) if env_port else None
+    except Exception:
+        env_port = None
+
+    # 1) If the profile already wrote DevToolsActivePort, try to attach to that.
+    file_port = _read_devtools_active_port(udir)
+    if file_port and _is_port_open("127.0.0.1", file_port):
+        ctx.debugger_host = "127.0.0.1"
+        ctx.debugger_port = file_port
+        return
+
+    # 2) If allowed, attach to a known open port
+    if ALLOW_ATTACH_ANY:
+        for p in filter(None, [env_port, 9223]):
+            if _is_port_open("127.0.0.1", p):
+                ctx.debugger_host = "127.0.0.1"
+                ctx.debugger_port = p
+                return
+
+    # 3) Launch our own debuggable Chrome
+    port = env_port or 9225
+    _launch_chrome_with_debug(cfg, port)
+
+    # Wait until Chrome writes the file OR the TCP port answers
+    t0 = time.time()
+    while time.time() - t0 < max_wait_secs:
+        p = _read_devtools_active_port(udir)
+        if (p and _is_port_open("127.0.0.1", p)) or _is_port_open("127.0.0.1", port):
+            ctx.debugger_host = "127.0.0.1"
+            ctx.debugger_port = p or port
+            return
+        time.sleep(0.1)
+
+    ctx.debugger_host = None
+    ctx.debugger_port = None
+
+
+def _handle_for_target(driver, target_id: Optional[str]) -> Optional[str]:
+    """Get window handle for a Chrome DevTools target ID."""
+    import time
+    
+    if not target_id:
+        return None
+
+    # Fast path: Selenium handle suffix matches CDP targetId
+    for h in driver.window_handles:
+        try:
+            if h.endswith(target_id):
+                return h
+        except Exception:
+            pass
+
+    # Nudge Chrome to foreground that target, then retry
+    try:
+        driver.execute_cdp_cmd("Target.activateTarget", {"targetId": target_id})
+    except Exception:
+        pass
+
+    for _ in range(20):  # ~1s total
+        for h in driver.window_handles:
+            try:
+                if h.endswith(target_id):
+                    return h
+            except Exception:
+                continue
+        time.sleep(0.05)
+
+    # Robust path: probe handles via CDP
+    current = driver.current_window_handle if driver.window_handles else None
+    try:
+        for h in driver.window_handles:
+            try:
+                driver.switch_to.window(h)
+                info = driver.execute_cdp_cmd("Target.getTargetInfo", {}) or {}
+                tid = (info.get("targetInfo") or {}).get("targetId") or info.get("targetId")
+                if tid == target_id:
+                    return h
+            except Exception:
+                continue
+
+        # Last resort: enumerate all targets
+        try:
+            targets = driver.execute_cdp_cmd("Target.getTargets", {}) or {}
+            for ti in (targets.get("targetInfos") or []):
+                if ti.get("targetId") == target_id:
+                    try:
+                        driver.execute_cdp_cmd("Target.activateTarget", {"targetId": target_id})
+                    except Exception:
+                        pass
+                    # One last quick scan
+                    for h in driver.window_handles:
+                        try:
+                            if h.endswith(target_id):
+                                return h
+                        except Exception:
+                            continue
+                    break
+        except Exception:
+            pass
+    finally:
+        if current and current in getattr(driver, "window_handles", []):
+            try:
+                driver.switch_to.window(current)
+            except Exception:
+                pass
+
+    return None
+
+
+__all__ = [
+    '_read_devtools_active_port',
+    'devtools_active_port_from_file',
+    '_devtools_user_data_dir',
+    '_verify_port_matches_profile',
+    '_same_dir',
+    'is_debugger_listening',
+    '_ensure_debugger_ready',
+    '_handle_for_target',
+]