brave-real-browser 1.5.95 → 1.5.98

package/FIXES_NEEDED.md

@@ -0,0 +1,131 @@
+# Brave-Real-Browser - Critical Fixes Needed
+
+## ⚠️ Note
+यह project compiled JavaScript library है। Source code इस repository में नहीं है।
+
+## Critical Issues to Fix in Source Repository
+
+### 1. **pageController Error Handling** (Critical)
+**File**: `src/module/pageController.js` (in source repo)
+**Issue**: Promise rejections और errors को properly handle नहीं किया गया
+**Fix Required**:
+```javascript
+// Add comprehensive try-catch blocks
+async function handleNavigation(page, url) {
+  try {
+    await page.goto(url, { timeout: 30000 });
+  } catch (error) {
+    if (error.name === 'TimeoutError') {
+      throw new NavigationTimeoutError(`Navigation to ${url} timed out`);
+    }
+    throw new NavigationError(`Failed to navigate: ${error.message}`);
+  }
+}
+
+// Add error recovery mechanisms
+async function withRetry(fn, maxRetries = 3) {
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (i === maxRetries - 1) throw error;
+      await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
+    }
+  }
+}
+```
+
+### 2. **turnstileSolver Infinite Loop Fix** (Critical)
+**File**: `src/module/turnstileSolver.js` (in source repo)
+**Issue**: Infinite loop possibility without timeout or max attempts
+**Fix Required**:
+```javascript
+async function solveTurnstile(page, maxAttempts = 10, timeout = 60000) {
+  const startTime = Date.now();
+  let attempts = 0;
+  
+  while (attempts < maxAttempts) {
+    // Check timeout
+    if (Date.now() - startTime > timeout) {
+      throw new TurnstileTimeoutError('Turnstile solving timed out');
+    }
+    
+    attempts++;
+    
+    try {
+      const solved = await attemptSolve(page);
+      if (solved) return true;
+    } catch (error) {
+      console.error(`Turnstile attempt ${attempts} failed:`, error);
+    }
+    
+    // Exponential backoff
+    await new Promise(resolve => 
+      setTimeout(resolve, Math.min(1000 * Math.pow(2, attempts), 10000))
+    );
+  }
+  
+  throw new TurnstileMaxAttemptsError(`Failed after ${maxAttempts} attempts`);
+}
+```
+
+### 3. **Proxy Validation** (Medium)
+**Fix Required**:
+```javascript
+function validateProxy(proxy) {
+  if (!proxy) return null;
+  
+  const proxyRegex = /^(https?|socks[45]):\/\/([^:]+):(\d+)$/;
+  if (!proxyRegex.test(proxy)) {
+    throw new Error('Invalid proxy format. Expected: protocol://host:port');
+  }
+  
+  return proxy;
+}
+```
+
+### 4. **Better Error Messages**
+```javascript
+class BrowserError extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.name = 'BrowserError';
+    this.code = code;
+    this.details = details;
+  }
+}
+
+class NavigationError extends BrowserError {
+  constructor(message, details) {
+    super(message, 'NAVIGATION_ERROR', details);
+    this.name = 'NavigationError';
+  }
+}
+```
+
+## Version Synchronization Required
+- Current version: 1.5.95
+- Should match: brave-real-launcher, brave-real-puppeteer-core
+- Add version validation on startup
+
+## Dependencies to Update
+```json
+{
+  "dependencies": {
+    "brave-real-launcher": "^1.5.95",
+    "brave-real-puppeteer-core": "^1.5.95"
+  }
+}
+```
+
+## Testing Requirements
+1. Add unit tests for error handling
+2. Add integration tests with other components
+3. Add timeout/infinite loop regression tests
+4. Add proxy validation tests
+
+## Documentation Needed
+1. API documentation
+2. Error handling guide
+3. Configuration examples
+4. Troubleshooting guide

package/lib/cjs/errors.js

