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

package/dist/nodes/SmartBrowserAutomation/BrowserSessionManager.js

@@ -85,70 +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(mcpUrlObj.pathname);
-            }
-            catch (e) {
-                // Should be caught by parseUrl above, but just in case
-                throw new Error(`Invalid MCP Endpoint path: "${trimmedMcpEndpoint}".`);
-            }
-        }
-        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
+        // 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

@@ -149,13 +149,17 @@ 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,
-            toolCount: mcpTools.length,
-            tools: mcpTools.map((t) => ({
+            initializationMode: 'strict_cdp_connect',
+            toolCount: exposedTools.length,
+            tools: exposedTools.map((t) => ({
                 name: t.name,
                 description: t.description ?? '',
             })),
@@ -164,7 +168,7 @@ class SmartBrowserAutomationTools {
         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 ?? '');

package/package.json

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