n8n-nodes-smart-browser-automation 1.6.23 → 1.6.25

package/dist/nodes/SmartBrowserAutomation/BrowserSessionManager.d.ts

@@ -12,6 +12,7 @@ declare class BrowserSessionManager {
     private tools;
     private constructor();
     static getInstance(): BrowserSessionManager;
+    private parseUrl;
     initialize(mcpEndpoint: string, useCDP: boolean, cdpEndpoint?: string): Promise<MCPTool[]>;
     private getAllTools;
     callTool(toolName: string, toolArgs?: any): Promise<any>;

package/dist/nodes/SmartBrowserAutomation/BrowserSessionManager.js

@@ -48,6 +48,17 @@ class BrowserSessionManager {
         }
         return BrowserSessionManager.instance;
     }
+    /*
+     * Safe URL parser helper
+     */
+    parseUrl(url, description) {
+        try {
+            return new URL(url);
+        }
+        catch (error) {
+            throw new Error(`Invalid ${description}: "${url}". Please ensure it is a valid URL (e.g. starting with http:// or https://).`);
+        }
+    }
     async initialize(mcpEndpoint, useCDP, cdpEndpoint) {
         // Validate endpoint inputs early to avoid confusing runtime errors
         let trimmedMcpEndpoint = String(mcpEndpoint ?? '').trim();
@@ -55,10 +66,11 @@ class BrowserSessionManager {
             throw new Error('MCP Endpoint is required');
         }
         // Be forgiving: if user passes host:port without scheme, assume http://
-        // Examples: localhost:3000, 127.0.0.1:3000, example.com:8080
         if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmedMcpEndpoint)) {
             trimmedMcpEndpoint = `http://${trimmedMcpEndpoint}`;
         }
