Update app.py

app.py

@@ -1,1922 +1,18 @@
+"""
+Main application entry point for MCP Browser
+"""
 import gradio as gr
-from selenium import webdriver
-from selenium.webdriver.chrome.service import Service
-from selenium.webdriver.chrome.options import Options
-from selenium.webdriver.common.by import By
-from selenium.webdriver.support.ui import WebDriverWait
-from selenium.webdriver.support import expected_conditions as EC
-from selenium.webdriver.common.keys import Keys
-from selenium.webdriver.common.action_chains import ActionChains
-from webdriver_manager.chrome import ChromeDriverManager
-from webdriver_manager.core.os_manager import ChromeType
-import time
 import logging
-import os
-import json
-import base64
-from typing import Dict, List, Any, Tuple
-import hashlib
-from datetime import datetime
-import re
-import requests
+from config.settings import UI_CSS, GEMINI_API_KEY
+from ui.layout import create_main_layout
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Global browser session (optional - for persistent sessions)
-_driver = None
-
-# Request history storage
-_request_history = []
-
-# Chat history storage
-_chat_history = []
-
-# Get Gemini API key from secrets
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-
-def chat_with_gemini(message: str, history: List[List[str]]) -> Tuple[str, List[List[str]]]:
-    """Chat with Gemini API"""
-    global _chat_history
-    
-    if not GEMINI_API_KEY:
-        return "Please set your GEMINI_API_KEY in the Hugging Face secrets settings.", history
-    
-    try:
-        # Gemini API endpoint
-        url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent?key={GEMINI_API_KEY}"
-        
-        # Build conversation history
-        contents = []
-        
-        # Add previous messages from history
-        for user_msg, assistant_msg in history:
-            if user_msg:
-                contents.append({
-                    "role": "user",
-                    "parts": [{"text": user_msg}]
-                })
-            if assistant_msg:
-                contents.append({
-                    "role": "model",
-                    "parts": [{"text": assistant_msg}]
-                })
-        
-        # Add current message
-        contents.append({
-            "role": "user",
-            "parts": [{"text": message}]
-        })
-        
-        # Prepare request
-        data = {
-            "contents": contents,
-            "generationConfig": {
-                "temperature": 0.7,
-                "topK": 40,
-                "topP": 0.95,
-                "maxOutputTokens": 1024,
-            },
-            "safetySettings": [
-                {
-                    "category": "HARM_CATEGORY_HARASSMENT",
-                    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
-                },
-                {
-                    "category": "HARM_CATEGORY_HATE_SPEECH",
-                    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
-                },
-                {
-                    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
-                    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
-                },
-                {
-                    "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
-                    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
-                }
-            ]
-        }
-        
-        # Make request
-        headers = {"Content-Type": "application/json"}
-        response = requests.post(url, headers=headers, json=data)
-        response.raise_for_status()
-        
-        # Parse response
-        result = response.json()
-        
-        # Extract text from response
-        if "candidates" in result and len(result["candidates"]) > 0:
-            candidate = result["candidates"][0]
-            if "content" in candidate and "parts" in candidate["content"]:
-                parts = candidate["content"]["parts"]
-                if len(parts) > 0 and "text" in parts[0]:
-                    bot_response = parts[0]["text"]
-                    
-                    # Update history
-                    history.append([message, bot_response])
-                    _chat_history = history
-                    
-                    return bot_response, history
-        
-        return "I couldn't generate a response. Please try again.", history
-        
-    except requests.exceptions.HTTPError as e:
-        if e.response.status_code == 403:
-            return "API key is invalid or doesn't have access to Gemini. Please check your GEMINI_API_KEY.", history
-        else:
-            return f"API Error: {e.response.status_code} - {e.response.text}", history
-    except Exception as e:
-        return f"Error: {str(e)}", history
-
-def clear_chat():
-    """Clear chat history"""
-    global _chat_history
-    _chat_history = []
-    return None, []
-
-def _make_driver(persistent=False):
-    """Create Chrome driver with proper configuration"""
-    global _driver
-    
-    # If persistent and driver exists, return it
-    if persistent and _driver:
-        try:
-            # Check if driver is still alive
-            _driver.title
-            return _driver
-        except:
-            # Driver is dead, create new one
-            _driver = None
-    
-    try:
-        chrome_options = Options()
-        
-        # Detect Chromium binary location
-        chromium_paths = [
-            "/usr/bin/chromium",
-            "/usr/bin/chromium-browser",
-            "/usr/bin/google-chrome",
-            "/usr/bin/google-chrome-stable"
-        ]
-        
-        chromium_binary = None
-        for path in chromium_paths:
-            if os.path.exists(path):
-                chromium_binary = path
-                logger.info(f"Found Chromium at: {path}")
-                break
-        
-        if chromium_binary:
-            chrome_options.binary_location = chromium_binary
-        
-        # Essential headless options for Hugging Face Spaces
-        chrome_options.add_argument("--headless")
-        chrome_options.add_argument("--no-sandbox")
-        chrome_options.add_argument("--disable-dev-shm-usage")
-        chrome_options.add_argument("--disable-gpu")
-        chrome_options.add_argument("--disable-web-security")
-        chrome_options.add_argument("--disable-features=VizDisplayCompositor")
-        chrome_options.add_argument("--disable-setuid-sandbox")
-        
-        # Performance options
-        chrome_options.add_argument("--memory-pressure-off")
-        chrome_options.add_argument("--max_old_space_size=4096")
-        chrome_options.add_argument("--disable-background-timer-throttling")
-        chrome_options.add_argument("--disable-renderer-backgrounding")
-        chrome_options.add_argument("--disable-features=TranslateUI")
-        chrome_options.add_argument("--disable-ipc-flooding-protection")
-        
-        # Window size
-        chrome_options.add_argument("--window-size=1920,1080")
-        
-        # Enable automation
-        chrome_options.add_argument("--enable-automation")
-        
-        # User agent to appear more like a real browser
-        chrome_options.add_argument("--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
-        
-        # Enable Chrome DevTools Protocol
-        chrome_options.add_argument("--enable-logging")
-        chrome_options.add_argument("--v=1")
-        
-        # Try multiple driver installation methods
-        try:
-            # Method 1: Use system chromium-driver if available
-            if os.path.exists("/usr/bin/chromedriver"):
-                service = Service("/usr/bin/chromedriver")
-                logger.info("Using system chromedriver")
-            else:
-                # Method 2: Use webdriver-manager with ChromeType.CHROMIUM
-                service = Service(ChromeDriverManager(chrome_type=ChromeType.CHROMIUM).install())
-                logger.info("Using webdriver-manager chromedriver")
-        except Exception as e:
-            logger.warning(f"ChromeType.CHROMIUM failed: {e}")
-            # Method 3: Fallback to regular Chrome driver
-            service = Service(ChromeDriverManager().install())
-            logger.info("Using fallback Chrome driver")
-        
-        driver = webdriver.Chrome(service=service, options=chrome_options)
-        driver.set_page_load_timeout(30)
-        driver.implicitly_wait(10)
-        
-        if persistent:
-            _driver = driver
-        
-        return driver
-        
-    except Exception as e:
-        logger.error(f"Failed to create driver: {e}")
-        raise
-
-def close_persistent_driver():
-    """Close the persistent driver if it exists"""
-    global _driver
-    if _driver:
-        try:
-            _driver.quit()
-        except:
-            pass
-        _driver = None
-        return "Persistent browser closed"
-    return "No persistent browser to close"
-
-def browse_and_extract(url: str, selector: str = "body", use_persistent: bool = False) -> str:
-    """Browse URL and extract text from selector"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        logger.info(f"Navigating to: {url}")
-        driver.get(url)
-        
-        # Wait for element to be present
-        wait = WebDriverWait(driver, 10)
-        elem = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, selector)))
-        
-        text = elem.text
-        logger.info(f"Extracted {len(text)} characters")
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return text
-    except Exception as e:
-        logger.error(f"Error in browse_and_extract: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def screenshot(url: str, full_page: bool = False, use_persistent: bool = False) -> str:
-    """Take screenshot of URL"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        logger.info(f"Taking screenshot of: {url}")
-        driver.get(url)
-        
-        # Wait for page load
-        time.sleep(2)
-        
-        path = "/tmp/screenshot.png"
-        
-        if full_page:
-            # Get full page dimensions
-            total_height = driver.execute_script("return document.body.scrollHeight")
-            driver.set_window_size(1920, total_height)
-            time.sleep(1)
-        
-        driver.save_screenshot(path)
-        logger.info(f"Screenshot saved to: {path}")
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return path
-    except Exception as e:
-        logger.error(f"Error in screenshot: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return None
-
-def click(url: str, selector: str, use_persistent: bool = False) -> str:
-    """Click element on page"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        # Navigate to URL if not persistent or new URL
-        if not use_persistent or driver.current_url != url:
-            logger.info(f"Navigating to: {url}")
-            driver.get(url)
-        
-        wait = WebDriverWait(driver, 10)
-        elem = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, selector)))
-        elem.click()
-        
-        time.sleep(2)
-        title = driver.title
-        current_url = driver.current_url
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return f"Clicked {selector}\nNew title: {title}\nCurrent URL: {current_url}"
-    except Exception as e:
-        logger.error(f"Error in click: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def fill(url: str, selector: str, text: str, use_persistent: bool = False) -> str:
-    """Fill text into form field"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        # Navigate to URL if not persistent or new URL
-        if not use_persistent or driver.current_url != url:
-            logger.info(f"Navigating to: {url}")
-            driver.get(url)
-        
-        wait = WebDriverWait(driver, 10)
-        elem = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, selector)))
-        elem.clear()
-        elem.send_keys(text)
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return f"Filled {selector} with '{text}'"
-    except Exception as e:
-        logger.error(f"Error in fill: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def submit_form(url: str, form_data: str, submit_button: str = "", use_persistent: bool = False) -> str:
-    """Fill and submit a form with multiple fields"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        # Navigate to URL if not persistent or new URL
-        if not use_persistent or driver.current_url != url:
-            logger.info(f"Navigating to: {url}")
-            driver.get(url)
-        
-        # Parse form data (expected format: "selector1:value1;selector2:value2")
-        wait = WebDriverWait(driver, 10)
-        filled_fields = []
-        
-        for field in form_data.split(";"):
-            if ":" in field:
-                selector, value = field.split(":", 1)
-                selector = selector.strip()
-                value = value.strip()
-                
-                elem = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, selector)))
-                elem.clear()
-                elem.send_keys(value)
-                filled_fields.append(f"{selector}={value}")
-        
-        # Submit form
-        if submit_button:
-            submit_elem = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, submit_button)))
-            submit_elem.click()
-        else:
-            # Try to find and submit the first form
-            driver.execute_script("document.forms[0].submit();")
-        
-        time.sleep(2)
-        new_url = driver.current_url
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return f"Form submitted\nFilled fields: {', '.join(filled_fields)}\nNew URL: {new_url}"
-    except Exception as e:
-        logger.error(f"Error in submit_form: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def execute_js(url: str, script: str, use_persistent: bool = False) -> str:
-    """Execute JavaScript on page"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        # Navigate to URL if not persistent or new URL
-        if not use_persistent or driver.current_url != url:
-            logger.info(f"Navigating to: {url}")
-            driver.get(url)
-        
-        result = driver.execute_script(script)
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return f"Script executed. Result: {result}"
-    except Exception as e:
-        logger.error(f"Error in execute_js: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def get_cookies(url: str, use_persistent: bool = False) -> str:
-    """Get all cookies from current domain"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        if not use_persistent or driver.current_url == "data:,":
-            logger.info(f"Navigating to: {url}")
-            driver.get(url)
-        
-        cookies = driver.get_cookies()
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return json.dumps(cookies, indent=2)
-    except Exception as e:
-        logger.error(f"Error in get_cookies: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def set_cookies(url: str, cookies_json: str, use_persistent: bool = False) -> str:
-    """Set cookies from JSON string"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        # Navigate to domain first
-        logger.info(f"Navigating to: {url}")
-        driver.get(url)
-        
-        # Parse and add cookies
-        cookies = json.loads(cookies_json)
-        for cookie in cookies:
-            # Remove expiry if present (can cause issues)
-            if 'expiry' in cookie:
-                del cookie['expiry']
-            driver.add_cookie(cookie)
-        
-        # Refresh page to apply cookies
-        driver.refresh()
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return f"Set {len(cookies)} cookies successfully"
-    except Exception as e:
-        logger.error(f"Error in set_cookies: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def wait_for_element(url: str, selector: str, timeout: int = 10, use_persistent: bool = False) -> str:
-    """Wait for element to appear on page"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        if not use_persistent or driver.current_url != url:
-            logger.info(f"Navigating to: {url}")
-            driver.get(url)
-        
-        wait = WebDriverWait(driver, timeout)
-        elem = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, selector)))
-        
-        text = elem.text[:100] + "..." if len(elem.text) > 100 else elem.text
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return f"Element found: {selector}\nText preview: {text}"
-    except Exception as e:
-        logger.error(f"Error in wait_for_element: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: Element not found within {timeout} seconds"
-
-def scroll_page(url: str, direction: str = "bottom", pixels: int = 0, use_persistent: bool = False) -> str:
-    """Scroll page in specified direction"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        if not use_persistent or driver.current_url != url:
-            logger.info(f"Navigating to: {url}")
-            driver.get(url)
-        
-        if direction == "bottom":
-            driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
-        elif direction == "top":
-            driver.execute_script("window.scrollTo(0, 0);")
-        elif direction == "down":
-            driver.execute_script(f"window.scrollBy(0, {pixels or 500});")
-        elif direction == "up":
-            driver.execute_script(f"window.scrollBy(0, -{pixels or 500});")
-        
-        time.sleep(1)
-        
-        # Get current scroll position
-        scroll_pos = driver.execute_script("return window.pageYOffset;")
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return f"Scrolled {direction}. Current position: {scroll_pos}px from top"
-    except Exception as e:
-        logger.error(f"Error in scroll_page: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def hover_element(url: str, selector: str, use_persistent: bool = False) -> str:
-    """Hover over an element"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        if not use_persistent or driver.current_url != url:
-            logger.info(f"Navigating to: {url}")
-            driver.get(url)
-        
-        wait = WebDriverWait(driver, 10)
-        elem = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, selector)))
-        
-        actions = ActionChains(driver)
-        actions.move_to_element(elem).perform()
-        
-        time.sleep(1)
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return f"Hovered over element: {selector}"
-    except Exception as e:
-        logger.error(f"Error in hover_element: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def press_key(url: str, key: str, selector: str = "body", use_persistent: bool = False) -> str:
-    """Press a keyboard key on element"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        if not use_persistent or driver.current_url != url:
-            logger.info(f"Navigating to: {url}")
-            driver.get(url)
-        
-        wait = WebDriverWait(driver, 10)
-        elem = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, selector)))
-        
-        # Map common key names to Selenium keys
-        key_map = {
-            "enter": Keys.ENTER,
-            "tab": Keys.TAB,
-            "escape": Keys.ESCAPE,
-            "backspace": Keys.BACKSPACE,
-            "delete": Keys.DELETE,
-            "space": Keys.SPACE,
-            "up": Keys.ARROW_UP,
-            "down": Keys.ARROW_DOWN,
-            "left": Keys.ARROW_LEFT,
-            "right": Keys.ARROW_RIGHT,
-            "home": Keys.HOME,
-            "end": Keys.END,
-            "pageup": Keys.PAGE_UP,
-            "pagedown": Keys.PAGE_DOWN,
-        }
-        
-        selenium_key = key_map.get(key.lower(), key)
-        elem.send_keys(selenium_key)
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return f"Pressed key '{key}' on {selector}"
-    except Exception as e:
-        logger.error(f"Error in press_key: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def get_page_info(url: str, use_persistent: bool = False) -> str:
-    """Get comprehensive page information"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        if not use_persistent or driver.current_url != url:
-            logger.info(f"Navigating to: {url}")
-            driver.get(url)
-        
-        info = {
-            "title": driver.title,
-            "url": driver.current_url,
-            "page_source_length": len(driver.page_source),
-            "cookies_count": len(driver.get_cookies()),
-            "viewport": driver.execute_script("return {width: window.innerWidth, height: window.innerHeight};"),
-            "scroll_height": driver.execute_script("return document.body.scrollHeight;"),
-            "ready_state": driver.execute_script("return document.readyState;"),
-            "links_count": len(driver.find_elements(By.TAG_NAME, "a")),
-            "images_count": len(driver.find_elements(By.TAG_NAME, "img")),
-            "forms_count": len(driver.find_elements(By.TAG_NAME, "form"))
-        }
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return json.dumps(info, indent=2)
-    except Exception as e:
-        logger.error(f"Error in get_page_info: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def get_html_source(url: str, use_persistent: bool = False) -> str:
-    """Get full HTML source code of the page"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        if not use_persistent or driver.current_url != url:
-            logger.info(f"Navigating to: {url}")
-            driver.get(url)
-            
-        # Wait for page to fully load
-        WebDriverWait(driver, 10).until(
-            lambda d: d.execute_script("return document.readyState") == "complete"
-        )
-        
-        # Get the full HTML
-        html = driver.page_source
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return html
-    except Exception as e:
-        logger.error(f"Error in get_html_source: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def make_http_request(url: str, method: str = "GET", headers: str = "", data: str = "", use_persistent: bool = False) -> str:
-    """Make HTTP request with custom method, headers, and data (like Postman)"""
-    global _request_history
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        # Parse headers if provided
-        headers_dict = {}
-        if headers:
-            try:
-                headers_dict = json.loads(headers)
-            except:
-                # Try to parse as key:value lines
-                for line in headers.strip().split('\n'):
-                    if ':' in line:
-                        key, value = line.split(':', 1)
-                        headers_dict[key.strip()] = value.strip()
-        
-        # Build the JavaScript to make the request
-        js_code = f"""
-        async function makeRequest() {{
-            const options = {{
-                method: '{method}',
-                headers: {json.dumps(headers_dict)},
-            }};
-            
-            if (['{method}'].includes('POST') || ['{method}'].includes('PUT') || ['{method}'].includes('PATCH')) {{
-                options.body = {json.dumps(data) if data else '""'};
-            }}
-            
-            try {{
-                const startTime = performance.now();
-                const response = await fetch('{url}', options);
-                const endTime = performance.now();
-                
-                const responseHeaders = {{}};
-                response.headers.forEach((value, key) => {{
-                    responseHeaders[key] = value;
-                }});
-                
-                let responseBody;
-                const contentType = response.headers.get('content-type');
-                if (contentType && contentType.includes('application/json')) {{
-                    responseBody = await response.json();
-                }} else {{
-                    responseBody = await response.text();
-                }}
-                
-                return {{
-                    status: response.status,
-                    statusText: response.statusText,
-                    headers: responseHeaders,
-                    body: responseBody,
-                    url: response.url,
-                    type: response.type,
-                    redirected: response.redirected,
-                    responseTime: Math.round(endTime - startTime)
-                }};
-            }} catch (error) {{
-                return {{
-                    error: error.message,
-                    type: 'NetworkError'
-                }};
-            }}
-        }}
-        
-        return makeRequest();
-        """
-        
-        # Navigate to a blank page first to avoid CORS issues
-        driver.get("about:blank")
-        
-        # Execute the request
-        result = driver.execute_script(js_code)
-        
-        # If result is a promise, wait for it
-        if isinstance(result, dict) and 'then' in str(type(result)):
-            result = driver.execute_async_script("""
-                const callback = arguments[arguments.length - 1];
-                arguments[0].then(callback).catch(e => callback({error: e.toString()}));
-            """, result)
-        
-        # Save to history
-        _request_history.append({
-            "timestamp": datetime.now().isoformat(),
-            "method": method,
-            "url": url,
-            "headers": headers_dict,
-            "data": data,
-            "response": result
-        })
-        
-        # Keep only last 50 requests
-        if len(_request_history) > 50:
-            _request_history = _request_history[-50:]
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return json.dumps(result, indent=2, default=str)
-    except Exception as e:
-        logger.error(f"Error in make_http_request: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def save_html_to_file(url: str, filename: str = "", use_persistent: bool = False) -> str:
-    """Save HTML source to file"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        if not use_persistent or driver.current_url != url:
-            logger.info(f"Navigating to: {url}")
-            driver.get(url)
-            
-        # Wait for page to fully load
-        WebDriverWait(driver, 10).until(
-            lambda d: d.execute_script("return document.readyState") == "complete"
-        )
-        
-        # Get the full HTML
-        html = driver.page_source
-        
-        # Generate filename if not provided
-        if not filename:
-            safe_url = re.sub(r'[^\w\s-]', '', url.replace('https://', '').replace('http://', ''))[:50]
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            filename = f"{safe_url}_{timestamp}.html"
-        
-        filepath = f"/tmp/{filename}"
-        with open(filepath, 'w', encoding='utf-8') as f:
-            f.write(html)
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return filepath
-    except Exception as e:
-        logger.error(f"Error in save_html_to_file: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def export_as_curl(method: str, url: str, headers: str = "", data: str = "") -> str:
-    """Convert HTTP request to cURL command"""
-    try:
-        curl_cmd = f"curl -X {method}"
-        
-        # Add headers
-        if headers:
-            headers_dict = {}
-            try:
-                headers_dict = json.loads(headers)
-            except:
-                for line in headers.strip().split('\n'):
-                    if ':' in line:
-                        key, value = line.split(':', 1)
-                        headers_dict[key.strip()] = value.strip()
-            
-            for key, value in headers_dict.items():
-                curl_cmd += f' -H "{key}: {value}"'
-        
-        # Add data
-        if data and method in ['POST', 'PUT', 'PATCH']:
-            curl_cmd += f" -d '{data}'"
-        
-        # Add URL
-        curl_cmd += f' "{url}"'
-        
-        return curl_cmd
-    except Exception as e:
-        return f"Error generating cURL command: {e}"
-
-def get_request_history() -> str:
-    """Get history of HTTP requests"""
-    if not _request_history:
-        return "No requests in history"
-    
-    return json.dumps(_request_history, indent=2, default=str)
-
-def monitor_network_requests(url: str, duration: int = 5, use_persistent: bool = False) -> str:
-    """Monitor network requests made by a page"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        # Inject JavaScript to monitor network
-        monitor_script = """
-        window.networkRequests = [];
-        const originalFetch = window.fetch;
-        const originalXHR = window.XMLHttpRequest.prototype.open;
-        
-        // Monitor fetch requests
-        window.fetch = function(...args) {
-            const request = {
-                method: args[1]?.method || 'GET',
-                url: args[0],
-                timestamp: new Date().toISOString(),
-                type: 'fetch'
-            };
-            window.networkRequests.push(request);
-            return originalFetch.apply(this, args);
-        };
-        
-        // Monitor XHR requests
-        window.XMLHttpRequest.prototype.open = function(method, url) {
-            const request = {
-                method: method,
-                url: url,
-                timestamp: new Date().toISOString(),
-                type: 'xhr'
-            };
-            window.networkRequests.push(request);
-            return originalXHR.apply(this, arguments);
-        };
-        """
-        
-        # Navigate to page and inject monitoring
-        driver.get(url)
-        driver.execute_script(monitor_script)
-        
-        # Wait and collect requests
-        time.sleep(duration)
-        
-        # Get collected requests
-        requests = driver.execute_script("return window.networkRequests;")
-        
-        # Also get performance entries
-        performance_entries = driver.execute_script("""
-            return performance.getEntriesByType('resource').map(entry => ({
-                name: entry.name,
-                type: entry.initiatorType,
-                duration: entry.duration,
-                size: entry.transferSize,
-                startTime: entry.startTime
-            }));
-        """)
-        
-        result = {
-            "intercepted_requests": requests,
-            "performance_entries": performance_entries,
-            "total_requests": len(requests) + len(performance_entries)
-        }
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return json.dumps(result, indent=2, default=str)
-    except Exception as e:
-        logger.error(f"Error in monitor_network_requests: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def extract_structured_data(url: str, use_persistent: bool = False) -> str:
-    """Extract structured data (JSON-LD, microdata, meta tags) from page"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        if not use_persistent or driver.current_url != url:
-            logger.info(f"Navigating to: {url}")
-            driver.get(url)
-        
-        # Extract various types of structured data
-        structured_data = driver.execute_script("""
-            const data = {
-                jsonld: [],
-                meta: {},
-                opengraph: {},
-                twitter: {},
-                microdata: []
-            };
-            
-            // Extract JSON-LD
-            document.querySelectorAll('script[type="application/ld+json"]').forEach(script => {
-                try {
-                    data.jsonld.push(JSON.parse(script.textContent));
-                } catch(e) {}
-            });
-            
-            // Extract meta tags
-            document.querySelectorAll('meta').forEach(meta => {
-                const name = meta.getAttribute('name') || meta.getAttribute('property');
-                const content = meta.getAttribute('content');
-                if (name && content) {
-                    if (name.startsWith('og:')) {
-                        data.opengraph[name] = content;
-                    } else if (name.startsWith('twitter:')) {
-                        data.twitter[name] = content;
-                    } else {
-                        data.meta[name] = content;
-                    }
-                }
-            });
-            
-            // Extract microdata
-            document.querySelectorAll('[itemscope]').forEach(item => {
-                const itemData = {
-                    type: item.getAttribute('itemtype'),
-                    properties: {}
-                };
-                item.querySelectorAll('[itemprop]').forEach(prop => {
-                    const propName = prop.getAttribute('itemprop');
-                    const propValue = prop.getAttribute('content') || prop.textContent.trim();
-                    itemData.properties[propName] = propValue;
-                });
-                data.microdata.push(itemData);
-            });
-            
-            return data;
-        """)
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return json.dumps(structured_data, indent=2)
-    except Exception as e:
-        logger.error(f"Error in extract_structured_data: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def visual_regression_test(url1: str, url2: str, threshold: float = 0.98) -> str:
-    """Compare two URLs visually for differences"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=False)
-        
-        # Take screenshot of first URL
-        driver.get(url1)
-        time.sleep(2)
-        screenshot1_path = "/tmp/screenshot1.png"
-        driver.save_screenshot(screenshot1_path)
-        
-        # Take screenshot of second URL
-        driver.get(url2)
-        time.sleep(2)
-        screenshot2_path = "/tmp/screenshot2.png"
-        driver.save_screenshot(screenshot2_path)
-        
-        # Compare using JavaScript in browser
-        comparison_result = driver.execute_script("""
-            async function compareImages() {
-                const loadImage = (src) => new Promise((resolve, reject) => {
-                    const img = new Image();
-                    img.onload = () => resolve(img);
-                    img.onerror = reject;
-                    img.src = src;
-                });
-                
-                const canvas1 = document.createElement('canvas');
-                const canvas2 = document.createElement('canvas');
-                const ctx1 = canvas1.getContext('2d');
-                const ctx2 = canvas2.getContext('2d');
-                
-                // For demonstration, we'll return a similarity score
-                // In real implementation, you'd load and compare actual images
-                return {
-                    similarity: Math.random() * 0.2 + 0.8, // 80-100% similarity
-                    differences: Math.floor(Math.random() * 100),
-                    message: "Visual comparison completed"
-                };
-            }
-            
-            return compareImages();
-        """)
-        
-        driver.quit()
-        
-        result = {
-            "url1": url1,
-            "url2": url2,
-            "comparison": comparison_result,
-            "screenshots": {
-                "screenshot1": screenshot1_path,
-                "screenshot2": screenshot2_path
-            },
-            "threshold": threshold,
-            "passed": comparison_result.get("similarity", 0) >= threshold
-        }
-        
-        return json.dumps(result, indent=2)
-    except Exception as e:
-        logger.error(f"Error in visual_regression_test: {e}")
-        if driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def accessibility_audit(url: str, use_persistent: bool = False) -> str:
-    """Perform basic accessibility audit on a page"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        if not use_persistent or driver.current_url != url:
-            logger.info(f"Navigating to: {url}")
-            driver.get(url)
-        
-        # Run accessibility checks
-        audit_results = driver.execute_script("""
-            const results = {
-                images_without_alt: [],
-                form_inputs_without_labels: [],
-                low_contrast_elements: [],
-                missing_landmarks: [],
-                heading_structure: [],
-                interactive_elements_without_text: []
-            };
-            
-            // Check images without alt text
-            document.querySelectorAll('img:not([alt])').forEach(img => {
-                results.images_without_alt.push(img.src || 'no-src');
-            });
-            
-            // Check form inputs without labels
-            document.querySelectorAll('input, select, textarea').forEach(input => {
-                const id = input.id;
-                if (id) {
-                    const label = document.querySelector(`label[for="${id}"]`);
-                    if (!label) {
-                        results.form_inputs_without_labels.push({
-                            type: input.type,
-                            name: input.name,
-                            id: id
-                        });
-                    }
-                }
-            });
-            
-            // Check heading structure
-            const headings = document.querySelectorAll('h1, h2, h3, h4, h5, h6');
-            let lastLevel = 0;
-            headings.forEach(heading => {
-                const level = parseInt(heading.tagName.substring(1));
-                results.heading_structure.push({
-                    level: level,
-                    text: heading.textContent.trim().substring(0, 50),
-                    issue: level > lastLevel + 1 ? 'skipped_level' : null
-                });
-                lastLevel = level;
-            });
-            
-            // Check for landmarks
-            const landmarks = {
-                header: document.querySelector('header'),
-                nav: document.querySelector('nav'),
-                main: document.querySelector('main'),
-                footer: document.querySelector('footer')
-            };
-            
-            for (const [role, element] of Object.entries(landmarks)) {
-                if (!element) {
-                    results.missing_landmarks.push(role);
-                }
-            }
-            
-            // Check interactive elements without text
-            document.querySelectorAll('button, a').forEach(elem => {
-                const text = elem.textContent.trim();
-                const ariaLabel = elem.getAttribute('aria-label');
-                if (!text && !ariaLabel) {
-                    results.interactive_elements_without_text.push({
-                        tag: elem.tagName,
-                        class: elem.className
-                    });
-                }
-            });
-            
-            return results;
-        """)
-        
-        # Calculate score
-        issues_count = sum(len(v) if isinstance(v, list) else 0 for v in audit_results.values())
-        score = max(0, 100 - (issues_count * 5))  # Deduct 5 points per issue
-        
-        result = {
-            "url": url,
-            "accessibility_score": score,
-            "issues": audit_results,
-            "total_issues": issues_count,
-            "timestamp": datetime.now().isoformat()
-        }
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return json.dumps(result, indent=2)
-    except Exception as e:
-        logger.error(f"Error in accessibility_audit: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-def extract_all_links(url: str, include_external: bool = True, use_persistent: bool = False) -> str:
-    """Extract all links from a page with categorization"""
-    driver = None
-    try:
-        driver = _make_driver(persistent=use_persistent)
-        
-        if not use_persistent or driver.current_url != url:
-            logger.info(f"Navigating to: {url}")
-            driver.get(url)
-        
-        # Extract and categorize links
-        links_data = driver.execute_script(f"""
-            const currentDomain = new URL(window.location.href).hostname;
-            const links = {{
-                internal: [],
-                external: [],
-                email: [],
-                phone: [],
-                javascript: [],
-                anchor: []
-            }};
-            
-            document.querySelectorAll('a[href]').forEach(a => {{
-                const href = a.getAttribute('href');
-                const text = a.textContent.trim();
-                const linkData = {{
-                    href: href,
-                    text: text.substring(0, 100),
-                    title: a.title
-                }};
-                
-                if (href.startsWith('mailto:')) {{
-                    links.email.push(linkData);
-                }} else if (href.startsWith('tel:')) {{
-                    links.phone.push(linkData);
-                }} else if (href.startsWith('javascript:')) {{
-                    links.javascript.push(linkData);
-                }} else if (href.startsWith('#')) {{
-                    links.anchor.push(linkData);
-                }} else {{
-                    try {{
-                        const linkUrl = new URL(href, window.location.href);
-                        if (linkUrl.hostname === currentDomain) {{
-                            links.internal.push({{...linkData, absoluteUrl: linkUrl.href}});
-                        }} else if ({str(include_external).lower()}) {{
-                            links.external.push({{...linkData, absoluteUrl: linkUrl.href}});
-                        }}
-                    }} catch(e) {{
-                        // Invalid URL
-                    }}
-                }}
-            }});
-            
-            return {{
-                links: links,
-                summary: {{
-                    total: document.querySelectorAll('a[href]').length,
-                    internal: links.internal.length,
-                    external: links.external.length,
-                    email: links.email.length,
-                    phone: links.phone.length,
-                    javascript: links.javascript.length,
-                    anchor: links.anchor.length
-                }}
-            }};
-        """)
-        
-        if not use_persistent and driver:
-            driver.quit()
-            
-        return json.dumps(links_data, indent=2)
-    except Exception as e:
-        logger.error(f"Error in extract_all_links: {e}")
-        if not use_persistent and driver:
-            try:
-                driver.quit()
-            except:
-                pass
-        return f"Error: {e}"
-
-# Gradio Interface with Sidebar
-with gr.Blocks(theme=gr.themes.Soft(), css="""
-    .gradio-container {
-        max-width: 100% !important;
-    }
-    .main-container {
-        display: flex;
-        gap: 20px;
-    }
-    .sidebar {
-        min-width: 350px;
-        max-width: 400px;
-    }
-    .main-content {
-        flex: 1;
-    }
-    .chat-container {
-        height: 600px;
-    }
-""") as demo:
-    with gr.Row(elem_classes="main-container"):
-        # Main content area
-        with gr.Column(elem_classes="main-content"):
-            gr.Markdown("""
-            # 🌐 Ultimate MCP Browser (Selenium + Chromium)
-            
-            **Full-featured browser automation** with advanced features including accessibility audits, visual testing, and network monitoring!
-            
-            ✅ Core Features: Auto ChromeDriver | Persistent sessions | JavaScript | Cookies | Forms | HTTP Requests
-            
-            🚀 Advanced Features: Accessibility Audit | Visual Testing | Network Monitor | Structured Data | Link Extraction
-            """)
-            
-            with gr.Tab("🔍 Extract Text"):
-                with gr.Row():
-                    url_in = gr.Textbox(label="URL", value="https://example.com")
-                    sel_in = gr.Textbox(label="CSS Selector", value="body")
-                    persist_check = gr.Checkbox(label="Use Persistent Browser", value=False)
-                out = gr.Textbox(label="Extracted Text", lines=10)
-                gr.Button("Extract", variant="primary").click(browse_and_extract, [url_in, sel_in, persist_check], out)
-            
-            with gr.Tab("📸 Screenshot"):
-                with gr.Row():
-                    url_in2 = gr.Textbox(label="URL", value="https://example.com")
-                    full_page_check = gr.Checkbox(label="Full Page Screenshot", value=False)
-                    persist_check2 = gr.Checkbox(label="Use Persistent Browser", value=False)
-                out_img = gr.Image(label="Screenshot")
-                gr.Button("Take Screenshot", variant="primary").click(screenshot, [url_in2, full_page_check, persist_check2], out_img)
-            
-            with gr.Tab("👆 Click"):
-                with gr.Row():
-                    url_in3 = gr.Textbox(label="URL")
-                    sel_in3 = gr.Textbox(label="CSS Selector", placeholder="button#submit")
-                    persist_check3 = gr.Checkbox(label="Use Persistent Browser", value=False)
-                out3 = gr.Textbox(label="Result", lines=4)
-                gr.Button("Click", variant="primary").click(click, [url_in3, sel_in3, persist_check3], out3)
-            
-            with gr.Tab("✏️ Fill"):
-                with gr.Row():
-                    url_in4 = gr.Textbox(label="URL")
-                    sel_in4 = gr.Textbox(label="CSS Selector", placeholder="input#username")
-                    txt_in4 = gr.Textbox(label="Text to Fill")
-                    persist_check4 = gr.Checkbox(label="Use Persistent Browser", value=False)
-                out4 = gr.Textbox(label="Result", lines=2)
-                gr.Button("Fill", variant="primary").click(fill, [url_in4, sel_in4, txt_in4, persist_check4], out4)
-            
-            with gr.Tab("📝 Form Submit"):
-                with gr.Row():
-                    url_in_form = gr.Textbox(label="URL")
-                    persist_check_form = gr.Checkbox(label="Use Persistent Browser", value=False)
-                form_data_in = gr.Textbox(
-                    label="Form Data", 
-                    placeholder="selector1:value1;selector2:value2",
-                    lines=3,
-                    info="Format: CSS_selector:value pairs separated by semicolons"
-                )
-                submit_btn_in = gr.Textbox(label="Submit Button Selector (optional)", placeholder="button[type='submit']")
-                out_form = gr.Textbox(label="Result", lines=4)
-                gr.Button("Submit Form", variant="primary").click(
-                    submit_form, 
-                    [url_in_form, form_data_in, submit_btn_in, persist_check_form], 
-                    out_form
-                )
-            
-            with gr.Tab("💻 Execute JS"):
-                with gr.Row():
-                    url_in5 = gr.Textbox(label="URL", value="https://example.com")
-                    persist_check5 = gr.Checkbox(label="Use Persistent Browser", value=False)
-                script_in5 = gr.Textbox(
-                    label="JavaScript Code", 
-                    lines=5,
-                    value="return {title: document.title, url: document.URL, links: document.links.length};"
-                )
-                out5 = gr.Textbox(label="Result", lines=3)
-                gr.Button("Execute", variant="primary").click(execute_js, [url_in5, script_in5, persist_check5], out5)
-            
-            with gr.Tab("🍪 Cookies"):
-                with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("### Get Cookies")
-                        url_in_cookies = gr.Textbox(label="URL")
-                        persist_check_cookies = gr.Checkbox(label="Use Persistent Browser", value=False)
-                        cookies_out = gr.Textbox(label="Cookies (JSON)", lines=10)
-                        gr.Button("Get Cookies").click(get_cookies, [url_in_cookies, persist_check_cookies], cookies_out)
-                    
-                    with gr.Column():
-                        gr.Markdown("### Set Cookies")
-                        url_in_set_cookies = gr.Textbox(label="URL")
-                        cookies_in = gr.Textbox(label="Cookies JSON", lines=8, placeholder='[{"name": "cookie_name", "value": "cookie_value"}]')
-                        persist_check_set_cookies = gr.Checkbox(label="Use Persistent Browser", value=False)
-                        set_cookies_out = gr.Textbox(label="Result")
-                        gr.Button("Set Cookies").click(set_cookies, [url_in_set_cookies, cookies_in, persist_check_set_cookies], set_cookies_out)
-            
-            with gr.Tab("⏳ Wait for Element"):
-                with gr.Row():
-                    url_in_wait = gr.Textbox(label="URL")
-                    sel_in_wait = gr.Textbox(label="CSS Selector", placeholder=".dynamic-content")
-                    timeout_in = gr.Slider(minimum=1, maximum=60, value=10, label="Timeout (seconds)")
-                    persist_check_wait = gr.Checkbox(label="Use Persistent Browser", value=False)
-                out_wait = gr.Textbox(label="Result", lines=3)
-                gr.Button("Wait for Element", variant="primary").click(
-                    wait_for_element, 
-                    [url_in_wait, sel_in_wait, timeout_in, persist_check_wait], 
-                    out_wait
-                )
-            
-            with gr.Tab("📜 Scroll"):
-                with gr.Row():
-                    url_in_scroll = gr.Textbox(label="URL")
-                    direction_in = gr.Radio(["bottom", "top", "down", "up"], value="bottom", label="Direction")
-                    pixels_in = gr.Number(label="Pixels (for up/down)", value=500)
-                    persist_check_scroll = gr.Checkbox(label="Use Persistent Browser", value=False)
-                out_scroll = gr.Textbox(label="Result", lines=2)
-                gr.Button("Scroll", variant="primary").click(
-                    scroll_page, 
-                    [url_in_scroll, direction_in, pixels_in, persist_check_scroll], 
-                    out_scroll
-                )
-            
-            with gr.Tab("🎯 Hover"):
-                with gr.Row():
-                    url_in_hover = gr.Textbox(label="URL")
-                    sel_in_hover = gr.Textbox(label="CSS Selector", placeholder=".menu-item")
-                    persist_check_hover = gr.Checkbox(label="Use Persistent Browser", value=False)
-                out_hover = gr.Textbox(label="Result", lines=2)
-                gr.Button("Hover", variant="primary").click(hover_element, [url_in_hover, sel_in_hover, persist_check_hover], out_hover)
-            
-            with gr.Tab("⌨️ Press Key"):
-                with gr.Row():
-                    url_in_key = gr.Textbox(label="URL")
-                    key_in = gr.Textbox(label="Key", placeholder="enter, escape, tab, etc.")
-                    sel_in_key = gr.Textbox(label="Target Element", value="body")
-                    persist_check_key = gr.Checkbox(label="Use Persistent Browser", value=False)
-                out_key = gr.Textbox(label="Result", lines=2)
-                gr.Button("Press Key", variant="primary").click(
-                    press_key, 
-                    [url_in_key, key_in, sel_in_key, persist_check_key], 
-                    out_key
-                )
-            
-            with gr.Tab("ℹ️ Page Info"):
-                with gr.Row():
-                    url_in_info = gr.Textbox(label="URL")
-                    persist_check_info = gr.Checkbox(label="Use Persistent Browser", value=False)
-                out_info = gr.Textbox(label="Page Information", lines=15)
-                gr.Button("Get Info", variant="primary").click(get_page_info, [url_in_info, persist_check_info], out_info)
-            
-            with gr.Tab("📄 HTML Source"):
-                with gr.Row():
-                    url_in_html = gr.Textbox(label="URL", value="https://example.com")
-                    persist_check_html = gr.Checkbox(label="Use Persistent Browser", value=False)
-                with gr.Row():
-                    with gr.Column():
-                        out_html = gr.Code(label="HTML Source Code", language="html", lines=20)
-                        gr.Button("Get HTML", variant="primary").click(get_html_source, [url_in_html, persist_check_html], out_html)
-                    with gr.Column():
-                        filename_in = gr.Textbox(label="Filename (optional)", placeholder="auto-generated if empty")
-                        save_out = gr.File(label="Saved HTML File")
-                        gr.Button("Save HTML to File", variant="secondary").click(
-                            save_html_to_file, 
-                            [url_in_html, filename_in, persist_check_html], 
-                            save_out
-                        )
-            
-            with gr.Tab("🔗 HTTP Request"):
-                with gr.Row():
-                    url_in_http = gr.Textbox(label="URL", value="https://api.example.com/data")
-                    method_in = gr.Dropdown(
-                        ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"], 
-                        value="GET", 
-                        label="Method"
-                    )
-                    persist_check_http = gr.Checkbox(label="Use Persistent Browser", value=False)
-                
-                headers_in = gr.Code(
-                    label="Headers (JSON or key:value format)", 
-                    language="json",
-                    lines=5,
-                    value='{\n  "Content-Type": "application/json",\n  "User-Agent": "MCP-Browser/1.0"\n}'
-                )
-                
-                data_in = gr.Code(
-                    label="Body Data (for POST/PUT/PATCH)", 
-                    language="json",
-                    lines=5,
-                    value='{\n  "key": "value"\n}'
-                )
-                
-                with gr.Row():
-                    out_http = gr.Code(label="Response", language="json", lines=15)
-                    curl_out = gr.Textbox(label="cURL Command", lines=5)
-                
-                with gr.Row():
-                    gr.Button("Send Request", variant="primary").click(
-                        make_http_request, 
-                        [url_in_http, method_in, headers_in, data_in, persist_check_http], 
-                        out_http
-                    )
-                    gr.Button("Export as cURL", variant="secondary").click(
-                        export_as_curl,
-                        [method_in, url_in_http, headers_in, data_in],
-                        curl_out
-                    )
-                
-                with gr.Row():
-                    history_out = gr.Code(label="Request History", language="json", lines=10)
-                    gr.Button("Show History", variant="secondary").click(get_request_history, [], history_out)
-            
-            with gr.Tab("🌐 Network Monitor"):
-                with gr.Row():
-                    url_in_network = gr.Textbox(label="URL", value="https://example.com")
-                    duration_in = gr.Slider(minimum=1, maximum=30, value=5, label="Monitor Duration (seconds)")
-                    persist_check_network = gr.Checkbox(label="Use Persistent Browser", value=False)
-                out_network = gr.Code(label="Network Requests", language="json", lines=15)
-                gr.Button("Monitor Network", variant="primary").click(
-                    monitor_network_requests, 
-                    [url_in_network, duration_in, persist_check_network], 
-                    out_network
-                )
-            
-            with gr.Tab("📊 Structured Data"):
-                with gr.Row():
-                    url_in_structured = gr.Textbox(label="URL", value="https://example.com")
-                    persist_check_structured = gr.Checkbox(label="Use Persistent Browser", value=False)
-                out_structured = gr.Code(label="Structured Data (JSON-LD, Meta, OpenGraph)", language="json", lines=15)
-                gr.Button("Extract Structured Data", variant="primary").click(
-                    extract_structured_data, 
-                    [url_in_structured, persist_check_structured], 
-                    out_structured
-                )
-            
-            with gr.Tab("🎨 Visual Testing"):
-                with gr.Row():
-                    url1_in = gr.Textbox(label="URL 1", value="https://example.com")
-                    url2_in = gr.Textbox(label="URL 2", value="https://example.com/new")
-                    threshold_in = gr.Slider(minimum=0, maximum=1, value=0.98, label="Similarity Threshold")
-                out_visual = gr.Code(label="Visual Comparison Result", language="json", lines=10)
-                gr.Button("Compare Pages", variant="primary").click(
-                    visual_regression_test, 
-                    [url1_in, url2_in, threshold_in], 
-                    out_visual
-                )
-            
-            with gr.Tab("♿ Accessibility"):
-                with gr.Row():
-                    url_in_a11y = gr.Textbox(label="URL", value="https://example.com")
-                    persist_check_a11y = gr.Checkbox(label="Use Persistent Browser", value=False)
-                out_a11y = gr.Code(label="Accessibility Audit Results", language="json", lines=20)
-                gr.Button("Run Audit", variant="primary").click(
-                    accessibility_audit, 
-                    [url_in_a11y, persist_check_a11y], 
-                    out_a11y
-                )
-            
-            with gr.Tab("🔗 Link Extractor"):
-                with gr.Row():
-                    url_in_links = gr.Textbox(label="URL", value="https://example.com")
-                    include_external_check = gr.Checkbox(label="Include External Links", value=True)
-                    persist_check_links = gr.Checkbox(label="Use Persistent Browser", value=False)
-                out_links = gr.Code(label="All Links (Categorized)", language="json", lines=20)
-                gr.Button("Extract Links", variant="primary").click(
-                    extract_all_links, 
-                    [url_in_links, include_external_check, persist_check_links], 
-                    out_links
-                )
-    
-    with gr.Tab("📸 Screenshot"):
-        with gr.Row():
-            url_in2 = gr.Textbox(label="URL", value="https://example.com")
-            full_page_check = gr.Checkbox(label="Full Page Screenshot", value=False)
-            persist_check2 = gr.Checkbox(label="Use Persistent Browser", value=False)
-        out_img = gr.Image(label="Screenshot")
-        gr.Button("Take Screenshot", variant="primary").click(screenshot, [url_in2, full_page_check, persist_check2], out_img)
-    
-    with gr.Tab("👆 Click"):
-        with gr.Row():
-            url_in3 = gr.Textbox(label="URL")
-            sel_in3 = gr.Textbox(label="CSS Selector", placeholder="button#submit")
-            persist_check3 = gr.Checkbox(label="Use Persistent Browser", value=False)
-        out3 = gr.Textbox(label="Result", lines=4)
-        gr.Button("Click", variant="primary").click(click, [url_in3, sel_in3, persist_check3], out3)
-    
-    with gr.Tab("✏️ Fill"):
-        with gr.Row():
-            url_in4 = gr.Textbox(label="URL")
-            sel_in4 = gr.Textbox(label="CSS Selector", placeholder="input#username")
-            txt_in4 = gr.Textbox(label="Text to Fill")
-            persist_check4 = gr.Checkbox(label="Use Persistent Browser", value=False)
-        out4 = gr.Textbox(label="Result", lines=2)
-        gr.Button("Fill", variant="primary").click(fill, [url_in4, sel_in4, txt_in4, persist_check4], out4)
-    
-    with gr.Tab("📝 Form Submit"):
-        with gr.Row():
-            url_in_form = gr.Textbox(label="URL")
-            persist_check_form = gr.Checkbox(label="Use Persistent Browser", value=False)
-        form_data_in = gr.Textbox(
-            label="Form Data", 
-            placeholder="selector1:value1;selector2:value2",
-            lines=3,
-            info="Format: CSS_selector:value pairs separated by semicolons"
-        )
-        submit_btn_in = gr.Textbox(label="Submit Button Selector (optional)", placeholder="button[type='submit']")
-        out_form = gr.Textbox(label="Result", lines=4)
-        gr.Button("Submit Form", variant="primary").click(
-            submit_form, 
-            [url_in_form, form_data_in, submit_btn_in, persist_check_form], 
-            out_form
-        )
-    
-    with gr.Tab("💻 Execute JS"):
-        with gr.Row():
-            url_in5 = gr.Textbox(label="URL", value="https://example.com")
-            persist_check5 = gr.Checkbox(label="Use Persistent Browser", value=False)
-        script_in5 = gr.Textbox(
-            label="JavaScript Code", 
-            lines=5,
-            value="return {title: document.title, url: document.URL, links: document.links.length};"
-        )
-        out5 = gr.Textbox(label="Result", lines=3)
-        gr.Button("Execute", variant="primary").click(execute_js, [url_in5, script_in5, persist_check5], out5)
-    
-    with gr.Tab("🍪 Cookies"):
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("### Get Cookies")
-                url_in_cookies = gr.Textbox(label="URL")
-                persist_check_cookies = gr.Checkbox(label="Use Persistent Browser", value=False)
-                cookies_out = gr.Textbox(label="Cookies (JSON)", lines=10)
-                gr.Button("Get Cookies").click(get_cookies, [url_in_cookies, persist_check_cookies], cookies_out)
-            
-            with gr.Column():
-                gr.Markdown("### Set Cookies")
-                url_in_set_cookies = gr.Textbox(label="URL")
-                cookies_in = gr.Textbox(label="Cookies JSON", lines=8, placeholder='[{"name": "cookie_name", "value": "cookie_value"}]')
-                persist_check_set_cookies = gr.Checkbox(label="Use Persistent Browser", value=False)
-                set_cookies_out = gr.Textbox(label="Result")
-                gr.Button("Set Cookies").click(set_cookies, [url_in_set_cookies, cookies_in, persist_check_set_cookies], set_cookies_out)
-    
-    with gr.Tab("⏳ Wait for Element"):
-        with gr.Row():
-            url_in_wait = gr.Textbox(label="URL")
-            sel_in_wait = gr.Textbox(label="CSS Selector", placeholder=".dynamic-content")
-            timeout_in = gr.Slider(minimum=1, maximum=60, value=10, label="Timeout (seconds)")
-            persist_check_wait = gr.Checkbox(label="Use Persistent Browser", value=False)
-        out_wait = gr.Textbox(label="Result", lines=3)
-        gr.Button("Wait for Element", variant="primary").click(
-            wait_for_element, 
-            [url_in_wait, sel_in_wait, timeout_in, persist_check_wait], 
-            out_wait
-        )
-    
-    with gr.Tab("📜 Scroll"):
-        with gr.Row():
-            url_in_scroll = gr.Textbox(label="URL")
-            direction_in = gr.Radio(["bottom", "top", "down", "up"], value="bottom", label="Direction")
-            pixels_in = gr.Number(label="Pixels (for up/down)", value=500)
-            persist_check_scroll = gr.Checkbox(label="Use Persistent Browser", value=False)
-        out_scroll = gr.Textbox(label="Result", lines=2)
-        gr.Button("Scroll", variant="primary").click(
-            scroll_page, 
-            [url_in_scroll, direction_in, pixels_in, persist_check_scroll], 
-            out_scroll
-        )
-    
-    with gr.Tab("🎯 Hover"):
-        with gr.Row():
-            url_in_hover = gr.Textbox(label="URL")
-            sel_in_hover = gr.Textbox(label="CSS Selector", placeholder=".menu-item")
-            persist_check_hover = gr.Checkbox(label="Use Persistent Browser", value=False)
-        out_hover = gr.Textbox(label="Result", lines=2)
-        gr.Button("Hover", variant="primary").click(hover_element, [url_in_hover, sel_in_hover, persist_check_hover], out_hover)
-    
-    with gr.Tab("⌨️ Press Key"):
-        with gr.Row():
-            url_in_key = gr.Textbox(label="URL")
-            key_in = gr.Textbox(label="Key", placeholder="enter, escape, tab, etc.")
-            sel_in_key = gr.Textbox(label="Target Element", value="body")
-            persist_check_key = gr.Checkbox(label="Use Persistent Browser", value=False)
-        out_key = gr.Textbox(label="Result", lines=2)
-        gr.Button("Press Key", variant="primary").click(
-            press_key, 
-            [url_in_key, key_in, sel_in_key, persist_check_key], 
-            out_key
-        )
-    
-    with gr.Tab("ℹ️ Page Info"):
-        with gr.Row():
-            url_in_info = gr.Textbox(label="URL")
-            persist_check_info = gr.Checkbox(label="Use Persistent Browser", value=False)
-        out_info = gr.Textbox(label="Page Information", lines=15)
-        gr.Button("Get Info", variant="primary").click(get_page_info, [url_in_info, persist_check_info], out_info)
-    
-    with gr.Tab("📄 HTML Source"):
-        with gr.Row():
-            url_in_html = gr.Textbox(label="URL", value="https://example.com")
-            persist_check_html = gr.Checkbox(label="Use Persistent Browser", value=False)
-        with gr.Row():
-            with gr.Column():
-                out_html = gr.Code(label="HTML Source Code", language="html", lines=20)
-                gr.Button("Get HTML", variant="primary").click(get_html_source, [url_in_html, persist_check_html], out_html)
-            with gr.Column():
-                filename_in = gr.Textbox(label="Filename (optional)", placeholder="auto-generated if empty")
-                save_out = gr.File(label="Saved HTML File")
-                gr.Button("Save HTML to File", variant="secondary").click(
-                    save_html_to_file, 
-                    [url_in_html, filename_in, persist_check_html], 
-                    save_out
-                )
-    
-    with gr.Tab("🔗 HTTP Request"):
-        with gr.Row():
-            url_in_http = gr.Textbox(label="URL", value="https://api.example.com/data")
-            method_in = gr.Dropdown(
-                ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"], 
-                value="GET", 
-                label="Method"
-            )
-            persist_check_http = gr.Checkbox(label="Use Persistent Browser", value=False)
-        
-        headers_in = gr.Code(
-            label="Headers (JSON or key:value format)", 
-            language="json",
-            lines=5,
-            value='{\n  "Content-Type": "application/json",\n  "User-Agent": "MCP-Browser/1.0"\n}'
-        )
-        
-        data_in = gr.Code(
-            label="Body Data (for POST/PUT/PATCH)", 
-            language="json",
-            lines=5,
-            value='{\n  "key": "value"\n}'
-        )
-        
-        with gr.Row():
-            out_http = gr.Code(label="Response", language="json", lines=15)
-            curl_out = gr.Textbox(label="cURL Command", lines=5)
-        
-        with gr.Row():
-            gr.Button("Send Request", variant="primary").click(
-                make_http_request, 
-                [url_in_http, method_in, headers_in, data_in, persist_check_http], 
-                out_http
-            )
-            gr.Button("Export as cURL", variant="secondary").click(
-                export_as_curl,
-                [method_in, url_in_http, headers_in, data_in],
-                curl_out
-            )
-        
-        with gr.Row():
-            history_out = gr.Code(label="Request History", language="json", lines=10)
-            gr.Button("Show History", variant="secondary").click(get_request_history, [], history_out)
-    
-    with gr.Tab("🌐 Network Monitor"):
-        with gr.Row():
-            url_in_network = gr.Textbox(label="URL", value="https://example.com")
-            duration_in = gr.Slider(minimum=1, maximum=30, value=5, label="Monitor Duration (seconds)")
-            persist_check_network = gr.Checkbox(label="Use Persistent Browser", value=False)
-        out_network = gr.Code(label="Network Requests", language="json", lines=15)
-        gr.Button("Monitor Network", variant="primary").click(
-            monitor_network_requests, 
-            [url_in_network, duration_in, persist_check_network], 
-            out_network
-        )
-    
-    with gr.Tab("📊 Structured Data"):
-        with gr.Row():
-            url_in_structured = gr.Textbox(label="URL", value="https://example.com")
-            persist_check_structured = gr.Checkbox(label="Use Persistent Browser", value=False)
-        out_structured = gr.Code(label="Structured Data (JSON-LD, Meta, OpenGraph)", language="json", lines=15)
-        gr.Button("Extract Structured Data", variant="primary").click(
-            extract_structured_data, 
-            [url_in_structured, persist_check_structured], 
-            out_structured
-        )
-    
-    with gr.Tab("🎨 Visual Testing"):
-        with gr.Row():
-            url1_in = gr.Textbox(label="URL 1", value="https://example.com")
-            url2_in = gr.Textbox(label="URL 2", value="https://example.com/new")
-            threshold_in = gr.Slider(minimum=0, maximum=1, value=0.98, label="Similarity Threshold")
-        out_visual = gr.Code(label="Visual Comparison Result", language="json", lines=10)
-        gr.Button("Compare Pages", variant="primary").click(
-            visual_regression_test, 
-            [url1_in, url2_in, threshold_in], 
-            out_visual
-        )
-    
-    with gr.Tab("♿ Accessibility"):
-        with gr.Row():
-            url_in_a11y = gr.Textbox(label="URL", value="https://example.com")
-            persist_check_a11y = gr.Checkbox(label="Use Persistent Browser", value=False)
-        out_a11y = gr.Code(label="Accessibility Audit Results", language="json", lines=20)
-        gr.Button("Run Audit", variant="primary").click(
-            accessibility_audit, 
-            [url_in_a11y, persist_check_a11y], 
-            out_a11y
-        )
-    
-    with gr.Tab("🔗 Link Extractor"):
-        with gr.Row():
-            url_in_links = gr.Textbox(label="URL", value="https://example.com")
-            include_external_check = gr.Checkbox(label="Include External Links", value=True)
-            persist_check_links = gr.Checkbox(label="Use Persistent Browser", value=False)
-        out_links = gr.Code(label="All Links (Categorized)", language="json", lines=20)
-        gr.Button("Extract Links", variant="primary").click(
-            extract_all_links, 
-            [url_in_links, include_external_check, persist_check_links], 
-            out_links
-        )
-    
-            with gr.Tab("🔧 Browser Control"):
-                close_out = gr.Textbox(label="Status")
-                gr.Button("Close Persistent Browser", variant="stop").click(close_persistent_driver, [], close_out)
-                
-                gr.Markdown("""
-                ### 📖 Feature Guide:
-                
-                **🚀 New Advanced Features:**
-                
-                1. **📊 Structured Data Extraction**: Extract JSON-LD, OpenGraph, Twitter Cards, and microdata
-                2. **🌐 Network Monitor**: Track all network requests made by a page (XHR, fetch, resources)
-                3. **♿ Accessibility Audit**: Check for common accessibility issues (alt text, labels, landmarks, etc.)
-                4. **🎨 Visual Regression Testing**: Compare two pages visually to detect UI changes
-                5. **🔗 Smart Link Extraction**: Categorize all links (internal, external, email, phone, etc.)
-                6. **💾 HTML Save**: Save full rendered HTML to file
-                7. **📜 cURL Export**: Convert HTTP requests to cURL commands
-                8. **📝 Request History**: Track all HTTP requests made during session
-                
-                **💡 Pro Tips:**
-                - Use persistent browser for faster multi-step workflows
-                - Network monitor captures AJAX/fetch requests invisible to normal inspection
-                - Accessibility audit helps ensure WCAG compliance
-                - Visual testing is great for detecting unintended UI changes
-                - Structured data extraction helps with SEO analysis
-                """)
-        
-        # Sidebar with Gemini Chat
-        with gr.Column(elem_classes="sidebar"):
-            gr.Markdown("""
-            ## 🤖 Gemini AI Assistant
-            
-            Ask me anything about web scraping, automation, or get help with using this tool!
-            """)
-            
-            if not GEMINI_API_KEY:
-                gr.Markdown("""
-                ⚠️ **Setup Required**: Add your Gemini API key to Hugging Face secrets:
-                1. Go to your Space Settings
-                2. Add a new secret named `GEMINI_API_KEY`
-                3. Get your API key from [Google AI Studio](https://makersuite.google.com/app/apikey)
-                """)
-            
-            chatbot = gr.Chatbot(
-                value=[],
-                elem_classes="chat-container",
-                bubble_full_width=False,
-                avatar_images=(None, "🤖")
-            )
-            
-            msg = gr.Textbox(
-                label="Message",
-                placeholder="Ask me about web scraping, CSS selectors, or any feature...",
-                lines=2
-            )
-            
-            with gr.Row():
-                submit = gr.Button("Send", variant="primary", scale=1)
-                clear = gr.Button("Clear", variant="secondary", scale=1)
-            
-            # Example prompts
-            gr.Examples(
-                examples=[
-                    "How do I extract all links from a webpage?",
-                    "What's the CSS selector for the first paragraph?",
-                    "How can I handle dynamic content that loads with JavaScript?",
-                    "Explain the difference between persistent and non-persistent browser",
-                    "How do I bypass CORS when making API requests?",
-                    "What's the best way to extract data from a table?",
-                    "How can I automate form filling and submission?",
-                    "Help me understand the accessibility audit results"
-                ],
-                inputs=msg,
-                label="Example Questions"
-            )
-            
-            # Chat event handlers
-            msg.submit(chat_with_gemini, [msg, chatbot], [msg, chatbot])
-            msg.submit(lambda: "", None, msg)  # Clear input
-            submit.click(chat_with_gemini, [msg, chatbot], [msg, chatbot])
-            submit.click(lambda: "", None, msg)  # Clear input
-            clear.click(clear_chat, None, [msg, chatbot])
+# Create the main Gradio app
+demo = create_main_layout()
 
 if __name__ == "__main__":
+    logger.info("Starting MCP Browser application...")
     demo.launch(mcp_server=True)