mcpbrowser 0.2.35 → 0.2.37

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 cherchyk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -20,7 +20,7 @@ Or search "MCPBrowser" in VS Code Extensions view.
 **From GitHub Release:**
 Download from [GitHub Releases](https://github.com/cherchyk/MCPBrowser/releases):
 ```bash
-code --install-extension mcpbrowser-0.2.32.vsix
+code --install-extension mcpbrowser-0.2.37.vsix
 ```
 
 The extension automatically:
@@ -31,7 +31,7 @@ The extension automatically:
 📦 [View on Marketplace](https://marketplace.visualstudio.com/items?itemName=cherchyk.mcpbrowser)
 
 ### Option 2: npm Package (Recommended for Manual Setup)
-Published on npm as [mcpbrowser](https://www.npmjs.com/package/mcpbrowser) v0.2.32.
+Published on npm as [mcpbrowser](https://www.npmjs.com/package/mcpbrowser) v0.2.37.
 
 Add to your `mcp.json`:
 ```jsonc
@@ -48,7 +48,7 @@ Add to your `mcp.json`:
 - Mac/Linux: `~/.config/Code/User/mcp.json`
 
 ### Option 3: MCP Registry
-Available in the [MCP Registry](https://registry.modelcontextprotocol.io/) as `io.github.cherchyk/browser` v0.2.32.
+Available in the [MCP Registry](https://registry.modelcontextprotocol.io/) as `io.github.cherchyk/browser` v0.2.37.
 
 Search for "browser" in the registry to find configuration instructions.
 
@@ -132,7 +132,7 @@ Restart VS Code or reload the window for the changes to take effect.
 In Claude Code or Copilot Chat, you should see the `MCPBrowser` server listed. Ask it to fetch an authenticated URL and it will drive your signed-in Chrome session.
 
 ## How it works
-- Tool `fetch_webpage_protected` (inside the MCP server) drives your live Chrome/Edge (DevTools Protocol) so it inherits your auth cookies, returning `html` (truncated up to 2M chars) for analysis.
+- Tool `fetch_webpage` (inside the MCP server) drives your live Chrome/Edge (DevTools Protocol) so it inherits your auth cookies, returning `html` (truncated up to 2M chars) for analysis.
 - **Smart confirmation**: AI assistant asks for confirmation ONLY on first request to a new domain - explains browser will open for authentication. Subsequent requests to same domain work automatically (session preserved).
 - **Domain-aware tab reuse**: Automatically reuses the same tab for URLs on the same domain, preserving authentication session. Different domains open new tabs.
 - **Automatic page loading**: Waits for network idle (`networkidle0`) by default, ensuring JavaScript-heavy pages (SPAs, dashboards) fully load before returning content.
@@ -141,6 +141,151 @@ In Claude Code or Copilot Chat, you should see the `MCPBrowser` server listed. A
 - **Smart timeouts**: 60s default for page fetch, 10 min for auth redirects. Tabs stay open indefinitely for reuse (no auto-close).
 - The AI assistant's LLM invokes this tool via MCP; this repo itself does not run an LLM.
 
+## 🎯 Interactive Features (NEW!)
+
+MCPBrowser now supports **human-like interaction** with web pages! You can click buttons, fill forms, and interact with dynamic content just like a human would.
+
+### Available Tools
+
+#### 1. `click_element` - Click on page elements
+Click on any element - buttons, links, divs with onclick handlers, or any clickable element.
+
+**Parameters:**
+- `url` (required): URL of the page (must be already loaded via `fetch_webpage`)
+- `selector` (optional): CSS selector for the element (e.g., `#submit-btn`, `.login-button`)
+- `text` (optional): Text content to search for if selector not provided (e.g., "Sign In", "Submit")
+- `timeout` (optional): Maximum wait time in milliseconds (default: 30000)
+
+**Example:**
+```javascript
+// Click by selector
+{ url: "https://example.com", selector: "#login-button" }
+
+// Click by text content
+{ url: "https://example.com", text: "Sign In" }
+```
+
+#### 2. `type_text` - Type text into input fields
+Type text into input fields, textareas, or any editable element with human-like typing simulation.
+
+**Parameters:**
+- `url` (required): URL of the page
+- `selector` (required): CSS selector for the input element
+- `text` (required): Text to type
+- `clear` (optional): Clear existing text first (default: true)
+- `delay` (optional): Delay between keystrokes in ms (default: 50)
+- `timeout` (optional): Maximum wait time in milliseconds (default: 30000)
+
+**Example:**
+```javascript
+{ 
+  url: "https://example.com", 
+  selector: "#username", 
+  text: "myuser@example.com" 
+}
+```
+
+#### 3. `get_interactive_elements` - List all interactive elements
+Discover all clickable and interactive elements on the page - links, buttons, inputs, elements with onclick handlers.
+
+**Parameters:**
+- `url` (required): URL of the page
+- `limit` (optional): Maximum number of elements to return (default: 50)
+
+**Returns:** Array of elements with details (tag, text, selector, href, type, id, hasOnClick, role)
+
+**Example:**
+```javascript
+{ url: "https://example.com", limit: 20 }
+```
+
+#### 4. `wait_for_element` - Wait for element to appear
+Wait for an element to appear on the page (useful after clicking something that triggers dynamic content).
+
+**Parameters:**
+- `url` (required): URL of the page
+- `selector` (optional): CSS selector to wait for
+- `text` (optional): Text content to wait for if selector not provided
+- `timeout` (optional): Maximum wait time in milliseconds (default: 30000)
+
+**Example:**
+```javascript
+{ url: "https://example.com", selector: ".success-message" }
+```
+
+#### 5. `get_current_html` - Get updated HTML without reloading (NEW! 🚀)
+**Efficiently** get the current HTML state from an already-loaded page **without navigation or reloading**. Use this after interactions (`click_element`, `type_text`, `wait_for_element`) to get the updated DOM state.
+
+**Why use this instead of `fetch_webpage`?**
+- ⚡ **Much faster** - no page reload, just extracts current DOM
+- 🎯 **More accurate** - captures exact state after interaction
+- 💾 **Preserves state** - doesn't lose dynamic JavaScript state
+- 🔄 **Efficient** - perfect for interactive workflows
+
+**Parameters:**
+- `url` (required): URL of the page (must be already loaded via `fetch_webpage`)
+- `removeUnnecessaryHTML` (optional): Clean HTML for size reduction (default: true, ~90% smaller)
+
+**Example:**
+```javascript
+{ url: "https://example.com", removeUnnecessaryHTML: true }
+```
+
+**Performance comparison:**
+```
+fetch_webpage after interaction:  2-5 seconds (reloads page)
+get_current_html after interaction: 0.1-0.3 seconds (just extracts HTML) ✅
+```
+
+### Usage Workflow
+
+**Efficient interactive workflow (NEW!):**
+
+1. **First, fetch the page:**
+   ```javascript
+   fetch_webpage({ url: "https://example.com/login" })
+   ```
+
+2. **Discover interactive elements:**
+   ```javascript
+   get_interactive_elements({ url: "https://example.com/login" })
+   ```
+
+3. **Fill in the form:**
+   ```javascript
+   type_text({ url: "https://example.com/login", selector: "#username", text: "user@example.com" })
+   type_text({ url: "https://example.com/login", selector: "#password", text: "mypassword" })
+   ```
+
+4. **Click the submit button:**
+   ```javascript
+   click_element({ url: "https://example.com/login", selector: "#submit" })
+   // or by text: click_element({ url: "https://example.com/login", text: "Sign In" })
+   ```
+
+5. **Wait for content to load:**
+   ```javascript
+   wait_for_element({ url: "https://example.com/dashboard", selector: ".dashboard-content" })
+   ```
+
+6. **Get updated HTML efficiently (no reload!):**
+   ```javascript
+   get_current_html({ url: "https://example.com/dashboard" })
+   // ✅ Fast! Just extracts current DOM without reloading the page
+   ```
+
+**When to use `get_current_html` vs `fetch_webpage`:**
+- Use `fetch_webpage`: Initial page load, navigation to new URLs, auth flows
+- Use `get_current_html`: After clicks, form fills, waits - when page is already loaded ✅
+
+### Key Features
+- ✅ Works with **any clickable element** - not just `<a>` tags (buttons, divs with onclick, etc.)
+- ✅ **Text-based selection** - click elements by their visible text
+- ✅ **Human-like typing** - simulates natural keystroke delays
+- ✅ **Automatic scrolling** - scrolls elements into view before interaction
+- ✅ **Smart element detection** - finds the most specific match when searching by text
+- ✅ **Session preservation** - all interactions happen in the same browser tab
+
 ## Auth-assisted fetch flow
 - AI assistant can call with just the URL, or with no params if you set an env default (`DEFAULT_FETCH_URL` or `MCP_DEFAULT_FETCH_URL`). By default tabs stay open indefinitely for reuse (domain-aware).
 - First call opens the tab and leaves it open so you can sign in. No extra params needed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcpbrowser",
-  "version": "0.2.35",
+  "version": "0.2.37",
   "mcpName": "io.github.cherchyk/mcpbrowser",
   "type": "module",
   "description": "MCP server for in-browser web page fetching using Chrome DevTools Protocol",
@@ -10,7 +10,9 @@
   },
   "scripts": {
     "mcp": "node src/mcp-browser.js",
-    "test": "node --test tests/*.test.js"
+    "test": "node tests/run-all.js",
+    "test:unit": "node tests/run-unit.js",
+    "test:ci": "node tests/run-unit.js"
   },
   "keywords": [
     "mcp",

package/server.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/cherchyk/MCPBrowser",
     "source": "github"
   },
-  "version": "0.2.35",
+  "version": "0.2.37",
   "packages": [
     {
       "registryType": "npm",

package/src/actions/click-element.js

@@ -0,0 +1,176 @@
+/**
+ * click.js - Click element action
+ * 
+ * This function handles two distinct use cases:
+ * 
+ * 1. NAVIGATION/CONTENT UPDATES (returnHtml: true, default):
+ *    - Clicks the element
+ *    - Waits for page stability (network idle, DOM updates)
+ *    - Returns the updated HTML content
+ *    - Use for: Links, navigation buttons, SPA route changes (e.g., Gmail folders)
+ *    - Takes 3-8 seconds due to stability wait
+ * 
+ * 2. FAST FORM INTERACTIONS (returnHtml: false):
+ *    - Clicks the element
+ *    - Minimal 300ms wait
+ *    - Returns success without HTML
+ *    - Use for: Checkboxes, radio buttons, form fields that don't navigate
+ *    - Takes <1 second
+ * 
+ * Why this design?
+ * - Solves SPA navigation issue: URL hash changes instantly (#inbox → #trash),
+ *   but content loads asynchronously. Without waiting, we'd return old content.
+ * - Consistent with fetch_webpage: Both wait for stability and return HTML
+ * - Flexible: Can disable waiting for fast form interactions
+ */
+
+import { getBrowser, domainPages } from '../core/browser.js';
+import { extractAndProcessHtml, waitForPageStability } from '../core/page.js';
+
+/**
+ * Click on an element on the page
+ * 
+ * @param {Object} params - Click parameters
+ * @param {string} params.url - The URL of the page to interact with
+ * @param {string} [params.selector] - CSS selector for the element to click
+ * @param {string} [params.text] - Text content to search for (alternative to selector)
+ * @param {number} [params.waitForElementTimeout=30000] - Maximum time (ms) to wait for element to appear before failing
+ * @param {boolean} [params.returnHtml=true] - Whether to wait for stability and return HTML
+ * @param {boolean} [params.removeUnnecessaryHTML=true] - Whether to clean HTML (only if returnHtml is true)
+ * @param {number} [params.postClickWait=1000] - Milliseconds to wait after click for SPAs to render dynamic content
+ * @returns {Promise<Object>} Result object with success status and details
+ * 
+ * @example
+ * // Navigate to Gmail Bin folder (waits for emails to load, returns HTML)
+ * const result = await clickElement({ url: gmailUrl, text: "Bin" });
+ * console.log(result.html); // Contains bin emails
+ * 
+ * @example
+ * // Fast checkbox click (no wait, no HTML)
+ * const result = await clickElement({ 
+ *   url: formUrl, 
+ *   selector: "#agree-checkbox",
+ *   returnHtml: false 
+ * });
+ */
+export async function clickElement({ url, selector, text, waitForElementTimeout = 30000, returnHtml = true, removeUnnecessaryHTML = true, postClickWait = 1000 }) {
+  if (!url) {
+    throw new Error("url parameter is required");
+  }
+  
+  if (!selector && !text) {
+    throw new Error("Either selector or text parameter is required");
+  }
+
+  let hostname;
+  try {
+    hostname = new URL(url).hostname;
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+
+  const browser = await getBrowser();
+  let page = domainPages.get(hostname);
+  
+  if (!page || page.isClosed()) {
+    return {
+      success: false,
+      error: `No open page found for ${hostname}. Please fetch the page first using fetch_webpage.`
+    };
+  }
+
+  try {
+    let elementHandle;
+    
+    if (selector) {
+      // Use CSS selector
+      await page.waitForSelector(selector, { timeout: waitForElementTimeout, visible: true });
+      elementHandle = await page.$(selector);
+    } else {
+      // Search by text content
+      await page.waitForFunction(
+        (searchText) => {
+          const elements = Array.from(document.querySelectorAll('*'));
+          return elements.some(el => {
+            const text = el.textContent?.trim();
+            return text && text.includes(searchText) && el.offsetParent !== null;
+          });
+        },
+        { timeout: waitForElementTimeout },
+        text
+      );
+      
+      elementHandle = await page.evaluateHandle((searchText) => {
+        const elements = Array.from(document.querySelectorAll('*'));
+        // Prioritize smaller elements (more specific matches)
+        const matches = elements.filter(el => {
+          const elText = el.textContent?.trim();
+          return elText && elText.includes(searchText) && el.offsetParent !== null;
+        });
+        matches.sort((a, b) => a.textContent.length - b.textContent.length);
+        return matches[0];
+      }, text);
+    }
+
+    if (!elementHandle || !elementHandle.asElement()) {
+      return {
+        success: false,
+        error: selector ? `Element not found: ${selector}` : `Element with text "${text}" not found`
+      };
+    }
+
+    // Scroll element into view and click
+    // For automation, use instant scroll instead of smooth animation to avoid delays
+    await page.evaluate(el => el.scrollIntoView({ behavior: 'auto', block: 'center' }), elementHandle);
+    // original:
+    // Smooth scroll (commented out for performance):
+    // await page.evaluate(el => el.scrollIntoView({ behavior: 'smooth', block: 'center' }), elementHandle);
+    // await new Promise(r => setTimeout(r, 300)); // Brief delay after scroll
+    
+    await elementHandle.click();
+    
+    if (returnHtml) {
+      // Wait for page to stabilize (handles both navigation and SPA content updates)
+      // This ensures content is fully loaded before returning, just like fetch_webpage does
+      await waitForPageStability(page);
+      
+      // Wait for SPAs to render dynamic content after click
+      if (postClickWait > 0) {
+        await new Promise(resolve => setTimeout(resolve, postClickWait));
+      }
+      
+      const currentUrl = page.url();
+      const html = await extractAndProcessHtml(page, removeUnnecessaryHTML);
+      
+      return {
+        success: true,
+        message: selector ? `Clicked element: ${selector}` : `Clicked element with text: "${text}"`,
+        currentUrl,
+        html,
+        clicked: selector || `text:"${text}"`
+      };
+    } else {
+      // Wait for page to stabilize even for fast clicks (ensures JS has finished)
+      await waitForPageStability(page);
+      
+      // Wait for SPAs to render dynamic content after click
+      if (postClickWait > 0) {
+        await new Promise(resolve => setTimeout(resolve, postClickWait));
+      }
+      
+      const currentUrl = page.url();
+      
+      return {
+        success: true,
+        message: selector ? `Clicked element: ${selector}` : `Clicked element with text: "${text}"`,
+        currentUrl,
+        clicked: selector || `text:"${text}"`
+      };
+    }
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to click element: ${err.message}`
+    };
+  }
+}

package/src/actions/close-tab.js

@@ -0,0 +1,100 @@
+/**
+ * Close a tab for a specific domain
+ */
+
+import { domainPages } from '../core/browser.js';
+
+/**
+ * Closes the browser tab for the given URL's hostname and removes it from the tab pool.
+ * This forces a fresh session on the next visit to that hostname.
+ * @param {object} params - Parameters
+ * @param {string} params.url - The URL whose hostname tab should be closed
+ * @returns {Promise<object>} Result indicating success or failure
+ */
+export async function closeTab({ url }) {
+  try {
+    // Validate URL
+    if (!url || typeof url !== 'string') {
+      return {
+        success: false,
+        error: 'Invalid or missing URL parameter'
+      };
+    }
+
+    // Extract hostname from URL
+    let hostname;
+    try {
+      hostname = new URL(url).hostname;
+    } catch {
+      return {
+        success: false,
+        error: 'Invalid URL format'
+      };
+    }
+    
+    // Check if we have a tab for this hostname
+    if (!domainPages.has(hostname)) {
+      // Hostname not found - try to find by actual page URL
+      // This handles redirects where tab was created with original hostname
+      // but now the page URL is different
+      let foundHostname = null;
+      for (const [key, page] of domainPages.entries()) {
+        try {
+          if (!page.isClosed() && page.url() === url) {
+            foundHostname = key;
+            break;
+          }
+        } catch {
+          // Skip pages we can't access
+        }
+      }
+      
+      if (!foundHostname) {
+        return {
+          success: true,
+          hostname,
+          message: 'No open tab found for this hostname',
+          alreadyClosed: true
+        };
+      }
+      
+      // Found the page by URL - use that hostname
+      hostname = foundHostname;
+    }
+
+    // Get and close the page
+    const page = domainPages.get(hostname);
+    
+    // Check if page is already closed
+    if (page.isClosed()) {
+      domainPages.delete(hostname);
+      return {
+        success: true,
+        hostname,
+        message: 'Tab was already closed',
+        alreadyClosed: true
+      };
+    }
+
+    // Close the page
+    await page.close();
+    
+    // Remove from domain pool
+    domainPages.delete(hostname);
+    
+    console.error(`[MCPBrowser] Closed tab for hostname: ${hostname}`);
+    
+    return {
+      success: true,
+      hostname,
+      message: `Successfully closed tab for ${hostname}`
+    };
+    
+  } catch (error) {
+    console.error(`[MCPBrowser] Error closing tab:`, error);
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}

package/src/actions/fetch-page.js

@@ -0,0 +1,130 @@
+/**
+ * fetch.js - Main page fetching functionality
+ * Handles web page fetching with authentication flows and tab reuse
+ */
+
+import { getBrowser, domainPages } from '../core/browser.js';
+import { getOrCreatePage, navigateToUrl, extractAndProcessHtml, waitForPageStability } from '../core/page.js';
+import { detectRedirectType, waitForAutoAuth, waitForManualAuth } from '../core/auth.js';
+
+/**
+ * Fetch a web page using Chrome browser, with support for authentication flows and tab reuse.
+ * Reuses existing tabs per domain when possible. Handles authentication redirects by waiting
+ * for user to complete login (up to 10 minutes). Processes HTML to remove unnecessary elements
+ * and convert relative URLs to absolute.
+ * @param {Object} params - Fetch parameters
+ * @param {string} params.url - The URL to fetch
+ * @param {boolean} [params.removeUnnecessaryHTML=true] - Whether to clean HTML (removes scripts, styles, etc.)
+ * @param {number} [params.postLoadWait=1000] - Milliseconds to wait after page load for SPAs to render
+ * @returns {Promise<Object>} Result object with success status, URL, HTML content, or error details
+ */
+export async function fetchPage({ url, removeUnnecessaryHTML = true, postLoadWait = 1000 }) {
+  // Hardcoded smart defaults - use 'domcontentloaded' for fastest loading
+  // (waits for HTML parsed, not all resources loaded - much faster for SPAs)
+  const waitUntil = "domcontentloaded";
+  const navigationTimeout = 30000;
+  const authCompletionTimeout = 600000;
+  const reuseLastKeptPage = true;
+  
+  if (!url) {
+    throw new Error("url parameter is required");
+  }
+
+  // Parse hostname for domain-based tab reuse
+  let hostname;
+  try {
+    hostname = new URL(url).hostname;
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+
+  const browser = await getBrowser();
+  let page = null;
+  
+  try {
+    // Get or create page for this domain
+    page = await getOrCreatePage(browser, hostname, reuseLastKeptPage);
+    
+    // Navigate to URL with fallback strategy
+    await navigateToUrl(page, url, waitUntil, navigationTimeout);
+    
+    const currentUrl = page.url();
+    const currentHostname = new URL(currentUrl).hostname;
+    console.error(`[MCPBrowser] Navigation completed: ${currentUrl}`);
+    
+    // Detect redirect type and handle accordingly
+    const redirectInfo = detectRedirectType(url, hostname, currentUrl, currentHostname);
+    
+    if (redirectInfo.type === 'requested_auth') {
+      console.error(`[MCPBrowser] User requested auth page directly, returning content`);
+      // Update domain mapping if needed
+      if (redirectInfo.currentHostname !== hostname) {
+        domainPages.delete(hostname);
+        domainPages.set(redirectInfo.currentHostname, page);
+        hostname = redirectInfo.currentHostname;
+      }
+    } else if (redirectInfo.type === 'permanent') {
+      console.error(`[MCPBrowser] Permanent redirect detected: ${hostname} → ${redirectInfo.currentHostname}`);
+      console.error(`[MCPBrowser] Accepting redirect and updating domain mapping`);
+      domainPages.delete(hostname);
+      domainPages.set(redirectInfo.currentHostname, page);
+      hostname = redirectInfo.currentHostname;
+    } else if (redirectInfo.type === 'auth') {
+      console.error(`[MCPBrowser] Authentication flow detected (${redirectInfo.flowType})`);
+      console.error(`[MCPBrowser] Current location: ${redirectInfo.currentUrl}`);
+      
+      // Try auto-auth first
+      const autoAuthResult = await waitForAutoAuth(page, redirectInfo.hostname, redirectInfo.originalBase);
+      
+      if (autoAuthResult.success) {
+        // Update hostname if changed
+        if (autoAuthResult.hostname !== hostname) {
+          domainPages.delete(hostname);
+          domainPages.set(autoAuthResult.hostname, page);
+          hostname = autoAuthResult.hostname;
+        }
+      } else {
+        // Wait for manual auth
+        const manualAuthResult = await waitForManualAuth(page, redirectInfo.hostname, redirectInfo.originalBase, authCompletionTimeout);
+        
+        if (!manualAuthResult.success) {
+          return { 
+            success: false, 
+            error: manualAuthResult.error, 
+            pageKeptOpen: true, 
+            hint: manualAuthResult.hint 
+          };
+        }
+        
+        // Update hostname if changed
+        if (manualAuthResult.hostname !== hostname) {
+          domainPages.delete(hostname);
+          domainPages.set(manualAuthResult.hostname, page);
+          hostname = manualAuthResult.hostname;
+        }
+      }
+      
+      // Wait for page stability after auth
+      await waitForPageStability(page);
+    }
+    
+    // Wait for SPAs to render dynamic content after page load
+    if (postLoadWait > 0) {
+      await new Promise(resolve => setTimeout(resolve, postLoadWait));
+    }
+    
+    // Extract and process HTML
+    const processedHtml = await extractAndProcessHtml(page, removeUnnecessaryHTML);
+    
+    return { 
+      success: true, 
+      currentUrl: page.url(),
+      html: processedHtml
+    };
+  } catch (err) {
+    const hint = "Tab is left open. Complete sign-in there, then call fetch_webpage again with just the URL.";
+    return { success: false, error: err.message || String(err), pageKeptOpen: true, hint };
+  } finally {
+    // Tab always stays open - domain-aware reuse handles cleanup
+  }
+}