brave-real-browser-mcp-server 2.37.4 → 2.37.7

package/.github/workflows/monorepo-publish.yml

@@ -67,18 +67,19 @@ jobs:
       - name: 🔍 Detect Changes
         id: changes
         run: |
-          # For manual trigger or schedule, publish all
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ] || [ "${{ github.event_name }}" = "schedule" ]; then
+          # For manual trigger, schedule, or push - publish all packages
+          # Push events already filtered by paths-ignore, so any push that reaches here has real changes
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ] || [ "${{ github.event_name }}" = "schedule" ] || [ "${{ github.event_name }}" = "push" ]; then
             echo "launcher=true" >> $GITHUB_OUTPUT
             echo "puppeteer=true" >> $GITHUB_OUTPUT
             echo "blocker=true" >> $GITHUB_OUTPUT
             echo "mcp=true" >> $GITHUB_OUTPUT
             echo "any=true" >> $GITHUB_OUTPUT
-            echo "📦 Manual/Schedule trigger - all packages will be processed"
+            echo "📦 ${{ github.event_name }} trigger - all packages will be processed"
             exit 0
           fi
 
-          # For push/PR, detect actual changes
+          # For PR only, detect actual changes
           if [ "${{ github.event_name }}" = "pull_request" ]; then
             BASE_SHA=${{ github.event.pull_request.base.sha }}
           else

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.37.4",
+  "version": "2.37.7",
   "description": "MCP Server for Brave Real Browser - Puppeteer with Brave Browser, Stealth Mode, Ad Blocker, and Turnstile Auto-Solver for undetectable web automation.",
   "main": "lib/cjs/index.js",
   "module": "lib/esm/index.mjs",
@@ -71,7 +71,7 @@
   "license": "ISC",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.3",
-    "brave-real-puppeteer-core": "^24.52.4",
+    "brave-real-puppeteer-core": "^24.52.9",
     "ghost-cursor": "^1.4.2",
     "puppeteer-extra": "^3.3.6",
     "puppeteer-extra-plugin-stealth": "^2.11.2",

package/packages/brave-real-blocker/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-blocker",
-  "version": "1.13.4",
+  "version": "1.13.9",
   "description": "Advanced uBlock Origin management and stealth features for Brave Real Browser",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -64,7 +64,7 @@
     "@types/adm-zip": "^0.5.5",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^20.0.0",
-    "brave-real-puppeteer-core": "^24.52.4",
+    "brave-real-puppeteer-core": "^24.52.9",
     "mocha": "^10.4.0",
     "puppeteer-core": "^24.35.0",
     "sinon": "^17.0.1",

package/packages/brave-real-launcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-launcher",
-  "version": "1.19.4",
+  "version": "1.19.9",
   "description": "Launch Brave Browser with ease from node. Based on chrome-launcher with Brave-specific support.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -54,7 +54,7 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "brave-real-blocker": "^1.13.4",
+    "brave-real-blocker": "^1.13.9",
     "escape-string-regexp": "^5.0.0",
     "is-wsl": "^3.1.0",
     "which": "^6.0.0"

package/packages/brave-real-launcher/src/chrome-version.ts

@@ -13,7 +13,7 @@ let cacheTimestamp: number = 0;
 const CACHE_DURATION_MS = 60 * 60 * 1000; // 1 hour
 
 // Fallback version if all APIs fail (updated to latest known stable)
