brave-real-browser-mcp-server 2.42.0 → 2.43.0

package/README.md

@@ -681,15 +681,22 @@ console.log(blocker === sameBlocker); // true
 | `npm run mcp` | Start MCP server (alias) |
 | `npm run mcp:verbose` | Start MCP server with tool details |
 | `npm run lsp` | Start LSP server for IDE intelligence |
+| `npm run lsp:tcp` | Start LSP server on TCP port 7777 |
 | `npm run list` | List all 23 optimized tools with categories |
-| `npm install` | Install all dependencies with workspace linking |
+| `npm install` | Install dependencies + auto-build workspaces + Brave check |
 | `npm test` | Run all tests (CJS + ESM) |
 | `npm run cjs_test` | Run CommonJS tests only |
 | `npm run esm_test` | Run ESM tests only |
-| `npm run build` | Build root package |
-| `npm run build:all` | Build all workspace packages |
+| `npm run build` | Build root package (pre-built lib/) |
+| `npm run build:all` | Build all workspace packages (blocker, launcher, puppeteer-core) |
+| `npm run clean:all` | Clean all workspace build outputs |
+| `npm run test:all` | Run tests for all workspace packages |
+| `npm run update-deps` | Manually check for dependency updates |
+| `npm run upstream-patch` | Update to latest upstream (puppeteer-core, playwright-core) |
 | `npm run lint` | Run linter |
 
+> **Note:** `npm install` automatically runs `npm run build:all` to compile TypeScript packages (brave-real-blocker, brave-real-launcher) before the auto-update check. This ensures the browser tools work immediately after installation.
+
 ### Workspace Scripts
 
 | Command | Description |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.42.0",
+  "version": "2.43.0",
   "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",
@@ -43,7 +43,7 @@
     "build:all": "npm run build --workspaces --if-present",
     "clean:all": "npm run clean --workspaces --if-present",
     "test:all": "npm run test --workspaces --if-present",
-    "postinstall": "node scripts/auto-update-deps.js || true",
+    "postinstall": "npm run build:all && node scripts/auto-update-deps.js || true",
     "update-deps": "node scripts/auto-update-deps.js",
     "upstream-patch": "node scripts/upstream-patcher.js"
   },
@@ -74,7 +74,7 @@
   "license": "ISC",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.3",
-    "brave-real-puppeteer-core": "^24.37.2-brave.4",
+    "brave-real-puppeteer-core": "^24.37.2-brave.6",
     "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.18.0",
+  "version": "1.19.0",
   "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.37.2-brave.4",
+    "brave-real-puppeteer-core": "^24.37.2-brave.6",
     "mocha": "^10.4.0",
     "puppeteer-core": ">=24.0.0",
     "sinon": "^17.0.1",

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

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-launcher",
-  "version": "1.24.0",
+  "version": "1.25.0",
   "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.18.0",
+    "brave-real-blocker": "^1.19.0",
     "escape-string-regexp": "^5.0.0",
     "is-wsl": "^3.1.0",
     "which": "^6.0.0"

