Resolves Ruff formatting woes.

Author: benjaminr

src/cdp_context.py

@@ -15,7 +15,7 @@
 Example:
     ```python
     from .cdp_context import require_cdp_client
-    
+
     @require_cdp_client
     async def my_tool_function(cdp_client):
         # CDP client is guaranteed to be connected
@@ -39,21 +39,21 @@ async def my_tool_function(cdp_client):
 def require_cdp_client(func: F) -> F:
     """
     Decorator that provides CDP client to tool functions with automatic validation.
-    
+
     This decorator eliminates the need for repetitive client access and connection
     checking in every tool function. It automatically:
-    
+
     1. Imports the CDP client from the main module
     2. Validates that the client exists and is connected
     3. Passes the validated client as the first parameter to the decorated function
     4. Returns appropriate error responses if client is unavailable
-    
+
     Args:
         func: The async function to decorate. Must accept cdp_client as first parameter.
-        
+
     Returns:
         The decorated function with automatic CDP client injection.
-        
+
     Example:
         ```python
         @require_cdp_client
@@ -65,47 +65,47 @@ async def get_page_title(cdp_client, **kwargs):
             return {"title": result["result"]["value"]}
         ```
     """
-    
+
     @wraps(func)
     async def wrapper(*args: Any, **kwargs: Any) -> Any:
         try:
             # Import CDP client dynamically to avoid circular imports
             from . import main
-            
+
             cdp_client = main.cdp_client
-            
+
             # Validate client availability and connection status
             if not cdp_client:
                 return create_error_response(
                     "CDP client not initialised. Please start Chrome first."
                 )
-            
+
             if not cdp_client.connected:
                 return create_error_response(
                     "Not connected to browser. Please connect to Chrome first."
                 )
-            
+
             # Call the original function with CDP client as first argument
             return await func(cdp_client, *args, **kwargs)
-            
+
         except ImportError:
             return create_error_response(
                 "CDP client module not available. Please check server configuration."
             )
         except Exception as e:
             return create_error_response(f"CDP context error: {str(e)}")
-    
+
     return wrapper
 
 
 class CDPContext:
     """
     Context manager for Chrome DevTools Protocol operations.
-    
+
     Provides a more explicit context-based approach for operations that require
     multiple CDP interactions. This is useful for complex operations that need
     to ensure the connection remains stable throughout the operation.
-    
+
     Example:
         ```python
         async with CDPContext() as cdp:
@@ -114,41 +114,41 @@ class CDPContext:
             result = await cdp.send_command("DOM.getDocument")
         ```
     """
-    
+
     def __init__(self) -> None:
         """Initialise the CDP context manager."""
         self.cdp_client = None
-    
+
     async def __aenter__(self):
         """
         Enter the async context and validate CDP client.
-        
+
         Returns:
             The validated CDP client instance.
-            
+
         Raises:
             RuntimeError: If CDP client is not available or not connected.
         """
         try:
             from . import main
-            
+
             self.cdp_client = main.cdp_client
-            
+
             if not self.cdp_client:
                 raise RuntimeError("CDP client not initialised. Please start Chrome first.")
-            
+
             if not self.cdp_client.connected:
                 raise RuntimeError("Not connected to browser. Please connect to Chrome first.")
-            
+
             return self.cdp_client
-            
+
         except ImportError as e:
             raise RuntimeError("CDP client module not available.") from e
-    
+
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """
         Exit the async context.
-        
+
         Currently performs no cleanup, but provides a hook for future
         connection management improvements.
         """
@@ -158,14 +158,14 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
 def get_cdp_client():
     """
     Get the current CDP client instance without validation.
-    
+
     This function provides direct access to the CDP client for cases where
     you need to check its status or perform conditional operations based on
     availability.
-    
+
     Returns:
         ChromeDevToolsClient | None: The CDP client instance or None if not available.
-        
+
     Example:
         ```python
         cdp = get_cdp_client()
@@ -178,4 +178,4 @@ def get_cdp_client():
         from . import main
         return main.cdp_client
     except ImportError:
-        return None
+        return None

src/main.py

@@ -11,7 +11,7 @@
 
 The server provides tools for:
 - Browser automation and management
-- Network request monitoring and analysis  
+- Network request monitoring and analysis
 - DOM inspection and manipulation
 - Console log retrieval and filtering
 - Performance metrics collection
@@ -64,18 +64,18 @@
 class ChromeDevToolsClient:
     """
     Chrome DevTools Protocol client with WebSocket communication capabilities.
-    
+
     This class manages the connection to Chrome's remote debugging interface,
     handles event processing, and executes CDP commands. It maintains state
     for network requests and console logs, and provides a robust interface
     for web application debugging.
-    
+
     The client automatically discovers available Chrome targets and establishes
     WebSocket connections for real-time communication with the browser.
-    
+
     Attributes:
         port: Chrome remote debugging port (default: 9222)
-        host: Hostname for Chrome connection (default: localhost)  
+        host: Hostname for Chrome connection (default: localhost)
         ws: WebSocket connection to Chrome DevTools
         connected: Connection status flag
         message_id: Incremental ID for CDP messages
@@ -88,7 +88,7 @@ class ChromeDevToolsClient:
     def __init__(self, port: int = 9222, host: str = "localhost") -> None:
         """
         Initialise the Chrome DevTools Protocol client.
-        
+
         Args:
             port: Chrome remote debugging port (overridden by CHROME_DEBUG_PORT env var)
             host: Hostname for Chrome connection
@@ -113,14 +113,14 @@ def __init__(self, port: int = 9222, host: str = "localhost") -> None:
     async def connect(self) -> bool:
         """
         Establish connection to Chrome DevTools via WebSocket.
-        
+
         Discovers available Chrome targets and connects to the first available
         target using WebSocket communication. Starts the message handling loop
         for processing incoming CDP events and responses.
-        
+
         Returns:
             bool: True if connection successful, False otherwise
-            
+
         Raises:
             ConnectionError: If no browser targets are available
         """

src/tools/__init__.py

@@ -20,11 +20,11 @@
 
 Example:
     Basic usage pattern for tool registration:
-    
+
     ```python
     from mcp.server.fastmcp import FastMCP
     from .chrome_management import register_chrome_tools
-    
+
     mcp = FastMCP("devtools-server")
     register_chrome_tools(mcp)
     ```