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

mcp_browser_use/actions/keyboard.py

@@ -0,0 +1,43 @@
+"""Keyboard input and scrolling."""
+
+from selenium.webdriver.common.keys import Keys
+
+from ..context import get_context
+
+
+def send_keys(keys_string: str) -> dict:
+    """Send keyboard input."""
+    ctx = get_context()
+    if not ctx.driver:
+        return {"ok": False, "error": "No driver available"}
+    try:
+        from selenium.webdriver.common.action_chains import ActionChains
+        ActionChains(ctx.driver).send_keys(keys_string).perform()
+        return {"ok": True}
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+
+
+def scroll(direction: str = "down", amount: int = 300) -> dict:
+    """Scroll the page."""
+    ctx = get_context()
+    if not ctx.driver:
+        return {"ok": False, "error": "No driver available"}
+    try:
+        if direction == "down":
+            ctx.driver.execute_script(f"window.scrollBy(0, {amount});")
+        elif direction == "up":
+            ctx.driver.execute_script(f"window.scrollBy(0, -{amount});")
+        elif direction == "top":
+            ctx.driver.execute_script("window.scrollTo(0, 0);")
+        elif direction == "bottom":
+            ctx.driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
+        return {"ok": True}
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+
+
+__all__ = [
+    'send_keys',
+    'scroll',
+]

mcp_browser_use/actions/navigation.py

@@ -0,0 +1,73 @@
+"""Navigation and page interaction."""
+
+import time
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+
+from ..context import get_context
+
+
+def _wait_document_ready(timeout: float = 10.0):
+    """Wait for document to be ready."""
+    ctx = get_context()
+    if not ctx.driver:
+        return
+
+    try:
+        WebDriverWait(ctx.driver, timeout).until(
+            lambda d: d.execute_script("return document.readyState") in ("interactive", "complete")
+        )
+    except Exception:
+        # Not fatal
+        pass
+
+
+def navigate_to_url(url: str) -> dict:
+    """Navigate to URL."""
+    ctx = get_context()
+    if not ctx.driver:
+        return {"ok": False, "error": "No driver available"}
+    try:
+        ctx.driver.get(url)
+        _wait_document_ready()
+        return {"ok": True}
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+
+
+def wait_for_element(selector: str, timeout: float = 10.0) -> dict:
+    """Wait for element to appear."""
+    ctx = get_context()
+    if not ctx.driver:
+        return {"ok": False, "error": "No driver available"}
+    try:
+        from selenium.webdriver.common.by import By
+        WebDriverWait(ctx.driver, timeout).until(
+            EC.presence_of_element_located((By.CSS_SELECTOR, selector))
+        )
+        return {"ok": True}
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+
+
+def get_current_page_meta() -> dict:
+    """Get current page metadata."""
+    ctx = get_context()
+    if not ctx.driver:
+        return {"ok": False, "error": "No driver available"}
+    try:
+        return {
+            "ok": True,
+            "url": ctx.driver.current_url,
+            "title": ctx.driver.title,
+        }
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+
+
+__all__ = [
+    '_wait_document_ready',
+    'navigate_to_url',
+    'wait_for_element',
+    'get_current_page_meta',
+]

mcp_browser_use/actions/screenshots.py

