mcpbrowser 0.3.28 → 0.3.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcpbrowser",
-  "version": "0.3.28",
+  "version": "0.3.30",
   "mcpName": "io.github.cherchyk/mcpbrowser",
   "type": "module",
   "description": "MCP browser server - fetch web pages using real Chrome/Edge/Brave browser. Handles authentication, SSO, CAPTCHAs, and anti-bot protection. Browser automation for AI assistants.",

package/src/actions/click-element.js

@@ -25,7 +25,7 @@
  */
 
 import { getBrowser, getValidatedPage } from '../core/browser.js';
-import { extractAndProcessHtml, waitForPageStability } from '../core/page.js';
+import { extractAndProcessHtml, waitForPageReady } from '../core/page.js';
 import { MCPResponse, InformationalResponse } from '../core/responses.js';
 import logger from '../core/logger.js';
 
@@ -262,60 +262,36 @@ export async function clickElement({ url, selector, text, waitForElementTimeout
     logger.debug(`Clicking: ${selector || `text="${text}"`}`);
     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
-      logger.debug('Waiting for page stability...');
-      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);
-      
-      logger.info(`click_element completed: ${selector || `text="${text}"`}`);
-      
-      return new ClickElementSuccessResponse(
-        currentUrl,
-        selector ? `Clicked element: ${selector}` : `Clicked element with text: "${text}"`,
-        html,
-        [
+    // Wait for page to stabilize (handles both navigation and SPA content updates)
+    logger.debug(`Waiting for page to be ready${returnHtml ? '' : ' (fast mode)'}...`);
+    await waitForPageReady(page, { afterInteraction: true });
+    
+    // Wait for SPAs to render dynamic content after click
+    if (postClickWait > 0) {
+      await new Promise(resolve => setTimeout(resolve, postClickWait));
+    }
+    
+    const currentUrl = page.url();
+    const clickMessage = selector ? `Clicked element: ${selector}` : `Clicked element with text: "${text}"`;
+    const html = returnHtml ? await extractAndProcessHtml(page, removeUnnecessaryHTML) : null;
+    const nextSteps = returnHtml
+      ? [
           "Use MCPBrowser's click_element again to navigate further",
           "Use MCPBrowser's type_text to fill forms if needed",
           "Use MCPBrowser's get_current_html to refresh page state",
           "Use MCPBrowser's take_screenshot if page has popups or visual content that's hard to parse from HTML",
           "Use MCPBrowser's close_tab when finished"
         ]
-      );
-    } else {
-      // Wait for page to stabilize even for fast clicks (ensures JS has finished)
-      logger.debug('Waiting for page stability (fast mode)...');
-      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();
-      
-      logger.info(`click_element completed: ${selector || `text="${text}"`}`);
-      
-      return new ClickElementSuccessResponse(
-        currentUrl,
-        selector ? `Clicked element: ${selector}` : `Clicked element with text: "${text}"`,
-        null,
-        [
+      : [
           "Use MCPBrowser's get_current_html to see updated page state",
           "Use MCPBrowser's take_screenshot if the page has popups, modals, or visual content",
           "Use MCPBrowser's click_element or MCPBrowser's type_text for more interactions",
           "Use MCPBrowser's close_tab when finished"
-        ]
-      );
-    }
+        ];
+    
+    logger.info(`click_element completed: ${selector || `text="${text}"`}`);
+    
+    return new ClickElementSuccessResponse(currentUrl, clickMessage, html, nextSteps);
   } catch (err) {
     logger.error(`click_element failed: ${err.message}`);
     return new InformationalResponse(

package/src/actions/fetch-page.js

@@ -4,8 +4,8 @@
  */
 
 import { getBrowser, domainPages } from '../core/browser.js';
-import { getOrCreatePage, queueRequest, navigateToUrl, waitForPageReady, extractAndProcessHtml, waitForPageStability } from '../core/page.js';
-import { detectRedirectType, waitForAutoAuth, waitForManualAuth } from '../core/auth.js';
+import { getOrCreatePage, queueRequest, navigateToUrl, waitForPageReady, extractAndProcessHtml } from '../core/page.js';
+import { isLikelyAuthUrl, waitForAuth } from '../core/auth.js';
 import { MCPResponse, ErrorResponse, HttpStatusResponse, InformationalResponse } from '../core/responses.js';
 import logger from '../core/logger.js';
 
@@ -141,7 +141,7 @@ export async function fetchPage({ url, browser = '', removeUnnecessaryHTML = tru
 
   // Queue this request - processed sequentially, one at a time
   return queueRequest(async () => {
-    return await doFetchPage({ url, hostname, browser, removeUnnecessaryHTML, postLoadWait });
+    return await doFetchPage({ url, browser, removeUnnecessaryHTML, postLoadWait });
   });
 }
 
@@ -149,12 +149,8 @@ export async function fetchPage({ url, browser = '', removeUnnecessaryHTML = tru
  * Internal function that does the actual page fetching.
  * Called by the queue processor - only one runs at a time.
  */
-async function doFetchPage({ url, hostname, browser, removeUnnecessaryHTML, postLoadWait }) {
-  // Hardcoded smart defaults
-  const waitUntil = "domcontentloaded";
-  const navigationTimeout = 30000;
-  const authCompletionTimeout = 600000;
-  const reuseLastKeptPage = true;
+async function doFetchPage({ url, browser, removeUnnecessaryHTML, postLoadWait }) {
+  const originalHostname = new URL(url).hostname;
 
   // Ensure browser connection
   let browserInstance;
@@ -174,94 +170,36 @@ async function doFetchPage({ url, hostname, browser, removeUnnecessaryHTML, post
   }
   
   try {
-    // Get or create page for this domain (simple - no locks needed)
-    let page = await getOrCreatePage(browserInstance, hostname, reuseLastKeptPage);
-    
-    // Navigate to URL (pure navigation)
-    const { statusCode, statusText } = await navigateToUrl(page, url, waitUntil, navigationTimeout);
-    
-    // Wait for page content to be ready (handles SPAs automatically)
+    let page = await getOrCreatePage(browserInstance, originalHostname);
+    let { statusCode, statusText } = await navigateToUrl(page, url, 'domcontentloaded', 30000);
     await waitForPageReady(page);
-    
-    const currentUrl = page.url();
-    const currentHostname = new URL(currentUrl).hostname;
-    
-    // Detect redirect type and handle accordingly
-    const redirectInfo = detectRedirectType(url, hostname, currentUrl, currentHostname);
-    
-    if (redirectInfo.type === 'requested_auth') {
-      logger.debug('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') {
-      logger.debug(`Redirect: ${hostname} → ${redirectInfo.currentHostname}`);
-      
-      // Check if we already have a tab for the redirected hostname
-      // (can happen after reconnect - we mapped mail.google.com but not gmail.com)
-      const existingPage = domainPages.get(redirectInfo.currentHostname);
-      if (existingPage && existingPage !== page && !existingPage.isClosed()) {
-        logger.debug(`Found existing tab for ${redirectInfo.currentHostname}, reusing it`);
-        // Close the new tab we just opened, use the existing one
-        await page.close().catch(() => {});
-        domainPages.delete(hostname);
-        page = existingPage;
-        // Map original hostname to existing page
-        domainPages.set(hostname, existingPage);
-      } else {
-        // Map both original and final hostname to the same page
-        domainPages.set(hostname, page);
-        domainPages.set(redirectInfo.currentHostname, page);
-      }
-      hostname = redirectInfo.currentHostname;
-    } else if (redirectInfo.type === 'auth') {
-      logger.info(`Authentication required: ${redirectInfo.flowType}`);
-      logger.info(`Auth URL: ${redirectInfo.currentUrl}`);
-      
-      // Try auto-auth first (check if existing session works)
-      const autoAuthResult = await waitForAutoAuth(page);
-      
-      if (autoAuthResult.success) {
-        logger.info(`Auto-auth successful, now at: ${page.url()}`);
-        // Update hostname to where we landed
-        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, authCompletionTimeout);
-        
-        if (!manualAuthResult.success) {
-          logger.error(`Authentication failed: ${manualAuthResult.error}`);
-          return new ErrorResponse(
-            manualAuthResult.error,
-            [
-              "Complete authentication in the browser window",
-              "Call MCPBrowser's fetch_webpage again with the same URL to retry",
-              "Use MCPBrowser's close_tab to reset the session if authentication fails"
-            ]
-          );
-        }
-        
-        // Update hostname to where we landed
-        if (manualAuthResult.hostname !== hostname) {
-          domainPages.delete(hostname);
-          domainPages.set(manualAuthResult.hostname, page);
-          hostname = manualAuthResult.hostname;
-        }
-        logger.info(`Authentication successful, now at: ${page.url()}`);
+
+    // Auth: handle multi-step auth flows (e.g., server OIDC → client MSAL)
+    // Loop because some sites bounce through auth multiple times before landing.
+    let authAttempts = 0;
+    while (isLikelyAuthUrl(page.url()) && !isLikelyAuthUrl(url) && authAttempts < 3) {
+      authAttempts++;
+      logger.info(`Authentication required (attempt ${authAttempts}): ${page.url()}`);
+      const authResult = await waitForAuth(page);
+      if (!authResult.success) {
+        return new ErrorResponse(
+          authResult.error,
+          [
+            "Complete authentication in the browser window",
+            "Call MCPBrowser's fetch_webpage again with the same URL to retry",
+            "Use MCPBrowser's close_tab to reset the session if authentication fails"
+          ]
+        );
       }
-      
-      // Wait for page stability after auth
-      await waitForPageStability(page);
+      await waitForPageReady(page, { afterInteraction: true });
+      statusCode = null;
+      statusText = '';
     }
-    
-    // Additional wait if requested (for pages that need extra time)
+
+    // Reconcile domain mappings after any redirect (permanent, auth, or none)
+    page = reconcileDomainMapping(page, originalHostname);
+
+    // Additional wait if requested
     if (postLoadWait > 0) {
       logger.debug(`Waiting ${postLoadWait}ms (postLoadWait)...`);
       await new Promise(resolve => setTimeout(resolve, postLoadWait));
@@ -272,15 +210,10 @@ async function doFetchPage({ url, hostname, browser, removeUnnecessaryHTML, post
     
     logger.info(`fetch_webpage completed: ${page.url()}`);
     
-    // Check for non-2xx HTTP status codes - return informational response (not red error)
+    // Check for non-2xx HTTP status codes
     if (statusCode && (statusCode >= 400 && statusCode < 600)) {
       logger.debug(`HTTP ${statusCode} ${statusText} - returning as informational response`);
-      return new HttpStatusResponse(
-        page.url(),
-        statusCode,
-        statusText,
-        processedHtml
-      );
+      return new HttpStatusResponse(page.url(), statusCode, statusText, processedHtml);
     }
     
     return new FetchPageSuccessResponse(
@@ -306,3 +239,32 @@ async function doFetchPage({ url, hostname, browser, removeUnnecessaryHTML, post
     );
   }
 }
+
+/**
+ * Reconcile domain mappings after navigation/redirect.
+ * If the page ended up on a different hostname, map both to the same tab.
+ * If another tab already exists for the new hostname, reuse it.
+ * @param {Page} page - The current Puppeteer page
+ * @param {string} originalHostname - The hostname from the original URL
+ * @returns {Page} The page to use (may differ if an existing tab was found)
+ */
+function reconcileDomainMapping(page, originalHostname) {
+  const currentHostname = new URL(page.url()).hostname;
+  if (currentHostname === originalHostname) return page;
+
+  logger.debug(`Redirect: ${originalHostname} → ${currentHostname}`);
+
+  const existing = domainPages.get(currentHostname);
+  if (existing && existing !== page && !existing.isClosed()) {
+    // Another tab already owns this hostname — close ours, reuse existing
+    logger.debug(`Found existing tab for ${currentHostname}, reusing it`);
+    page.close().catch(() => {});
+    domainPages.set(originalHostname, existing);
+    return existing;
+  }
+
+  // Map both hostnames to same page
+  domainPages.set(originalHostname, page);
+  domainPages.set(currentHostname, page);
+  return page;
+}

package/src/actions/type-text.js

@@ -3,7 +3,7 @@
  */
 
 import { getBrowser, getValidatedPage } from '../core/browser.js';
-import { extractAndProcessHtml, waitForPageStability } from '../core/page.js';
+import { extractAndProcessHtml, waitForPageReady } from '../core/page.js';
 import { MCPResponse, ErrorResponse, InformationalResponse } from '../core/responses.js';
 import logger from '../core/logger.js';
 
@@ -226,59 +226,35 @@ export async function typeText({ url, fields, returnHtml = true, removeUnnecessa
       ? filledSelectors[0] 
       : `${filledSelectors.length} fields (${filledSelectors.join(', ')})`;
     
-    if (returnHtml) {
-      // Wait for page to stabilize (handles form validation, autocomplete, etc.)
-      logger.debug('Waiting for page stability after typing...');
-      await waitForPageStability(page);
-      
-      // Wait for SPAs to render dynamic content after typing
-      if (postTypeWait > 0) {
-        await new Promise(resolve => setTimeout(resolve, postTypeWait));
-      }
-      
-      const currentUrl = page.url();
-      const html = await extractAndProcessHtml(page, removeUnnecessaryHTML);
-      
-      logger.info(`type_text completed: typed into ${fieldsSummary}`);
-      
-      return new TypeTextSuccessResponse(
-        currentUrl,
-        `Typed text into: ${fieldsSummary}`,
-        html,
-        [
+    // Wait for page to stabilize (handles form validation, autocomplete, etc.)
+    logger.debug(`Waiting for page to be ready after typing${returnHtml ? '' : ' (fast mode)'}...`);
+    await waitForPageReady(page, { afterInteraction: true });
+    
+    // Wait for SPAs to render dynamic content after typing
+    if (postTypeWait > 0) {
+      await new Promise(resolve => setTimeout(resolve, postTypeWait));
+    }
+    
+    const currentUrl = page.url();
+    const html = returnHtml ? await extractAndProcessHtml(page, removeUnnecessaryHTML) : null;
+    const nextSteps = returnHtml
+      ? [
           "Use MCPBrowser's type_text to fill additional fields",
           "Use MCPBrowser's click_element to submit the form or navigate",
           "Use MCPBrowser's get_current_html to check for validation messages",
           "Use MCPBrowser's take_screenshot if form has visual feedback or validation that's hard to parse from HTML",
           "Use MCPBrowser's close_tab when finished"
         ]
-      );
-    } else {
-      // Wait for page to stabilize even without returning HTML
-      logger.debug('Waiting for page stability after typing (fast mode)...');
-      await waitForPageStability(page);
-      
-      // Wait for SPAs to render dynamic content after typing
-      if (postTypeWait > 0) {
-        await new Promise(resolve => setTimeout(resolve, postTypeWait));
-      }
-      
-      const currentUrl = page.url();
-      
-      logger.info(`type_text completed: typed into ${fieldsSummary} (no HTML)`);
-      
-      return new TypeTextSuccessResponse(
-        currentUrl,
-        `Typed text into: ${fieldsSummary}`,
-        null,
-        [
+      : [
           "Use MCPBrowser's get_current_html to see updated page state",
           "Use MCPBrowser's take_screenshot if the page has visual feedback that's hard to parse",
           "Use MCPBrowser's type_text for additional fields or MCPBrowser's click_element to submit",
           "Use MCPBrowser's close_tab when finished"
-        ]
-      );
-    }
+        ];
+    
+    logger.info(`type_text completed: typed into ${fieldsSummary}${returnHtml ? '' : ' (no HTML)'}`);
+    
+    return new TypeTextSuccessResponse(currentUrl, `Typed text into: ${fieldsSummary}`, html, nextSteps);
   } catch (err) {
     // Build informative error message for agent
     const totalFields = fields.length;

package/src/browsers/ChromiumBrowser.js

@@ -9,8 +9,9 @@ import puppeteer from 'puppeteer-core';
 import { existsSync } from "fs";
 import os from "os";
 import path from "path";
-import { spawn } from "child_process";
+import { spawn, execSync } from "child_process";
 import logger from '../core/logger.js';
+import { isWSL, wslToWindowsPath, windowsPathToWSL } from '../utils.js';
 
 /**
  * Base class for all Chromium-based browsers
@@ -49,6 +50,18 @@ export class ChromiumBrowser extends BaseBrowser {
     const platform = os.platform();
     const home = os.homedir();
     
+    // In WSL the browser is a Windows process, so the user-data-dir
+    // must reside on a Windows-accessible filesystem (e.g. /mnt/c/…).
+    if (isWSL()) {
+      const windowsLocalAppData = this._getWindowsLocalAppData();
+      if (windowsLocalAppData) {
+        // windowsLocalAppData is already a WSL path like /mnt/c/Users/.../AppData/Local
+        return path.join(windowsLocalAppData, `MCPBrowser/${this.config.userDataDirName}`);
+      }
+      // Fallback: predictable location on C: drive
+      return `/mnt/c/MCPBrowserData/${this.config.userDataDirName}`;
+    }
+    
     if (platform === "win32") {
       return path.join(home, `AppData/Local/MCPBrowser/${this.config.userDataDirName}`);
     } else if (platform === "darwin") {
@@ -74,6 +87,37 @@ export class ChromiumBrowser extends BaseBrowser {
     }
   }
 
+  /**
+   * Resolve the Windows %LOCALAPPDATA% directory as a WSL path.
+   * Cached per-process. Returns null on failure.
+   * @returns {string|null} WSL-style path (e.g. /mnt/c/Users/.../AppData/Local)
+   * @private
+   */
+  _getWindowsLocalAppData() {
+    // Use a class-level cache so we only shell out once
+    if (ChromiumBrowser._wslLocalAppData !== undefined) {
+      return ChromiumBrowser._wslLocalAppData;
+    }
+
+    try {
+      const raw = execSync('cmd.exe /c echo %LOCALAPPDATA%', {
+        encoding: 'utf8',
+        timeout: 5000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+
+      if (raw && !raw.includes('%LOCALAPPDATA%')) {
+        ChromiumBrowser._wslLocalAppData = windowsPathToWSL(raw);
+        return ChromiumBrowser._wslLocalAppData;
+      }
+    } catch {
+      // cmd.exe not available or timed out
+    }
+
+    ChromiumBrowser._wslLocalAppData = null;
+    return null;
+  }
+
   /**
    * Find the browser executable path
    * @returns {string|undefined}
@@ -109,14 +153,24 @@ export class ChromiumBrowser extends BaseBrowser {
       }
 
       const userDataDir = this.getDefaultUserDataDir();
+
+      // When running inside WSL the browser executable is a Windows process.
+      // It does not understand WSL paths (/mnt/c/…), so convert to a native
+      // Windows path for the --user-data-dir argument.
+      const userDataDirArg = isWSL() ? wslToWindowsPath(userDataDir) : userDataDir;
+
       const args = [
         `--remote-debugging-port=${this.config.port}`,
-        `--user-data-dir=${userDataDir}`,
+        `--user-data-dir=${userDataDirArg}`,
         '--no-first-run',
         '--no-default-browser-check'
       ];
 
       logger.info(`Launching ${this.config.name} with remote debugging on port ${this.config.port}...`);
+      if (isWSL()) {
+        logger.info(`WSL detected – launching Windows browser at ${execPath}`);
+        logger.info(`  user-data-dir (Windows): ${userDataDirArg}`);
+      }
       
       const child = spawn(execPath, args, {
         detached: true,
@@ -181,3 +235,6 @@ export class ChromiumBrowser extends BaseBrowser {
     this.browser = null;
   }
 }
+
+// Static cache for WSL %LOCALAPPDATA% lookup (undefined = not yet resolved)
+ChromiumBrowser._wslLocalAppData = undefined;

package/src/browsers/brave.js

@@ -5,9 +5,11 @@
 
 import { ChromiumBrowser } from './ChromiumBrowser.js';
 import os from "os";
+import { isWSL } from '../utils.js';
 
 /**
  * Get platform-specific default paths where Brave browser is typically installed.
+ * When running under WSL, Windows-side paths (via /mnt/c/) are also included.
  * @returns {string[]} Array of possible Brave executable paths for the current platform
  */
 function getDefaultBravePaths() {
@@ -24,13 +26,21 @@ function getDefaultBravePaths() {
       "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
     ];
   } else {
-    return [
+    const paths = [
       "/usr/bin/brave",
       "/usr/bin/brave-browser",
       "/usr/bin/brave-browser-stable",
       "/opt/brave.com/brave/brave-browser",
       "/snap/bin/brave",
     ];
+    // In WSL, also look for Windows-side Brave via /mnt/c/
+    if (isWSL()) {
+      paths.push(
+        "/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe",
+        "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
+      );
+    }
+    return paths;
   }
 }
 

package/src/browsers/chrome.js

@@ -5,9 +5,11 @@
 
 import { ChromiumBrowser } from './ChromiumBrowser.js';
 import os from "os";
+import { isWSL } from '../utils.js';
 
 /**
  * Get platform-specific default paths where Chrome is typically installed.
+ * When running under WSL, Windows-side paths (via /mnt/c/) are also included.
  * @returns {string[]} Array of possible Chrome executable paths for the current platform
  */
 function getDefaultChromePaths() {
@@ -24,11 +26,19 @@ function getDefaultChromePaths() {
       "/Applications/Chromium.app/Contents/MacOS/Chromium",
     ];
   } else {
-    return [
+    const paths = [
       "/usr/bin/google-chrome",
       "/usr/bin/chromium-browser",
       "/usr/bin/chromium",
     ];
+    // In WSL, also look for Windows-side Chrome via /mnt/c/
+    if (isWSL()) {
+      paths.push(
+        "/mnt/c/Program Files/Google/Chrome/Application/chrome.exe",
+        "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+      );
+    }
+    return paths;
   }
 }
 

package/src/browsers/edge.js

@@ -5,9 +5,11 @@
 
 import { ChromiumBrowser } from './ChromiumBrowser.js';
 import os from "os";
+import { isWSL } from '../utils.js';
 
 /**
  * Get platform-specific default paths where Edge browser is typically installed.
+ * When running under WSL, Windows-side paths (via /mnt/c/) are also included.
  * @returns {string[]} Array of possible Edge executable paths for the current platform
  */
 function getDefaultEdgePaths() {
@@ -23,13 +25,21 @@ function getDefaultEdgePaths() {
       "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
     ];
   } else {
-    return [
+    const paths = [
       "/usr/bin/microsoft-edge",
       "/usr/bin/microsoft-edge-stable",
       "/usr/bin/microsoft-edge-beta",
       "/usr/bin/microsoft-edge-dev",
       "/opt/microsoft/msedge/msedge",
     ];
+    // In WSL, also look for Windows-side Edge via /mnt/c/
+    if (isWSL()) {
+      paths.push(
+        "/mnt/c/Program Files/Microsoft/Edge/Application/msedge.exe",
+        "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe",
+      );
+    }
+    return paths;
   }
 }