+        // Validate URL format immediately
+        const mcpUrlObj = this.parseUrl(trimmedMcpEndpoint, 'MCP Endpoint');
         if (/^wss?:\/\//i.test(trimmedMcpEndpoint)) {
             throw new Error(`Invalid MCP Endpoint: "${trimmedMcpEndpoint}". ` +
                 'MCP Endpoint must be an http(s) URL (for SSE or Streamable HTTP). ' +
@@ -73,69 +85,82 @@ class BrowserSessionManager {
                 throw new Error(`Invalid CDP Endpoint: "${trimmedCdp}". CDP Endpoint must be a ws(s) URL (e.g. ws://localhost:9222 or wss://.../devtools/...).`);
             }
         }
-        // Only initialize if not already done or config changed
-        if (this.isInitialized &&
+        // Check checks if we are already initialized with the same config
+        // BUT if we are using CDP, we want to ensure we call the connect tool again
+        // to make sure the browser session is active (referencing user request).
+        const isConfigMatch = this.isInitialized &&
             this.config.mcpEndpoint === mcpEndpoint &&
             this.config.useCDP === useCDP &&
-            this.config.cdpEndpoint === cdpEndpoint) {
+            this.config.cdpEndpoint === cdpEndpoint;
+        if (isConfigMatch && !useCDP) {
+            // For non-CDP (standard MCP tools), we can safely return cached tools
             return this.tools;
         }
-        // Close existing session if config changed
-        if (this.mcpClient) {
-            await this.close();
-        }
-        // Initialize MCP client
-        this.mcpClient = new index_js_1.Client({ name: 'n8n-browser-automation', version: '1.0.0' }, { capabilities: {} });
-        // Determine transport based on endpoint type
-        const isUrl = trimmedMcpEndpoint.startsWith('http://') || trimmedMcpEndpoint.startsWith('https://');
-        let urlIsSse = false;
-        if (isUrl) {
-            try {
-                urlIsSse = /(^|\/)sse\/?(\?|#|$)/i.test(new URL(trimmedMcpEndpoint).pathname);
-            }
-            catch (e) {
-                throw new Error(`Invalid MCP Endpoint: "${trimmedMcpEndpoint}". MCP Endpoint must be a valid http(s) URL (or a local file path for stdio).`);
-            }
-        }
-        if (isUrl) {
-            if (urlIsSse) {
-                // Connect via SSE
-                const { SSEClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/sse.js')));
-                this.transport = new SSEClientTransport(new URL(trimmedMcpEndpoint));
-            }
-            else {
-                // Connect via Streamable HTTP
-                const { StreamableHTTPClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/streamableHttp.js')));
-                this.transport = new StreamableHTTPClientTransport(new URL(trimmedMcpEndpoint));
+        // If config changed, or strict strict re-connect is needed (though we try to reuse client if endpoint is same)
+        if (this.config.mcpEndpoint !== mcpEndpoint || !this.mcpClient) {
+            // Full re-initialization needed
+            if (this.mcpClient) {
+                await this.close();
             }
+            this.isInitialized = false;
         }
         else {
-            // Connect via Stdio (lazy import so environments that only use SSE don't need stdio deps)
-            const { StdioClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/stdio.js')));
-            this.transport = new StdioClientTransport({
-                command: 'node',
-                args: [mcpEndpoint],
-                env: {
-                    ...process.env,
-                    ...(useCDP && cdpEndpoint ? { CDP_URL: cdpEndpoint } : {}),
-                },
-            });
+            // MCP endpoint is same, just need to re-run tools logic (like CDP connect)
+            // We can skip client creation
         }
-        try {
-            await this.mcpClient.connect(this.transport);
-            // Stability delay for HTTP connections to ensure session is fully open
-            // Remote servers often need a moment to register the session before accepting POST calls
+        if (!this.mcpClient) {
+            // Initialize MCP client
+            this.mcpClient = new index_js_1.Client({ name: 'n8n-browser-automation', version: '1.0.0' }, { capabilities: {} });
+            // Determine transport based on endpoint type
+            const isUrl = trimmedMcpEndpoint.startsWith('http://') || trimmedMcpEndpoint.startsWith('https://');
+            let urlIsSse = false;
             if (isUrl) {
-                if (process.env.NODE_ENV !== 'production') {
-                    console.log(`[MCP] Connected to ${trimmedMcpEndpoint}. Waiting for session stabilization...`);
+                try {
+                    urlIsSse = /(^|\/)sse\/?(\?|#|$)/i.test(mcpUrlObj.pathname);
+                }
+                catch (e) {
+                    throw new Error(`Invalid MCP Endpoint path: "${trimmedMcpEndpoint}".`);
                 }
-                await new Promise(resolve => setTimeout(resolve, 2000));
             }
-        }
-        catch (error) {
-            this.isInitialized = false;
-            const transportType = isUrl ? (urlIsSse ? 'SSE' : 'Streamable HTTP') : 'Stdio';
-            throw new Error(`Failed to connect to MCP server via ${transportType} at ${trimmedMcpEndpoint}. Error: ${error.message}`);
+            if (isUrl) {
+                if (urlIsSse) {
+                    // Connect via SSE
+                    const { SSEClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/sse.js')));
+                    this.transport = new SSEClientTransport(new URL(trimmedMcpEndpoint)); // Safe because we parsed it above
+                }
+                else {
+                    // Connect via Streamable HTTP
+                    const { StreamableHTTPClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/streamableHttp.js')));
+                    this.transport = new StreamableHTTPClientTransport(new URL(trimmedMcpEndpoint)); // Safe because we parsed it above
+                }
+            }
+            else {
+                // Connect via Stdio (lazy import so environments that only use SSE don't need stdio deps)
+                const { StdioClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/stdio.js')));
+                this.transport = new StdioClientTransport({
+                    command: 'node',
+                    args: [mcpEndpoint],
+                    env: {
+                        ...process.env,
+                        ...(useCDP && cdpEndpoint ? { CDP_URL: cdpEndpoint } : {}),
+                    },
+                });
+            }
+            try {
+                await this.mcpClient.connect(this.transport);
+                // Stability delay for HTTP connections to ensure session is fully open
+                if (isUrl) {
+                    if (process.env.NODE_ENV !== 'production') {
+                        console.log(`[MCP] Connected to ${trimmedMcpEndpoint}. Waiting for session stabilization...`);
+                    }
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                }
+            }
+            catch (error) {
+                this.isInitialized = false;
+                const transportType = isUrl ? (urlIsSse ? 'SSE' : 'Streamable HTTP') : 'Stdio';
+                throw new Error(`Failed to connect to MCP server via ${transportType} at ${trimmedMcpEndpoint}. Error: ${error.message}`);
+            }
         }
         this.isInitialized = true;
         this.config = { mcpEndpoint, useCDP, cdpEndpoint };

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

@@ -86,8 +86,8 @@ class SmartBrowserAutomationTools {
             name: 'Browser Automation Tools',
         },
         inputs: [],
-        outputs: [n8n_workflow_1.NodeConnectionTypes.AiTool],
-        outputNames: ['Tools'],
+        outputs: [n8n_workflow_1.NodeConnectionTypes.AiTool, n8n_workflow_1.NodeConnectionTypes.Main],
+        outputNames: ['Tools', 'Debug'],
         icon: 'file:smartBrowserAutomation.svg',
         credentials: [
             {
@@ -140,7 +140,7 @@ class SmartBrowserAutomationTools {
             const e = error;
             const mode = useCDP ? 'cdp' : 'launch';
             const details = `mcp=${mcpEndpoint} | mode=${mode}${useCDP ? ` | cdp=${cdpUrl || 'unset'}` : ''}`;
-            throw new n8n_workflow_1.NodeOperationError(node, `Failed to connect to MCP (${details}): ${e.message}`, {
+            throw new n8n_workflow_1.NodeOperationError(node, `Failed to connect to MCP. ${details}. Original error: ${e.message}`, {
                 itemIndex,
                 description: details,
             });
@@ -149,10 +149,26 @@ class SmartBrowserAutomationTools {
         if (!mcpTools.length) {
             throw new n8n_workflow_1.NodeOperationError(node, 'MCP Server returned no tools', { itemIndex });
         }
+        // Filter out 'browser_connect_cdp' from the tools list if we are managing it automatically
+        // This prevents the AI from trying to connect manually and confusing the state
+        const exposedTools = mcpTools.filter((t) => t.name !== 'browser_connect_cdp');
+        // Emit a debug item on the Main output so users can see endpoints and tool list in the UI
+        const debugJson = {
+            mcpEndpoint,
+            browserMode: credentials.browserMode,
+            cdpEndpoint: useCDP ? cdpUrl : undefined,
+            initializationMode: 'strict_cdp_connect',
+            toolCount: exposedTools.length,
+            tools: exposedTools.map((t) => ({
+                name: t.name,
+                description: t.description ?? '',
+            })),
+        };
+        this.addOutputData(n8n_workflow_1.NodeConnectionTypes.Main, 0, [[{ json: debugJson }]]);
         const { DynamicStructuredTool } = await importDynamicStructuredTool();
         const { Toolkit } = await importToolkitBase();
         const ctx = this;
-        const tools = await Promise.all(mcpTools.map(async (tool) => {
+        const tools = await Promise.all(exposedTools.map(async (tool) => {
             const schema = await (0, jsonSchemaToZod_1.jsonSchemaToZod)(tool.inputSchema);
             const toolName = tool.name;
             const toolDescription = (tool.description ?? '');
@@ -173,13 +189,33 @@ class SmartBrowserAutomationTools {
                     catch { }
                     const { index } = ctx.addInputData(n8n_workflow_1.NodeConnectionTypes.AiTool, [[{ json: input }]], runIndex);
                     try {
+                        console.log(`[AI Agent] Executing tool ${toolName} with args:`, JSON.stringify(args));
                         const result = await sessionManager.callTool(toolName, args);
                         const output = { tool: toolName, result };
-                        ctx.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiTool, index, [[{ json: output }]]);
+                        // Ensure the output is an array of INodeExecutionData
+                        const executionData = [[{ json: output }]];
+                        ctx.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiTool, index, executionData);
                         return formatMcpToolResult(result);
                     }
                     catch (e) {
-                        ctx.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiTool, index, e);
+                        const errorMsg = e.message || String(e);
+                        console.error(`[AI Agent] Tool ${toolName} failed:`, errorMsg);
+                        // Fix: properly format error for addOutputData
+                        const errorOutput = [[{
+                                    json: {
+                                        tool: toolName,
+                                        error: errorMsg,
+                                        stack: e.stack
+                                    }
+                                }]];
+                        // Safely attempt to report error to UI
+                        try {
+                            ctx.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiTool, index, errorOutput);
+                        }
+                        catch (addError) {
+                            console.error('[AI Agent] Failed to add error output:', addError);
+                        }
+                        // Re-throw so the AI Agent knows it failed
                         throw e;
                     }
                 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-smart-browser-automation",
-  "version": "1.6.23",
+  "version": "1.6.25",
   "description": "n8n node for AI-driven browser automation using MCP",
   "keywords": [
     "n8n-community-node-package",
@@ -63,4 +63,4 @@
     "@modelcontextprotocol/sdk": "1.17.0",
     "zod": "3.25.76"
   }
-}
+}