@@ -0,0 +1,85 @@
+"""Screenshot and page snapshot functionality."""
+
+import os
+import time
+import io
+import base64
+from typing import Optional
+
+from ..context import get_context
+
+
+def _make_page_snapshot() -> dict:
+    """
+    Capture the raw page snapshot (no cleaning, no truncation).
+    Returns a dict: {"url": str|None, "title": str|None, "html": str}
+    """
+    from .navigation import _wait_document_ready
+
+    ctx = get_context()
+    url = None
+    title = None
+    html = ""
+    try:
+        if ctx.driver is not None:
+            try:
+                ctx.driver.switch_to.default_content()
+            except Exception:
+                pass
+            try:
+                url = ctx.driver.current_url
+            except Exception:
+                url = None
+            try:
+                title = ctx.driver.title
+            except Exception:
+                title = None
+
+            # Ensure DOM is ready, then apply configurable settle
+            try:
+                _wait_document_ready(timeout=5.0)
+            except Exception:
+                pass
+            try:
+                settle_ms = int(os.getenv("SNAPSHOT_SETTLE_MS", "200") or "0")
+                if settle_ms > 0:
+                    time.sleep(settle_ms / 1000.0)
+            except Exception:
+                pass
+
+            # Prefer outerHTML; fall back to page_source
+            try:
+                html = ctx.driver.execute_script("return document.documentElement.outerHTML") or ""
+                if not html:
+                    html = ctx.driver.page_source or ""
+            except Exception:
+                try:
+                    html = ctx.driver.page_source or ""
+                except Exception:
+                    html = ""
+    except Exception:
+        pass
+    return {"url": url, "title": title, "html": html}
+
+
+def take_screenshot(filename: Optional[str] = None) -> dict:
+    """Take a screenshot."""
+    ctx = get_context()
+    if not ctx.driver:
+        return {"ok": False, "error": "No driver available"}
+    try:
+        if filename:
+            ctx.driver.save_screenshot(filename)
+            return {"ok": True, "path": filename}
+        else:
+            png_data = ctx.driver.get_screenshot_as_png()
+            b64 = base64.b64encode(png_data).decode('utf-8')
+            return {"ok": True, "data": b64}
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+
+
+__all__ = [
+    '_make_page_snapshot',
+    'take_screenshot',
+]

mcp_browser_use/browser/__init__.py

@@ -0,0 +1 @@
+"""Browser management module."""

mcp_browser_use/browser/chrome.py

@@ -0,0 +1,150 @@
+"""Chrome browser management - Main orchestration."""
+
+import os
+import time
+import platform
+from pathlib import Path
+from typing import Tuple, Optional
+import psutil
+
+# Import from refactored modules
+from .chrome_executable import validate_user_data_dir, get_chrome_binary_for_platform
+from .chrome_launcher import (
+    try_attach_existing_chrome,
+    launch_on_fixed_port,
+    launch_on_dynamic_port,
+    build_chrome_command,
+    launch_chrome_process,
+)
+from .chrome_process import find_chrome_by_port
+from .devtools import devtools_active_port_from_file, is_debugger_listening
+from .process import read_rendezvous, write_rendezvous
+from ..locking.file_mutex import acquire_start_lock, release_start_lock
+from ..constants import START_LOCK_WAIT_SEC
+
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+def _launch_chrome_with_debug(cfg: dict, port: int) -> None:
+    """
+    Launch Chrome with remote debugging on a specific port.
+
+    This is a simple wrapper around the chrome_launcher functions,
+    used by devtools.py when it needs to launch Chrome directly.
+
+    Args:
+        cfg: Configuration dict with user_data_dir, profile_name, chrome_path (optional)
+        port: Remote debugging port to use
+
+    Raises:
+        RuntimeError: If Chrome fails to launch
+    """
+    # Get Chrome binary
+    chrome_path = cfg.get("chrome_path")
+    if not chrome_path:
+        chrome_path = get_chrome_binary_for_platform()
+
+    # Build command
+    cmd = build_chrome_command(
+        binary=chrome_path,
+        port=port,
+        user_data_dir=cfg["user_data_dir"],
+        profile_name=cfg.get("profile_name", "Default"),
+    )
+
+    # Launch process
+    proc = launch_chrome_process(cmd, port)
+
+    # On Windows, Chrome's launcher process exits immediately after spawning background processes.
+    # This is normal behavior. Only check for immediate exit on non-Windows platforms.
+    if platform.system() != "Windows":
+        time.sleep(0.2)  # Brief wait to check if process exits immediately
+        if proc.poll() is not None:
+            raise RuntimeError(f"Chrome process exited immediately with code {proc.returncode}")
+
+    logger.info(f"Launched Chrome on port {port}, pid={proc.pid}")
+
+
+def start_or_attach_chrome_from_env(config: dict) -> Tuple[str, int, Optional[psutil.Process]]:
+    """
+    Start or attach to Chrome with remote debugging enabled.
+
+    This is the main orchestration function that coordinates:
+    1. Directory validation
+    2. Attempting to attach to existing Chrome
+    3. Launching on fixed or dynamic port
+    4. Rendezvous file management
+
+    Args:
+        config: Configuration dict with user_data_dir, profile_name, fixed_port (optional)
+
+    Returns:
+        Tuple of (host, port, proc) where proc is None if attached to existing Chrome
+
+    Raises:
+        RuntimeError: If Chrome fails to start or validation fails
+    """
+    user_data_dir = config["user_data_dir"]
+    fixed_port = config.get("fixed_port")
+    host = "127.0.0.1"
+
+    # Ensure directory exists
+    Path(user_data_dir).mkdir(parents=True, exist_ok=True)
+
+    # Validate directory
+    validate_user_data_dir(user_data_dir)
+
+    # Try to attach to existing Chrome first (if no fixed port specified)
+    if not fixed_port:
+        result = try_attach_existing_chrome(config, host)
+        if result:
+            return result
+
+    # Fixed port path
+    if fixed_port:
+        return launch_on_fixed_port(config, host, fixed_port)
+
+    # Rendezvous path (multi-process coordination)
+    port, pid = read_rendezvous(config)
+    if port:
+        return host, port, None
+
+    got_lock = acquire_start_lock(config, timeout_sec=START_LOCK_WAIT_SEC)
+    try:
+        if not got_lock:
+            # Wait for rendezvous by the process that got the lock
+            for _ in range(50):
+                port, pid = read_rendezvous(config)
+                if port:
+                    return host, port, None
+
+                # Also try attaching via DevToolsActivePort if it appears
+                p2 = devtools_active_port_from_file(user_data_dir)
+                if p2 and is_debugger_listening(host, p2):
+                    chrome_proc = find_chrome_by_port(p2)
+                    write_rendezvous(config, p2, chrome_proc.pid if chrome_proc else os.getpid())
+                    return host, p2, None
+
+                time.sleep(0.1)
+
+            raise RuntimeError("Timeout acquiring start lock for Chrome rendezvous.")
+
+        # Inside lock: recheck rendezvous
+        port, pid = read_rendezvous(config)
+        if port:
+            return host, port, None
+
+        # Launch Chrome on dynamic port
+        return launch_on_dynamic_port(config, host)
+
+    finally:
+        if got_lock:
+            release_start_lock(config)
+
+
+__all__ = [
+    'start_or_attach_chrome_from_env',
+    '_launch_chrome_with_debug',
+]