-export const FALLBACK_VERSION = '144.0.7559.59';
+export const FALLBACK_VERSION = '144.0.7559.133';
 
 /**
  * Fetches the latest stable Chrome version from Chromium Dashboard API

package/packages/brave-real-puppeteer-core/README.md

@@ -8,8 +8,7 @@
 - ⚡ **1-5ms Ultra-Fast Timing** - Optimized performance
 - 🦁 **Brave Browser Integration** - Auto-detection on all platforms
 - 🤖 **AI-Powered Testing** - Intelligent validation
-- 🔄 **Auto-Updates** - Daily sync with Puppeteer/Playwright releases
-- 🎭 **CAPTCHA Handling** - Built-in solver support
+- 🔄 **Version Sync** - Check for latest Puppeteer/Playwright releases
 - 📱 **Device Emulation** - Mobile and tablet emulation
 - 🌍 **Geo Spoofing** - Location spoofing
 - 🖱️ **Human Mouse** - Realistic mouse movements
@@ -37,11 +36,6 @@ npm test                         # Run 8 unit tests
 npm run test-bot-detector        # GUI bot detection test
 npm run test-bot-detector-headless # Headless bot detection test
 npm run test-bot-detector-mobile # Mobile bot detection test
-npm run test-puppeteer           # Puppeteer tests
-npm run test-playwright          # Playwright tests
-npm run test-cloudflare          # Cloudflare bypass test
-npm run test-recaptcha           # reCAPTCHA test
-npm run test-features            # All features test
 npm run ai-agent                 # AI-powered testing
 ```
 
@@ -79,8 +73,7 @@ brave-real-puppeteer-core/
 │   ├── playwright-core/         # Playwright patches  
 │   └── stealth-core/            # Core stealth patches
 ├── scripts/
-│   ├── patcher.js               # Main patcher (CLI)
-│   ├── enhanced-patcher.js      # Comprehensive patching
+│   ├── patcher.js               # Main patcher with stealth (CLI)
 │   ├── stealth-injector.js      # 131KB stealth code
 │   ├── ai-agent.js              # AI testing assistant
 │   ├── test-bot-detector.js     # Bot detection tests
@@ -90,7 +83,7 @@ brave-real-puppeteer-core/
 │   ├── human_mouse.js           # Human-like mouse
 │   ├── session-manager.js       # Session management
 │   ├── proxy-manager.js         # Proxy rotation
-│   └── ...28 total scripts
+│   └── ...21 total scripts
 └── test/
     └── test.cjs                 # Unit tests (8 tests)
 ```
@@ -112,31 +105,44 @@ brave-real-puppeteer-core/
 
 | Category | Features |
 |----------|----------|
+| **CDP Bypasses** | Runtime.Enable, sourceURL masking, Console.enable, exposeFunction |
 | Navigator | webdriver, plugins, languages, userAgentData |
 | Canvas | Fingerprint noise, toDataURL spoofing |
 | WebGL | GPU profiles, renderer spoofing |
 | Performance | 1-5ms timing, instant responses |
 | Automation | All bot signatures removed |
 | Mouse | Human-like movements (ghost-cursor) |
-| CAPTCHA | Auto-solving support |
 | Geolocation | Location spoofing |
 
 ## 💡 Usage
 
-### Puppeteer
+### Easy Integration (Recommended)
+
+#### Puppeteer - One-Liner
 ```javascript
-const puppeteer = require('puppeteer-core');
-// Patches are auto-applied at npm install time
+import puppeteer from 'puppeteer-core';
+import { applyStealthToPuppeteer } from 'brave-real-puppeteer-core';
 
-const browser = await puppeteer.launch({
-  executablePath: '/path/to/brave',
-  headless: false
-});
+const browser = await puppeteer.launch({ executablePath: '/path/to/brave' });
 const page = await browser.newPage();
-await page.goto('https://bot.sannysoft.com');
+await applyStealthToPuppeteer(page); // That's it!
+
+await page.goto('https://bot-detector.rebrowser.net/');
+```
+
+#### Playwright - One-Liner
+```javascript
+import { chromium } from 'playwright-core';
+import { applyStealthToPlaywright } from 'brave-real-puppeteer-core';
+
+const browser = await chromium.launch({ executablePath: '/path/to/brave' });
+const page = await browser.newPage();
+await applyStealthToPlaywright(page); // That's it!
+
+await page.goto('https://bot-detector.rebrowser.net/');
 ```
 
-### With brave-real-browser (Recommended)
+### With brave-real-browser (Full Integration)
 ```javascript
 const { connect } = require('brave-real-browser');
 
@@ -148,6 +154,19 @@ const { browser, page } = await connect({
 await page.goto('https://example.com');
 ```
 
+### Manual Puppeteer
+```javascript
+const puppeteer = require('puppeteer-core');
+// Patches are auto-applied at npm install time
+
+const browser = await puppeteer.launch({
+  executablePath: '/path/to/brave',
+  headless: false
+});
+const page = await browser.newPage();
+await page.goto('https://bot.sannysoft.com');
+```
+
 ## 🔧 Environment Variables
 
 ```bash
@@ -163,6 +182,80 @@ REBROWSER_ULTRA_FAST_PERFORMANCE=1
 - **Datadome**: 100% pass
 - **Cloudflare Turnstile**: ✅ Auto-solved
 - **reCAPTCHA v3**: High score
+- **Bot Detector**: 80% pass (8/10 tests) - All critical tests pass
+
+## 📦 Module Support
+
+This package supports multiple module formats for maximum compatibility:
+
+| Format | File | Usage | Node.js Version |
+|--------|------|-------|-----------------|
+| **ESM** | `index.js` | Modern JavaScript (ES6+) | 18+ (Recommended) |
+| **CJS** | `index.cjs` | CommonJS | 12+ |
+| **ES5** | N/A | Legacy JavaScript | 10+ (Requires build) |
+
+### Usage Examples
+
+#### ESM (Recommended for Node.js 18+)
+```javascript
+import puppeteer from 'brave-real-puppeteer-core';
+const browser = await puppeteer.launch();
+```
+
+#### CJS (For Node.js 12-17)
+```javascript
+const puppeteer = require('brave-real-puppeteer-core');
+const browser = await puppeteer.launch();
+```
+
+### ES5 Support
+
+ES5 support requires additional transpilation setup. The package targets Node.js 18+ which natively supports ES6+ features, so ES5 transpilation is not required for the default use case.
+
+**To add ES5 support:**
+1. Install Babel: `npm install --save-dev @babel/core @babel/preset-env`
+2. Create `.babelrc`:
+```json
+{
+  "presets": [["@babel/preset-env", {
+    "targets": {
+      "node": "10"
+    }
+  }]]
+}
+```
+3. Add build script to package.json:
+```json
+{
+  "scripts": {
+    "build:es5": "babel index.js --out-file index.es5.js"
+  }
+}
+```
+
+## 🔄 Refresh Persistence
+
+The package includes robust refresh persistence to ensure stealth scripts survive page refreshes:
+
+- **CDP Scripts**: Automatically injected on every new document
+- **Manual Refresh Handler**: Re-injects scripts after F5 refresh
+- **Lifecycle Monitoring**: Monitors page visibility and load events
+- **Error Stack Sanitization**: Persists across refreshes for sourceUrlLeak test
+- **Continuous Monitoring**: Active monitoring for 60 seconds after page load
+
+### Testing Refresh Persistence
+
+Run the bot detector test to verify refresh persistence:
+
+```bash
+npm run test-bot-detector
+```
+
+The test will:
+1. Navigate to https://bot-detector.rebrowser.net/
+2. Wait for all tests to pass (initial load)
+3. Refresh the page (F5)
+4. Verify all critical tests still pass after refresh
 
 ## 📄 License
 

package/packages/brave-real-puppeteer-core/index.d.ts

@@ -1,4 +1,125 @@
+// Re-export everything from puppeteer-core
 export * from 'puppeteer-core';
-import { PuppeteerNode } from 'puppeteer-core';
+import { PuppeteerNode, Page as PuppeteerPage } from 'puppeteer-core';
 declare const puppeteer: PuppeteerNode;
 export default puppeteer;
+
+// Stealth Options
+export interface StealthOptions {
+  /** Enable CDP-level bypasses (Runtime.Enable, sourceURL, etc.) Default: true */
+  cdpBypasses?: boolean;
+  /** Enable comprehensive JS-level stealth. Default: true */
+  comprehensiveStealth?: boolean;
+  /** Custom user agent string. Default: auto-generated */
+  userAgent?: string | null;
+  /** Enable mobile simulation. Default: false */
+  mobile?: boolean;
+}
+
+// Easy Integration APIs
+
+/**
+ * Apply stealth to a Puppeteer page - One-liner API
+ * @param page - Puppeteer page instance
+ * @param options - Stealth options
+ * @returns Promise resolving to true on success
+ * 
+ * @example
+ * import { applyStealthToPuppeteer } from 'brave-real-puppeteer-core';
+ * const browser = await puppeteer.launch();
+ * const page = await browser.newPage();
+ * await applyStealthToPuppeteer(page);
+ */
+export function applyStealthToPuppeteer(page: PuppeteerPage, options?: StealthOptions): Promise<boolean>;
+
+/**
+ * Apply stealth to a Playwright page - One-liner API
+ * @param page - Playwright page instance
+ * @param options - Stealth options
+ * @returns Promise resolving to true on success
+ * 
+ * @example
+ * import { applyStealthToPlaywright } from 'brave-real-puppeteer-core';
+ * const browser = await chromium.launch();
+ * const page = await browser.newPage();
+ * await applyStealthToPlaywright(page);
+ */
+export function applyStealthToPlaywright(page: any, options?: StealthOptions): Promise<boolean>;
+
+/**
+ * Apply stealth to a Playwright browser context - For all pages
+ * @param context - Playwright browser context
+ * @param options - Stealth options
+ */
+export function applyStealthToPlaywrightContext(context: any, options?: StealthOptions): Promise<boolean>;
+
+// Stealth Script Generators
+
+/** Get comprehensive stealth script */
+export function getComprehensiveStealthScript(): string;
+
+/** Get Puppeteer-optimized stealth script */
+export function getPuppeteerOptimizedScript(options?: StealthOptions): string;
+
+/** Get Playwright-optimized stealth script */
+export function getPlaywrightOptimizedScript(options?: StealthOptions): string;
+
+/** Get all CDP bypass scripts combined */
+export function getCDPBypassScripts(): string;
+
+// Individual CDP Bypass Functions
+
+/** Runtime.Enable bypass - Prevents CDP Runtime.Enable detection */
+export function injectRuntimeEnableBypass(): string;
+
+/** Source URL masking - Hides pptr:/playwright: sourceURL comments */
+export function injectSourceURLMasking(): string;
+
+/** Console.enable bypass - Masks Console.enable CDP command detection */
+export function injectConsoleEnableBypass(): string;
+
+/** ExposeFunction masking - Hides page.exposeFunction bindings */
+export function injectExposeFunctionMasking(): string;
+
+/** Utility World Name masking - Hides __puppeteer_utility_world__ */
+export function injectUtilityWorldMasking(): string;
+
+// Dynamic Chrome Version
+
+/** Get current Chrome version (auto-synced with Google APIs) */
+export function getCurrentChromeVersion(): string;
+
+/** Generate dynamic User-Agent string */
+export function getDynamicUserAgent(mobile?: boolean): string;
+
+/** Generate dynamic User-Agent metadata for Client Hints */
+export function getDynamicUserAgentMetadata(mobile?: boolean): {
+  brands: Array<{ brand: string; version: string }>;
+  fullVersionList: Array<{ brand: string; version: string }>;
+  platform: string;
+  platformVersion: string;
+  architecture: string;
+  model: string;
+  mobile: boolean;
+  bitness: string;
+  wow64: boolean;
+};
+
+// Blocker Integration (from brave-real-launcher)
+export function initBlocker(): Promise<any>;
+export function getBlocker(): any;
+export function createBlockerFactory(): any;
+export function autoEnableOnPage(page: any): Promise<void>;
+export function createEcosystemChain(browser: any): any;
+export const BraveBlocker: any;
+export function launch(options?: any): Promise<any>;
+export const DEFAULT_FLAGS: string[];
+export const BraveLauncher: any;
+export function getStealthFlags(): string[];
+export function getDynamicUserAgents(): any;
+
+// Connect with Blocker
+export function connectWithBlocker(options?: any, launchedBrave?: any): Promise<{
+  browser: any;
+  blocker: any | null;
+}>;