@@ -0,0 +1,299 @@
+/**
+ * Error Handling System for Brave Real Browser
+ * 
+ * Provides standardized error classes and utilities for browser operations
+ */
+
+// ============================================================================
+// ERROR CATEGORIES
+// ============================================================================
+
+const ErrorCategory = {
+  // Browser connection errors
+  CONNECTION_FAILED: 'CONNECTION_FAILED',
+  BROWSER_LAUNCH_FAILED: 'BROWSER_LAUNCH_FAILED',
+  BROWSER_CLOSED: 'BROWSER_CLOSED',
+  
+  // Page errors
+  PAGE_CREATION_FAILED: 'PAGE_CREATION_FAILED',
+  PAGE_CLOSED: 'PAGE_CLOSED',
+  
+  // Plugin errors
+  PLUGIN_LOAD_FAILED: 'PLUGIN_LOAD_FAILED',
+  
+  // Proxy errors
+  PROXY_CONNECTION_FAILED: 'PROXY_CONNECTION_FAILED',
+  INVALID_PROXY_CONFIG: 'INVALID_PROXY_CONFIG',
+  
+  // System errors
+  XVFB_INIT_FAILED: 'XVFB_INIT_FAILED',
+  PORT_UNAVAILABLE: 'PORT_UNAVAILABLE',
+  
+  // Protocol errors
+  PROTOCOL_ERROR: 'PROTOCOL_ERROR',
+  TIMEOUT_ERROR: 'TIMEOUT_ERROR',
+  
+  // Unknown
+  UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+};
+
+// ============================================================================
+// ERROR SEVERITY LEVELS
+// ============================================================================
+
+const ErrorSeverity = {
+  LOW: 'LOW',
+  MEDIUM: 'MEDIUM',
+  HIGH: 'HIGH',
+  CRITICAL: 'CRITICAL',
+};
+
+// ============================================================================
+// CUSTOM ERROR CLASS
+// ============================================================================
+
+/**
+ * Base error class for Brave Real Browser errors
+ */
+class BraveRealBrowserError extends Error {
+  constructor(
+    message,
+    category = ErrorCategory.UNKNOWN_ERROR,
+    severity = ErrorSeverity.MEDIUM,
+    isRecoverable = false,
+    context = {}
+  ) {
+    super(message);
+    this.name = 'BraveRealBrowserError';
+    this.category = category;
+    this.severity = severity;
+    this.isRecoverable = isRecoverable;
+    this.timestamp = new Date();
+    this.context = context;
+    
+    // Maintains proper stack trace
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+
+  /**
+   * Convert error to user-friendly message
+   */
+  toUserMessage() {
+    let message = `❌ ${this.message}\n\n`;
+    message += `📋 Category: ${this.category}\n`;
+    message += `⚠️ Severity: ${this.severity}\n`;
+    
+    if (Object.keys(this.context).length > 0) {
+      message += `\n🔍 Context: ${JSON.stringify(this.context, null, 2)}\n`;
+    }
+    
+    return message;
+  }
+}
+
+// ============================================================================
+// ERROR FACTORY FUNCTIONS
+// ============================================================================
+
+/**
+ * Create browser launch error
+ */
+function createBrowserLaunchError(originalError, context = {}) {
+  return new BraveRealBrowserError(
+    `Failed to launch browser: ${originalError.message}`,
+    ErrorCategory.BROWSER_LAUNCH_FAILED,
+    ErrorSeverity.CRITICAL,
+    false,
+    { originalError: originalError.message, ...context }
+  );
+}
+
+/**
+ * Create connection error
+ */
+function createConnectionError(url, originalError) {
+  return new BraveRealBrowserError(
+    `Failed to connect to browser at ${url}: ${originalError.message}`,
+    ErrorCategory.CONNECTION_FAILED,
+    ErrorSeverity.CRITICAL,
+    true,
+    { url, originalError: originalError.message }
+  );
+}
+
+/**
+ * Create page creation error
+ */
+function createPageCreationError(originalError) {
+  return new BraveRealBrowserError(
+    `Failed to create or access page: ${originalError.message}`,
+    ErrorCategory.PAGE_CREATION_FAILED,
+    ErrorSeverity.HIGH,
+    true,
+    { originalError: originalError.message }
+  );
+}
+
+/**
+ * Create plugin load error
+ */
+function createPluginLoadError(pluginName, originalError) {
+  return new BraveRealBrowserError(
+    `Failed to load plugin '${pluginName}': ${originalError.message}`,
+    ErrorCategory.PLUGIN_LOAD_FAILED,
+    ErrorSeverity.MEDIUM,
+    true,
+    { pluginName, originalError: originalError.message }
+  );
+}
+
+/**
+ * Create proxy error
+ */
+function createProxyError(proxyConfig, originalError) {
+  return new BraveRealBrowserError(
+    `Proxy connection failed: ${originalError.message}`,
+    ErrorCategory.PROXY_CONNECTION_FAILED,
+    ErrorSeverity.HIGH,
+    true,
+    { proxyConfig, originalError: originalError.message }
+  );
+}
+
+/**
+ * Create XVFB initialization error
+ */
+function createXvfbError(originalError) {
+  return new BraveRealBrowserError(
+    `Failed to initialize Xvfb: ${originalError.message}`,
+    ErrorCategory.XVFB_INIT_FAILED,
+    ErrorSeverity.MEDIUM,
+    false,
+    { 
+      originalError: originalError.message,
+      suggestion: 'Install xvfb with: sudo apt-get install xvfb'
+    }
+  );
+}
+
+/**
+ * Create port unavailable error
+ */
+function createPortUnavailableError(port) {
+  return new BraveRealBrowserError(
+    `Port ${port} is not available`,
+    ErrorCategory.PORT_UNAVAILABLE,
+    ErrorSeverity.HIGH,
+    true,
+    { port }
+  );
+}
+
+// ============================================================================
+// ERROR CATEGORIZATION
+// ============================================================================
+
+/**
+ * Categorize a generic error into BraveRealBrowserError
+ */
+function categorizeError(error) {
+  // Already a BraveRealBrowserError
+  if (error instanceof BraveRealBrowserError) {
+    return error;
+  }
+  
+  // Convert to Error if not already
+  const err = error instanceof Error ? error : new Error(String(error));
+  const message = err.message.toLowerCase();
+  
+  // Browser launch errors
+  if (message.includes('failed to launch') || message.includes('chrome') && message.includes('launch')) {
+    return createBrowserLaunchError(err);
+  }
+  
+  // Connection errors
+  if (message.includes('econnrefused') || message.includes('connection refused')) {
+    return new BraveRealBrowserError(
+      err.message,
+      ErrorCategory.CONNECTION_FAILED,
+      ErrorSeverity.CRITICAL,
+      true,
+      { originalError: err.message }
+    );
+  }
+  
+  // Protocol errors
+  if (message.includes('protocol error') || message.includes('target closed')) {
+    return new BraveRealBrowserError(
+      err.message,
+      ErrorCategory.PROTOCOL_ERROR,
+      ErrorSeverity.HIGH,
+      true,
+      { originalError: err.message }
+    );
+  }
+  
+  // Timeout errors
+  if (message.includes('timeout')) {
+    return new BraveRealBrowserError(
+      err.message,
+      ErrorCategory.TIMEOUT_ERROR,
+      ErrorSeverity.MEDIUM,
+      true,
+      { originalError: err.message }
+    );
+  }
+  
+  // Port errors
+  if (message.includes('eaddrinuse') || message.includes('address in use')) {
+    return new BraveRealBrowserError(
+      err.message,
+      ErrorCategory.PORT_UNAVAILABLE,
+      ErrorSeverity.HIGH,
+      true,
+      { originalError: err.message }
+    );
+  }
+  
+  // Default unknown error
+  return new BraveRealBrowserError(
+    err.message,
+    ErrorCategory.UNKNOWN_ERROR,
+    ErrorSeverity.MEDIUM,
+    false,
+    { originalError: err.message, stack: err.stack }
+  );
+}
+
+/**
+ * Check if error is recoverable
+ */
+function isRecoverableError(error) {
+  if (error instanceof BraveRealBrowserError) {
+    return error.isRecoverable;
+  }
+  
+  const categorized = categorizeError(error);
+  return categorized.isRecoverable;
+}
+
+// ============================================================================
+// EXPORTS
+// ============================================================================
+
+module.exports = {
+  ErrorCategory,
+  ErrorSeverity,
+  BraveRealBrowserError,
+  createBrowserLaunchError,
+  createConnectionError,
+  createPageCreationError,
+  createPluginLoadError,
+  createProxyError,
+  createXvfbError,
+  createPortUnavailableError,
+  categorizeError,
+  isRecoverableError,
+};

package/lib/cjs/module/pageController.js

@@ -2,6 +2,11 @@ const { createCursor } = require('ghost-cursor');
 const { checkTurnstile } = require('./turnstile.js');
 const kill = require('tree-kill');
 
+// Configuration constants
+const TURNSTILE_CHECK_INTERVAL = 1000; // 1 second
+const TURNSTILE_MAX_ATTEMPTS = 300; // 5 minutes max (300 attempts * 1 second)
+const TURNSTILE_TIMEOUT = 300000; // 5 minutes in milliseconds
+
 function getRandomInt(min, max) {
     min = Math.ceil(min);
     max = Math.floor(max);
@@ -10,60 +15,162 @@ function getRandomInt(min, max) {
 
 async function pageController({ browser, page, proxy, turnstile, xvfbsession, pid, plugins, killProcess = false, chrome }) {
 
-    let solveStatus = turnstile
+    let solveStatus = turnstile;
+    let turnstileSolverRunning = false;
+
+    // Safe cleanup function
+    const cleanup = async () => {
+        solveStatus = false;
+        if (killProcess === true) {
+            if (xvfbsession) {
+                try { 
+                    xvfbsession.stopSync();
+                } catch (err) { 
+                    console.error('Error stopping Xvfb session:', err.message);
+                }
+            }
+            if (chrome) {
+                try { 
+                    chrome.kill();
+                } catch (err) { 
+                    console.error('Error killing Chrome process:', err.message);
+                }
+            }
+            if (pid) {
+                try { 
+                    kill(pid, 'SIGKILL', (err) => {
+                        if (err) console.error('Error killing process:', err.message);
+                    });
+                } catch (err) { 
+                    console.error('Error in kill command:', err.message);
+                }
+            }
+        }
+    };
 
     page.on('close', () => {
-        solveStatus = false
+        solveStatus = false;
     });
 
-
     browser.on('disconnected', async () => {
-        solveStatus = false
-        if (killProcess === true) {
-            if (xvfbsession) try { xvfbsession.stopSync() } catch (err) { }
-            if (chrome) try { chrome.kill() } catch (err) { console.log(err); }
-            if (pid) try { kill(pid, 'SIGKILL', () => { }) } catch (err) { }
-        }
+        await cleanup();
     });
 
+    // Enhanced turnstile solver with timeout and max attempts protection
     async function turnstileSolver() {
-        while (solveStatus) {
-            await checkTurnstile({ page }).catch(() => { });
-            await new Promise(r => setTimeout(r, 1000));
+        if (turnstileSolverRunning) {
+            console.warn('Turnstile solver already running, skipping duplicate start');
+            return;
         }
-        return
-    }
+        
+        turnstileSolverRunning = true;
+        const startTime = Date.now();
+        let attempts = 0;
+
+        try {
+            while (solveStatus && attempts < TURNSTILE_MAX_ATTEMPTS) {
+                // Check timeout
+                if (Date.now() - startTime > TURNSTILE_TIMEOUT) {
+                    console.warn('Turnstile solver timeout reached after', attempts, 'attempts');
+                    break;
+                }
+
+                // Check if page is still valid
+                if (page.isClosed()) {
+                    console.log('Page closed, stopping turnstile solver');
+                    break;
+                }
+
+                attempts++;
+
+                try {
+                    await checkTurnstile({ page });
+                } catch (err) {
+                    // Silent fail for individual checks, log only if debug enabled
+                    if (process.env.DEBUG === 'true') {
+                        console.debug('Turnstile check failed:', err.message);
+                    }
+                }
+
+                // Wait before next check
+                await new Promise(r => setTimeout(r, TURNSTILE_CHECK_INTERVAL));
+            }
 
-    turnstileSolver()
+            if (attempts >= TURNSTILE_MAX_ATTEMPTS) {
+                console.warn('Turnstile solver stopped: max attempts reached');
+            }
+        } catch (err) {
+            console.error('Error in turnstile solver:', err.message);
+        } finally {
+            turnstileSolverRunning = false;
+        }
+    }
 
-    if (proxy.username && proxy.password) await page.authenticate({ username: proxy.username, password: proxy.password });
+    // Start turnstile solver only if enabled
+    if (turnstile) {
+        turnstileSolver().catch(err => {
+            console.error('Failed to start turnstile solver:', err.message);
+        });
+    }
 
-    if (plugins.length > 0) {
-        for (const plugin of plugins) {
-            plugin.onPageCreated(page)
+    // Proxy authentication with error handling
+    if (proxy && proxy.username && proxy.password) {
+        try {
+            await page.authenticate({ 
+                username: proxy.username, 
+                password: proxy.password 
+            });
+        } catch (err) {
+            console.error('Proxy authentication failed:', err.message);
+            throw new Error(`Failed to authenticate proxy: ${err.message}`);
         }
     }
 
-    await page.evaluateOnNewDocument(() => {
-        Object.defineProperty(MouseEvent.prototype, 'screenX', {
-            get: function () {
-                return this.clientX + window.screenX;
+    // Plugin initialization with error handling
+    if (plugins && plugins.length > 0) {
+        for (const plugin of plugins) {
+            try {
+                if (plugin && typeof plugin.onPageCreated === 'function') {
+                    await plugin.onPageCreated(page);
+                }
+            } catch (err) {
+                console.error('Plugin initialization failed:', err.message);
+                // Continue with other plugins even if one fails
             }
-        });
+        }
+    }
 
-        Object.defineProperty(MouseEvent.prototype, 'screenY', {
-            get: function () {
-                return this.clientY + window.screenY;
-            }
+    // Mouse event handling with error handling
+    try {
+        await page.evaluateOnNewDocument(() => {
+            Object.defineProperty(MouseEvent.prototype, 'screenX', {
+                get: function () {
+                    return this.clientX + window.screenX;
+                }
+            });
+
+            Object.defineProperty(MouseEvent.prototype, 'screenY', {
+                get: function () {
+                    return this.clientY + window.screenY;
+                }
+            });
         });
+    } catch (err) {
+        console.error('Failed to setup mouse event handlers:', err.message);
+        // Non-critical, continue anyway
+    }
 
-    });
-
-    const cursor = createCursor(page);
-    page.realCursor = cursor
-    page.realClick = cursor.click
+    // Cursor setup with error handling
+    try {
+        const cursor = createCursor(page);
+        page.realCursor = cursor;
+        page.realClick = cursor.click;
+    } catch (err) {
+        console.error('Failed to create ghost cursor:', err.message);
+        // Non-critical, continue anyway
+    }
 
-    return page
+    return page;
 }
 
 module.exports = { pageController }

package/lib/esm/module/pageController.mjs

@@ -2,65 +2,175 @@ import { createCursor } from 'ghost-cursor';
 import { checkTurnstile } from './turnstile.mjs';
 import kill from 'tree-kill';
 
+// Configuration constants
+const TURNSTILE_CHECK_INTERVAL = 1000; // 1 second
+const TURNSTILE_MAX_ATTEMPTS = 300; // 5 minutes max (300 attempts * 1 second)
+const TURNSTILE_TIMEOUT = 300000; // 5 minutes in milliseconds
+
 function getRandomInt(min, max) {
     min = Math.ceil(min);
     max = Math.floor(max);
     return Math.floor(Math.random() * (max - min + 1)) + min;
 }
 
-export async function pageController({ browser, page, proxy, turnstile, xvfbsession, pid, plugins, killProcess = false, chrome }) {
+async function pageController({ browser, page, proxy, turnstile, xvfbsession, pid, plugins, killProcess = false, chrome }) {
+
+    let solveStatus = turnstile;
+    let turnstileSolverRunning = false;
 
-    let solveStatus = turnstile
+    // Safe cleanup function
+    const cleanup = async () => {
+        solveStatus = false;
+        if (killProcess === true) {
+            if (xvfbsession) {
+                try { 
+                    xvfbsession.stopSync();
+                } catch (err) { 
+                    console.error('Error stopping Xvfb session:', err.message);
+                }
+            }
+            if (chrome) {
+                try { 
+                    chrome.kill();
+                } catch (err) { 
+                    console.error('Error killing Chrome process:', err.message);
+                }
+            }
+            if (pid) {
+                try { 
+                    kill(pid, 'SIGKILL', (err) => {
+                        if (err) console.error('Error killing process:', err.message);
+                    });
+                } catch (err) { 
+                    console.error('Error in kill command:', err.message);
+                }
+            }
+        }
+    };
 
     page.on('close', () => {
-        solveStatus = false
+        solveStatus = false;
     });
 
-
     browser.on('disconnected', async () => {
-        solveStatus = false
-        if (killProcess === true) {
-            if (xvfbsession) try { xvfbsession.stopSync() } catch (err) { }
-            if (chrome) try { chrome.kill() } catch (err) { console.log(err); }
-            if (pid) try { kill(pid, 'SIGKILL', () => { }) } catch (err) { }
-        }
+        await cleanup();
     });
 
+    // Enhanced turnstile solver with timeout and max attempts protection
     async function turnstileSolver() {
-        while (solveStatus) {
-            await checkTurnstile({ page }).catch(() => { });
-            await new Promise(r => setTimeout(r, 1000));
+        if (turnstileSolverRunning) {
+            console.warn('Turnstile solver already running, skipping duplicate start');
+            return;
         }
-        return
-    }
+        
+        turnstileSolverRunning = true;
+        const startTime = Date.now();
+        let attempts = 0;
 
-    turnstileSolver()
+        try {
+            while (solveStatus && attempts < TURNSTILE_MAX_ATTEMPTS) {
+                // Check timeout
+                if (Date.now() - startTime > TURNSTILE_TIMEOUT) {
+                    console.warn('Turnstile solver timeout reached after', attempts, 'attempts');
+                    break;
+                }
 
-    if (proxy.username && proxy.password) await page.authenticate({ username: proxy.username, password: proxy.password });
+                // Check if page is still valid
+                if (page.isClosed()) {
+                    console.log('Page closed, stopping turnstile solver');
+                    break;
+                }
 
-    if (plugins.length > 0) {
-        for (const plugin of plugins) {
-            plugin.onPageCreated(page)
+                attempts++;
+
+                try {
+                    await checkTurnstile({ page });
+                } catch (err) {
+                    // Silent fail for individual checks, log only if debug enabled
+                    if (process.env.DEBUG === 'true') {
+                        console.debug('Turnstile check failed:', err.message);
+                    }
+                }
+
+                // Wait before next check
+                await new Promise(r => setTimeout(r, TURNSTILE_CHECK_INTERVAL));
+            }
+
+            if (attempts >= TURNSTILE_MAX_ATTEMPTS) {
+                console.warn('Turnstile solver stopped: max attempts reached');
+            }
+        } catch (err) {
+            console.error('Error in turnstile solver:', err.message);
+        } finally {
+            turnstileSolverRunning = false;
         }
     }
 
-    await page.evaluateOnNewDocument(() => {
-        Object.defineProperty(MouseEvent.prototype, 'screenX', {
-            get: function () {
-                return this.clientX + window.screenX;
-            }
+    // Start turnstile solver only if enabled
+    if (turnstile) {
+        turnstileSolver().catch(err => {
+            console.error('Failed to start turnstile solver:', err.message);
         });
+    }
+
+    // Proxy authentication with error handling
+    if (proxy && proxy.username && proxy.password) {
+        try {
+            await page.authenticate({ 
+                username: proxy.username, 
+                password: proxy.password 
+            });
+        } catch (err) {
+            console.error('Proxy authentication failed:', err.message);
+            throw new Error(`Failed to authenticate proxy: ${err.message}`);
+        }
+    }
 
-        Object.defineProperty(MouseEvent.prototype, 'screenY', {
-            get: function () {
-                return this.clientY + window.screenY;
+    // Plugin initialization with error handling
+    if (plugins && plugins.length > 0) {
+        for (const plugin of plugins) {
+            try {
+                if (plugin && typeof plugin.onPageCreated === 'function') {
+                    await plugin.onPageCreated(page);
+                }
+            } catch (err) {
+                console.error('Plugin initialization failed:', err.message);
+                // Continue with other plugins even if one fails
             }
+        }
+    }
+
+    // Mouse event handling with error handling
+    try {
+        await page.evaluateOnNewDocument(() => {
+            Object.defineProperty(MouseEvent.prototype, 'screenX', {
+                get: function () {
+                    return this.clientX + window.screenX;
+                }
+            });
+
+            Object.defineProperty(MouseEvent.prototype, 'screenY', {
+                get: function () {
+                    return this.clientY + window.screenY;
+                }
+            });
         });
+    } catch (err) {
+        console.error('Failed to setup mouse event handlers:', err.message);
+        // Non-critical, continue anyway
+    }
 
-    });
+    // Cursor setup with error handling
+    try {
+        const cursor = createCursor(page);
+        page.realCursor = cursor;
+        page.realClick = cursor.click;
+    } catch (err) {
+        console.error('Failed to create ghost cursor:', err.message);
+        // Non-critical, continue anyway
+    }
+
+    return page;
+}
 
-    const cursor = createCursor(page);
-    page.realCursor = cursor
-    page.realClick = cursor.click
-    return page
-}
+export { pageController };

package/lib/esm/module/turnstile.mjs

@@ -1,7 +1,6 @@
-export const checkTurnstile = ({ page }) => {
+const checkTurnstile = ({ page }) => {
     return new Promise(async (resolve, reject) => {
         var waitInterval = setTimeout(() => { clearInterval(waitInterval); resolve(false) }, 5000);
-
         try {
             const elements = await page.$$('[name="cf-turnstile-response"]');
             if (elements.length <= 0) {
@@ -59,4 +58,6 @@ export const checkTurnstile = ({ page }) => {
             resolve(false)
         }
     })
-}
+}
+
+export { checkTurnstile };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser",
-  "version": "1.5.95",
+  "version": "1.5.98",
   "description": "This package is designed to bypass puppeteer's bot-detecting captchas such as Cloudflare. It acts like a real browser and can be managed with puppeteer.",
   "main": "lib/cjs/index.js",
   "module": "lib/esm/index.mjs",
@@ -40,7 +40,7 @@
   "dependencies": {
     "brave-real-launcher": "latest",
     "brave-real-puppeteer-core": "latest",
-    "ghost-cursor": "^1.4.1 ",
+    "ghost-cursor": "^1.4.1",
     "puppeteer-extra": "^3.3.6",
     "tree-kill": "^1.2.2",
     "xvfb": "^0.4.0"