@debugelectron/debug-electron-mcp 1.6.9 → 1.6.10

package/README.md

@@ -48,7 +48,7 @@ Transform your Electron development experience with **AI-powered automation**:
 {
   "mcp": {
     "servers": {
-      "electron": {
+      "debug-electron-mcp": {
         "command": "npx",
         "args": ["-y", "@debugelectron/debug-electron-mcp@latest"]
       }
@@ -61,7 +61,7 @@ Transform your Electron development experience with **AI-powered automation**:
 ```json
 {
   "mcpServers": {
-    "electron": {
+    "debug-electron-mcp": {
       "command": "npx",
       "args": ["-y", "@debugelectron/debug-electron-mcp@latest"]
     }
@@ -73,7 +73,7 @@ Transform your Electron development experience with **AI-powered automation**:
 ```json
 {
   "mcpServers": {
-    "electron": {
+    "debug-electron-mcp": {
       "command": "npx",
       "args": ["-y", "@debugelectron/debug-electron-mcp@latest"]
     }
@@ -316,7 +316,14 @@ When configuring an Electron app for MCP Server:
 | --------------------------------------- | ----------------------------------------------------------------------------------- | ------------------------------------------------ |
 | `click_by_selector`                     | `{"selector": "css-selector"}`                                                      | `{"selector": "button.primary"}`                 |
 | `click_by_text`                         | `{"text": "button text"}`                                                           | `{"text": "Submit"}`                             |
+| `hover`                                 | `{"selector": "css-selector"}`                                                      | `{"selector": "#menu-item"}`                     |
+| `drag`                                  | `{"startSelector": "source", "endSelector": "target"}`                              | `{"startSelector": "#item", "endSelector": "#zone"}` |
+| `wait`                                  | `{"duration": 1000}` or `{"selector": "..."}` or `{"text": "..."}`                  | `{"selector": "#loaded-content"}`                |
+| `type`                                  | `{"selector": "...", "text": "..."}`                                                | `{"selector": "#search", "text": "hello"}`       |
 | `fill_input`                            | `{"value": "text", "selector": "..."}` or `{"value": "text", "placeholder": "..."}` | `{"placeholder": "Enter name", "value": "John"}` |
+| `get_attribute`                         | `{"selector": "...", "attribute": "..."}`                                           | `{"selector": "img", "attribute": "src"}`        |
+| `is_visible`                            | `{"selector": "..."}`                                                               | `{"selector": "#error-message"}`                 |
+| `count`                                 | `{"selector": "..."}`                                                               | `{"selector": ".list-item"}`                     |
 | `send_keyboard_shortcut`                | `{"text": "key combination"}`                                                       | `{"text": "Ctrl+N"}`                             |
 | `eval`                                  | `{"code": "javascript"}`                                                            | `{"code": "document.title"}`                     |
 | `get_title`, `get_url`, `get_body_text` | No args needed                                                                      | `{}` or omit args                                |
@@ -441,6 +448,13 @@ Execute JavaScript commands in the running Electron application via WebSocket.
 - `click_by_text`: Click elements by their visible text, aria-label, or title (more reliable than selectors)
 - `fill_input`: Fill input fields by selector, placeholder text, or associated label text
 - `select_option`: Select dropdown options by value or visible text
+- `hover`: Hover over elements (simulates mouseenter/mouseover)
+- `drag`: Drag elements from one location to another (supports dataTransfer)
+- `wait`: Wait for duration, element selector, or text presence
+- `type`: Type text character-by-character into inputs
+- `get_attribute`: Get value of any element attribute
+- `is_visible`: Check if element exists and is visible in viewport
+- `count`: Count elements matching a selector (total and visible)
 - `get_page_structure`: Get organized overview of all page elements (buttons, inputs, selects, links)
 - `get_title`: Get document title
 - `get_url`: Get current URL

package/dist/index.js

@@ -4289,7 +4289,14 @@ const TakeScreenshotSchema = external_zod_namespaceObject.z.object({
         .string()
         .optional()
         .describe('Path to save the screenshot (optional, defaults to temp directory)'),
-    windowTitle: external_zod_namespaceObject.z.string().optional().describe('Specific window title to screenshot (optional)'),
+    targetId: external_zod_namespaceObject.z
+        .string()
+        .optional()
+        .describe('CDP target ID to screenshot a specific window (exact match, takes priority over windowTitle)'),
+    windowTitle: external_zod_namespaceObject.z
+        .string()
+        .optional()
+        .describe('Window title to screenshot (case-insensitive partial match). Use list_electron_windows to see available windows.'),
 });
 const ReadElectronLogsSchema = external_zod_namespaceObject.z.object({
     logType: external_zod_namespaceObject.z
@@ -4321,17 +4328,26 @@ var ToolName;
     ToolName["GET_ELECTRON_WINDOW_INFO"] = "get_electron_window_info";
     ToolName["LIST_ELECTRON_WINDOWS"] = "list_electron_windows";
 })(ToolName || (ToolName = {}));
+// Helper function to convert Zod schemas to JSON Schema with proper typing
+// Using 'as any' to work around deep type instantiation issues with zod-to-json-schema
+const toJsonSchema = (schema) => (0,external_zod_to_json_schema_namespaceObject.zodToJsonSchema)(schema);
 // Define tools available to the MCP server
 const tools = [
     {
         name: ToolName.GET_ELECTRON_WINDOW_INFO,
         description: 'Get information about running Electron applications and their windows. Automatically detects any Electron app with remote debugging enabled (port 9222).',
-        inputSchema: (0,external_zod_to_json_schema_namespaceObject.zodToJsonSchema)(GetElectronWindowInfoSchema),
+        inputSchema: toJsonSchema(GetElectronWindowInfoSchema),
     },
     {
         name: ToolName.TAKE_SCREENSHOT,
-        description: 'Take a screenshot of any running Electron application window. Returns base64 image data for AI analysis. No files created unless outputPath is specified.',
-        inputSchema: (0,external_zod_to_json_schema_namespaceObject.zodToJsonSchema)(TakeScreenshotSchema),
+        description: `Take a screenshot of any running Electron application window. Returns base64 image data for AI analysis. No files created unless outputPath is specified.
+
+Multi-window support:
+- targetId: Specify a CDP target ID to screenshot a specific window (exact match, takes priority)
+- windowTitle: Specify a window title to target (case-insensitive partial match)
+- If neither is specified, screenshots the first available main window (backward compatible)
+- Use 'list_electron_windows' to see available windows and their IDs`,
+        inputSchema: toJsonSchema(TakeScreenshotSchema),
     },
     {
         name: ToolName.SEND_COMMAND_TO_ELECTRON,
@@ -4351,6 +4367,15 @@ Enhanced UI interaction commands:
 - 'get_title', 'get_url', 'get_body_text': Basic page information
 - 'eval': Execute custom JavaScript code with enhanced error reporting
 
+Additional interaction commands:
+- 'hover': Hover over an element by selector (triggers mouseenter/mouseover events)
+- 'drag': Drag from one element to another {"startSelector": "...", "endSelector": "..."}
+- 'wait': Wait for element, text, or duration {"selector": "..."} or {"text": "..."} or {"duration": 1000}
+- 'type': Type text character by character {"text": "...", "selector": "..."} (triggers key events)
+- 'get_attribute': Get element attribute value {"selector": "...", "attribute": "href"}
+- 'is_visible': Check if element is visible {"selector": "..."} returns visibility info
+- 'count': Count elements matching selector {"selector": "..."} returns total and visible count
+
 IMPORTANT: Arguments must be passed as an object with the correct properties:
 
 Examples:
@@ -4359,6 +4384,13 @@ Examples:
 - fill_input: {"placeholder": "Enter name", "value": "John Doe"}
 - fill_input: {"selector": "#email", "value": "user@example.com"}
 - send_keyboard_shortcut: {"text": "Enter"}
+- hover: {"selector": ".dropdown-trigger"}
+- drag: {"startSelector": ".draggable", "endSelector": ".drop-zone"}
+- wait: {"selector": ".loading-spinner", "timeout": 5000}
+- type: {"text": "Hello World", "selector": "#input-field"}
+- get_attribute: {"selector": "a.link", "attribute": "href"}
+- is_visible: {"selector": ".modal"}
+- count: {"selector": "li.item"}
 - eval: {"code": "document.title"}
 
 Use 'get_page_structure' or 'debug_elements' first to understand available elements, then use specific interaction commands.
@@ -4368,17 +4400,17 @@ Multi-window support:
 - windowTitle: Specify a window title to target (case-insensitive partial match)
 - If neither is specified, commands are sent to the first available main window (backward compatible)
 - Use 'list_electron_windows' to see available windows and their IDs`,
-        inputSchema: (0,external_zod_to_json_schema_namespaceObject.zodToJsonSchema)(SendCommandToElectronSchema),
+        inputSchema: toJsonSchema(SendCommandToElectronSchema),
     },
     {
         name: ToolName.LIST_ELECTRON_WINDOWS,
         description: "List all available Electron window targets across all detected applications. Returns window IDs, titles, URLs, and ports. Use the returned IDs with send_command_to_electron's targetId parameter to target specific windows.",
-        inputSchema: (0,external_zod_to_json_schema_namespaceObject.zodToJsonSchema)(ListElectronWindowsSchema),
+        inputSchema: toJsonSchema(ListElectronWindowsSchema),
     },
     {
         name: ToolName.READ_ELECTRON_LOGS,
         description: 'Read console logs and output from running Electron applications. Useful for debugging and monitoring app behavior.',
-        inputSchema: (0,external_zod_to_json_schema_namespaceObject.zodToJsonSchema)(ReadElectronLogsSchema),
+        inputSchema: toJsonSchema(ReadElectronLogsSchema),
     },
 ];
 
@@ -6277,10 +6309,379 @@ async function sendCommandToElectron(command, args, windowOptions) {
             
             return JSON.stringify({ forms, formCount: forms.length }, null, 2);
           })()
+        `;
+                break;
+            case 'hover':
+                // Hover over an element
+                const hoverSelector = args?.selector || '';
+                if (!hoverSelector) {
+                    return 'ERROR: Missing selector. Use: {"selector": "your-css-selector"}';
+                }
+                if (hoverSelector.includes('javascript:') || hoverSelector.includes('<script')) {
+                    return 'Invalid selector: contains dangerous content';
+                }
+                const escapedHoverSelector = JSON.stringify(hoverSelector);
+                javascriptCode = `
+          (function() {
+            try {
+              const element = document.querySelector(${escapedHoverSelector});
+              if (!element) {
+                return 'Element not found: ' + ${escapedHoverSelector};
+              }
+              
+              const rect = element.getBoundingClientRect();
+              if (rect.width === 0 || rect.height === 0) {
+                return 'Element not visible';
+              }
+              
+              const mouseenterEvent = new MouseEvent('mouseenter', {
+                bubbles: false,
+                cancelable: true,
+                view: window,
+                clientX: rect.left + rect.width / 2,
+                clientY: rect.top + rect.height / 2
+              });
+              
+              const mouseoverEvent = new MouseEvent('mouseover', {
+                bubbles: true,
+                cancelable: true,
+                view: window,
+                clientX: rect.left + rect.width / 2,
+                clientY: rect.top + rect.height / 2
+              });
+              
+              element.dispatchEvent(mouseenterEvent);
+              element.dispatchEvent(mouseoverEvent);
+              
+              return 'Hovered over element: ' + element.tagName + 
+                     (element.textContent ? ' - "' + element.textContent.substring(0, 50).trim() + '"' : '');
+            } catch (e) {
+              return 'Error hovering: ' + e.message;
+            }
+          })();
+        `;
+                break;
+            case 'drag':
+                // Drag from one element to another
+                const startSel = args?.startSelector || args?.selector || '';
+                const endSel = args?.endSelector || '';
+                if (!startSel || !endSel) {
+                    return 'ERROR: Missing selectors. Use: {"startSelector": "source-element", "endSelector": "target-element"}';
+                }
+                if (startSel.includes('javascript:') || endSel.includes('javascript:')) {
+                    return 'Invalid selector: contains dangerous content';
+                }
+                const escapedStartSel = JSON.stringify(startSel);
+                const escapedEndSel = JSON.stringify(endSel);
+                javascriptCode = `
+          (function() {
+            try {
+              const startElement = document.querySelector(${escapedStartSel});
+              const endElement = document.querySelector(${escapedEndSel});
+              
+              if (!startElement) return 'Start element not found: ' + ${escapedStartSel};
+              if (!endElement) return 'End element not found: ' + ${escapedEndSel};
+              
+              const startRect = startElement.getBoundingClientRect();
+              const endRect = endElement.getBoundingClientRect();
+              
+              const startX = startRect.left + startRect.width / 2;
+              const startY = startRect.top + startRect.height / 2;
+              const endX = endRect.left + endRect.width / 2;
+              const endY = endRect.top + endRect.height / 2;
+              
+              const dataTransfer = new DataTransfer();
+              dataTransfer.setData('text/plain', startElement.id || '');
+              dataTransfer.effectAllowed = 'copyMove';
+              dataTransfer.dropEffect = 'move';
+              
+              const dragStartEvent = new DragEvent('dragstart', {
+                bubbles: true, cancelable: true, clientX: startX, clientY: startY, dataTransfer: dataTransfer
+              });
+              const dragEvent = new DragEvent('drag', {
+                bubbles: true, cancelable: true, clientX: endX, clientY: endY, dataTransfer: dataTransfer
+              });
+              const dragEnterEvent = new DragEvent('dragenter', {
+                bubbles: true, cancelable: true, clientX: endX, clientY: endY, dataTransfer: dataTransfer
+              });
+              const dragOverEvent = new DragEvent('dragover', {
+                bubbles: true, cancelable: true, clientX: endX, clientY: endY, dataTransfer: dataTransfer
+              });
+              const dropEvent = new DragEvent('drop', {
+                bubbles: true, cancelable: true, clientX: endX, clientY: endY, dataTransfer: dataTransfer
+              });
+              const dragEndEvent = new DragEvent('dragend', {
+                bubbles: true, cancelable: true, clientX: endX, clientY: endY, dataTransfer: dataTransfer
+              });
+              
+              startElement.dispatchEvent(dragStartEvent);
+              startElement.dispatchEvent(dragEvent);
+              endElement.dispatchEvent(dragEnterEvent);
+              endElement.dispatchEvent(dragOverEvent);
+              endElement.dispatchEvent(dropEvent);
+              startElement.dispatchEvent(dragEndEvent);
+              
+              return 'Dragged from ' + startElement.tagName + ' to ' + endElement.tagName;
+            } catch (e) {
+              return 'Error performing drag: ' + e.message;
+            }
+          })();
+        `;
+                break;
+            case 'wait':
+                // Wait for element, text, or specified time
+                const waitSelector = args?.selector || '';
+                const waitText = args?.text || '';
+                const waitDuration = args?.duration || 0;
+                const waitTimeout = args?.timeout || 5000;
+                if (!waitSelector && !waitText && !waitDuration) {
+                    return 'ERROR: Specify selector, text, or duration. Use: {"selector": "..."} or {"text": "..."} or {"duration": 1000}';
+                }
+                if (waitDuration > 0) {
+                    javascriptCode = `
+            (function() {
+              return new Promise(resolve => {
+                setTimeout(() => resolve('Waited ${waitDuration}ms'), ${waitDuration});
+              });
+            })();
+          `;
+                }
+                else if (waitSelector) {
+                    const escapedWaitSelector = JSON.stringify(waitSelector);
+                    javascriptCode = `
+            (function() {
+              return new Promise((resolve) => {
+                const startTime = Date.now();
+                const timeout = ${waitTimeout};
+                
+                function check() {
+                  const element = document.querySelector(${escapedWaitSelector});
+                  if (element && element.getBoundingClientRect().width > 0) {
+                    resolve('Element found: ' + ${escapedWaitSelector} + ' (after ' + (Date.now() - startTime) + 'ms)');
+                    return;
+                  }
+                  if (Date.now() - startTime > timeout) {
+                    resolve('Timeout waiting for element: ' + ${escapedWaitSelector});
+                    return;
+                  }
+                  setTimeout(check, 100);
+                }
+                check();
+              });
+            })();
+          `;
+                }
+                else if (waitText) {
+                    const escapedWaitText = JSON.stringify(waitText);
+                    javascriptCode = `
+            (function() {
+              return new Promise((resolve) => {
+                const startTime = Date.now();
+                const timeout = ${waitTimeout};
+                
+                function check() {
+                  if (document.body.innerText.includes(${escapedWaitText})) {
+                    resolve('Text found: ' + ${escapedWaitText} + ' (after ' + (Date.now() - startTime) + 'ms)');
+                    return;
+                  }
+                  if (Date.now() - startTime > timeout) {
+                    resolve('Timeout waiting for text: ' + ${escapedWaitText});
+                    return;
+                  }
+                  setTimeout(check, 100);
+                }
+                check();
+              });
+            })();
+          `;
+                }
+                else {
+                    javascriptCode = `'Invalid wait parameters'`;
+                }
+                break;
+            case 'type':
+                // Type text character by character (different from fill which sets value directly)
+                const typeText = args?.text || '';
+                const typeSelector = args?.selector || '';
+                const typeSlowly = args?.slowly !== false; // Default to true for realistic typing
+                if (!typeText) {
+                    return 'ERROR: Missing text. Use: {"text": "text to type"} or {"text": "...", "selector": "input-selector"}';
+                }
+                const escapedTypeText = JSON.stringify(typeText);
+                const escapedTypeSelector = typeSelector ? JSON.stringify(typeSelector) : 'null';
+                javascriptCode = `
+          (function() {
+            try {
+              let element;
+              if (${escapedTypeSelector}) {
+                element = document.querySelector(${escapedTypeSelector});
+                if (!element) return 'Element not found: ' + ${escapedTypeSelector};
+              } else {
+                element = document.activeElement;
+                if (!element || element === document.body) {
+                  return 'No element focused. Use {"selector": "..."} to specify an input';
+                }
+              }
+              
+              element.focus();
+              
+              const text = ${escapedTypeText};
+              const slowly = ${typeSlowly};
+              
+              if (slowly) {
+                return new Promise((resolve) => {
+                  let index = 0;
+                  
+                  function typeNext() {
+                    if (index >= text.length) {
+                      resolve('Typed: "' + text + '" into ' + element.tagName);
+                      return;
+                    }
+                    
+                    const char = text[index];
+                    
+                    element.dispatchEvent(new KeyboardEvent('keydown', {
+                      key: char,
+                      code: 'Key' + char.toUpperCase(),
+                      bubbles: true
+                    }));
+                    
+                    if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {
+                      element.value += char;
+                      element.dispatchEvent(new Event('input', { bubbles: true }));
+                    }
+                    
+                    element.dispatchEvent(new KeyboardEvent('keyup', {
+                      key: char,
+                      code: 'Key' + char.toUpperCase(),
+                      bubbles: true
+                    }));
+                    
+                    index++;
+                    setTimeout(typeNext, 50);
+                  }
+                  
+                  typeNext();
+                });
+              } else {
+                if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {
+                  element.value += text;
+                  element.dispatchEvent(new Event('input', { bubbles: true }));
+                  element.dispatchEvent(new Event('change', { bubbles: true }));
+                }
+                return 'Typed: "' + text + '" into ' + element.tagName;
+              }
+            } catch (e) {
+              return 'Error typing: ' + e.message;
+            }
+          })();
+        `;
+                break;
+            case 'get_attribute':
+                // Get an attribute value from an element
+                const attrSelector = args?.selector || '';
+                const attrName = args?.attribute || '';
+                if (!attrSelector || !attrName) {
+                    return 'ERROR: Missing selector or attribute. Use: {"selector": "...", "attribute": "href"}';
+                }
+                const escapedAttrSelector = JSON.stringify(attrSelector);
+                const escapedAttrName = JSON.stringify(attrName);
+                javascriptCode = `
+          (function() {
+            try {
+              const element = document.querySelector(${escapedAttrSelector});
+              if (!element) {
+                return 'Element not found: ' + ${escapedAttrSelector};
+              }
+              
+              const value = element.getAttribute(${escapedAttrName});
+              if (value === null) {
+                return 'Attribute not found: ' + ${escapedAttrName} + ' on ' + element.tagName;
+              }
+              
+              return JSON.stringify({
+                selector: ${escapedAttrSelector},
+                attribute: ${escapedAttrName},
+                value: value
+              });
+            } catch (e) {
+              return 'Error getting attribute: ' + e.message;
+            }
+          })();
+        `;
+                break;
+            case 'is_visible':
+                // Check if an element is visible
+                const visSelector = args?.selector || '';
+                if (!visSelector) {
+                    return 'ERROR: Missing selector. Use: {"selector": "your-css-selector"}';
+                }
+                const escapedVisSelector = JSON.stringify(visSelector);
+                javascriptCode = `
+          (function() {
+            try {
+              const element = document.querySelector(${escapedVisSelector});
+              if (!element) {
+                return JSON.stringify({ selector: ${escapedVisSelector}, exists: false, visible: false });
+              }
+              
+              const rect = element.getBoundingClientRect();
+              const style = window.getComputedStyle(element);
+              
+              const isVisible = rect.width > 0 &&
+                rect.height > 0 &&
+                style.visibility !== 'hidden' &&
+                style.display !== 'none' &&
+                style.opacity !== '0';
+              
+              const inViewport = rect.top < window.innerHeight &&
+                rect.bottom > 0 &&
+                rect.left < window.innerWidth &&
+                rect.right > 0;
+              
+              return JSON.stringify({
+                selector: ${escapedVisSelector},
+                exists: true,
+                visible: isVisible,
+                inViewport: inViewport,
+                dimensions: { width: rect.width, height: rect.height },
+                position: { top: rect.top, left: rect.left }
+              });
+            } catch (e) {
+              return 'Error checking visibility: ' + e.message;
+            }
+          })();
+        `;
+                break;
+            case 'count':
+                // Count elements matching a selector
+                const countSelector = args?.selector || '';
+                if (!countSelector) {
+                    return 'ERROR: Missing selector. Use: {"selector": "your-css-selector"}';
+                }
+                const escapedCountSelector = JSON.stringify(countSelector);
+                javascriptCode = `
+          (function() {
+            try {
+              const elements = document.querySelectorAll(${escapedCountSelector});
+              const visibleCount = Array.from(elements).filter(el => {
+                const rect = el.getBoundingClientRect();
+                return rect.width > 0 && rect.height > 0;
+              }).length;
+              
+              return JSON.stringify({
+                selector: ${escapedCountSelector},
+                total: elements.length,
+                visible: visibleCount
+              });
+            } catch (e) {
+              return 'Error counting elements: ' + e.message;
+            }
+          })();
         `;
                 break;
             case 'console_log':
-                javascriptCode = `console.log('MCP Command:', '${args?.message || 'Hello from MCP!'}'); 'Console message sent'`;
+                javascriptCode = `console.log('MCP Command:', ${JSON.stringify(args?.message ?? 'Hello from MCP!')}); 'Console message sent'`;
                 break;
             case 'eval':
                 const rawCode = typeof args === 'string' ? args : args?.code || command;
@@ -6567,9 +6968,11 @@ const promises_namespaceObject = require("fs/promises");
 /**
  * Take a screenshot of the running Electron application using Chrome DevTools Protocol
  */
-async function takeScreenshot(outputPath, windowTitle) {
+async function takeScreenshot(options = {}) {
+    const { outputPath, targetId, windowTitle } = options;
     logger.info('📸 Taking screenshot of Electron application', {
         outputPath,
+        targetId,
         windowTitle,
         timestamp: new Date().toISOString(),
     });
@@ -6579,12 +6982,39 @@ async function takeScreenshot(outputPath, windowTitle) {
         if (apps.length === 0) {
             throw new Error('No running Electron applications found with remote debugging enabled');
         }
-        // Use the first app found (or find by title if specified)
+        // Find target app and target based on options
+        // Priority: targetId > windowTitle > first available window
         let targetApp = apps[0];
-        if (windowTitle) {
-            const namedApp = apps.find((app) => app.targets.some((target) => target.title?.toLowerCase().includes(windowTitle.toLowerCase())));
-            if (namedApp) {
-                targetApp = namedApp;
+        let targetInfo = null;
+        if (targetId) {
+            // Search for exact targetId match across all apps
+            for (const app of apps) {
+                const match = app.targets.find((t) => t.id === targetId);
+                if (match) {
+                    targetApp = app;
+                    targetInfo = { port: app.port, targetId: match.id };
+                    logger.debug(`Found target by ID "${targetId}" on port ${app.port}`);
+                    break;
+                }
+            }
+            if (!targetInfo) {
+                throw new Error(`No window found with targetId "${targetId}". Use list_electron_windows to see available targets.`);
+            }
+        }
+        else if (windowTitle) {
+            // Search for case-insensitive partial title match
+            const searchTitle = windowTitle.toLowerCase();
+            for (const app of apps) {
+                const match = app.targets.find((t) => t.title && t.title.toLowerCase().includes(searchTitle));
+                if (match) {
+                    targetApp = app;
+                    targetInfo = { port: app.port, targetId: match.id };
+                    logger.debug(`Found target by title "${windowTitle}" on port ${app.port}`);
+                    break;
+                }
+            }
+            if (!targetInfo) {
+                throw new Error(`No window found with title matching "${windowTitle}". Use list_electron_windows to see available targets.`);
             }
         }
         // Connect to the Electron app's debugging port
@@ -6598,22 +7028,33 @@ async function takeScreenshot(outputPath, windowTitle) {
         if (pages.length === 0) {
             throw new Error('No pages found in the browser context');
         }
-        // Find the main application page (skip DevTools pages)
+        // Find the target page
         let targetPage = pages[0];
-        for (const page of pages) {
-            const url = page.url();
-            const title = await page.title().catch(() => '');
-            // Skip DevTools and about:blank pages
-            if (!url.includes('devtools://') &&
-                !url.includes('about:blank') &&
-                title &&
-                !title.includes('DevTools')) {
-                // If windowTitle is specified, try to match it
-                if (windowTitle && title.toLowerCase().includes(windowTitle.toLowerCase())) {
-                    targetPage = page;
-                    break;
+        if (targetInfo?.targetId) {
+            // If we found a specific target, try to find the matching page
+            // Note: We need to find the page by URL/title since CDP targetId doesn't directly map to Playwright pages
+            const targetData = targetApp.targets.find((t) => t.id === targetInfo.targetId);
+            if (targetData) {
+                for (const page of pages) {
+                    const pageUrl = page.url();
+                    // Match by URL since that's more reliable than title
+                    if (pageUrl === targetData.url) {
+                        targetPage = page;
+                        break;
+                    }
                 }
-                else if (!windowTitle) {
+            }
+        }
+        else {
+            // Find the main application page (skip DevTools pages)
+            for (const page of pages) {
+                const url = page.url();
+                const title = await page.title().catch(() => '');
+                // Skip DevTools and about:blank pages
+                if (!url.includes('devtools://') &&
+                    !url.includes('about:blank') &&
+                    title &&
+                    !title.includes('DevTools')) {
                     targetPage = page;
                     break;
                 }
@@ -6677,8 +7118,8 @@ async function handleToolCall(request) {
                 };
             }
             case ToolName.TAKE_SCREENSHOT: {
-                const { outputPath, windowTitle } = TakeScreenshotSchema.parse(args);
-                const result = await takeScreenshot(outputPath, windowTitle);
+                const { outputPath, targetId, windowTitle } = TakeScreenshotSchema.parse(args);
+                const result = await takeScreenshot({ outputPath, targetId, windowTitle });
                 const content = [];
                 if (result.filePath) {
                     content.push({