n8n-nodes-smart-browser-automation 1.1.12 → 1.2.0

package/dist/nodes/SmartBrowserAutomation/BrowserSessionManager.js

@@ -75,12 +75,14 @@ class BrowserSessionManager {
             throw new Error('MCP client not initialized. Please configure credentials first.');
         }
         try {
-            // Log exact payload to debug truncation issues reported by users
+            // Log tool call for debugging
             console.log(`[MCP] Calling tool "${toolName}" with args:`, JSON.stringify(toolArgs || {}));
             const result = await this.mcpClient.callTool({
                 name: toolName,
                 arguments: toolArgs || {}
             });
+            // Log the response for debugging
+            console.log(`[MCP] Tool "${toolName}" response:`, JSON.stringify(result, null, 2));
             return result;
         }
         catch (error) {

package/dist/nodes/SmartBrowserAutomation/SmartBrowserAutomation.node.js

@@ -27,81 +27,11 @@ class SmartBrowserAutomation {
         ],
         usableAsTool: true,
         properties: [
-            {
-                displayName: 'Mode',
-                name: 'mode',
-                type: 'options',
-                noDataExpression: true,
-                options: [
-                    {
-                        name: 'AI Agent (Auto)',
-                        value: 'aiAgent',
-                        description: 'Let AI decide which tools to use - use this with AI Agent node',
-                    },
-                    {
-                        name: 'Manual',
-                        value: 'manual',
-                        description: 'Manually select tool and provide arguments',
-                    },
-                ],
-                default: 'aiAgent',
-                description: 'How to execute browser automation',
-            },
-            {
-                displayName: 'Tool Name or ID',
-                name: 'toolName',
-                type: 'options',
-                typeOptions: {
-                    loadOptionsMethod: 'getAvailableTools',
-                },
-                displayOptions: {
-                    show: {
-                        mode: ['manual'],
-                    },
-                },
-                default: 'browser_connect_cdp',
-                description: 'Select the browser automation tool to execute. Choose "Connect to Browser (CDP)" to initialize/switch browser sessions. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
-                required: true,
-            },
-            {
-                displayName: 'CDP Endpoint',
-                name: 'cdpUrl',
-                type: 'string',
-                displayOptions: {
-                    show: {
-                        mode: ['manual'],
-                        toolName: ['browser_connect_cdp'],
-                    },
-                },
-                default: '',
-                placeholder: 'wss://gridnew.doingerp.com/devtools/...',
-                description: 'The wss:// or http:// endpoint for the browser CDP connection',
-            },
-            {
-                displayName: 'Tool Arguments',
-                name: 'toolArgs',
-                type: 'json',
-                displayOptions: {
-                    show: {
-                        mode: ['manual'],
-                    },
-                    hide: {
-                        toolName: ['browser_connect_cdp'],
-                    },
-                },
-                default: '{}',
-                description: 'Arguments for the selected tool in JSON format',
-            },
             {
                 displayName: 'Operation',
                 name: 'operation',
                 type: 'options',
                 noDataExpression: true,
-                displayOptions: {
-                    show: {
-                        mode: ['aiAgent'],
-                    },
-                },
                 options: [
                     {
                         name: 'Initialize Session',
@@ -124,11 +54,6 @@ class SmartBrowserAutomation {
                 type: 'collection',
                 placeholder: 'Add Option',
                 default: {},
-                displayOptions: {
-                    show: {
-                        mode: ['aiAgent'],
-                    },
-                },
                 options: [
                     {
                         displayName: 'CDP Endpoint',
@@ -198,17 +123,27 @@ class SmartBrowserAutomation {
         const routerTool = {
             name: 'browser_tool',
             displayName: 'Browser Action',
-            description: `Perform browser automation actions. 
-			USAGE EXAMPLES:
-			- Navigate: action='navigate', params={ "url": "https://..." }
-			- Click: action='click', params={ "selector": "button.submit" }
-			- Type: action='type', params={ "selector": "#input", "text": "hello" }
-			- Scroll: action='scroll_to', params={ "selector": "footer" }
-			- Get Text: action='get_text', params={ "selector": ".content" }
-			- Screenshot: action='take_screenshot', params={}
-			
-			Available actions: navigate, click, type, press_key, scroll_to, get_text, take_screenshot, evaluate, etc.
-			Supported Params depend on the action.`,
+            description: `Execute browser automation actions. ALWAYS use this tool for browser interactions.
+
+WHEN TO USE:
+✓ User wants to visit/open/go to a website → action='navigate'
+✓ User wants to click something → action='click'  
+✓ User wants to type/enter text → action='type'
+✓ User wants to read/get text from page → action='snapshot' or action='get_text'
+✓ User wants a screenshot → action='take_screenshot'
+
+REQUIRED PARAMETERS:
+• action: The action name (navigate, click, type, snapshot, take_screenshot, etc.)
+• params: JSON object with action-specific parameters
+
+EXAMPLES:
+1. Navigate: { "action": "navigate", "params": { "url": "https://example.com" } }
+2. Click: { "action": "click", "params": { "element": "button text", "ref": "..." } }
+3. Type: { "action": "type", "params": { "element": "input field", "ref": "...", "text": "hello" } }
+4. Snapshot: { "action": "snapshot", "params": {} }
+5. Screenshot: { "action": "take_screenshot", "params": {} }
+
+IMPORTANT: For navigate action, params must include "url" key.`,
             properties: [
                 {
                     displayName: 'Action Name',
@@ -234,17 +169,20 @@ class SmartBrowserAutomation {
                     if (input.action === 'connect_cdp' || input.action === 'browser_connect_cdp') {
                         const endpoint = input.params?.endpoint;
                         if (endpoint) {
+                            console.log(`[Router] Connecting to CDP: ${endpoint}`);
                             await sessionManager.initialize(credentials.mcpEndpoint, true, endpoint);
                             return {
                                 content: [{ type: 'text', text: `Connected to browser at ${endpoint}.` }],
-                                isError: false
+                                isError: false,
+                                toolName: 'browser_connect_cdp',
+                                requestedAction: input.action
                             };
                         }
                     }
-                    // Auto-initialize if possible (blindly)
-                    await sessionManager.initialize(credentials.mcpEndpoint, credentials.browserMode === 'cdp', credentials.cdpEndpoint);
-                }
-                // Normalize action name
+                    // Session not ready and no explicit connection requested
+                    // This shouldn't happen - session should be initialized first
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Browser session not initialized. Please connect to browser first using Initialize Session or connect_cdp action.');
+                } // Normalize action name
                 let toolName = input.action;
                 if (!toolName.startsWith('browser_') && toolName !== 'connect_cdp') {
                     toolName = `browser_${toolName}`;
@@ -262,12 +200,19 @@ class SmartBrowserAutomation {
                 console.log(`[Router] Routing '${input.action}' to '${toolName}' with args:`, toolArgs);
                 try {
                     const result = await sessionManager.callTool(toolName, toolArgs);
+                    // Add tool name to result for visibility
+                    if (result && typeof result === 'object') {
+                        result.toolName = toolName;
+                        result.requestedAction = input.action;
+                    }
                     return result;
                 }
                 catch (error) {
                     return {
                         content: [{ type: 'text', text: `Error executing ${toolName}: ${error.message}` }],
-                        isError: true
+                        isError: true,
+                        toolName: toolName,
+                        requestedAction: input.action
                     };
                 }
             }
@@ -293,7 +238,8 @@ class SmartBrowserAutomation {
                 await sessionManager.initialize(credentials.mcpEndpoint, true, input.endpoint);
                 return {
                     content: [{ type: 'text', text: `Connected to browser at ${input.endpoint}.` }],
-                    isError: false
+                    isError: false,
+                    toolName: 'browser_connect_cdp'
                 };
             }
         };
@@ -304,112 +250,58 @@ class SmartBrowserAutomation {
         const returnData = [];
         const credentials = await this.getCredentials('smartBrowserAutomationApi');
         const sessionManager = BrowserSessionManager_1.default.getInstance();
-        const mode = this.getNodeParameter('mode', 0);
         for (let i = 0; i < items.length; i++) {
             try {
                 const options = this.getNodeParameter('options', i, {});
                 const verbose = options.verbose || false;
-                if (mode === 'manual') {
-                    // Manual mode: User selects tool and provides arguments
-                    const toolName = this.getNodeParameter('toolName', i);
-                    // Special case: Manual Browser Connection
-                    if (toolName === 'browser_connect_cdp') {
-                        const endpoint = this.getNodeParameter('cdpUrl', i);
-                        if (!endpoint) {
-                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'CDP Endpoint URL is required for browser_connect_cdp');
-                        }
+                const operation = this.getNodeParameter('operation', i);
+                if (operation === 'initialize') {
+                    const cdpUrl = credentials.cdpEndpoint;
+                    await sessionManager.initialize(credentials.mcpEndpoint, true, cdpUrl);
+                    // New logic: Auto-call browser_connect_cdp tool if a URL is provided
+                    if (options.cdpUrl) {
                         if (verbose) {
-                            console.log(`Connecting to browser CDP: ${endpoint}`);
+                            console.log(`Auto-calling 'browser_connect_cdp' with endpoint: ${options.cdpUrl}`);
+                        }
+                        try {
+                            const connectionResult = await sessionManager.callTool('browser_connect_cdp', { endpoint: options.cdpUrl });
+                            // Return only the connection result, no extra messages
+                            returnData.push({
+                                json: connectionResult,
+                                pairedItem: i,
+                            });
+                        }
+                        catch (error) {
+                            returnData.push({
+                                json: {
+                                    success: false,
+                                    error: `Failed to connect: ${error.message}`
+                                },
+                                pairedItem: i,
+                            });
                         }
-                        await sessionManager.initialize(credentials.mcpEndpoint, true, endpoint);
+                    }
+                    else {
+                        // No CDP URL provided
                         returnData.push({
                             json: {
                                 success: true,
-                                message: `Connected to browser at ${endpoint}`,
-                                timestamp: new Date().toISOString()
+                                message: 'MCP session initialized (no browser connection)'
                             },
                             pairedItem: i,
                         });
-                        continue;
-                    }
-                    const toolArgsStr = this.getNodeParameter('toolArgs', i);
-                    let toolArgs;
-                    try {
-                        toolArgs = JSON.parse(toolArgsStr);
-                    }
-                    catch (error) {
-                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid JSON in Tool Arguments: ${error.message}`);
                     }
-                    // Initialize session if not ready
-                    if (!sessionManager.isReady()) {
-                        await sessionManager.initialize(credentials.mcpEndpoint, credentials.browserMode === 'cdp', credentials.cdpEndpoint);
-                    }
-                    if (verbose) {
-                        console.log(`Executing tool: ${toolName} with args:`, toolArgs);
-                    }
-                    const result = await sessionManager.callTool(toolName, toolArgs);
+                }
+                else if (operation === 'close') {
+                    await sessionManager.close();
                     returnData.push({
-                        json: result,
+                        json: {
+                            success: true,
+                            message: 'Browser session closed',
+                        },
                         pairedItem: i,
                     });
                 }
-                else {
-                    // AI Agent mode: Just initialize or close
-                    const operation = this.getNodeParameter('operation', i);
-                    if (operation === 'initialize') {
-                        const cdpUrl = credentials.cdpEndpoint;
-                        await sessionManager.initialize(credentials.mcpEndpoint, true, cdpUrl);
-                        let connectionStatus = 'Skipped (No CDP URL provided)';
-                        let connectionResult = null;
-                        // New logic: Auto-call browser_connect_cdp tool if a URL is provided
-                        if (options.cdpUrl) {
-                            if (verbose) {
-                                console.log(`Auto-calling 'browser_connect_cdp' with endpoint: ${options.cdpUrl}`);
-                            }
-                            try {
-                                connectionResult = await sessionManager.callTool('browser_connect_cdp', { endpoint: options.cdpUrl });
-                                connectionStatus = 'Successfully connected';
-                            }
-                            catch (error) {
-                                connectionStatus = `Failed to connect: ${error.message}`;
-                                console.warn(`Failed to auto-connect browser via tool: ${error.message}`);
-                            }
-                        }
-                        // Guide for the Router Tool
-                        const actionGuide = `
-						Actions available via 'browser_tool':
-						- navigate: { "url": "https://..." }
-						- click: { "selector": "..." }
-						- type: { "selector": "...", "text": "..." }
-						- press_key: { "key": "Enter" }
-						- scroll_to: { "selector": "..." }
-						- get_text: { "selector": "..." }
-						- take_screenshot: {}
-						- evaluate: { "script": "return document.title;" }
-						...and all other MCP tools.
-						`;
-                        returnData.push({
-                            json: {
-                                success: true,
-                                message: `MCP session initialized at ${credentials.mcpEndpoint}`,
-                                browserConnection: connectionStatus,
-                                browserResponse: connectionResult,
-                                toolGuide: actionGuide,
-                            },
-                            pairedItem: i,
-                        });
-                    }
-                    else if (operation === 'close') {
-                        await sessionManager.close();
-                        returnData.push({
-                            json: {
-                                success: true,
-                                message: 'Browser session closed',
-                            },
-                            pairedItem: i,
-                        });
-                    }
-                }
             }
             catch (error) {
                 if (this.continueOnFail()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-smart-browser-automation",
-  "version": "1.1.12",
+  "version": "1.2.0",
   "description": "n8n node for AI-driven browser automation using MCP",
   "keywords": [
     "n8n-community-node-package",