n8n-nodes-smart-browser-automation 1.6.26 → 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/dist/nodes/SmartBrowserAutomation/utils/McpUtils.d.ts

@@ -17,6 +17,15 @@ export declare function getSelectedTools({ mode, includeTools, excludeTools, too
 export declare const getErrorDescriptionFromToolCall: (result: unknown) => string | undefined;
 export declare const createCallTool: (name: string, client: Client, timeout: number, onError: (error: string) => void) => (args: IDataObject) => Promise<{} | null>;
 export declare function mcpToolToDynamicTool(tool: McpTool, onCallTool: (args: any) => Promise<any>): Promise<DynamicStructuredTool>;
+/**
+ * Wraps a DynamicStructuredTool to log its execution to the n8n AI Tool output.
+ * This ensures the user sees the tool input and output in the n8n UI.
+ */
+export declare function logWrapper(tool: DynamicStructuredTool, nodeCtx: {
+    addOutputData: Function;
+    addInputData: Function;
+    getNextRunIndex?: Function;
+}): DynamicStructuredTool;
 export declare class McpToolkit extends Toolkit {
     tools: DynamicStructuredTool[];
     constructor(tools: DynamicStructuredTool[]);

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.McpToolkit = exports.createCallTool = exports.getErrorDescriptionFromToolCall = void 0;
 exports.getSelectedTools = getSelectedTools;
 exports.mcpToolToDynamicTool = mcpToolToDynamicTool;
+exports.logWrapper = logWrapper;
 const tools_1 = require("@langchain/core/tools");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const agents_1 = require("@langchain/classic/agents");
@@ -81,6 +82,63 @@ async function mcpToolToDynamicTool(tool, onCallTool) {
         metadata: { isFromToolkit: true },
     });
 }
+/**
+ * Wraps a DynamicStructuredTool to log its execution to the n8n AI Tool output.
+ * This ensures the user sees the tool input and output in the n8n UI.
+ */
+function logWrapper(tool, nodeCtx) {
+    // Access internal properties safely via casting if needed
+    const toolAny = tool;
+    const originalFunc = toolAny.func;
+    toolAny.func = async (args) => {
+        const toolName = toolAny.name;
+        const input = {
+            tool: toolName,
+            arguments: args,
+        };
+        let runIndex = 0;
+        try {
+            // n8n type hack: try to get run index if available
+            runIndex = nodeCtx.getNextRunIndex?.() ?? 0;
+        }
+        catch { }
+        // Log Input
+        // 2 is the index for NodeConnectionTypes.AiTool usually, check your node definition
+        // In SmartBrowserAutomationTools, output[0] = AiTool, output[1] = Main.
+        // Wait, NodeConnectionTypes are strings "ai_tool", "main".
+        // The `addInputData` returns { index, runIndex }.
+        // We need to use the connection name or index. 
+        // "ai_tool" is typically index 0 if listed first in outputs.
+        const { index } = nodeCtx.addInputData('ai_tool', [[{ json: input }]], runIndex);
+        try {
+            const result = await originalFunc(args);
+            const output = {
+                tool: toolName,
+                result: result,
+            };
+            // Log Output
+            // We wrap in [[ { json: ... } ]] because n8n expects INodeExecutionData[][]
+            nodeCtx.addOutputData('ai_tool', index, [[{ json: output }]]);
+            return result;
+        }
+        catch (error) {
+            // Log Error
+            const errorOutput = {
+                tool: toolName,
+                error: error.message || String(error),
+            };
+            // Try to log error output
+            try {
+                nodeCtx.addOutputData('ai_tool', index, [[{ json: errorOutput }]]);
+            }
+            catch (e) {
+                console.error(`Failed to log error for tool ${toolName}`, e);
+            }
+            throw error;
+        }
+    };
+    return tool;
+}
 class McpToolkit extends agents_1.Toolkit {
     tools;
     constructor(tools) {

package/package.json

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