n8n-nodes-smart-browser-automation 1.0.6 → 1.1.2

package/dist/nodes/SmartBrowserAutomation/BrowserSessionManager.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
 class BrowserSessionManager {
     static instance;
     mcpClient = null;
@@ -29,21 +30,30 @@ class BrowserSessionManager {
         }
         // Initialize MCP client
         this.mcpClient = new index_js_1.Client({ name: 'n8n-browser-automation', version: '1.0.0' }, { capabilities: {} });
-        // Connect to MCP server
-        this.transport = new stdio_js_1.StdioClientTransport({
-            command: 'node',
-            args: [mcpEndpoint],
-            env: {
-                ...process.env,
-                ...(useCDP && cdpEndpoint ? { CDP_URL: cdpEndpoint } : {})
-            }
-        });
+        // Determine transport based on endpoint type
+        const isUrl = mcpEndpoint.startsWith('http://') || mcpEndpoint.startsWith('https://');
+        if (isUrl) {
+            // Connect via SSE
+            this.transport = new sse_js_1.SSEClientTransport(new URL(mcpEndpoint));
+        }
+        else {
+            // Connect via Stdio
+            this.transport = new stdio_js_1.StdioClientTransport({
+                command: 'node',
+                args: [mcpEndpoint],
+                env: {
+                    ...process.env,
+                    ...(useCDP && cdpEndpoint ? { CDP_URL: cdpEndpoint } : {})
+                }
+            });
+        }
         try {
             await this.mcpClient.connect(this.transport);
         }
         catch (error) {
             this.isInitialized = false;
-            throw new Error(`Failed to connect to MCP server at ${mcpEndpoint}. Ensure the path is correct and accessible within your n8n environment. Error: ${error.message}`);
+            const transportType = isUrl ? 'SSE' : 'Stdio';
+            throw new Error(`Failed to connect to MCP server via ${transportType} at ${mcpEndpoint}. Error: ${error.message}`);
         }
         // Fetch available tools from MCP server
         const toolsResponse = await this.mcpClient.listTools();
@@ -56,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,14 +125,19 @@ class SmartBrowserAutomation {
                 type: 'collection',
                 placeholder: 'Add Option',
                 default: {},
+                displayOptions: {
+                    show: {
+                        mode: ['aiAgent'],
+                    },
+                },
                 options: [
                     {
                         displayName: 'CDP Endpoint',
                         name: 'cdpUrl',
                         type: 'string',
                         default: '',
-                        placeholder: 'wss://...',
-                        description: 'The CDP URL to connect to. Overrides the one in credentials if provided.',
+                        placeholder: 'wss://gridnew.doingerp.com/devtools/...',
+                        description: 'The wss:// or http:// endpoint for the browser CDP connection',
                     },
                     {
                         displayName: 'Enabled Tool Names or IDs',
@@ -146,16 +168,26 @@ class SmartBrowserAutomation {
                     const credentials = await this.getCredentials('smartBrowserAutomationApi');
                     const sessionManager = BrowserSessionManager_1.default.getInstance();
                     const tools = await sessionManager.initialize(credentials.mcpEndpoint, credentials.browserMode === 'cdp', credentials.cdpEndpoint);
-                    if (!tools || tools.length === 0) {
-                        return [{ name: 'No Tools Found - Check MCP Server', value: 'none' }];
+                    const nodeTools = [
+                        {
+                            name: 'Connect to Browser (CDP)',
+                            value: 'browser_connect_cdp',
+                            description: 'Connect to a browser via CDP URL',
+                        },
+                    ];
+                    if (tools && tools.length > 0) {
+                        nodeTools.push(...tools.map((tool) => ({
+                            name: tool.name.split('_').map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(' '),
+                            value: tool.name,
+                        })));
                     }
-                    return tools.map((tool) => ({
-                        name: tool.name.split('_').map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(' '),
-                        value: tool.name,
-                    }));
+                    return nodeTools;
                 }
                 catch (error) {
-                    return [{ name: `Error: ${error.message}`, value: 'error' }];
+                    return [
+                        { name: 'Connect to Browser (CDP)', value: 'browser_connect_cdp' },
+                        { name: `Error loading MCP tools: ${error.message}`, value: 'error' }
+                    ];
                 }
             },
         },
@@ -172,7 +204,7 @@ class SmartBrowserAutomation {
         }
         // Add a custom tool for the AI to connect to a specific CDP URL
         const connectTool = {
-            name: 'browser_cdp_connect',
+            name: 'browser_connect_cdp',
             displayName: 'Connect to Browser (CDP)',
             description: 'Connect to a specific browser instance using a CDP URL (wss://...)',
             properties: [
@@ -207,11 +239,27 @@ 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);
-                    // Initialize session if not ready
-                    if (!sessionManager.isReady()) {
-                        await sessionManager.initialize(credentials.mcpEndpoint, credentials.browserMode === 'cdp', credentials.cdpEndpoint);
+                    // 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');
+                        }
+                        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}`,
+                                timestamp: new Date().toISOString()
+                            },
+                            pairedItem: i,
+                        });
+                        continue;
                     }
+                    const toolArgsStr = this.getNodeParameter('toolArgs', i);
                     let toolArgs;
                     try {
                         toolArgs = JSON.parse(toolArgsStr);
@@ -219,6 +267,10 @@ class SmartBrowserAutomation {
                     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);
                     }
@@ -236,13 +288,29 @@ class SmartBrowserAutomation {
                     // AI Agent mode: Just initialize or close
                     const operation = this.getNodeParameter('operation', i);
                     if (operation === 'initialize') {
+                        // Pull CDP URL from options if available, fallback to credentials
                         const cdpUrl = options.cdpUrl || credentials.cdpEndpoint;
-                        const tools = await sessionManager.initialize(credentials.mcpEndpoint, true, // Force CDP if using initialize in AI mode
-                        cdpUrl);
+                        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' with endpoint: ${options.cdpUrl}`);
+                            }
+                            try {
+                                await sessionManager.callTool('browser_connect', { 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/package.json

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