package/packages/brave-real-puppeteer-core/index.es5.js

@@ -0,0 +1,96 @@
+/**
+ * brave-real-puppeteer-core (ES5 Compatible)
+ * Re-exports puppeteer-core with stealth patches applied at install time
+ * Compatible with older Node.js environments and bundlers
+ * 
+ * Ecosystem Chain:
+ *   brave-real-browser-mcp-server (top level)
+ *       --> brave-real-puppeteer-core (you are here)
+ *           --> brave-real-launcher
+ *               --> brave-real-blocker (singleton)
+ */
+
+'use strict';
+
+// Re-export everything from puppeteer-core
+var puppeteerCore = require('puppeteer-core');
+
+// Re-export blocker integration from brave-real-launcher for ecosystem chain
+var braveLauncher = require('brave-real-launcher');
+
+/**
+ * Connect to browser with auto-enabled blocker on all pages
+ * @param {Object} options - Connection options
+ * @param {Object} launchedBrave - LaunchedBrave instance from brave-real-launcher
+ * @returns {Promise<{browser: Browser, blocker: BlockerInstance}>}
+ */
+function connectWithBlocker(options, launchedBrave) {
+  options = options || {};
+  launchedBrave = launchedBrave || null;
+  
+  return puppeteerCore.connect(options).then(function(browser) {
+    // If launchedBrave has blocker, setup ecosystem chain
+    if (launchedBrave && launchedBrave.blocker) {
+      if (typeof launchedBrave.setupEcosystemChain === 'function') {
+        launchedBrave.setupEcosystemChain(browser);
+      }
+      
+      // Enable blocker on existing pages
+      return browser.pages().then(function(pages) {
+        var enablePromises = pages.map(function(page) {
+          if (typeof launchedBrave.enableBlockerOnPage === 'function') {
+            return launchedBrave.enableBlockerOnPage(page);
+          }
+          return Promise.resolve();
+        });
+        
+        return Promise.all(enablePromises).then(function() {
+          return {
+            browser: browser,
+            blocker: launchedBrave.blocker
+          };
+        });
+      });
+    }
+    
+    return {
+      browser: browser,
+      blocker: null
+    };
+  });
+}
+
+/**
+ * Launch browser using brave-real-launcher (ES5 compatible wrapper)
+ * @param {Object} options - Launch options
+ * @returns {Promise<LaunchedBrave>}
+ */
+function launch(options) {
+  options = options || {};
+  return braveLauncher.launch(options);
+}
+
+// Export all functions from puppeteer-core
+var exports = Object.keys(puppeteerCore).reduce(function(acc, key) {
+  acc[key] = puppeteerCore[key];
+  return acc;
+}, {});
+
+// Add ecosystem chain exports
+exports.initBlocker = braveLauncher.initBlocker;
+exports.getBlocker = braveLauncher.getBlocker;
+exports.createBlockerFactory = braveLauncher.createBlockerFactory;
+exports.autoEnableOnPage = braveLauncher.autoEnableOnPage;
+exports.createEcosystemChain = braveLauncher.createEcosystemChain;
+exports.BraveBlocker = braveLauncher.BraveBlocker;
+exports.launch = launch;
+exports.DEFAULT_FLAGS = braveLauncher.DEFAULT_FLAGS;
+exports.BraveLauncher = braveLauncher.BraveLauncher;
+exports.getStealthFlags = braveLauncher.getStealthFlags;
+exports.getDynamicUserAgents = braveLauncher.getDynamicUserAgents;
+exports.connectWithBlocker = connectWithBlocker;
+
+// Default export for ES5
+exports.default = puppeteerCore;
+
+module.exports = exports;

