n8n-nodes-smart-browser-automation 1.6.27 → 1.6.28

package/dist/nodes/SmartBrowserAutomation/utils/McpConnection.d.ts

@@ -1,6 +1,15 @@
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { type ISupplyDataFunctions, type IExecuteFunctions } from 'n8n-workflow';
 import { type McpTool } from './McpUtils';
+export type Result<T, E> = {
+    ok: true;
+    result: T;
+} | {
+    ok: false;
+    error: E;
+};
+export declare const createResultOk: <T>(result: T) => Result<T, never>;
+export declare const createResultError: <E>(error: E) => Result<never, E>;
 export interface McpConfig {
     mcpEndpoint: string;
     browserMode: string;
@@ -8,6 +17,7 @@ export interface McpConfig {
     transportType?: 'sse' | 'stdio';
     timeout?: number;
 }
+export declare function connectMcpClient(config: McpConfig): Promise<Result<Client, Error>>;
 export declare function connectAndGetTools(_ctx: ISupplyDataFunctions | IExecuteFunctions, config: McpConfig): Promise<{
     client: Client;
     mcpTools: McpTool[];

package/dist/nodes/SmartBrowserAutomation/utils/McpConnection.js

@@ -1,61 +1,96 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResultError = exports.createResultOk = void 0;
+exports.connectMcpClient = connectMcpClient;
 exports.connectAndGetTools = connectAndGetTools;
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
 const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
 const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
-async function connectAndGetTools(_ctx, config) {
+const createResultOk = (result) => ({ ok: true, result });
+exports.createResultOk = createResultOk;
+const createResultError = (error) => ({ ok: false, error });
+exports.createResultError = createResultError;
+// --- URL Helpers from read.txt ---
+function safeCreateUrl(url, baseUrl) {
+    try {
+        return (0, exports.createResultOk)(new URL(url, baseUrl));
+    }
+    catch (error) {
+        return (0, exports.createResultError)(error);
+    }
+}
+function normalizeAndValidateUrl(input) {
+    // Remove invisible characters first (my addition, keeping robustness)
+    const cleanInput = input.replace(/[^\x20-\x7E]/g, '').trim();
+    const withProtocol = !/^https?:\/\//i.test(cleanInput) ? `http://${cleanInput}` : cleanInput;
+    const parsedUrl = safeCreateUrl(withProtocol);
+    if (!parsedUrl.ok) {
+        return (0, exports.createResultError)(parsedUrl.error);
+    }
+    return parsedUrl;
+}
+// --- Main Connection Logic ---
+async function connectMcpClient(config) {
+    const endpointUrl = config.mcpEndpoint;
+    // Handle Stdio separately as it's not a URL
+    // Rough heuristic: if it looks like a command (no / or ://), it's stdio. 
+    // But users might put "localhost:3000". `normalizeAndValidateUrl` handles localhost:3000 by adding http.
+    // We need a way to distinguish.
+    // For now, let's assume if it validates as a URL, we try URL. 
+    // But "python main.py" is not a URL.
     let client;
     let Transport;
+    // User explicitly requested "only url" and "client method"
+    // We strictly enforce URL validation and connection.
+    const validUrl = normalizeAndValidateUrl(endpointUrl);
+    if (!validUrl.ok) {
+        return (0, exports.createResultError)(new Error(`Invalid MCP Endpoint URL: ${endpointUrl} (Error: ${validUrl.error.message})`));
+    }
+    const urlObj = validUrl.result;
+    // Detect SSE
+    // Logic from read.txt
+    const isSse = /(^|\/)sse\/?(\?|#|$)/i.test(urlObj.pathname);
+    client = new index_js_1.Client({ name: 'n8n-smart-browser-automation', version: '1.0.0' }, { capabilities: {} });
     try {
-        const mcpEndpoint = config.mcpEndpoint.trim();
-        const isUrl = mcpEndpoint.startsWith('http://') || mcpEndpoint.startsWith('https://');
-        if (isUrl) {
-            // Check for SSE
-            let urlIsSse = false;
-            try {
-                const url = new URL(mcpEndpoint);
-                urlIsSse = /(^|\/)sse\/?(\?|#|$)/i.test(url.pathname);
-            }
-            catch (e) {
-                return {
-                    client: null,
-                    mcpTools: [],
-                    error: { error: 'Invalid URL', message: `Invalid MCP Endpoint URL: ${mcpEndpoint}` }
-                };
-            }
-            if (urlIsSse) {
-                Transport = new sse_js_1.SSEClientTransport(new URL(mcpEndpoint));
-            }
-            else {
-                Transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(mcpEndpoint));
-            }
+        if (isSse) {
+            Transport = new sse_js_1.SSEClientTransport(urlObj, {
+                fetch: fetch,
+            });
         }
         else {
-            // Stdio
-            Transport = new stdio_js_1.StdioClientTransport({
-                command: 'node',
-                args: [mcpEndpoint],
-                // Pass env if needed, including CDP_URL if we want the server to pick it up via env
-                env: {
-                    ...process.env,
-                    ...(config.cdpEndpoint ? { CDP_URL: config.cdpEndpoint } : {}),
-                },
+            Transport = new streamableHttp_js_1.StreamableHTTPClientTransport(urlObj, {
+                fetch: fetch,
             });
         }
-        client = new index_js_1.Client({ name: 'n8n-smart-browser-automation', version: '1.0.0' }, { capabilities: {} });
         await client.connect(Transport);
-        // List tools
+        return (0, exports.createResultOk)(client);
+    }
+    catch (e) {
+        return (0, exports.createResultError)(new Error(`Connection Failed (${isSse ? 'SSE' : 'HTTP'}): ${e.message}`));
+    }
+}
+async function connectAndGetTools(_ctx, config) {
+    const connResult = await connectMcpClient(config);
+    if (!connResult.ok) {
+        return {
+            client: null,
+            mcpTools: [],
+            error: { error: 'Connection Failed', message: connResult.error.message }
+        };
+    }
+    const client = connResult.result;
+    try {
         const result = await client.listTools();
         const tools = (result.tools || []);
         return { client, mcpTools: tools };
     }
-    catch (err) {
+    catch (e) {
+        // Don't forget to close if listing fails
+        await client.close();
         return {
             client: null,
             mcpTools: [],
-            error: { error: 'Connection Failed', message: err.message || String(err) }
+            error: { error: 'List Tools Failed', message: e.message }
         };
     }
 }

package/package.json

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