Update app.py

app.py

@@ -3,95 +3,328 @@ 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 webdriver_manager.chrome import ChromeDriverManager
+from webdriver_manager.core.os_manager import ChromeType
 import time
+import logging
+import os
 
-def _make_driver():
-    chrome_options = Options()
-    chrome_options.binary_location = "/usr/bin/chromium"  # use HF Chromium
-    chrome_options.add_argument("--headless")
-    chrome_options.add_argument("--no-sandbox")
-    chrome_options.add_argument("--disable-dev-shm-usage")
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-    # webdriver-manager downloads the matching driver
-    service = Service(ChromeDriverManager().install())
-    driver = webdriver.Chrome(service=service, options=chrome_options)
-    driver.set_page_load_timeout(15)
-    return driver
+# Global browser session (optional - for persistent sessions)
+_driver = None
 
-def browse_and_extract(url: str, selector: str = "body") -> str:
+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:
-        driver = _make_driver()
+        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")
+        
+        # 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)
-        elem = driver.find_element(By.CSS_SELECTOR, selector)
+        
+        # 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
-        driver.quit()
+        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) -> str:
+def screenshot(url: str, use_persistent: bool = False) -> str:
+    """Take screenshot of URL"""
+    driver = None
     try:
-        driver = _make_driver()
+        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"
         driver.save_screenshot(path)
-        driver.quit()
+        logger.info(f"Screenshot saved to: {path}")
+        
+        if not use_persistent and driver:
+            driver.quit()
+            
         return path
     except Exception as e:
-        return f"Error: {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) -> str:
+def click(url: str, selector: str, use_persistent: bool = False) -> str:
+    """Click element on page"""
+    driver = None
     try:
-        driver = _make_driver()
-        driver.get(url)
-        elem = driver.find_element(By.CSS_SELECTOR, selector)
+        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
-        driver.quit()
-        return f"Clicked {selector}, new title: {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) -> str:
+def fill(url: str, selector: str, text: str, use_persistent: bool = False) -> str:
+    """Fill text into form field"""
+    driver = None
     try:
-        driver = _make_driver()
-        driver.get(url)
-        elem = driver.find_element(By.CSS_SELECTOR, selector)
+        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)
-        driver.quit()
+        
+        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}"
 
-with gr.Blocks() as demo:
-    gr.Markdown("# 🌐 MCP Browser (Selenium + Chromium)")
-
-    with gr.Tab("Extract Text"):
-        url_in = gr.Textbox(label="URL")
-        sel_in = gr.Textbox(label="CSS Selector", value="body")
-        out = gr.Textbox(label="Extracted Text", lines=15)
-        gr.Button("Run").click(browse_and_extract, [url_in, sel_in], out)
+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}"
 
-    with gr.Tab("Screenshot"):
-        url_in2 = gr.Textbox(label="URL")
+# Gradio Interface
+with gr.Blocks() as demo:
+    gr.Markdown("""
+    # 🌐 MCP Browser (Selenium + Chromium)
+    
+    **Fixed version** with proper ChromeDriver management for Chromium v140+
+    
+    ✅ Features:
+    - Auto-detects ChromeDriver version
+    - Optional persistent browser sessions
+    - JavaScript execution
+    - Better error handling
+    """)
+    
+    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").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")
+            persist_check2 = gr.Checkbox(label="Use Persistent Browser", value=False)
         out_img = gr.Image(label="Screenshot")
-        gr.Button("Take Screenshot").click(screenshot, url_in2, out_img)
-
-    with gr.Tab("Click"):
-        url_in3 = gr.Textbox(label="URL")
-        sel_in3 = gr.Textbox(label="CSS Selector")
-        out3 = gr.Textbox(label="Result")
-        gr.Button("Click").click(click, [url_in3, sel_in3], out3)
-
-    with gr.Tab("Fill"):
-        url_in4 = gr.Textbox(label="URL")
-        sel_in4 = gr.Textbox(label="CSS Selector")
-        txt_in4 = gr.Textbox(label="Text to Fill")
-        out4 = gr.Textbox(label="Result")
-        gr.Button("Fill").click(fill, [url_in4, sel_in4, txt_in4], out4)
+        gr.Button("Take Screenshot").click(screenshot, [url_in2, 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").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").click(fill, [url_in4, sel_in4, txt_in4, persist_check4], out4)
+    
+    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 document.title + ' - ' + document.URL;"
+        )
+        out5 = gr.Textbox(label="Result", lines=3)
+        gr.Button("Execute").click(execute_js, [url_in5, script_in5, persist_check5], out5)
+    
+    with gr.Tab("🔧 Browser Control"):
+        close_out = gr.Textbox(label="Status")
+        gr.Button("Close Persistent Browser").click(close_persistent_driver, [], close_out)
+        
+        gr.Markdown("""
+        ### Usage Tips:
+        1. **Persistent Browser**: Keep the same browser session across multiple actions
+        2. **CSS Selectors**: Use standard CSS selectors (e.g., `#id`, `.class`, `tag`)
+        3. **JavaScript**: Execute any JS code and get return values
+        """)
 
 if __name__ == "__main__":
-    demo.launch(mcp_server=True)
+    demo.launch(mcp_server=True)