n8n-nodes-smart-browser-automation 1.0.8 → 1.1.3

package/dist/nodes/SmartBrowserAutomation/BrowserSessionManager.js

@@ -66,11 +66,20 @@ class BrowserSessionManager {
         if (!this.mcpClient || !this.isInitialized) {
             throw new Error('MCP client not initialized. Please configure credentials first.');
         }
-        const result = await this.mcpClient.callTool({
-            name: toolName,
-            arguments: toolArgs || {}
-        });
-        return result;
+        try {
+            if (this.config.mcpEndpoint?.includes('http')) {
+                console.log(`Calling remote tool: ${toolName} on ${this.config.mcpEndpoint}`);
+            }
+            const result = await this.mcpClient.callTool({
+                name: toolName,
+                arguments: toolArgs || {}
+            });
+            return result;
+        }
+        catch (error) {
+            console.error(`MCP Tool Call Error (${toolName}):`, error);
+            throw new Error(`MCP Tool Error: ${error.message}${error.data ? ' - ' + JSON.stringify(error.data) : ''}`);
+        }
     }
     getTools() {
         return this.tools;

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

@@ -60,10 +60,24 @@ class SmartBrowserAutomation {
                         mode: ['manual'],
                     },
                 },
-                default: '',
-                description: 'Select the browser automation tool to execute. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                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',
@@ -72,6 +86,9 @@ class SmartBrowserAutomation {
                     show: {
                         mode: ['manual'],
                     },
+                    hide: {
+                        toolName: ['browser_connect_cdp'],
+                    },
                 },
                 default: '{}',
                 description: 'Arguments for the selected tool in JSON format',
@@ -108,7 +125,20 @@ class SmartBrowserAutomation {
                 type: 'collection',
                 placeholder: 'Add Option',
                 default: {},
+                displayOptions: {
+                    show: {
+                        mode: ['aiAgent'],
+                    },
+                },
                 options: [
+                    {
+                        displayName: 'CDP Endpoint',
+                        name: 'cdpUrl',
+                        type: 'string',
+                        default: '',
+                        placeholder: 'wss://gridnew.doingerp.com/devtools/...',
+                        description: 'The wss:// or http:// endpoint for the browser CDP connection',
+                    },
                     {
                         displayName: 'Enabled Tool Names or IDs',
                         name: 'enabledTools',
@@ -191,7 +221,10 @@ class SmartBrowserAutomation {
                 const sessionManager = BrowserSessionManager_1.default.getInstance();
                 const credentials = await this.getCredentials('smartBrowserAutomationApi');
                 await sessionManager.initialize(credentials.mcpEndpoint, true, input.endpoint);
-                return { success: true, message: `Connected to browser at ${input.endpoint}` };
+                return {
+                    content: [{ type: 'text', text: `Successfully connected to browser at ${input.endpoint}` }],
+                    isError: false
+                };
             }
         };
         return [connectTool, ...tools];
@@ -209,27 +242,34 @@ class SmartBrowserAutomation {
                 if (mode === 'manual') {
                     // Manual mode: User selects tool and provides arguments
                     const toolName = this.getNodeParameter('toolName', i);
-                    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}`);
-                    }
                     // Special case: Manual Browser Connection
                     if (toolName === 'browser_connect_cdp') {
-                        const endpoint = toolArgs.endpoint;
+                        const endpoint = this.getNodeParameter('cdpUrl', i);
                         if (!endpoint) {
-                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Endpoint URL is required for browser_connect_cdp');
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'CDP Endpoint URL is required for browser_connect_cdp');
+                        }
+                        if (verbose) {
+                            console.log(`Connecting to browser CDP: ${endpoint}`);
                         }
                         await sessionManager.initialize(credentials.mcpEndpoint, true, endpoint);
                         returnData.push({
-                            json: { success: true, message: `Connected to browser at ${endpoint}` },
+                            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);
@@ -239,11 +279,7 @@ class SmartBrowserAutomation {
                     }
                     const result = await sessionManager.callTool(toolName, toolArgs);
                     returnData.push({
-                        json: {
-                            success: true,
-                            tool: toolName,
-                            result,
-                        },
+                        json: result,
                         pairedItem: i,
                     });
                 }
@@ -251,13 +287,29 @@ class SmartBrowserAutomation {
                     // AI Agent mode: Just initialize or close
                     const operation = this.getNodeParameter('operation', i);
                     if (operation === 'initialize') {
-                        // In AI mode, we use the credentials or fallback to nothing
-                        const cdpUrl = credentials.cdpEndpoint;
+                        // Pull CDP URL from options if available, fallback to credentials
+                        const cdpUrl = options.cdpUrl || credentials.cdpEndpoint;
+                        if (verbose) {
+                            console.log(`Initializing AI session with CDP: ${cdpUrl}`);
+                        }
                         const tools = await sessionManager.initialize(credentials.mcpEndpoint, true, cdpUrl);
+                        // New logic: Auto-call browser_connect tool if a URL is provided
+                        if (options.cdpUrl) {
+                            if (verbose) {
+                                console.log(`Auto-calling 'browser_connect_cdp' with endpoint: ${options.cdpUrl}`);
+                            }
+                            try {
+                                await sessionManager.callTool('browser_connect_cdp', { endpoint: options.cdpUrl });
+                            }
+                            catch (error) {
+                                console.warn(`Failed to auto-connect browser via tool: ${error.message}`);
+                                // We don't throw here to allow the AI to potentially fix it or show the error
+                            }
+                        }
                         returnData.push({
                             json: {
                                 success: true,
-                                message: 'Browser session initialized. Tools are now available to AI Agent.',
+                                message: `MCP session initialized. Browser connect tool called for ${cdpUrl}.`,
                                 toolsCount: tools.length,
                                 tools: tools.map((t) => ({
                                     name: t.name,

package/dist/nodes/SmartBrowserAutomation/tools/DynamicBrowserTools.js

@@ -66,16 +66,10 @@ async function createDynamicBrowserTools(credentials) {
             async execute(toolInput) {
                 try {
                     const result = await sessionManager.callTool(toolName, toolInput);
-                    return {
-                        success: true,
-                        result: JSON.stringify(result, null, 2),
-                    };
+                    return result;
                 }
                 catch (error) {
-                    return {
-                        success: false,
-                        error: error.message || 'Unknown error occurred',
-                    };
+                    throw new Error(error.message || 'Unknown error occurred');
                 }
             }
         };

package/package.json

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