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

package/dist/nodes/SmartBrowserAutomation/BrowserSessionManager.js

@@ -75,14 +75,14 @@ class BrowserSessionManager {
             throw new Error('MCP client not initialized. Please configure credentials first.');
         }
         try {
-            // Only log in development/debug mode
-            if (process.env.NODE_ENV !== 'production' && process.env.DEBUG) {
-                console.log(`[MCP] Calling tool "${toolName}" with args:`, JSON.stringify(toolArgs || {}));
-            }
+            // 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,6 +169,7 @@ 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}.` }],
@@ -243,10 +179,10 @@ class SmartBrowserAutomation {
                             };
                         }
                     }
-                    // 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}`;
@@ -314,106 +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}`);
                         }
-                        await sessionManager.initialize(credentials.mcpEndpoint, true, endpoint);
-                        returnData.push({
-                            json: {
-                                success: true,
-                                message: `Connected to browser at ${endpoint}`,
-                                timestamp: new Date().toISOString()
-                            },
-                            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);
-                    returnData.push({
-                        json: result,
-                        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);
-                        // 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 {
-                                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,
-                                });
-                            }
+                        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,
+                            });
                         }
-                        else {
-                            // No CDP URL provided
+                        catch (error) {
                             returnData.push({
                                 json: {
-                                    success: true,
-                                    message: 'MCP session initialized (no browser connection)'
+                                    success: false,
+                                    error: `Failed to connect: ${error.message}`
                                 },
                                 pairedItem: i,
                             });
                         }
                     }
-                    else if (operation === 'close') {
-                        await sessionManager.close();
+                    else {
+                        // No CDP URL provided
                         returnData.push({
                             json: {
                                 success: true,
-                                message: 'Browser session closed',
+                                message: 'MCP session initialized (no browser connection)'
                             },
                             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.13",
+  "version": "1.2.0",
   "description": "n8n node for AI-driven browser automation using MCP",
   "keywords": [
     "n8n-community-node-package",