@laststance/electron-mcp-server 1.5.2 → 1.6.1

package/dist/index.js

@@ -2122,6 +2122,14 @@ const CommandArgsSchema = external_zod_namespaceObject.z
 const SendCommandToElectronSchema = external_zod_namespaceObject.z.object({
     command: external_zod_namespaceObject.z.string().describe('Command to send to the Electron process'),
     args: CommandArgsSchema.optional().describe('Arguments for the command - must be an object with appropriate properties based on the command type'),
+    targetId: external_zod_namespaceObject.z
+        .string()
+        .optional()
+        .describe('CDP target ID to send the command to a specific window (exact match)'),
+    windowTitle: external_zod_namespaceObject.z
+        .string()
+        .optional()
+        .describe('Window title to target (case-insensitive partial match). Use list_electron_windows to see available windows.'),
 });
 const TakeScreenshotSchema = external_zod_namespaceObject.z.object({
     outputPath: external_zod_namespaceObject.z
@@ -2141,6 +2149,12 @@ const ReadElectronLogsSchema = external_zod_namespaceObject.z.object({
 const GetElectronWindowInfoSchema = external_zod_namespaceObject.z.object({
     includeChildren: external_zod_namespaceObject.z.boolean().optional().describe('Include child windows information'),
 });
+const ListElectronWindowsSchema = external_zod_namespaceObject.z.object({
+    includeDevTools: external_zod_namespaceObject.z
+        .boolean()
+        .optional()
+        .describe('Include DevTools windows in the list (default: false)'),
+});
 
 ;// ./src/tools.ts
 
@@ -2152,6 +2166,7 @@ var ToolName;
     ToolName["TAKE_SCREENSHOT"] = "take_screenshot";
     ToolName["READ_ELECTRON_LOGS"] = "read_electron_logs";
     ToolName["GET_ELECTRON_WINDOW_INFO"] = "get_electron_window_info";
+    ToolName["LIST_ELECTRON_WINDOWS"] = "list_electron_windows";
 })(ToolName || (ToolName = {}));
 // Define tools available to the MCP server
 const tools = [
@@ -2193,9 +2208,20 @@ Examples:
 - send_keyboard_shortcut: {"text": "Enter"}
 - eval: {"code": "document.title"}
 
-Use 'get_page_structure' or 'debug_elements' first to understand available elements, then use specific interaction commands.`,
+Use 'get_page_structure' or 'debug_elements' first to understand available elements, then use specific interaction commands.
+
+Multi-window support:
+- targetId: Specify a CDP target ID to send commands to a specific window (exact match)
+- 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),
     },
+    {
+        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),
+    },
     {
         name: ToolName.READ_ELECTRON_LOGS,
         description: 'Read console logs and output from running Electron applications. Useful for debugging and monitoring app behavior.',
@@ -2371,6 +2397,31 @@ function findMainTarget(targets) {
     return (targets.find((target) => target.type === 'page' && !target.title.includes('DevTools')) ||
         targets.find((target) => target.type === 'page'));
 }
+/**
+ * List all available Electron window targets across all detected apps.
+ * @param includeDevTools - Whether to include DevTools windows (default: false)
+ * @returns Array of window targets with id, title, url, port, and type
+ */
+async function listElectronWindows(includeDevTools = false) {
+    const foundApps = await scanForElectronApps();
+    const windows = [];
+    for (const app of foundApps) {
+        for (const target of app.targets) {
+            // Filter out DevTools windows unless explicitly requested
+            if (!includeDevTools && target.url && target.url.startsWith('devtools://')) {
+                continue;
+            }
+            windows.push({
+                id: target.id,
+                title: target.title || '',
+                url: target.url || '',
+                port: app.port,
+                type: target.type || 'page',
+            });
+        }
+    }
+    return windows;
+}
 /**
  * Get window information from any running Electron app
  */
@@ -2430,14 +2481,56 @@ async function getElectronWindowInfo(includeChildren = false) {
 
 
 /**
- * Find and connect to a running Electron application
+ * Find and connect to a running Electron application.
+ * @param options - Optional targeting options to select a specific window
+ * @returns The DevTools target matching the given options
+ * @example
+ * findElectronTarget() // first available main window
+ * findElectronTarget({ targetId: 'ABC123' }) // exact ID match
+ * findElectronTarget({ windowTitle: 'Settings' }) // partial title match
  */
-async function findElectronTarget() {
+async function findElectronTarget(options) {
     logger.debug('Looking for running Electron applications...');
     const foundApps = await scanForElectronApps();
     if (foundApps.length === 0) {
         throw new Error('No running Electron application found with remote debugging enabled. Start your app with: electron . --remote-debugging-port=9222');
     }
+    // If targetId is specified, search all apps for exact ID match
+    if (options?.targetId) {
+        for (const app of foundApps) {
+            const match = app.targets.find((t) => t.id === options.targetId);
+            if (match) {
+                logger.debug(`Found target by ID "${options.targetId}" on port ${app.port}`);
+                return {
+                    id: match.id,
+                    title: match.title,
+                    url: match.url,
+                    webSocketDebuggerUrl: match.webSocketDebuggerUrl,
+                    type: match.type,
+                };
+            }
+        }
+        throw new Error(`No window found with targetId "${options.targetId}". Use list_electron_windows to see available targets.`);
+    }
+    // If windowTitle is specified, search all apps for case-insensitive partial match
+    if (options?.windowTitle) {
+        const searchTitle = options.windowTitle.toLowerCase();
+        for (const app of foundApps) {
+            const match = app.targets.find((t) => t.title && t.title.toLowerCase().includes(searchTitle));
+            if (match) {
+                logger.debug(`Found target by title "${options.windowTitle}" on port ${app.port}`);
+                return {
+                    id: match.id,
+                    title: match.title,
+                    url: match.url,
+                    webSocketDebuggerUrl: match.webSocketDebuggerUrl,
+                    type: match.type,
+                };
+            }
+        }
+        throw new Error(`No window found with title matching "${options.windowTitle}". Use list_electron_windows to see available targets.`);
+    }
+    // Default: use first app's main target (backward compatible)
     const app = foundApps[0];
     const mainTarget = findMainTarget(app.targets);
     if (!mainTarget) {
@@ -3610,11 +3703,14 @@ function generatePageStructureCommand() {
 
 
 /**
- * Enhanced command executor with improved React support
+ * Enhanced command executor with improved React support.
+ * @param command - The command to execute
+ * @param args - Command-specific arguments
+ * @param windowOptions - Optional window targeting (targetId or windowTitle)
  */
-async function sendCommandToElectron(command, args) {
+async function sendCommandToElectron(command, args, windowOptions) {
     try {
-        const target = await findElectronTarget();
+        const target = await findElectronTarget(windowOptions);
         let javascriptCode;
         switch (command.toLowerCase()) {
             case 'get_title':
@@ -5661,7 +5757,7 @@ async function handleToolCall(request) {
                 return { content, isError: false };
             }
             case ToolName.SEND_COMMAND_TO_ELECTRON: {
-                const { command, args: commandArgs } = SendCommandToElectronSchema.parse(args);
+                const { command, args: commandArgs, targetId, windowTitle, } = SendCommandToElectronSchema.parse(args);
                 // Execute command through security manager
                 const securityResult = await securityManager.executeSecurely({
                     command,
@@ -5692,8 +5788,10 @@ async function handleToolCall(request) {
                         isError: true,
                     };
                 }
+                // Build window target options if specified
+                const windowOptions = targetId || windowTitle ? { targetId, windowTitle } : undefined;
                 // Execute the actual command if security checks pass
-                const result = await sendCommandToElectron(command, commandArgs);
+                const result = await sendCommandToElectron(command, commandArgs, windowOptions);
                 return {
                     content: [{ type: 'text', text: result }],
                     isError: false,
@@ -5723,6 +5821,51 @@ async function handleToolCall(request) {
                     isError: false,
                 };
             }
+            case ToolName.LIST_ELECTRON_WINDOWS: {
+                const { includeDevTools } = ListElectronWindowsSchema.parse(args);
+                const securityResult = await securityManager.executeSecurely({
+                    command: 'list_windows',
+                    args,
+                    sourceIP,
+                    userAgent,
+                    operationType: 'window_info',
+                });
+                if (securityResult.blocked) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Operation blocked: ${securityResult.error}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const windows = await listElectronWindows(includeDevTools);
+                if (windows.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'No Electron windows found. Ensure your app is running with --remote-debugging-port=9222',
+                            },
+                        ],
+                        isError: false,
+                    };
+                }
+                const formatted = windows
+                    .map((w) => `- [${w.id}] "${w.title}" (port: ${w.port}, type: ${w.type})\n  URL: ${w.url}`)
+                    .join('\n');
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Available Electron windows (${windows.length}):\n\n${formatted}`,
+                        },
+                    ],
+                    isError: false,
+                };
+            }
             default:
                 return {
                     content: [
@@ -5765,7 +5908,7 @@ async function handleToolCall(request) {
 
 
 
-(0,external_dotenv_namespaceObject.config)();
+(0,external_dotenv_namespaceObject.config)({ quiet: true });
 // Create MCP server instance
 const server = new Server({
     name: 'electron-mcp-server',