package/packages/brave-real-puppeteer-core/index.js

@@ -31,6 +31,176 @@ export {
   getDynamicUserAgents
 } from 'brave-real-launcher';
 
+// Import stealth functions for easy integration
+import { 
+  getComprehensiveStealthScript,
+  getPuppeteerOptimizedScript,
+  getPlaywrightOptimizedScript,
+  getCDPBypassScripts,
+  injectRuntimeEnableBypass,
+  injectSourceURLMasking,
+  injectConsoleEnableBypass,
+  injectExposeFunctionMasking,
+  injectUtilityWorldMasking,
+  getCurrentChromeVersion,
+  getDynamicUserAgent,
+  getDynamicUserAgentMetadata
+} from './scripts/stealth-injector.js';
+
+// Re-export stealth functions
+export {
+  getComprehensiveStealthScript,
+  getPuppeteerOptimizedScript,
+  getPlaywrightOptimizedScript,
+  getCDPBypassScripts,
+  injectRuntimeEnableBypass,
+  injectSourceURLMasking,
+  injectConsoleEnableBypass,
+  injectExposeFunctionMasking,
+  injectUtilityWorldMasking,
+  getCurrentChromeVersion,
+  getDynamicUserAgent,
+  getDynamicUserAgentMetadata
+};
+
+/**
+ * Apply stealth to a Puppeteer page - One-liner API
+ * @param {Page} page - Puppeteer page instance
+ * @param {Object} options - Stealth options
+ * @returns {Promise<void>}
+ * 
+ * @example
+ * import { applyStealthToPuppeteer } from 'brave-real-puppeteer-core';
+ * const browser = await puppeteer.launch();
+ * const page = await browser.newPage();
+ * await applyStealthToPuppeteer(page);
+ */
+export async function applyStealthToPuppeteer(page, options = {}) {
+  const {
+    cdpBypasses = true,
+    comprehensiveStealth = true,
+    userAgent = null
+  } = options;
+  
+  try {
+    // Get CDP session
+    const client = await page.target().createCDPSession();
+    
+    // Apply CDP bypasses first (before any other scripts)
+    if (cdpBypasses) {
+      const cdpScript = getCDPBypassScripts();
+      await client.send('Page.addScriptToEvaluateOnNewDocument', {
+        source: cdpScript,
+        runImmediately: true
+      });
+    }
+    
+    // Apply comprehensive stealth
+    if (comprehensiveStealth) {
+      const stealthScript = getPuppeteerOptimizedScript(options);
+      await client.send('Page.addScriptToEvaluateOnNewDocument', {
+        source: stealthScript,
+        runImmediately: true
+      });
+    }
+    
+    // Set user agent if provided or use dynamic
+    const ua = userAgent || getDynamicUserAgent(false);
+    const uaMetadata = getDynamicUserAgentMetadata(false);
+    
+    await client.send('Emulation.setUserAgentOverride', {
+      userAgent: ua,
+      userAgentMetadata: {
+        brands: uaMetadata.brands,
+        fullVersionList: uaMetadata.fullVersionList,
+        platform: uaMetadata.platform,
+        platformVersion: uaMetadata.platformVersion,
+        architecture: uaMetadata.architecture,
+        model: uaMetadata.model,
+        mobile: uaMetadata.mobile,
+        bitness: uaMetadata.bitness,
+        wow64: uaMetadata.wow64
+      }
+    });
+    
+    console.log('[brave-real-puppeteer-core] Stealth applied to Puppeteer page');
+    return true;
+  } catch (error) {
+    console.error('[brave-real-puppeteer-core] Failed to apply stealth:', error.message);
+    return false;
+  }
+}
+
+/**
+ * Apply stealth to a Playwright page - One-liner API
+ * @param {Page} page - Playwright page instance
+ * @param {Object} options - Stealth options
+ * @returns {Promise<void>}
+ * 
+ * @example
+ * import { applyStealthToPlaywright } from 'brave-real-puppeteer-core';
+ * const browser = await chromium.launch();
+ * const page = await browser.newPage();
+ * await applyStealthToPlaywright(page);
+ */
+export async function applyStealthToPlaywright(page, options = {}) {
+  const {
+    cdpBypasses = true,
+    comprehensiveStealth = true,
+    userAgent = null
+  } = options;
+  
+  try {
+    // For Playwright, use addInitScript
+    if (cdpBypasses) {
+      const cdpScript = getCDPBypassScripts();
+      await page.addInitScript(cdpScript);
+    }
+    
+    if (comprehensiveStealth) {
+      const stealthScript = getPlaywrightOptimizedScript(options);
+      await page.addInitScript(stealthScript);
+    }
+    
+    console.log('[brave-real-puppeteer-core] Stealth applied to Playwright page');
+    return true;
+  } catch (error) {
+    console.error('[brave-real-puppeteer-core] Failed to apply stealth:', error.message);
+    return false;
+  }
+}
+
+/**
+ * Apply stealth to a Playwright context - For all pages in context
+ * @param {BrowserContext} context - Playwright browser context
+ * @param {Object} options - Stealth options
+ * @returns {Promise<void>}
+ */
+export async function applyStealthToPlaywrightContext(context, options = {}) {
+  const {
+    cdpBypasses = true,
+    comprehensiveStealth = true
+  } = options;
+  
+  try {
+    if (cdpBypasses) {
+      const cdpScript = getCDPBypassScripts();
+      await context.addInitScript(cdpScript);
+    }
+    
+    if (comprehensiveStealth) {
+      const stealthScript = getPlaywrightOptimizedScript(options);
+      await context.addInitScript(stealthScript);
+    }
+    
+    console.log('[brave-real-puppeteer-core] Stealth applied to Playwright context');
+    return true;
+  } catch (error) {
+    console.error('[brave-real-puppeteer-core] Failed to apply stealth:', error.message);
+    return false;
+  }
+}
+
 /**
  * Connect to browser with auto-enabled blocker on all pages
  * @param {Object} options - Connection options