real-browser-mcp-server 1.1.1 → 1.1.3

package/Dockerfile

@@ -58,7 +58,6 @@ COPY --from=builder /app/node_modules ./node_modules
 COPY --from=builder /app/package*.json ./
 COPY --from=builder /app/lib ./lib
 COPY --from=builder /app/test ./test
-COPY --from=builder /app/packages ./packages
 COPY --from=builder /app/typings.d.ts ./
 
 # Set ownership to non-root user

package/README.md

@@ -11,11 +11,31 @@ This server is **100% compatible with all major AI IDEs** (Cursor, VS Code, Clin
 
 ---
 
+## ⚙️ Installation & Setup
+
+To install and run the server locally, clone the repository, install NPM dependencies, and configure the undetected browser binary using **Patchright**:
+
+```bash
+# 1. Clone the repository
+git clone https://github.com/codeiva4u/Real-Browser-Mcp-Server.git
+
+# 2. Navigate to the project directory
+cd Real-Browser-Mcp-Server
+
+# 3. Install dependencies
+npm install
+
+# 4. Install Chromium-Driver for Patchright (Undetected Browser binary)
+npx patchright install chromium
+```
+
+---
+
 ## 🚀 Key Evasion & Stealth Features
 
 * **Undetected Browser Engine**: Powered by **Patchright Chromium**, bypassing modern fingerprinting checks (does not expose automation indicators or Webdriver/BiDi flags).
 * **Integrated Ad & Tracker Blocker**: Utilizes `@ghostery/adblocker-playwright` with asynchronous pre-compiled filter caching to `adblocker.bin`, blocking ads and speed-bumps completely offline.
-* **Human-like Interactions**: Integrates **playwright-ghost** (Bézier curves auto-hooking) to transparently simulate human mouse movements, velocity, and natural hover-before-click behaviors.
+* **Human-like Interactions**: Integrates **ghost-cursor-patchright** (Bézier curves) to transparently simulate human mouse movements, velocity, and natural hover-before-click behaviors. Features **Physics-based Smooth Scrolling** (`page.realScroll`) utilizing real mouse-wheel events and Cubic Ease-Out deceleration to perfectly mimic manual trackpad/mouse flicks, bypassing advanced behavioral detectors.
 * **Turnstile Auto-Solver**: Seamlessly detects and bypasses Cloudflare Turnstile widgets.
 * **Anti-Race Condition Guards**: Robust state-guards ensure popup blockers, shims, and adblockers attach exactly once per page, preventing context destruction.
 
@@ -60,14 +80,17 @@ Add the server entry to your global MCP settings file (typically found at `%APPD
 {
   "mcpServers": {
     "real-browser-mcp-server": {
-      "command": "node",
+      "type": "stdio",
+      "command": "C:/Program Files/nodejs/node.exe",
       "args": [
         "c:/Users/Admin/Desktop/Software/Real-Browser-Mcp-Server/src/index.js"
       ],
       "env": {
         "HEADLESS": "false"
       },
-      "disabled": false
+      "disabled": false,
+      "autoApprove": [],
+      "timeout": 120
     }
   }
 }
@@ -116,9 +139,9 @@ Configure the server in your `opencode.jsonc` or standard MCP settings configura
 
 ---
 
-## 🌐 Complete MCP Tool Reference (22 Tools)
+## 🌐 Complete MCP Tool Reference (25 Tools)
 
-The server exposes 22 highly optimized tools categorized into functional units:
+The server exposes 25 highly optimized tools categorized into functional units:
 
 ### 🌐 Browser & Session
 | Tool Name | Description | Parameters |
@@ -138,7 +161,7 @@ The server exposes 22 highly optimized tools categorized into functional units:
 | `click` | Human-like click using AI healing, ghost cursor, and iframe support. | `selector` (string), `hoverFirst` (boolean) |
 | `type` | Type text with human speed variation, smart clearing, and iframe support. | `selector` (string), `text` (string) |
 | `solve_captcha` | Auto-solve CAPTCHAs (Turnstile, reCAPTCHA, hCaptcha, OCR). | `selector` (string) |
-| `random_scroll` | Simulated human scrolling with natural patterns and lazy-load triggers. | `direction` (string), `amount` (number) |
+| `random_scroll` | Simulated human scrolling with natural patterns and lazy-load triggers. | `direction` (string), `amount` (number), `smooth` (boolean) |
 | `press_key` | Press keyboard keys with modifier key support (Ctrl/Shift/Alt). | `key` (string), `modifiers` (array) |
 | `execute_js` | Run custom asynchronous/synchronous JavaScript inside a page or iframe. | `code` (string), `iframeIndex` (number) |
 
@@ -162,6 +185,17 @@ The server exposes 22 highly optimized tools categorized into functional units:
 | `wait` | Smart delay with AI prediction or static timeout. | `duration` (number) |
 | `progress_tracker` | Track running automation progress with AI-estimated remaining times. | `step` (string), `percentage` (number) |
 
+### 📸 Capture
+| Tool Name | Description | Parameters |
+|:---|:---|:---|
+| `screenshot` | Capture viewport, full page, or a specific element. Returns the image to the AI agent (base64) and can save to a file. | `fullPage` (boolean), `selector` (string), `format` (png/jpeg), `path` (string) |
+| `save_as_pdf` | Save the current page as a PDF via Chromium print-to-PDF (headless mode only). | `path` (string), `format` (string), `landscape` (boolean) |
+
+### 👁️ AI Vision (Eyes)
+| Tool Name | Description | Parameters |
+|:---|:---|:---|
+| `see_page` | Lets the AI **visually SEE** the page like human eyes: returns the actual screenshot image to the agent **plus** a "visual map" of every visible interactive element (button/link/input) with its on-screen position, text label, and a click-ready selector. Use it to look before deciding where to click/type. | `fullPage` (boolean), `format` (png/jpeg), `includeElements` (boolean), `maxElements` (number) |
+
 ---
 
 ## 📈 Evasion Performance & Test Coverage
@@ -180,6 +214,39 @@ Our test suites run headless/headed simulations against all major fingerprinting
 | **CreepJS Fingerprinting** | Advanced trust rating and fingerprint check | ✅ Pass |
 | **Pixelscan Fingerprint** | Masque & Canvas fingerprint masking check | ✅ Pass (No Masking Detected) |
 
+### 🧪 Local Test Suite Execution Status
+
+Both the CommonJS and ES Module test suites execute and pass successfully under Node.js:
+
+| Test Suite / Environment | Test Case | Status |
+|:---|:---|:---|
+| **CommonJS (`cjs_test`)** | DrissionPage Detector | ✅ Passed |
+| **CommonJS (`cjs_test`)** | Sannysoft WebDriver Detector | ✅ Passed |
+| **CommonJS (`cjs_test`)** | Cloudflare WAF | ✅ Passed |
+| **CommonJS (`cjs_test`)** | Cloudflare Turnstile | ✅ Passed |
+| **CommonJS (`cjs_test`)** | Fingerprint JS Bot Detector | ✅ Passed |
+| **CommonJS (`cjs_test`)** | Recaptcha V3 Score | ✅ Passed |
+| **CommonJS (`cjs_test`)** | Pixelscan Fingerprint Check | ✅ Passed |
+| **CommonJS (`cjs_test`)** | Human-like Move & Click | ✅ Passed |
+| **CommonJS (`cjs_test`)** | Human-like Typing | ✅ Passed |
+| **CommonJS (`cjs_test`)** | Human-like Scrolling | ✅ Passed |
+| **CommonJS (`cjs_test`)** | Form Automation Demonstration | ✅ Passed |
+| **CommonJS (`cjs_test`)** | Content Strategy Demonstration | ✅ Passed |
+| **ES Module (`esm_test`)** | DrissionPage Detector | ✅ Passed |
+| **ES Module (`esm_test`)** | Sannysoft WebDriver Detector | ✅ Passed |
+| **ES Module (`esm_test`)** | Cloudflare WAF | ✅ Passed |
+| **ES Module (`esm_test`)** | Cloudflare Turnstile | ✅ Passed |
+| **ES Module (`esm_test`)** | Fingerprint JS Bot Detector | ✅ Passed |
+| **ES Module (`esm_test`)** | Recaptcha V3 Score | ✅ Passed |
+| **ES Module (`esm_test`)** | Pixelscan Fingerprint Check | ✅ Passed |
+| **ES Module (`esm_test`)** | Human-like Move & Click | ✅ Passed |
+| **ES Module (`esm_test`)** | Human-like Typing | ✅ Passed |
+| **ES Module (`esm_test`)** | Human-like Scrolling | ✅ Passed |
+| **ES Module (`esm_test`)** | Form Automation Demonstration | ✅ Passed |
+| **ES Module (`esm_test`)** | Content Strategy Demonstration | ✅ Passed |
+
+---
+
 ---
 
 ## 💻 Programmatic Usage (Node.js SDK)
@@ -201,6 +268,9 @@ const { connect } = require('real-browser-mcp-server');
   // Real mouse movement and click
   await page.realClick('#my-button');
   
+  // Real human-like smooth scrolling (60FPS Cubic Ease-Out physics)
+  await page.realScroll(400); // scrolls down 400px smoothly
+  
   await browser.close();
 })();
 ```
@@ -216,6 +286,10 @@ const { browser, page } = await connect({
 
 await page.goto('https://example.com');
 await page.realClick('#my-button');
+
+// Real human-like smooth scrolling (60FPS Cubic Ease-Out physics)
+await page.realScroll(400); // scrolls down 400px smoothly
+
 await browser.close();
 ```
 
@@ -231,11 +305,12 @@ Run these scripts from the project root directory:
 | `npm run dev` | Alias to start the MCP server. |
 | `npm run mcp` | Start the MCP server. |
 | `npm run mcp:verbose` | Start the MCP server with verbose logging on `stderr`. |
-| `npm run list` | Clean list of all 22 tools with emojis and categories. |
+| `npm run list` | Clean list of all 25 tools with emojis and categories. |
 | `npm run build` | Validate workspace structure and confirm library status. |
 | `npm test` | Execute the full test suite (CJS & ESM). |
 | `npm run cjs_test` | Run CommonJS test scripts. |
 | `npm run esm_test` | Run ECMAScript Module test scripts. |
+| `npm run mcp_test` | Fast, network-independent MCP smoke test (handshake + tool registry validation). |
 
 ---
 

package/lib/cjs/index.js

@@ -1,9 +1,7 @@
+const { chromium } = require("patchright");
+const { createCursor } = require("ghost-cursor-patchright");
 const { PlaywrightBlocker } = require("@ghostery/adblocker-playwright");
 const { pageController } = require("./module/pageController.js");
-
-// Dynamically load pure ESM playwright-ghost to be fully compatible with CommonJS
-const playwrightGhostPromise = import("playwright-ghost/patchright");
-const recommendedPromise = import("playwright-ghost/plugins/recommended");
 const fs = require('fs');
 const path = require('path');
 
@@ -68,13 +66,28 @@ function loadEnvFile() {
 loadEnvFile();
 
 function getDefaultHeadless() {
-  const envHeadless = (process.env.HEADLESS || '').toLowerCase();
-  return envHeadless === 'true';
+  const envHeadless = process.env.HEADLESS;
+  if (envHeadless !== undefined && envHeadless !== null && envHeadless !== '') {
+    const value = envHeadless.toLowerCase().trim();
+    return value === 'true' || value === '1' || value === 'yes';
+  }
+  // Auto-detect CI environments
+  if (process.env.CI || process.env.GITHUB_ACTIONS || process.env.TRAVIS || process.env.CIRCLECI) {
+    return true;
+  }
+  // Auto-detect headless Linux environments without X11 or Wayland
+  if (process.platform === 'linux') {
+    const hasDisplay = process.env.DISPLAY || process.env.WAYLAND_DISPLAY;
+    if (!hasDisplay) {
+      return true;
+    }
+  }
+  return false;
 }
 
-function applyPuppeteerShims(browser, page) {
-  if (page._shimsApplied) return page;
-  page._shimsApplied = true;
+function setupRealPage(browser, page) {
+  if (page._setupApplied) return page;
+  page._setupApplied = true;
 
   // Enable ad blocker
   if (adBlockerInstance) {
@@ -87,93 +100,165 @@ function applyPuppeteerShims(browser, page) {
     });
   }
 
-  // Cookie shims (Puppeteer → Playwright context)
-  if (!page.cookies) {
-    page.cookies = async (urls) => {
-      return await page.context().cookies(urls ? (Array.isArray(urls) ? urls : [urls]) : []);
-    };
-  }
-
-  if (!page.setCookie) {
-    page.setCookie = async (...cookies) => {
-      const formatted = cookies.map(c => ({
-        name: c.name,
-        value: c.value,
-        domain: c.domain || new URL(page.url()).hostname,
-        path: c.path || '/',
-        expires: c.expires || undefined,
-        httpOnly: c.httpOnly,
-        secure: c.secure,
-        sameSite: c.sameSite
-      }));
-      await page.context().addCookies(formatted);
-    };
-  }
+  // Human-like smooth scrolling with 60FPS Cubic Ease-Out physics
+  page.realScroll = async (deltaY, duration = 600) => {
+    try {
+      const stepDelay = 15; // ~60 FPS
+      const steps = Math.max(10, Math.floor(duration / stepDelay));
+      const easeOutCubic = (t) => 1 - Math.pow(1 - t, 3);
+      let currentScroll = 0;
+      for (let i = 1; i <= steps; i++) {
+        const t = i / steps;
+        const targetScroll = deltaY * easeOutCubic(t);
+        const diff = targetScroll - currentScroll;
+        await page.mouse.wheel(0, diff);
+        currentScroll = targetScroll;
+        await new Promise(r => setTimeout(r, stepDelay));
+      }
+    } catch (e) {
+      // Fallback to native window scroll in case of wheel errors
+      try {
+        await page.evaluate((y) => window.scrollBy({ top: y, behavior: 'smooth' }), deltaY);
+      } catch (_) {}
+    }
+  };
 
-  if (!page.deleteCookie) {
-    page.deleteCookie = async (...cookies) => {
-      await page.context().clearCookies();
+  // Ghost Cursor integration - Bézier curve human-like mouse movement
+  try {
+    const cursor = createCursor(page);
+    page.realCursor = {
+      move: async (selector, options = {}) => {
+        try {
+          await cursor.actions.move(selector, options);
+        } catch (e) {
+          // Fallback to native hover if ghost-cursor fails
+          try { await page.hover(selector); } catch (_) {}
+        }
+      }
     };
-  }
-
-  // Navigation shims
-  if (!page.waitForNetworkIdle) {
-    page.waitForNetworkIdle = async (options = {}) => {
+    page.realClick = async (selector, options = {}) => {
       try {
-        await page.waitForLoadState('networkidle', { timeout: options.timeout });
+        await cursor.actions.click({ target: selector, ...options });
       } catch (e) {
-        // Ignore networkidle timeouts if they are non-fatal
+        // Fallback to native click if ghost-cursor fails
+        await page.click(selector, options);
       }
     };
+  } catch (e) {
+    // Fallback if ghost-cursor-patchright fails to initialize
+    if (!page.realClick) {
+      page.realClick = async (selector, options) => {
+        await page.click(selector, options);
+      };
+    }
+    if (!page.realCursor) {
+      page.realCursor = {
+        move: async (selector) => {
+          try { await page.hover(selector); } catch (_) {}
+        }
+      };
+    }
   }
 
-  if (!page.evaluateOnNewDocument) {
-    page.evaluateOnNewDocument = async (fn, ...args) => {
-      return await page.addInitScript(fn, ...args);
-    };
+  return page;
+
+}
+
+function getBraveExecutablePath() {
+  if (process.env.BRAVE_PATH && fs.existsSync(process.env.BRAVE_PATH)) {
+    return process.env.BRAVE_PATH;
   }
 
-  // Ghost Cursor integration via playwright-ghost auto-hooking
-  page.realCursor = {
-    move: async (selector, options = {}) => {
+  const platform = process.platform;
+  const { execSync } = require('child_process');
+
+  // Try automatic scanning via CLI / registry query
+  if (platform === 'win32') {
+    const regQueries = [
+      'reg query "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\brave.exe" /ve',
+      'reg query "HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\brave.exe" /ve',
+      'reg query "HKEY_LOCAL_MACHINE\\SOFTWARE\\Clients\\StartMenuInternet\\Brave-Browser\\shell\\open\\command" /ve'
+    ];
+
+    for (const cmd of regQueries) {
       try {
-        await page.hover(selector, options);
-      } catch (e) {
-        // Silently fallback if element is not found
-      }
+        const output = execSync(cmd, { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+        const match = output.match(/REG_SZ\s+(.*)/);
+        if (match && match[1]) {
+          let p = match[1].trim().replace(/^"|"$/g, '');
+          if (!p.toLowerCase().endsWith('.exe')) {
+            const exeIndex = p.toLowerCase().indexOf('.exe');
+            if (exeIndex !== -1) {
+              p = p.substring(0, exeIndex + 4).replace(/^"|"$/g, '');
+            }
+          }
+          if (fs.existsSync(p)) return p;
+        }
+      } catch (e) {}
     }
-  };
-  page.realClick = async (selector, options = {}) => {
-    await page.click(selector, options);
-  };
 
-  // Mouse wheel shim (Puppeteer object → Playwright positional args)
-  if (page.mouse && page.mouse.wheel) {
-    const originalWheel = page.mouse.wheel.bind(page.mouse);
-    page.mouse.wheel = async (x, y) => {
-      if (typeof x === 'object' && x !== null) {
-        const deltaX = x.deltaX || 0;
-        const deltaY = x.deltaY || 0;
-        return await originalWheel(deltaX, deltaY);
+    try {
+      const output = execSync('where brave.exe', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim().split('\r\n')[0];
+      if (output && fs.existsSync(output)) return output;
+    } catch (e) {}
+  } else if (platform === 'darwin') {
+    try {
+      const output = execSync('mdfind "kMDItemCFBundleIdentifier == \'com.brave.Browser\'"', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim().split('\n')[0];
+      if (output) {
+        const p = path.join(output, 'Contents', 'MacOS', 'Brave Browser');
+        if (fs.existsSync(p)) return p;
       }
-      return await originalWheel(x, y);
-    };
+    } catch (e) {}
+  } else {
+    try {
+      const output = execSync('which brave-browser || which brave', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+      if (output && fs.existsSync(output)) return output;
+    } catch (e) {}
   }
 
-  // Browser shims
-  if (!browser.process) {
-    browser.process = () => ({
-      pid: browser._childProcess?.pid || 1337
-    });
+  // Fallback to hardcoded common paths
+  let paths = [];
+  if (platform === 'win32') {
+    paths = [
+      path.join(process.env.PROGRAMFILES || 'C:\\Program Files', 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'),
+      path.join(process.env['PROGRAMFILES(X86)'] || 'C:\\Program Files (x86)', 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'),
+      path.join(process.env.LOCALAPPDATA || '', 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe')
+    ].filter(p => p);
+  } else if (platform === 'darwin') {
+    paths = [
+      '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser'
+    ];
+  } else {
+    paths = [
+      '/usr/bin/brave-browser',
+      '/usr/bin/brave',
+      '/usr/bin/brave-browser-stable',
+      '/usr/bin/brave-browser-beta',
+      '/usr/bin/brave-browser-nightly',
+      '/usr/local/bin/brave-browser',
+      '/usr/local/bin/brave'
+    ];
   }
 
-  if (!browser.pages) {
-    browser.pages = async () => {
-      return browser.contexts().flatMap(c => c.pages());
-    };
+  for (const p of paths) {
+    if (p && fs.existsSync(p)) {
+      return p;
+    }
   }
 
-  return page;
+  return null;
+}
+
+async function applyUserAgentOverride(page, userAgent, userAgentMetadata) {
+  try {
+    const client = await page.context().newCDPSession(page);
+    await client.send('Emulation.setUserAgentOverride', {
+      userAgent: userAgent,
+      userAgentMetadata: userAgentMetadata
+    });
+  } catch (e) {
+    // Ignore errors
+  }
 }
 
 async function connect({
@@ -181,6 +266,7 @@ async function connect({
   headless = getDefaultHeadless(),
   proxy = {},
   turnstile = false,
+  executablePath = undefined,
 } = {}) {
   let playwrightProxy = undefined;
   if (proxy && proxy.host && proxy.port) {
@@ -193,23 +279,81 @@ async function connect({
     }
   }
 
+  // 1. Launch a temporary browser to retrieve the native user agent and properties
+  const tempBrowser = await chromium.launch({
+    headless: true,
+    args: ['--no-sandbox', '--disable-setuid-sandbox'],
+    ...(executablePath ? { executablePath } : {}),
+  });
+  const tempContext = await tempBrowser.newContext();
+  const tempPage = await tempContext.newPage();
+  let nativeUa = '';
+  let isBrave = false;
+  try {
+    nativeUa = await tempPage.evaluate(() => navigator.userAgent);
+    isBrave = await tempPage.evaluate(() => typeof navigator.brave !== 'undefined');
+  } catch (e) {
+    nativeUa = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/148.0.0.0 Safari/537.36';
+    isBrave = executablePath && executablePath.toLowerCase().includes('brave');
+  }
+  await tempBrowser.close();
+
+  let modifiedUa = nativeUa.replace(/HeadlessChrome\//g, 'Chrome/');
+  const chromeVersionMatch = modifiedUa.match(/Chrome\/([\d.]+)/);
+  const chromeVersion = chromeVersionMatch ? chromeVersionMatch[1] : '148.0.0.0';
+  const majorVersion = chromeVersion.split('.')[0];
+
+  const brands = [
+    { brand: 'Chromium', version: majorVersion },
+    { brand: 'Not/A)Brand', version: '99' }
+  ];
+  if (isBrave) {
+    brands.unshift({ brand: 'Brave', version: majorVersion });
+  } else {
+    brands.unshift({ brand: 'Google Chrome', version: majorVersion });
+  }
+
+  let platformName = 'Windows';
+  if (nativeUa.includes('Macintosh') || nativeUa.includes('Mac OS X')) {
+    platformName = 'macOS';
+  } else if (nativeUa.includes('Linux')) {
+    platformName = 'Linux';
+  }
+
+  const userAgentMetadata = {
+    brands: brands,
+    mobile: false,
+    platform: platformName,
+    platformVersion: platformName === 'macOS' ? '14.0.0' : platformName === 'Linux' ? '6.0.0' : '10.0.0',
+    architecture: 'x86',
+    model: '',
+    bitness: '64',
+    wow64: false
+  };
+
   const chromiumArgs = [
+    `--user-agent=${modifiedUa}`,
     '--disable-blink-features=AutomationControlled',
     '--no-sandbox',
     '--disable-setuid-sandbox',
     ...args
   ];
 
-  // Load the dynamic ES Module imports
-  const { default: playwright } = await playwrightGhostPromise;
-  const { default: recommended } = await recommendedPromise;
-  const { chromium } = playwright;
+  // If headless is true, we run with headless: false but pass '--headless=new' to args.
+  // This triggers Chromium's modern undetected headless mode instead of Playwright's default old headless shell.
+  let launchHeadless = headless;
+  if (headless === true) {
+    launchHeadless = false;
+    if (!chromiumArgs.includes('--headless=new')) {
+      chromiumArgs.push('--headless=new');
+    }
+  }
 
   const browser = await chromium.launch({
-    headless,
+    headless: launchHeadless,
     args: chromiumArgs,
     proxy: playwrightProxy,
-    plugins: [recommended()]
+    ...(executablePath ? { executablePath } : {}),
   });
 
   // Ensure ad blocker is ready
@@ -221,7 +365,9 @@ async function connect({
 
   let page = await context.newPage();
 
-  applyPuppeteerShims(browser, page);
+  await applyUserAgentOverride(page, modifiedUa, userAgentMetadata);
+
+  setupRealPage(browser, page);
 
   page = await pageController({
     browser,
@@ -231,7 +377,8 @@ async function connect({
   });
 
   context.on('page', async (newPage) => {
-    applyPuppeteerShims(browser, newPage);
+    await applyUserAgentOverride(newPage, modifiedUa, userAgentMetadata);
+    setupRealPage(browser, newPage);
     await pageController({
       browser,
       page: newPage,