@agent360/browser-mcp 1.13.0 → 1.15.0

package/README.md

@@ -1,10 +1,16 @@
 # Browser MCP by Agent360
 
+[![npm version](https://img.shields.io/npm/v/@agent360/browser-mcp)](https://www.npmjs.com/package/@agent360/browser-mcp)
+[![npm downloads](https://img.shields.io/npm/dw/@agent360/browser-mcp)](https://www.npmjs.com/package/@agent360/browser-mcp)
+[![GitHub stars](https://img.shields.io/github/stars/Agent360dk/browser-mcp)](https://github.com/Agent360dk/browser-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![MCP](https://img.shields.io/badge/MCP-compatible-blue)](https://modelcontextprotocol.io)
+
 **Control your real Chrome from Claude Code — with your logins, cookies, and 2FA.**
 
 ![Browser MCP Demo](assets/demo.gif)
 
-The only browser MCP with **multi-session support** (10 concurrent AI sessions), **human-in-the-loop** (2FA, CAPTCHA, credentials), and **built-in provider integrations** (Stripe, HubSpot, Slack, and 9 more).
+The only browser MCP with **multi-session support** (10 concurrent AI sessions), **human-in-the-loop** (2FA, CAPTCHA, credentials), and **built-in provider integrations** (Stripe, HubSpot, Slack, and 6 more). 25 tools total.
 
 ## Install
 
@@ -20,7 +26,7 @@ Then load the extension in Chrome:
 3. Click **Load unpacked** → select `~/.browser-mcp/extension/`
 4. Restart Claude Code
 
-That's it. 21 browser tools are now available in Claude Code.
+That's it. 25 browser tools are now available in Claude Code.
 
 ## Why This Over Playwright MCP / BrowserMCP?
 
@@ -30,14 +36,14 @@ That's it. 21 browser tools are now available in Claude Code.
 | **Logins/cookies** | Already authenticated | Must log in every time | Already authenticated |
 | **Multi-session** | 10 concurrent sessions with color-coded tab groups | Single session | Single session |
 | **Human-in-the-loop** | `browser_ask_user` — 2FA, CAPTCHA, credential input | None | None |
-| **Provider integrations** | 12 built-in (Stripe, HubSpot, Slack...) | None | None |
+| **Provider integrations** | 9 built-in (Stripe, HubSpot, Slack...) | None | None |
 | **CORS bypass** | `browser_fetch` from extension background | N/A | Limited |
 | **Network monitoring** | `browser_wait_for_network` via CDP | Built-in | None |
 | **CSP-strict sites** | Chrome Debugger API throughout | Works (headless) | Limited |
 | **Custom dropdowns** | Angular Material, React Select support | Works (headless) | Limited |
 | **Install** | `npx @agent360/browser-mcp install` | `npx @anthropic-ai/mcp-playwright` | Manual clone |
 
-## 21 Tools
+## 25 Tools
 
 ### Navigation & Content
 | Tool | Description |
@@ -78,6 +84,11 @@ That's it. 21 browser tools are now available in Claude Code.
 | `browser_wait_for_network` | Wait for specific API call to complete |
 | `browser_extract_token` | Navigate to provider dashboard + extract API token |
 
+### CAPTCHA Solving
+| Tool | Description |
+|------|-------------|
+| `browser_solve_captcha` | Detect and solve CAPTCHAs. Auto-detects reCAPTCHA v2/v3, hCaptcha, Turnstile, FunCaptcha. Actions: `detect`, `click_checkbox` (auto-click, ~80% pass with Google login), `click_grid` (AI vision guided), `ask_human` (fallback) |
+
 ### Human-in-the-Loop
 | Tool | Description |
 |------|-------------|
@@ -112,8 +123,6 @@ Claude Session 3 ←(stdio)→ MCP :9878 ←(WS)→
 | Mailchimp | `...-us1` | admin.mailchimp.com |
 | Google | OAuth Client | console.cloud.google.com |
 | LinkedIn | Client ID/Secret | linkedin.com/developers |
-| Facebook | `EAA...` | developers.facebook.com |
-| Instagram | Via Facebook | developers.facebook.com |
 
 ## Architecture
 

package/bin/cli.js

@@ -21,6 +21,8 @@ if (command === 'install') {
   install();
 } else if (!command) {
   // No subcommand = start MCP server (Claude Code calls this)
+  // Auto-update extension files if installed via npx
+  autoUpdateExtension();
   await import('../index.js');
 } else {
   console.log(`
@@ -75,16 +77,48 @@ function install() {
 
   // 3. Print next steps
   console.log(`
-📋 Next steps:
-  1. Open Chrome → chrome://extensions
-  2. Enable "Developer mode" (top right toggle)
-  3. Click "Load unpacked"
-  4. Select: ${extensionDir}
-  5. Restart Claude Code — browser tools are now available
+📋 First-time setup (one time only):
+  1. Open Chrome
+  2. Go to chrome://extensions (type it in the address bar)
+  3. Enable "Developer mode" (toggle in top right corner)
+  4. Click "Load unpacked" button (top left)
+  5. Navigate to and select this folder:
+     ${extensionDir}
+  6. The extension "Agent360 Browser MCP" appears with a puzzle icon
+  7. Restart Claude Code — 28 browser tools are now available!
+
+🔄 Auto-updates (fully automatic):
+   - MCP server: always fetches latest from npm (npx @latest)
+   - Extension files: auto-copied when npm version is newer
+   - Extension reload: auto-triggered via WebSocket
+   - You don't need to do anything — updates happen on every Claude Code session start
+
+📖 Docs: https://browsermcp.dev
+`);
+}
 
-🔄 Auto-updates: The MCP server always uses the latest npm version.
-   Extension updates: re-run "npx @agent360/browser-mcp install"
+function autoUpdateExtension() {
+  const home = homedir();
+  const extensionDir = join(home, '.browser-mcp', 'extension');
+  const sourceExtension = join(pkgRoot, 'extension');
 
-📖 Docs: https://github.com/Agent360dk/browser-mcp
-`);
+  if (!existsSync(extensionDir) || !existsSync(sourceExtension)) return;
+
+  try {
+    // Compare manifest versions
+    const installedManifest = join(extensionDir, 'manifest.json');
+    const sourceManifest = join(sourceExtension, 'manifest.json');
+    if (!existsSync(installedManifest)) return;
+
+    const installed = JSON.parse(readFileSync(installedManifest, 'utf8'));
+    const source = JSON.parse(readFileSync(sourceManifest, 'utf8'));
+
+    if (installed.version !== source.version) {
+      cpSync(sourceExtension, extensionDir, { recursive: true });
+      process.stderr.write(`[MCP] Extension auto-updated: ${installed.version} → ${source.version}\n`);
+      process.stderr.write('[MCP] Extension will auto-reload when connected\n');
+      // Signal to index.js that extension needs reload
+      process.env.BROWSER_MCP_EXTENSION_UPDATED = '1';
+    }
+  } catch {}
 }

package/extension/background.js

@@ -118,9 +118,9 @@ function persistSessions() {
 }
 
 // Get the active tab for this session (last navigated), or create one.
-// IMPORTANT: Also activates the tab so Chrome APIs (captureVisibleTab,
-// executeScript) operate on the correct tab, not whatever the user is viewing.
-async function getSessionTab(port, activate = true) {
+// activate=false (default): runs in background — no focus stealing.
+// activate=true: only for commands that NEED visible tab (screenshot, ask_user, navigate, execute_script).
+async function getSessionTab(port, activate = false) {
   const session = getSession(port);
   let target = null;
 
@@ -255,9 +255,22 @@ async function debuggerClick(tabId, x, y) {
       type: 'mouseReleased', x, y, button: 'left', clickCount: 1,
     });
     // 3. CDP doesn't synthesize 'click' event from mousePressed/mouseReleased.
-    //    React/Angular listen on 'click', not mouseup. Fire it via JS as backup.
+    //    Fire JS click + React fiber lookup as backup for React SPAs.
     await chrome.debugger.sendCommand({ tabId }, 'Runtime.evaluate', {
-      expression: `document.elementFromPoint(${x}, ${y})?.click()`,
+      expression: `(() => {
+        const el = document.elementFromPoint(${x}, ${y});
+        if (!el) return;
+        el.click();
+        // React fiber fallback — find and call onClick handler directly
+        const fiberKey = Object.keys(el).find(k => k.startsWith('__reactFiber') || k.startsWith('__reactInternalInstance'));
+        if (fiberKey) {
+          let fiber = el[fiberKey];
+          for (let i = 0; i < 10 && fiber; i++) {
+            if (fiber.memoizedProps?.onClick) { fiber.memoizedProps.onClick(new MouseEvent('click', {bubbles:true})); break; }
+            fiber = fiber.return;
+          }
+        }
+      })()`,
     });
   } finally {
     await debuggerDetach(tabId);
@@ -632,7 +645,7 @@ async function dispatch(port, method, params) {
       // Always reuse the active tab — navigate in place, don't create new tabs
       // Only create new tab if explicitly requested via new_tab param
       if (params.new_tab) {
-        tab = await chrome.tabs.create({ url: params.url, active: true });
+        tab = await chrome.tabs.create({ url: params.url, active: false });
         await addTabToSession(port, tab.id);
       } else {
         await chrome.tabs.update(tab.id, { url: params.url });
@@ -762,7 +775,10 @@ async function dispatch(port, method, params) {
           if (!el) return { ok: false, error: 'Element not found: ' + sel };
           el.scrollIntoView({ block: 'center', behavior: 'instant' });
           el.focus();
-          el.value = val;
+          // Use nativeInputValueSetter to bypass React controlled input
+          const proto = el.tagName === 'TEXTAREA' ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+          const setter = Object.getOwnPropertyDescriptor(proto, 'value')?.set;
+          if (setter) setter.call(el, val); else el.value = val;
           el.dispatchEvent(new Event('input', { bubbles: true }));
           el.dispatchEvent(new Event('change', { bubbles: true }));
           return { ok: true };
@@ -827,16 +843,25 @@ async function dispatch(port, method, params) {
     case 'scroll': {
       const tab = await getSessionTab(port);
       if (tab.url.startsWith('chrome://')) throw new Error('Cannot interact with chrome:// pages');
-      // Scroll to element or by pixels
+      // Scroll to element
       if (params.selector) {
         const el = await resolveElement(tab.id, params.selector);
         if (!el) return { ok: false, error: 'Element not found: ' + params.selector };
         return { ok: true, scrolled_to: params.selector };
       }
-      // Scroll by pixels
+      // Scroll by pixels using CDP mouseWheel — works in React containers with overflow:scroll
       const dx = params.x || 0;
       const dy = params.y || 0;
-      await debuggerEval(tab.id, `window.scrollBy(${dx}, ${dy})`);
+      try {
+        await debuggerAttach(tab.id);
+        await chrome.debugger.sendCommand({ tabId: tab.id }, 'Input.dispatchMouseEvent', {
+          type: 'mouseWheel', x: 400, y: 300, deltaX: dx, deltaY: dy,
+        });
+        await debuggerDetach(tab.id);
+      } catch {
+        // Fallback to window.scrollBy for simple pages
+        await debuggerEval(tab.id, `window.scrollBy(${dx}, ${dy})`);
+      }
       return { ok: true, scrolled: { x: dx, y: dy } };
     }
 
@@ -1061,8 +1086,91 @@ async function dispatch(port, method, params) {
       return { value, method: 'debugger' };
     }
 
-    case 'ask_user': {
+    case 'set_cookies': {
+      const results = [];
+      const cookieList = Array.isArray(params.cookies) ? params.cookies : [params];
+      for (const c of cookieList) {
+        try {
+          const cookie = await chrome.cookies.set({
+            url: c.url || `https://${c.domain}`,
+            name: c.name,
+            value: c.value,
+            domain: c.domain,
+            path: c.path || '/',
+            secure: c.secure !== false,
+            httpOnly: c.httpOnly || false,
+            sameSite: c.sameSite || 'lax',
+          });
+          results.push({ ok: true, name: c.name });
+        } catch (e) {
+          results.push({ ok: false, name: c.name, error: e.message });
+        }
+      }
+      return { results };
+    }
+
+    case 'set_local_storage': {
+      const tab = await getSessionTab(port);
+      if (tab.url.startsWith('chrome://')) throw new Error('Cannot access chrome:// pages');
+      const key = params.key;
+      const val = params.value;
+      const expr = `localStorage.setItem(${JSON.stringify(key)}, ${JSON.stringify(val)})`;
+      try {
+        const scriptResult = await safeExecuteScript(tab.id, (k, v) => { localStorage.setItem(k, v); return { ok: true }; }, [key, val]);
+        if (!scriptResult.cspBlocked) return scriptResult.result;
+      } catch {}
+      await debuggerEval(tab.id, expr);
+      return { ok: true, method: 'debugger' };
+    }
+
+    case 'console_logs': {
       const tab = await getSessionTab(port);
+      const count = params.count || 50;
+      try {
+        await debuggerAttach(tab.id);
+        await chrome.debugger.sendCommand({ tabId: tab.id }, 'Runtime.enable');
+        // Collect console messages for a brief period
+        const logs = [];
+        const handler = (source, method, eventParams) => {
+          if (source.tabId === tab.id && method === 'Runtime.consoleAPICalled') {
+            logs.push({
+              type: eventParams.type,
+              text: eventParams.args?.map(a => a.value || a.description || '').join(' '),
+              timestamp: eventParams.timestamp,
+            });
+          }
+        };
+        chrome.debugger.onEvent.addListener(handler);
+        // Also grab existing console via page JS
+        const { result } = await chrome.debugger.sendCommand({ tabId: tab.id }, 'Runtime.evaluate', {
+          expression: `(() => {
+            if (!window.__mcpConsoleLogs) {
+              window.__mcpConsoleLogs = [];
+              const orig = { log: console.log, warn: console.warn, error: console.error, info: console.info };
+              for (const [type, fn] of Object.entries(orig)) {
+                console[type] = (...args) => {
+                  window.__mcpConsoleLogs.push({ type, text: args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' '), ts: Date.now() });
+                  if (window.__mcpConsoleLogs.length > 200) window.__mcpConsoleLogs.shift();
+                  fn.apply(console, args);
+                };
+              }
+            }
+            return JSON.stringify(window.__mcpConsoleLogs.slice(-${count}));
+          })()`,
+          returnByValue: true,
+        });
+        chrome.debugger.onEvent.removeListener(handler);
+        await debuggerDetach(tab.id);
+        const existing = JSON.parse(result.value || '[]');
+        return { logs: [...existing, ...logs].slice(-count) };
+      } catch (e) {
+        try { await debuggerDetach(tab.id); } catch {}
+        return { logs: [], error: e.message };
+      }
+    }
+
+    case 'ask_user': {
+      const tab = await getSessionTab(port, true);
       const timeout = params.timeout || 120000;
       const fields = params.fields || [];
       const hasFields = fields.length > 0;
@@ -1262,11 +1370,249 @@ async function dispatch(port, method, params) {
       return { ok: true, remaining: session.tabIds.size };
     }
 
+    case 'solve_captcha': {
+      const tab = await getSessionTab(port);
+      const action = params.action || 'detect';
+
+      // ── Detect CAPTCHA on page ──
+      if (action === 'detect') {
+        const detection = await detectCaptcha(tab.id);
+        return detection;
+      }
+
+      // ── Auto-click reCAPTCHA checkbox ──
+      if (action === 'click_checkbox') {
+        const result = await clickRecaptchaCheckbox(tab.id);
+        // Wait for challenge or pass
+        await new Promise(r => setTimeout(r, 2500));
+        // Re-detect to see if it passed or image challenge appeared
+        const after = await detectCaptcha(tab.id);
+        return { ...result, after };
+      }
+
+      // ── Click specific grid cells (AI vision guided) ──
+      if (action === 'click_grid') {
+        const cells = params.cells || [];
+        if (!cells.length) return { error: 'No cells specified' };
+        const result = await clickCaptchaGridCells(tab.id, cells);
+        return result;
+      }
+
+      // ── Human fallback ──
+      if (action === 'ask_human') {
+        return { method: 'human', instructions: 'Call browser_ask_user with message: "A CAPTCHA needs to be solved. Please solve it in the browser and click Done when finished."' };
+      }
+
+      return { error: 'Unknown action: ' + action };
+    }
+
+    case 'reload_extension': {
+      // MCP server signals that extension files were updated via npx
+      // Reload after a short delay to allow response to be sent
+      setTimeout(() => chrome.runtime.reload(), 500);
+      return { ok: true, message: 'Extension reloading in 500ms' };
+    }
+
     default:
       throw new Error('Unknown method: ' + method);
   }
 }
 
+// ── CAPTCHA Detection & Solving Helpers ─────────────────────────────────────
+
+async function detectCaptcha(tabId) {
+  try {
+    await debuggerAttach(tabId);
+    const { result } = await chrome.debugger.sendCommand({ tabId }, 'Runtime.evaluate', {
+      expression: `(() => {
+        const res = { found: false, types: [] };
+
+        // reCAPTCHA v2 — checkbox iframe
+        const recaptchaAnchor = document.querySelector('iframe[src*="recaptcha/api2/anchor"], iframe[src*="recaptcha/enterprise/anchor"]');
+        if (recaptchaAnchor) {
+          res.found = true;
+          res.types.push('recaptcha_v2_checkbox');
+          const container = document.querySelector('.g-recaptcha');
+          if (container) res.sitekey = container.getAttribute('data-sitekey');
+        }
+
+        // reCAPTCHA v2 — image challenge iframe
+        const recaptchaChallenge = document.querySelector('iframe[src*="recaptcha/api2/bframe"], iframe[src*="recaptcha/enterprise/bframe"]');
+        if (recaptchaChallenge) {
+          res.found = true;
+          if (!res.types.includes('recaptcha_v2_checkbox')) res.types.push('recaptcha_v2_image');
+          res.types.push('recaptcha_v2_challenge_visible');
+          // Get iframe dimensions for grid clicking
+          const rect = recaptchaChallenge.getBoundingClientRect();
+          res.challengeFrame = { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
+        }
+
+        // reCAPTCHA v3 — invisible badge
+        const recaptchaV3 = document.querySelector('.grecaptcha-badge');
+        if (recaptchaV3 && !recaptchaAnchor) {
+          res.found = true;
+          res.types.push('recaptcha_v3_invisible');
+          res.note = 'reCAPTCHA v3 is invisible and score-based. Real Chrome with Google login usually passes automatically. No action needed.';
+        }
+
+        // hCaptcha
+        const hcaptcha = document.querySelector('iframe[src*="hcaptcha.com"], .h-captcha');
+        if (hcaptcha) {
+          res.found = true;
+          res.types.push('hcaptcha');
+          const container = document.querySelector('.h-captcha');
+          if (container) res.sitekey = container.getAttribute('data-sitekey');
+        }
+
+        // Cloudflare Turnstile
+        const turnstile = document.querySelector('iframe[src*="challenges.cloudflare.com"], .cf-turnstile');
+        if (turnstile) {
+          res.found = true;
+          res.types.push('cloudflare_turnstile');
+          const container = document.querySelector('.cf-turnstile');
+          if (container) res.sitekey = container.getAttribute('data-sitekey');
+        }
+
+        // Cloudflare challenge page (5-second interstitial)
+        if (document.title.includes('Just a moment') || document.querySelector('#challenge-running')) {
+          res.found = true;
+          res.types.push('cloudflare_challenge_page');
+          res.note = 'Cloudflare challenge page. Wait 5-10 seconds — real Chrome usually passes automatically.';
+        }
+
+        // FunCaptcha / Arkose Labs
+        const funcaptcha = document.querySelector('#FunCaptcha, iframe[src*="funcaptcha"], iframe[src*="arkoselabs"]');
+        if (funcaptcha) {
+          res.found = true;
+          res.types.push('funcaptcha');
+        }
+
+        if (!res.found) res.note = 'No CAPTCHA detected on this page.';
+        res.pageUrl = window.location.href;
+        return JSON.stringify(res);
+      })()`,
+      returnByValue: true,
+    });
+    await debuggerDetach(tabId);
+    return JSON.parse(result.value);
+  } catch (e) {
+    try { await debuggerDetach(tabId); } catch {}
+    return { found: false, error: e.message };
+  }
+}
+
+async function clickRecaptchaCheckbox(tabId) {
+  try {
+    await debuggerAttach(tabId);
+    // Find the reCAPTCHA anchor iframe position
+    const { result } = await chrome.debugger.sendCommand({ tabId }, 'Runtime.evaluate', {
+      expression: `(() => {
+        const iframe = document.querySelector('iframe[src*="recaptcha/api2/anchor"], iframe[src*="recaptcha/enterprise/anchor"]');
+        if (!iframe) return JSON.stringify({ found: false });
+        const rect = iframe.getBoundingClientRect();
+        // Checkbox is roughly at 27,30 inside the iframe (standard reCAPTCHA layout)
+        return JSON.stringify({ found: true, x: rect.x + 27, y: rect.y + 30 });
+      })()`,
+      returnByValue: true,
+    });
+    const pos = JSON.parse(result.value);
+    if (!pos.found) {
+      await debuggerDetach(tabId);
+      return { clicked: false, reason: 'reCAPTCHA checkbox iframe not found' };
+    }
+
+    // Click the checkbox using real mouse events
+    await chrome.debugger.sendCommand({ tabId }, 'Input.dispatchMouseEvent', {
+      type: 'mouseMoved', x: pos.x, y: pos.y,
+    });
+    await new Promise(r => setTimeout(r, 100 + Math.random() * 200));
+    await chrome.debugger.sendCommand({ tabId }, 'Input.dispatchMouseEvent', {
+      type: 'mousePressed', x: pos.x, y: pos.y, button: 'left', clickCount: 1,
+    });
+    await chrome.debugger.sendCommand({ tabId }, 'Input.dispatchMouseEvent', {
+      type: 'mouseReleased', x: pos.x, y: pos.y, button: 'left', clickCount: 1,
+    });
+    await debuggerDetach(tabId);
+    return { clicked: true, position: pos, note: 'Checkbox clicked. Wait 2-3 seconds then re-detect to check if passed or image challenge appeared.' };
+  } catch (e) {
+    try { await debuggerDetach(tabId); } catch {}
+    return { clicked: false, error: e.message };
+  }
+}
+
+async function clickCaptchaGridCells(tabId, cells) {
+  try {
+    await debuggerAttach(tabId);
+    // Find the challenge iframe position and dimensions
+    const { result } = await chrome.debugger.sendCommand({ tabId }, 'Runtime.evaluate', {
+      expression: `(() => {
+        const iframe = document.querySelector('iframe[src*="recaptcha/api2/bframe"], iframe[src*="recaptcha/enterprise/bframe"]');
+        if (!iframe) return JSON.stringify({ found: false });
+        const rect = iframe.getBoundingClientRect();
+        return JSON.stringify({ found: true, x: rect.x, y: rect.y, width: rect.width, height: rect.height });
+      })()`,
+      returnByValue: true,
+    });
+    const frame = JSON.parse(result.value);
+    if (!frame.found) {
+      await debuggerDetach(tabId);
+      return { clicked: false, reason: 'Challenge iframe not found. Take a screenshot to verify CAPTCHA state.' };
+    }
+
+    // Determine grid size — reCAPTCHA uses 3x3 or 4x4 grids
+    // The image grid starts ~100px from top of iframe, and is roughly square
+    const gridTop = frame.y + 100;
+    const gridLeft = frame.x + 14;
+    const gridSize = frame.width - 28; // padding on each side
+    const cols = cells.some(c => c >= 9) ? 4 : 3;
+    const rows = cols;
+    const cellSize = gridSize / cols;
+
+    const maxCell = cols * rows - 1;
+    const validCells = cells.filter(c => c >= 0 && c <= maxCell);
+    if (!validCells.length) {
+      await debuggerDetach(tabId);
+      return { clicked: false, error: `All cell indices out of bounds. Grid is ${cols}x${rows}, valid range: 0-${maxCell}` };
+    }
+
+    const clicked = [];
+    for (const cell of validCells) {
+      const row = Math.floor(cell / cols);
+      const col = cell % cols;
+      const x = Math.round(gridLeft + col * cellSize + cellSize / 2);
+      const y = Math.round(gridTop + row * cellSize + cellSize / 2);
+
+      // Human-like click with small random offset
+      const ox = x + Math.round((Math.random() - 0.5) * cellSize * 0.3);
+      const oy = y + Math.round((Math.random() - 0.5) * cellSize * 0.3);
+
+      await chrome.debugger.sendCommand({ tabId }, 'Input.dispatchMouseEvent', {
+        type: 'mouseMoved', x: ox, y: oy,
+      });
+      await new Promise(r => setTimeout(r, 150 + Math.random() * 300));
+      await chrome.debugger.sendCommand({ tabId }, 'Input.dispatchMouseEvent', {
+        type: 'mousePressed', x: ox, y: oy, button: 'left', clickCount: 1,
+      });
+      await chrome.debugger.sendCommand({ tabId }, 'Input.dispatchMouseEvent', {
+        type: 'mouseReleased', x: ox, y: oy, button: 'left', clickCount: 1,
+      });
+      await new Promise(r => setTimeout(r, 200 + Math.random() * 400));
+      clicked.push({ cell, row, col, x: ox, y: oy });
+    }
+
+    await debuggerDetach(tabId);
+    return {
+      clicked: true,
+      cells: clicked,
+      grid: `${cols}x${rows}`,
+      note: 'Cells clicked. Take a screenshot to verify, then click the "Verify" / "Skip" button if needed.',
+    };
+  } catch (e) {
+    try { await debuggerDetach(tabId); } catch {}
+    return { clicked: false, error: e.message };
+  }
+}
+
 // ── Start ───────────────────────────────────────────────────────────────────
 ensureOffscreen().catch(console.error);
 

package/extension/manifest.json

@@ -1,8 +1,8 @@
 {
   "manifest_version": 3,
   "name": "Agent360 Browser MCP",
-  "version": "1.13.0",
-  "description": "Lader Claude Code styre din browser — forbind tjenester, hent tokens, automatisér workflows. Multi-session support.",
+  "version": "1.15.0",
+  "description": "Control your real Chrome from Claude Code — navigate, click, fill, screenshot, solve CAPTCHAs. 24 tools, multi-session, human-in-the-loop.",
   "permissions": [
     "tabs",
     "tabGroups",

package/extension/popup.html

@@ -44,21 +44,21 @@
 
   <div class="status">
     <div class="dot off" id="dot"></div>
-    <span class="label" id="label">Tjekker...</span>
+    <span class="label" id="label">Checking...</span>
   </div>
 
   <div class="section-title">Sessions</div>
   <div id="sessions" class="sessions">
-    <div class="empty">Ingen aktive sessions</div>
+    <div class="empty">No active sessions</div>
   </div>
 
   <div class="section-title">Action Log</div>
   <div class="log" id="log">
-    <div class="empty">Ingen actions endnu</div>
+    <div class="empty">No actions yet</div>
   </div>
 
   <button id="reconnect">Reconnect</button>
-  <button id="clearLog" style="margin-top:4px">Ryd log</button>
+  <button id="clearLog" style="margin-top:4px">Clear log</button>
 
   <script src="popup.js"></script>
 </body>

package/index.js

@@ -78,6 +78,15 @@ function createWSS(port = BASE_PORT) {
     extensionSocket = ws;
     process.stderr.write(`[MCP] Chrome extension connected on port ${port}\n`);
 
+    // If extension was auto-updated, trigger reload
+    if (process.env.BROWSER_MCP_EXTENSION_UPDATED === '1') {
+      process.env.BROWSER_MCP_EXTENSION_UPDATED = '';
+      process.stderr.write('[MCP] Extension files updated — triggering auto-reload\n');
+      setTimeout(() => {
+        sendToExtension('reload_extension', {}, 5000).catch(() => {});
+      }, 1000);
+    }
+
     ws.on('message', (data) => {
       let msg;
       try { msg = JSON.parse(data.toString()); } catch { return; }
@@ -179,9 +188,14 @@ const INSTRUCTIONS = `You control the user's real Chrome browser via this MCP se
 - browser_press_key("a", ctrl=true) — select all
 
 ## CAPTCHA handling
-- After navigate, check the response for captcha_detected field
-- If captcha_detected is set, use browser_ask_user: "A CAPTCHA was detected on this page. Please solve it in the browser, then click Done."
-- After user solves it, retry the navigation or continue with the page
+Use browser_solve_captcha to detect and solve CAPTCHAs automatically:
+1. Call browser_solve_captcha() — detects CAPTCHA type on page
+2. If reCAPTCHA v2 checkbox found → call browser_solve_captcha(action="click_checkbox") — auto-clicks, passes ~80% with logged-in Google
+3. If image challenge appears → call browser_screenshot, analyze the grid visually, then call browser_solve_captcha(action="click_grid", cells=[2,5,7]) with the correct cell indices
+4. If all else fails → call browser_solve_captcha(action="ask_human") to show overlay to user
+5. After solving, retry the action that was blocked
+
+For image grid challenges: cells are 0-indexed, left-to-right, top-to-bottom. A 3x3 grid has cells 0-8. A 4x4 grid has cells 0-15.
 
 ## OAuth popups
 - OAuth popups (Google, Microsoft, GitHub, Slack, HubSpot) are automatically intercepted and added to your session's tab group
@@ -205,7 +219,7 @@ If the extension files were updated, ask the user to reload it:
 You cannot navigate to chrome:// pages — the user must do this manually.`;
 
 const mcpServer = new Server(
-  { name: 'agent360-browser', version: '1.12.0' },
+  { name: 'agent360-browser', version: '1.15.0' },
   { capabilities: { tools: {} } },
   { instructions: INSTRUCTIONS },
 );
@@ -243,6 +257,10 @@ mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
       browser_get_new_tab: 'get_new_tab',
       browser_switch_tab: 'switch_tab',
       browser_close_tab: 'close_tab',
+      browser_set_cookies: 'set_cookies',
+      browser_set_local_storage: 'set_local_storage',
+      browser_console_logs: 'console_logs',
+      browser_solve_captcha: 'solve_captcha',
     };
 
     if (name === 'browser_extract_token') {
@@ -254,7 +272,8 @@ mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
       return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
     }
 
-    const timeout = method === 'ask_user' ? (args?.timeout || 120000) + 5000 : 30000;
+    const timeout = method === 'ask_user' ? (args?.timeout || 120000) + 5000 :
+                    method === 'solve_captcha' ? 60000 : 30000;
     const result = await sendToExtension(method, args || {}, timeout);
 
     if (name === 'browser_screenshot' && result?.image) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agent360/browser-mcp",
-  "version": "1.13.0",
-  "description": "Browser MCP — control your real Chrome from Claude Code. Multi-session, human-in-the-loop, 21 tools.",
+  "version": "1.15.0",
+  "description": "Browser MCP — control your real Chrome from Claude Code. 28 tools, CAPTCHA solving, multi-session, human-in-the-loop.",
   "type": "module",
   "main": "index.js",
   "bin": {
@@ -19,18 +19,29 @@
   },
   "keywords": [
     "mcp",
+    "mcp-server",
+    "model-context-protocol",
     "browser",
+    "browser-mcp",
+    "browser-automation",
     "chrome",
+    "chrome-extension",
     "claude",
     "claude-code",
-    "automation",
     "ai-agent",
-    "browser-automation",
-    "model-context-protocol"
+    "captcha",
+    "captcha-solver",
+    "human-in-the-loop",
+    "web-automation",
+    "playwright-alternative",
+    "selenium-alternative"
   ],
+  "engines": {
+    "node": ">=18"
+  },
   "author": "Agent360 <hello@agent360.dk>",
   "license": "MIT",
-  "homepage": "https://github.com/Agent360dk/browser-mcp",
+  "homepage": "https://browsermcp.dev",
   "repository": {
     "type": "git",
     "url": "https://github.com/Agent360dk/browser-mcp.git"

package/tools.js

@@ -194,6 +194,47 @@ export const TOOLS = [
       },
     },
   },
+  {
+    name: 'browser_set_cookies',
+    description: 'Set one or more cookies for a domain.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Cookie name' },
+        value: { type: 'string', description: 'Cookie value' },
+        domain: { type: 'string', description: 'Cookie domain (e.g. ".example.com")' },
+        url: { type: 'string', description: 'URL for the cookie (alternative to domain)' },
+        path: { type: 'string', description: 'Cookie path (default: /)' },
+        secure: { type: 'boolean', description: 'Secure flag (default: true)' },
+        httpOnly: { type: 'boolean', description: 'HttpOnly flag (default: false)' },
+        sameSite: { type: 'string', enum: ['no_restriction', 'lax', 'strict'], description: 'SameSite attribute (default: lax)' },
+        cookies: { type: 'array', description: 'Array of cookie objects to set multiple at once', items: { type: 'object' } },
+      },
+      required: ['name', 'value'],
+    },
+  },
+  {
+    name: 'browser_set_local_storage',
+    description: 'Set a localStorage key-value pair on the current page.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        key: { type: 'string', description: 'localStorage key to set' },
+        value: { type: 'string', description: 'Value to store (string)' },
+      },
+      required: ['key', 'value'],
+    },
+  },
+  {
+    name: 'browser_console_logs',
+    description: 'Get recent console.log/warn/error messages from the page. Installs a lightweight interceptor on first call. Returns the last N console messages.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        count: { type: 'number', description: 'Number of recent messages to return (default: 50)' },
+      },
+    },
+  },
   {
     name: 'browser_ask_user',
     description: 'Show an overlay dialog asking the user to perform an action or provide information (credentials, 2FA, CAPTCHA, OAuth consent). Can include input fields for the user to fill in. Returns user responses.',
@@ -276,6 +317,21 @@ export const TOOLS = [
       required: ['provider'],
     },
   },
+  {
+    name: 'browser_solve_captcha',
+    description: 'Detect and solve CAPTCHAs on the current page. Auto-detects reCAPTCHA v2/v3, hCaptcha, Cloudflare Turnstile, and FunCaptcha. Tries auto-click first (works ~80% with logged-in Google), then returns a screenshot for AI vision analysis, then falls back to asking the user. Returns detection info and solving status.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: { type: 'string', enum: ['detect', 'click_checkbox', 'click_grid', 'ask_human'], description: 'Action to take. "detect" scans for CAPTCHAs. "click_checkbox" clicks the reCAPTCHA checkbox. "click_grid" clicks specific grid cells (pass cells param). "ask_human" shows overlay to user. Default: "detect"' },
+        cells: {
+          type: 'array',
+          items: { type: 'number' },
+          description: 'Grid cell indices to click (0-indexed, left-to-right, top-to-bottom) for image challenges. E.g. [2, 5, 7] to click cells 3, 6, 8.',
+        },
+      },
+    },
+  },
 ];
 
 // Known provider token pages for browser_extract_token