package/packages/brave-real-playwright-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-playwright-core",
-  "version": "1.60.0",
+  "version": "1.61.0",
   "description": "Brave-optimized Playwright Core (v1.57.0) with comprehensive stealth patches and error stack sanitization",
   "keywords": [
     "playwright",

package/packages/brave-real-puppeteer-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-puppeteer-core",
-  "version": "24.37.2-brave.4",
+  "version": "24.37.2-brave.6",
   "description": "🦁 Brave Real-World Optimized Puppeteer & Playwright Core with 1-5ms ultra-fast timing, 50+ professional stealth features, intelligent browser auto-detection, and 100% bot detection bypass. Features cross-platform Brave browser integration, comprehensive anti-detection, and breakthrough performance improvements.",
   "keywords": [
     "automation",
@@ -135,7 +135,7 @@
   },
   "dependencies": {
     "@puppeteer/browsers": "2.12.0",
-    "brave-real-launcher": "^1.24.0",
+    "brave-real-launcher": "^1.25.0",
     "chromium-bidi": "13.1.1",
     "debug": "^4.4.3",
     "devtools-protocol": "0.0.1566079",

package/src/mcp/handlers.js

@@ -793,17 +793,209 @@ const handlers = {
     return { success: true, type, value };
   },
 
-  // 5. Click
+  // 5. Click (ENHANCED: iframe + hover + auto video player detection)
   async click(params) {
     const { page } = requireBrowser();
-    const { selector, humanLike = true, clickCount = 1, delay = 0, autoAcceptDialogs = true } = params;
+    const { 
+      selector, 
+      humanLike = true, 
+      clickCount = 1, 
+      delay = 0, 
+      autoAcceptDialogs = true,
+      retries = 3,
+      timeout = 60000,
+      // Hover support for video player dynamic controls
+      hoverFirst = false,
+      hoverOnly = false,
+      hoverDuration = 500,
+      // iframe support
+      iframe,
+      iframeSelector,
+      // Additional options
+      scrollIntoView = true,
+      forceClick = false,
+      // NEW: Auto Video Player Detection & Control
+      autoDetectPlayer = false,
+      usePlayerAPI = true,
+      waitForPlay = false,
+      playerTimeout = 15000
+    } = params;
+
+    notifyProgress('click', 'started', `${hoverOnly ? 'Hovering' : 'Clicking'}: ${selector}${iframe !== undefined ? ` (iframe ${iframe})` : ''}${autoDetectPlayer ? ' (auto-detect player)' : ''}`);
 
-    notifyProgress('click', 'started', `Clicking: ${selector}`);
+    // Get the correct context (page or iframe)
+    let context = page;
+    let frameInfo = null;
+    let detectedPlayer = null;
+
+    // ═══════════════════════════════════════════════════════════════
+    // AUTO DETECT VIDEO PLAYER - Scan all iframes for video players
+    // Supports: JWPlayer, VideoJS, Plyr, VidStack, DooPlayer, HTML5
+    // ═══════════════════════════════════════════════════════════════
+    if (autoDetectPlayer) {
+      notifyProgress('click', 'progress', '🔍 Scanning all iframes for video players...');
+      
+      const frames = page.frames();
+      
+      for (let i = 0; i < frames.length; i++) {
+        try {
+          const frame = frames[i];
+          const frameUrl = frame.url();
+          
+          // Skip blank frames
+          if (frameUrl === 'about:blank' || !frameUrl) continue;
+          
+          // Detect player in this frame
+          const playerInfo = await frame.evaluate(() => {
+            const result = {
+              hasPlayer: false,
+              playerType: null,
+              hasVideo: false,
+              videoState: null,
+              controls: [],
+              downloadButton: null
+            };
+            
+            // Check for video element
+            const video = document.querySelector('video');
+            if (video) {
+              result.hasVideo = true;
+              result.videoState = {
+                paused: video.paused,
+                currentTime: video.currentTime,
+                duration: video.duration,
+                readyState: video.readyState
+              };
+            }
+            
+            // 1. JWPlayer Detection
+            if (window.jwplayer && typeof window.jwplayer === 'function') {
+              try {
+                const jw = window.jwplayer();
+                if (jw && jw.getState) {
+                  result.hasPlayer = true;
+                  result.playerType = 'jwplayer';
+                  result.playerState = jw.getState();
+                  result.controls.push('.jw-icon-display', '.jw-icon-playback', '[aria-label="Play"]');
+                  
+                  // Find download button in JWPlayer
+                  const dlBtn = document.querySelector('[aria-label="Download"], .jw-icon-download, [class*="download"]');
+                  if (dlBtn) result.downloadButton = '[aria-label="Download"]';
+                }
+              } catch (e) {}
+            }
+            
+            // 2. VideoJS Detection
+            if (window.videojs || document.querySelector('.video-js')) {
+              result.hasPlayer = true;
+              result.playerType = result.playerType || 'videojs';
+              result.controls.push('.vjs-big-play-button', '.vjs-play-control');
+            }
+            
+            // 3. Plyr Detection
+            if (window.Plyr || document.querySelector('.plyr')) {
+              result.hasPlayer = true;
+              result.playerType = result.playerType || 'plyr';
+              result.controls.push('.plyr__control--play', '[data-plyr="play"]');
+            }
+            
+            // 4. VidStack Detection
+            if (window.VidStack || document.querySelector('media-player')) {
+              result.hasPlayer = true;
+              result.playerType = result.playerType || 'vidstack';
+              result.controls.push('media-play-button', '[data-media-play]');
+            }
+            
+            // 5. DooPlayer Detection
+            if (window.DooPlay || document.querySelector('#dooplay') || document.querySelector('.dooplay')) {
+              result.hasPlayer = true;
+              result.playerType = result.playerType || 'dooplayer';
+              result.controls.push('.play-btn', '.dooplay-play');
+            }
+            
+            // 6. Generic HTML5 Video
+            if (result.hasVideo && !result.hasPlayer) {
+              result.hasPlayer = true;
+              result.playerType = 'html5';
+              result.controls.push('video');
+            }
+            
+            // Find any download button
+            if (!result.downloadButton) {
+              const dlSelectors = [
+                '[aria-label="Download"]', '[aria-label*="download"]',
+                '.download-btn', '.download', '[class*="download"]',
+                'a[download]', 'button[class*="download"]'
+              ];
+              for (const sel of dlSelectors) {
+                if (document.querySelector(sel)) {
+                  result.downloadButton = sel;
+                  break;
+                }
+              }
+            }
+            
+            return result;
+          }).catch(() => ({ hasPlayer: false }));
+          
+          if (playerInfo.hasPlayer) {
+            context = frame;
+            frameInfo = { 
+              index: i, 
+              url: frameUrl,
+              autoDetected: true
+            };
+            detectedPlayer = {
+              type: playerInfo.playerType,
+              state: playerInfo.playerState || playerInfo.videoState,
+              controls: playerInfo.controls,
+              downloadButton: playerInfo.downloadButton
+            };
+            
+            notifyProgress('click', 'progress', 
+              `✅ Found ${playerInfo.playerType.toUpperCase()} in iframe ${i}: ${frameUrl.substring(0, 50)}...`);
+            break;
+          }
+        } catch (e) {
+          // Skip frames that can't be accessed
+          continue;
+        }
+      }
+      
+      if (!detectedPlayer) {
+        notifyProgress('click', 'progress', '⚠️ No video player found in any iframe, using main page');
+      }
+    }
+
+    // Manual iframe selection (if not auto-detected)
+    if (!autoDetectPlayer && (iframe !== undefined || iframeSelector)) {
+      try {
+        const frames = page.frames();
+        
+        if (iframe !== undefined && frames[iframe]) {
+          context = frames[iframe];
+          frameInfo = { index: iframe, url: frames[iframe].url() };
+          notifyProgress('click', 'progress', `Switched to iframe ${iframe}: ${frames[iframe].url().substring(0, 50)}...`);
+        } else if (iframeSelector) {
+          const iframeHandle = await page.$(iframeSelector);
+          if (iframeHandle) {
+            const frame = await iframeHandle.contentFrame();
+            if (frame) {
+              context = frame;
+              frameInfo = { selector: iframeSelector, url: frame.url() };
+              notifyProgress('click', 'progress', `Switched to iframe by selector: ${iframeSelector}`);
+            }
+          }
+        }
+      } catch (e) {
+        notifyProgress('click', 'progress', `Warning: Could not switch to iframe - ${e.message}`);
+      }
+    }
 
     // Auto-close any blocking modals before clicking
     await handlers._handleBlockingModals(page);
 
-    // Auto-handle dialogs (alerts, confirms, prompts) to prevent blocking
+    // Auto-handle dialogs
     let dialogHandled = false;
     const dialogHandler = async (dialog) => {
       dialogHandled = true;
@@ -812,64 +1004,326 @@ const handlers = {
       notifyProgress('click', 'progress', `🔔 Auto-accepting ${type}: ${message.substring(0, 50)}...`);
       try {
         await dialog.accept();
-      } catch (e) {
-        // Ignore if already handled by global handler
-      }
+      } catch (e) { }
     };
 
     if (autoAcceptDialogs) {
       page.on('dialog', dialogHandler);
     }
 
+    let lastError = null;
+    let playerResult = null;
+
     try {
-      if (humanLike) {
-        try {
-          const { createCursor } = require('ghost-cursor');
-          const cursor = createCursor(page);
-          await cursor.click(selector);
-          notifyProgress('click', 'progress', 'Used human-like cursor movement');
-        } catch (e) {
-          await page.click(selector, { clickCount, delay });
+      // ═══════════════════════════════════════════════════════════════
+      // USE PLAYER API - More reliable than DOM click for video players
+      // ═══════════════════════════════════════════════════════════════
+      if (usePlayerAPI && detectedPlayer && (selector === 'video' || selector.includes('play') || selector.includes('Play'))) {
+        notifyProgress('click', 'progress', `🎬 Using ${detectedPlayer.type} API for playback...`);
+        
+        playerResult = await context.evaluate((playerType) => {
+          const result = { success: false, method: null, state: null };
+          
+          try {
+            if (playerType === 'jwplayer' && window.jwplayer) {
+              const jw = window.jwplayer();
+              const stateBefore = jw.getState();
+              jw.play();
+              result.success = true;
+              result.method = 'jwplayer.play()';
+              result.stateBefore = stateBefore;
+              result.stateAfter = jw.getState();
+            } else if (playerType === 'videojs' && window.videojs) {
+              const player = window.videojs.getPlayers()[Object.keys(window.videojs.getPlayers())[0]];
+              if (player) {
+                player.play();
+                result.success = true;
+                result.method = 'videojs.play()';
+              }
+            } else if (playerType === 'plyr' && window.Plyr) {
+              const plyr = document.querySelector('.plyr')?.__plyr;
+              if (plyr) {
+                plyr.play();
+                result.success = true;
+                result.method = 'plyr.play()';
+              }
+            } else {
+              // Fallback to HTML5 video
+              const video = document.querySelector('video');
+              if (video) {
+                video.play();
+                result.success = true;
+                result.method = 'video.play()';
+              }
+            }
+          } catch (e) {
+            result.error = e.message;
+          }
+          
+          return result;
+        }, detectedPlayer.type).catch(e => ({ success: false, error: e.message }));
+        
+        if (playerResult.success) {
+          notifyProgress('click', 'progress', `✅ ${playerResult.method} executed`);
+          
+          // Wait for play if requested
+          if (waitForPlay) {
+            notifyProgress('click', 'progress', '⏳ Waiting for video to start playing...');
+            
+            const startTime = Date.now();
+            let isPlaying = false;
+            
+            while (Date.now() - startTime < playerTimeout) {
+              const state = await context.evaluate(() => {
+                const video = document.querySelector('video');
+                if (video) {
+                  return {
+                    paused: video.paused,
+                    currentTime: video.currentTime,
+                    playing: !video.paused && video.currentTime > 0
+                  };
+                }
+                if (window.jwplayer) {
+                  const jw = window.jwplayer();
+                  return { playing: jw.getState() === 'playing', jwState: jw.getState() };
+                }
+                return { playing: false };
+              }).catch(() => ({ playing: false }));
+              
+              if (state.playing || state.currentTime > 0) {
+                isPlaying = true;
+                notifyProgress('click', 'progress', `▶️ Video is now playing (${state.currentTime?.toFixed(1) || 0}s)`);
+                break;
+              }
+              
+              await new Promise(r => setTimeout(r, 500));
+            }
+            
+            if (!isPlaying) {
+              notifyProgress('click', 'progress', '⚠️ Video may still be buffering');
+            }
+          }
+          
+          notifyProgress('click', 'completed', `Video playback started via ${playerResult.method}`, {
+            selector,
+            clicked: true,
+            playerAPI: true,
+            detectedPlayer,
+            iframe: frameInfo,
+            playerResult
+          });
+          
+          return {
+            success: true,
+            selector,
+            clicked: true,
+            playerAPI: true,
+            detectedPlayer,
+            iframe: frameInfo,
+            playerResult,
+            dialogHandled
+          };
         }
-      } else {
-        await page.click(selector, { clickCount, delay });
       }
 
-      // Small wait to allow dialogs to appear and be handled
-      await new Promise(r => setTimeout(r, 300));
+      // Retry loop for regular click
+      for (let attempt = 1; attempt <= retries; attempt++) {
+        try {
+          // Wait for selector with timeout
+          try {
+            await context.waitForSelector(selector, { timeout: Math.min(timeout / retries, 10000) });
+          } catch (e) {
+            if (attempt < retries) {
+              notifyProgress('click', 'progress', `Selector not found, retry ${attempt}/${retries}...`);
+              await new Promise(r => setTimeout(r, 1000));
+              continue;
+            }
+            throw new Error(`Selector not found: ${selector}`);
+          }
+
+          // Scroll into view if needed
+          if (scrollIntoView) {
+            await context.evaluate((sel) => {
+              const el = document.querySelector(sel);
+              if (el) el.scrollIntoView({ behavior: 'smooth', block: 'center' });
+            }, selector);
+            await new Promise(r => setTimeout(r, 300));
+          }
+
+          // HOVER functionality (for video player dynamic controls)
+          if (hoverFirst || hoverOnly) {
+            notifyProgress('click', 'progress', `Hovering over ${selector}...`);
+            
+            try {
+              await context.hover(selector);
+              notifyProgress('click', 'progress', `Hover successful, waiting ${hoverDuration}ms for controls...`);
+              await new Promise(r => setTimeout(r, hoverDuration));
+            } catch (hoverErr) {
+              notifyProgress('click', 'progress', `Standard hover failed, trying mouse movement...`);
+              const element = await context.$(selector);
+              if (element) {
+                const box = await element.boundingBox();
+                if (box) {
+                  await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+                  await new Promise(r => setTimeout(r, hoverDuration));
+                }
+              }
+            }
+            
+            if (hoverOnly) {
+              notifyProgress('click', 'completed', `Hover completed: ${selector}`, { selector, hovered: true, iframe: frameInfo });
+              return { success: true, selector, hovered: true, clicked: false, iframe: frameInfo, detectedPlayer };
+            }
+          }
+
+          // CLICK functionality
+          if (forceClick) {
+            await context.evaluate((sel) => {
+              const el = document.querySelector(sel);
+              if (el) el.click();
+            }, selector);
+            notifyProgress('click', 'progress', 'Used force click (JS)');
+          } else if (humanLike) {
+            try {
+              const { createCursor } = require('ghost-cursor');
+              const cursor = createCursor(page);
+              
+              if (context !== page) {
+                const element = await context.$(selector);
+                if (element) {
+                  const box = await element.boundingBox();
+                  if (box) {
+                    await cursor.moveTo({ x: box.x + box.width / 2, y: box.y + box.height / 2 });
+                    await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2, { clickCount, delay });
+                  }
+                }
+              } else {
+                await cursor.click(selector);
+              }
+              notifyProgress('click', 'progress', 'Used human-like cursor movement');
+            } catch (e) {
+              await context.click(selector, { clickCount, delay });
+            }
+          } else {
+            await context.click(selector, { clickCount, delay });
+          }
+
+          await new Promise(r => setTimeout(r, 300));
+
+          notifyProgress('click', 'completed', 
+            `${hoverFirst ? 'Hovered+' : ''}Clicked: ${selector}${dialogHandled ? ' (dialog auto-accepted)' : ''}`, 
+            { selector, humanLike, dialogHandled, iframe: frameInfo, detectedPlayer, attempts: attempt }
+          );
+
+          return { 
+            success: true, 
+            selector, 
+            clicked: true, 
+            dialogHandled, 
+            iframe: frameInfo, 
+            detectedPlayer,
+            attempts: attempt 
+          };
+
+        } catch (attemptError) {
+          lastError = attemptError;
+          if (attempt < retries) {
+            notifyProgress('click', 'progress', `Attempt ${attempt} failed: ${attemptError.message}, retrying...`);
+            await new Promise(r => setTimeout(r, 1000));
+          }
+        }
+      }
 
-      notifyProgress('click', 'completed', `Clicked: ${selector}${dialogHandled ? ' (dialog auto-accepted)' : ''}`, { selector, humanLike, dialogHandled });
+      throw lastError || new Error('Click failed after all retries');
 
-      return { success: true, selector, clicked: true, dialogHandled };
     } finally {
-      // Remove dialog handler to prevent memory leaks
       if (autoAcceptDialogs) {
         page.off('dialog', dialogHandler);
       }
     }
   },
 
-  // 6. Type
+  // 6. Type (ENHANCED: iframe support)
   async type(params) {
     const { page } = requireBrowser();
-    const { selector, text, delay = 50, clear = false } = params;
+    const { 
+      selector, 
+      text, 
+      delay = 50, 
+      clear = false,
+      // NEW: iframe support
+      iframe,
+      iframeSelector,
+      // NEW: Additional options
+      pressEnter = false,
+      waitForSelector = true
+    } = params;
+
+    notifyProgress('type', 'started', `Typing ${text.length} characters into ${selector}${iframe !== undefined ? ` (iframe ${iframe})` : ''}`);
 
-    notifyProgress('type', 'started', `Typing ${text.length} characters into ${selector}`);
+    // Get the correct context (page or iframe)
+    let context = page;
+    let frameInfo = null;
+
+    if (iframe !== undefined || iframeSelector) {
+      try {
+        const frames = page.frames();
+        
+        if (iframe !== undefined && frames[iframe]) {
+          context = frames[iframe];
+          frameInfo = { index: iframe, url: frames[iframe].url() };
+          notifyProgress('type', 'progress', `Switched to iframe ${iframe}`);
+        } else if (iframeSelector) {
+          const iframeHandle = await page.$(iframeSelector);
+          if (iframeHandle) {
+            const frame = await iframeHandle.contentFrame();
+            if (frame) {
+              context = frame;
+              frameInfo = { selector: iframeSelector, url: frame.url() };
+              notifyProgress('type', 'progress', `Switched to iframe by selector`);
+            }
+          }
+        }
+      } catch (e) {
+        notifyProgress('type', 'progress', `Warning: Could not switch to iframe - ${e.message}`);
+      }
+    }
 
     // Auto-close any blocking modals before typing
     await handlers._handleBlockingModals(page);
 
+    // Wait for selector if enabled
+    if (waitForSelector) {
+      try {
+        await context.waitForSelector(selector, { timeout: 10000 });
+      } catch (e) {
+        notifyProgress('type', 'error', `Selector not found: ${selector}`);
+        return { success: false, error: `Selector not found: ${selector}` };
+      }
+    }
+
+    // Clear existing text if needed
     if (clear) {
-      await page.click(selector, { clickCount: 3 });
-      await page.keyboard.press('Backspace');
+      await context.click(selector, { clickCount: 3 });
+      await context.evaluate((sel) => {
+        const el = document.querySelector(sel);
+        if (el) el.value = '';
+      }, selector);
       notifyProgress('type', 'progress', 'Cleared existing text');
     }
 
-    await page.type(selector, text, { delay });
+    // Type text with human-like delays
+    await context.type(selector, text, { delay });
+
+    // Press Enter if requested
+    if (pressEnter) {
+      await context.keyboard.press('Enter');
+      notifyProgress('type', 'progress', 'Pressed Enter');
+    }
 
-    notifyProgress('type', 'completed', `Typed ${text.length} characters`, { selector, textLength: text.length });
+    notifyProgress('type', 'completed', `Typed ${text.length} characters`, { selector, textLength: text.length, iframe: frameInfo });
 
-    return { success: true, selector, textLength: text.length };
+    return { success: true, selector, textLength: text.length, iframe: frameInfo };
   },
 
   // 7. Browser Close
@@ -2295,18 +2749,88 @@ const handlers = {
     return { success: true, selector, content };
   },
 
-  // 26. Execute JS
+  // 26. Execute JS (ENHANCED: iframe context support - FIXED)
   async execute_js(params) {
     const { page } = requireBrowser();
-    const { code, returnValue = true } = params;
+    const { 
+      code, 
+      returnValue = true,
+      // NEW: iframe support (FIXED)
+      iframe,
+      iframeSelector,
+      waitForIframe = true,
+      timeout = 30000
+    } = params;
+
+    notifyProgress('execute_js', 'started', `Executing JavaScript...${iframe !== undefined ? ` (iframe ${iframe})` : ''}`);
+
+    // Get the correct context (page or iframe)
+    let context = page;
+    let frameInfo = null;
+
+    if (iframe !== undefined || iframeSelector) {
+      try {
+        const frames = page.frames();
+        
+        if (iframe !== undefined) {
+          // iframe index provided
+          if (iframe === 0) {
+            // index 0 = main frame
+            context = page.mainFrame();
+            frameInfo = { index: 0, url: page.url(), isMain: true };
+          } else if (frames[iframe]) {
+            context = frames[iframe];
+            frameInfo = { index: iframe, url: frames[iframe].url() };
+            notifyProgress('execute_js', 'progress', `Switched to iframe ${iframe}: ${frames[iframe].url().substring(0, 50)}...`);
+          } else {
+            notifyProgress('execute_js', 'error', `iframe index ${iframe} not found. Total frames: ${frames.length}`);
+            return { success: false, error: `iframe index ${iframe} not found. Available: 0-${frames.length - 1}` };
+          }
+        } else if (iframeSelector) {
+          // Find iframe by selector
+          const iframeHandle = await page.$(iframeSelector);
+          if (iframeHandle) {
+            const frame = await iframeHandle.contentFrame();
+            if (frame) {
+              context = frame;
+              frameInfo = { selector: iframeSelector, url: frame.url() };
+              notifyProgress('execute_js', 'progress', `Switched to iframe by selector: ${iframeSelector}`);
+            }
+          } else {
+            return { success: false, error: `iframe selector not found: ${iframeSelector}` };
+          }
+        }
+
+        // Wait for iframe to be ready if needed
+        if (waitForIframe && context !== page) {
+          try {
+            await context.waitForFunction(() => document.readyState === 'complete', { timeout: 5000 });
+          } catch (e) {
+            notifyProgress('execute_js', 'progress', 'Warning: iframe may not be fully loaded');
+          }
+        }
 
-    notifyProgress('execute_js', 'started', 'Executing JavaScript...');
+      } catch (e) {
+        notifyProgress('execute_js', 'error', `iframe switch failed: ${e.message}`);
+        return { success: false, error: `iframe switch failed: ${e.message}` };
+      }
+    }
 
-    const result = await page.evaluate(code);
+    try {
+      // Execute the code in the correct context
+      const result = await context.evaluate(code);
+
+      notifyProgress('execute_js', 'completed', 'JavaScript executed', { 
+        hasResult: result !== undefined, 
+        iframe: frameInfo 
+      });
 
-    notifyProgress('execute_js', 'completed', 'JavaScript executed', { hasResult: result !== undefined });
+      return { success: true, result: returnValue ? result : undefined, iframe: frameInfo };
 
-    return { success: true, result: returnValue ? result : undefined };
+    } catch (evalError) {
+      notifyProgress('execute_js', 'error', `Execution error: ${evalError.message}`);
+      return { success: false, error: evalError.message, iframe: frameInfo };
+    }
   },
 
   // 27. Player API Hook (ENHANCED - searches iframes, detects more player types)

package/src/shared/tools.js

@@ -111,12 +111,12 @@ const TOOLS = [
     }
   },
 
-  // 5. Click
+  // 5. Click (ENHANCED: iframe + hover + auto video player detection)
   {
     name: 'click',
     emoji: '👆',
-    description: 'Human-like click with AI healing and auto-retry',
-    descriptionHindi: 'क्लिक करना (AI healing + human-like)',
+    description: 'Human-like click with AI healing, iframe support, hover for dynamic controls, and auto video player detection',
+    descriptionHindi: 'क्लिक करना (AI healing + iframe + auto video player detection)',
     category: 'interaction',
     requiresBrowser: true,
     requiresPage: true,
@@ -127,20 +127,36 @@ const TOOLS = [
         humanLike: { type: 'boolean', default: true, description: 'Ghost cursor human movement' },
         aiHeal: { type: 'boolean', default: true, description: 'Auto-find alternative selector if broken' },
         autoAcceptDialogs: { type: 'boolean', default: true, description: 'Auto-accept alerts/confirms to prevent blocking' },
-        retries: { type: 'number', default: 3 },
+        retries: { type: 'number', default: 3, description: 'Auto-retry on failure' },
         clickCount: { type: 'number', default: 1 },
-        delay: { type: 'number', default: 0 }
+        delay: { type: 'number', default: 0 },
+        timeout: { type: 'number', default: 60000, description: 'Timeout for element to appear' },
+        // Hover support for video player dynamic controls
+        hoverFirst: { type: 'boolean', default: false, description: 'Hover before click (for dynamic controls like video players)' },
+        hoverOnly: { type: 'boolean', default: false, description: 'Only hover, do not click (to reveal hidden controls)' },
+        hoverDuration: { type: 'number', default: 500, description: 'Wait time after hover before click (ms)' },
+        // iframe support
+        iframe: { type: 'number', description: 'Execute in specific iframe index (use media_extractor list_iframes to get index)' },
+        iframeSelector: { type: 'string', description: 'Alternative: iframe CSS selector instead of index' },
+        // Scroll into view
+        scrollIntoView: { type: 'boolean', default: true, description: 'Auto-scroll element into view before click' },
+        forceClick: { type: 'boolean', default: false, description: 'Force click even if element not visible (use JS click)' },
+        // NEW: Auto Video Player Detection & Control
+        autoDetectPlayer: { type: 'boolean', default: false, description: 'Auto-detect video player iframe (JWPlayer, VideoJS, Plyr, VidStack, DooPlayer)' },
+        usePlayerAPI: { type: 'boolean', default: true, description: 'Use player API (jwplayer.play()) instead of DOM click for reliable playback' },
+        waitForPlay: { type: 'boolean', default: false, description: 'Wait until video actually starts playing' },
+        playerTimeout: { type: 'number', default: 15000, description: 'Max wait time for video to start playing (ms)' }
       },
       required: ['selector']
     }
   },
 
-  // 6. Type
+  // 6. Type (ENHANCED: iframe support)
   {
     name: 'type',
     emoji: '⌨️',
-    description: 'Type text with human speed variation and smart clearing',
-    descriptionHindi: 'टेक्स्ट टाइप करना (human speed)',
+    description: 'Type text with human speed variation, smart clearing, and iframe support',
+    descriptionHindi: 'टेक्स्ट टाइप करना (human speed + iframe support)',
     category: 'interaction',
     requiresBrowser: true,
     requiresPage: true,
@@ -151,7 +167,13 @@ const TOOLS = [
         text: { type: 'string' },
         delay: { type: 'number', default: 50, description: 'Keystroke delay with natural variation' },
         clear: { type: 'boolean', default: true },
-        aiHeal: { type: 'boolean', default: true }
+        aiHeal: { type: 'boolean', default: true },
+        // NEW: iframe support
+        iframe: { type: 'number', description: 'Execute in specific iframe index' },
+        iframeSelector: { type: 'string', description: 'Alternative: iframe CSS selector' },
+        // NEW: Additional options
+        pressEnter: { type: 'boolean', default: false, description: 'Press Enter after typing' },
+        waitForSelector: { type: 'boolean', default: true, description: 'Wait for selector before typing' }
       },
       required: ['selector', 'text']
     }
@@ -520,12 +542,12 @@ const TOOLS = [
     }
   },
 
-  // 22. Execute JS
+  // 22. Execute JS (ENHANCED: iframe context fix)
   {
     name: 'execute_js',
     emoji: '💻',
-    description: 'Execute custom JavaScript with async support and error handling',
-    descriptionHindi: 'कस्टम JS चलाना (async + error handling)',
+    description: 'Execute custom JavaScript with async support, error handling, and iframe context',
+    descriptionHindi: 'कस्टम JS चलाना (async + iframe context support)',
     category: 'interaction',
     requiresBrowser: true,
     requiresPage: true,
@@ -536,7 +558,10 @@ const TOOLS = [
         returnValue: { type: 'boolean', default: true },
         async: { type: 'boolean', default: false, description: 'Execute async code' },
         timeout: { type: 'number', default: 30000 },
-        iframe: { type: 'number', description: 'Execute in specific iframe index' }
+        // FIXED: iframe context now works properly
+        iframe: { type: 'number', description: 'Execute in specific iframe index (0=main, 1+=iframes)' },
+        iframeSelector: { type: 'string', description: 'Alternative: iframe CSS selector' },
+        waitForIframe: { type: 'boolean', default: true, description: 'Wait for iframe to be ready' }
       },
       required: ['code']
     }