mcp_browser_use/browser/chrome_executable.py

@@ -0,0 +1,204 @@
+"""Chrome executable resolution, version detection, and directory validation."""
+
+import os
+import shutil
+import platform
+import subprocess
+from pathlib import Path
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+def resolve_chrome_executable(cfg: dict) -> str:
+    """
+    Resolve Chrome executable path from config or platform defaults.
+
+    Args:
+        cfg: Configuration dict with optional chrome_path, chrome_executable, etc.
+
+    Returns:
+        str: Path to Chrome executable
+
+    Raises:
+        FileNotFoundError: If Chrome executable cannot be found
+    """
+    if cfg.get("chrome_path"):
+        return cfg["chrome_path"]
+
+    # Try config keys first
+    candidates = [
+        cfg.get("chrome_executable"),
+        cfg.get("chrome_binary"),
+        cfg.get("chrome_executable_path"),
+        os.getenv("CHROME_EXECUTABLE_PATH"),
+    ]
+    # Common macOS fallbacks
+    defaults = [
+        "/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta",
+        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+    ]
+    for p in candidates + defaults:
+        if p and os.path.exists(p):
+            return p
+    raise FileNotFoundError(
+        "Chrome executable not found. Set CHROME_EXECUTABLE_PATH to the full binary path, "
+        "e.g. /Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta"
+    )
+
+
+def get_chrome_binary_for_platform(config: dict) -> str:
+    """
+    Get platform-specific Chrome binary path.
+
+    Tries to find Chrome binary based on the current platform.
+    Returns a reasonable default if not found.
+
+    Args:
+        config: Configuration dict with optional chrome_path
+
+    Returns:
+        str: Path to Chrome binary or "chrome" as fallback
+    """
+    if config.get("chrome_path"):
+        return config["chrome_path"]
+
+    system = platform.system()
+    candidates = []
+
+    if system == "Windows":
+        candidates = [
+            r"C:\Program Files\Google\Chrome Beta\Application\chrome.exe",
+            r"C:\Program Files (x86)\Google\Chrome Beta\Application\chrome.exe",
+            "chrome",
+        ]
+    elif system == "Darwin":
+        candidates = ["/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome"]
+    else:
+        candidates = ["google-chrome", "chrome", "chromium", "chromium-browser"]
+
+    for c in candidates:
+        if os.path.isfile(c) or shutil.which(c):
+            return c
+
+    return "chrome"
+
+
+def get_chrome_version() -> str:
+    """
+    Get Chrome version string from registry or executable.
+
+    Returns:
+        str: Chrome version string or error message
+    """
+    system = platform.system()
+    try:
+        if system == "Windows":
+            try:
+                import winreg
+                with winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Google\Chrome\BLBeacon") as key:
+                    version, _ = winreg.QueryValueEx(key, "version")
+                    return f"Google Chrome {version}"
+            except Exception:
+                pass
+            # Fallbacks
+            for candidate in [
+                r"C:\Program Files\Google\Chrome\Application\chrome.exe",
+                r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
+                "chrome",
+            ]:
+                try:
+                    path = candidate if os.path.isfile(candidate) else shutil.which(candidate)
+                    if path:
+                        out = subprocess.check_output([path, "--version"], stderr=subprocess.STDOUT).decode().strip()
+                        return out
+                except Exception:
+                    continue
+            return "Error fetching Chrome version: chrome binary not found"
+        elif system == "Darwin":
+            path = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+            out = subprocess.check_output([path, "--version"], stderr=subprocess.STDOUT).decode().strip()
+            return out
+        else:
+            for candidate in ["google-chrome", "chrome", "chromium", "chromium-browser"]:
+                try:
+                    path = shutil.which(candidate)
+                    if path:
+                        out = subprocess.check_output([path, "--version"], stderr=subprocess.STDOUT).decode().strip()
+                        return out
+                except Exception:
+                    continue
+            return "Error fetching Chrome version: chrome binary not found"
+    except Exception as e:
+        return f"Error fetching Chrome version: {e}"
+
+
+def is_default_user_data_dir(user_data_dir: str) -> bool:
+    """
+    Return True if user_data_dir is one of Chrome's default roots (where DevTools is refused).
+
+    Args:
+        user_data_dir: Path to Chrome user data directory
+
+    Returns:
+        bool: True if this is a default Chrome directory
+    """
+    p = Path(user_data_dir).expanduser().resolve()
+    system = platform.system()
+    defaults = []
+
+    if system == "Darwin":
+        defaults = [
+            Path.home() / "Library/Application Support/Google/Chrome",
+            Path.home() / "Library/Application Support/Google/Chrome Beta",
+            Path.home() / "Library/Application Support/Google/Chrome Canary",
+        ]
+    elif system == "Windows":
+        local = os.environ.get("LOCALAPPDATA", "")
+        if local:
+            base = Path(local) / "Google"
+            defaults = [
+                base / "Chrome" / "User Data",
+                base / "Chrome Beta" / "User Data",
+                base / "Chrome SxS" / "User Data",  # Canary
+            ]
+    else:  # Linux
+        home = Path.home()
+        defaults = [
+            home / ".config/google-chrome",
+            home / ".config/google-chrome-beta",
+            home / ".config/google-chrome-unstable",  # Canary
+            home / ".config/chromium",
+        ]
+
+    return any(p == d for d in defaults)
+
+
+def validate_user_data_dir(user_data_dir: str) -> None:
+    """
+    Validate user_data_dir and raise if it's a default directory.
+
+    Args:
+        user_data_dir: Path to Chrome user data directory
+
+    Raises:
+        RuntimeError: If user_data_dir is a default Chrome directory
+    """
+    if is_default_user_data_dir(user_data_dir):
+        if os.getenv("MCP_ALLOW_DEFAULT_USER_DATA_DIR", "0") != "1":
+            raise RuntimeError(
+                "Remote debugging is disabled on Chrome's default user-data directories.\n"
+                f"Set *_PROFILE_USER_DATA_DIR to a separate path (e.g., '{Path(user_data_dir).parent}/Chrome Beta MCP'), "
+                "optionally seed it from your existing profile, then retry.\n"
+                "To override (not recommended), set MCP_ALLOW_DEFAULT_USER_DATA_DIR=1."
+            )
+
+
+__all__ = [
+    'resolve_chrome_executable',
+    'get_chrome_binary_for_platform',
+    'get_chrome_version',
+    'is_default_user_data_dir',
+    'validate_user_data_dir',
+]