n8n-nodes-smart-browser-automation 1.1.11 → 1.1.13

package/dist/nodes/SmartBrowserAutomation/BrowserSessionManager.js

@@ -75,8 +75,10 @@ class BrowserSessionManager {
             throw new Error('MCP client not initialized. Please configure credentials first.');
         }
         try {
-            // Log exact payload to debug truncation issues reported by users
-            console.log(`[MCP] Calling tool "${toolName}" with args:`, JSON.stringify(toolArgs || {}));
+            // Only log in development/debug mode
+            if (process.env.NODE_ENV !== 'production' && process.env.DEBUG) {
+                console.log(`[MCP] Calling tool "${toolName}" with args:`, JSON.stringify(toolArgs || {}));
+            }
             const result = await this.mcpClient.callTool({
                 name: toolName,
                 arguments: toolArgs || {}

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

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SmartBrowserAutomation = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
-const DynamicBrowserTools_1 = require("./tools/DynamicBrowserTools");
 const BrowserSessionManager_1 = __importDefault(require("./BrowserSessionManager"));
 class SmartBrowserAutomation {
     description = {
@@ -194,32 +193,99 @@ class SmartBrowserAutomation {
     };
     // Expose tools to AI Agent nodes
     async getTools() {
-        const credentials = await this.getCredentials('smartBrowserAutomationApi');
-        const options = this.getNodeParameter('options', 0, {});
-        const enabledTools = options.enabledTools || [];
-        let tools = await (0, DynamicBrowserTools_1.createDynamicBrowserTools)(credentials);
-        // Filter tools if a selection was made
-        if (enabledTools.length > 0) {
-            tools = tools.filter(tool => enabledTools.includes(tool.name));
-        }
-        // Sort tools to prioritize core actions
-        const priorityTools = ['browser_navigate', 'browser_click', 'browser_type', 'browser_press_key', 'browser_scroll_to', 'browser_get_text'];
-        tools.sort((a, b) => {
-            const indexA = priorityTools.indexOf(a.name);
-            const indexB = priorityTools.indexOf(b.name);
-            if (indexA !== -1 && indexB !== -1)
-                return indexA - indexB;
-            if (indexA !== -1)
-                return -1;
-            if (indexB !== -1)
-                return 1;
-            return a.name.localeCompare(b.name);
-        });
-        // Add a custom tool for the AI to connect to a specific CDP URL
+        // To save tokens and prevent context overflow, we expose a single "Router Tool"
+        // instead of 54 individual tool definitions.
+        const routerTool = {
+            name: 'browser_tool',
+            displayName: 'Browser Action',
+            description: `Perform browser automation actions. 
+			USAGE EXAMPLES:
+			- Navigate: action='navigate', params={ "url": "https://..." }
+			- Click: action='click', params={ "selector": "button.submit" }
+			- Type: action='type', params={ "selector": "#input", "text": "hello" }
+			- Scroll: action='scroll_to', params={ "selector": "footer" }
+			- Get Text: action='get_text', params={ "selector": ".content" }
+			- Screenshot: action='take_screenshot', params={}
+			
+			Available actions: navigate, click, type, press_key, scroll_to, get_text, take_screenshot, evaluate, etc.
+			Supported Params depend on the action.`,
+            properties: [
+                {
+                    displayName: 'Action Name',
+                    name: 'action',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                },
+                {
+                    displayName: 'Parameters',
+                    name: 'params',
+                    type: 'json',
+                    default: '{}',
+                    description: 'JSON parameters for the action (e.g., { "URL": "..." })',
+                },
+            ],
+            async execute(input) {
+                const sessionManager = BrowserSessionManager_1.default.getInstance();
+                const credentials = await this.getCredentials('smartBrowserAutomationApi');
+                // Ensure session is initialized
+                if (!sessionManager.isReady()) {
+                    // Check for connection tool usage specifically
+                    if (input.action === 'connect_cdp' || input.action === 'browser_connect_cdp') {
+                        const endpoint = input.params?.endpoint;
+                        if (endpoint) {
+                            await sessionManager.initialize(credentials.mcpEndpoint, true, endpoint);
+                            return {
+                                content: [{ type: 'text', text: `Connected to browser at ${endpoint}.` }],
+                                isError: false,
+                                toolName: 'browser_connect_cdp',
+                                requestedAction: input.action
+                            };
+                        }
+                    }
+                    // Auto-initialize if possible (blindly)
+                    await sessionManager.initialize(credentials.mcpEndpoint, credentials.browserMode === 'cdp', credentials.cdpEndpoint);
+                }
+                // Normalize action name
+                let toolName = input.action;
+                if (!toolName.startsWith('browser_') && toolName !== 'connect_cdp') {
+                    toolName = `browser_${toolName}`;
+                }
+                // Handle params
+                let toolArgs = input.params || {};
+                if (typeof toolArgs === 'string') {
+                    try {
+                        toolArgs = JSON.parse(toolArgs);
+                    }
+                    catch (e) {
+                        // ignore
+                    }
+                }
+                console.log(`[Router] Routing '${input.action}' to '${toolName}' with args:`, toolArgs);
+                try {
+                    const result = await sessionManager.callTool(toolName, toolArgs);
+                    // Add tool name to result for visibility
+                    if (result && typeof result === 'object') {
+                        result.toolName = toolName;
+                        result.requestedAction = input.action;
+                    }
+                    return result;
+                }
+                catch (error) {
+                    return {
+                        content: [{ type: 'text', text: `Error executing ${toolName}: ${error.message}` }],
+                        isError: true,
+                        toolName: toolName,
+                        requestedAction: input.action
+                    };
+                }
+            }
+        };
+        // Add a custom tool for specific CDP connection (legacy support)
         const connectTool = {
             name: 'browser_connect_cdp',
             displayName: 'Connect to Browser (CDP)',
-            description: 'Connect to a specific browser instance using a CDP URL (wss://...)',
+            description: 'Connect to a specific browser instance using a CDP URL. Params: { "endpoint": "wss://..." }',
             properties: [
                 {
                     displayName: 'Endpoint URL',
@@ -227,7 +293,7 @@ class SmartBrowserAutomation {
                     type: 'string',
                     default: '',
                     required: true,
-                    description: 'The wss:// or http:// endpoint for the browser CDP connection',
+                    description: 'The wss:// or http:// endpoint',
                 },
             ],
             async execute(input) {
@@ -235,12 +301,13 @@ class SmartBrowserAutomation {
                 const credentials = await this.getCredentials('smartBrowserAutomationApi');
                 await sessionManager.initialize(credentials.mcpEndpoint, true, input.endpoint);
                 return {
-                    content: [{ type: 'text', text: `Connected to browser at ${input.endpoint}. You can now use tools like browser_navigate, browser_click, browser_type, etc.` }],
-                    isError: false
+                    content: [{ type: 'text', text: `Connected to browser at ${input.endpoint}.` }],
+                    isError: false,
+                    toolName: 'browser_connect_cdp'
                 };
             }
         };
-        return [connectTool, ...tools];
+        return [routerTool, connectTool];
     }
     async execute() {
         const items = this.getInputData();
@@ -301,41 +368,40 @@ class SmartBrowserAutomation {
                     const operation = this.getNodeParameter('operation', i);
                     if (operation === 'initialize') {
                         const cdpUrl = credentials.cdpEndpoint;
-                        const tools = await sessionManager.initialize(credentials.mcpEndpoint, true, cdpUrl);
-                        let connectionStatus = 'Skipped (No CDP URL provided)';
-                        let connectionResult = null;
+                        await sessionManager.initialize(credentials.mcpEndpoint, true, cdpUrl);
                         // New logic: Auto-call browser_connect_cdp tool if a URL is provided
                         if (options.cdpUrl) {
                             if (verbose) {
                                 console.log(`Auto-calling 'browser_connect_cdp' with endpoint: ${options.cdpUrl}`);
                             }
                             try {
-                                connectionResult = await sessionManager.callTool('browser_connect_cdp', { endpoint: options.cdpUrl });
-                                connectionStatus = 'Successfully connected';
+                                const connectionResult = await sessionManager.callTool('browser_connect_cdp', { endpoint: options.cdpUrl });
+                                // Return only the connection result, no extra messages
+                                returnData.push({
+                                    json: connectionResult,
+                                    pairedItem: i,
+                                });
                             }
                             catch (error) {
-                                connectionStatus = `Failed to connect: ${error.message}`;
-                                console.warn(`Failed to auto-connect browser via tool: ${error.message}`);
+                                returnData.push({
+                                    json: {
+                                        success: false,
+                                        error: `Failed to connect: ${error.message}`
+                                    },
+                                    pairedItem: i,
+                                });
                             }
                         }
-                        // Create a compact tool guide for the AI to fix hallucinations
-                        // We prioritise showing the most important tools first
-                        const coreTools = ['browser_navigate', 'browser_click', 'browser_type', 'browser_press_key', 'browser_scroll_to', 'browser_get_text', 'browser_take_screenshot', 'browser_evaluate'];
-                        const toolGuide = tools
-                            .filter(t => coreTools.includes(t.name))
-                            .map(t => `- ${t.name}: ${(t.description || '').substring(0, 100)}`)
-                            .join('\n');
-                        const otherToolsCount = tools.length - coreTools.length;
-                        returnData.push({
-                            json: {
-                                success: true,
-                                message: `MCP session initialized at ${credentials.mcpEndpoint}`,
-                                browserConnection: connectionStatus,
-                                browserResponse: connectionResult,
-                                toolGuide: `Available Tools (Top ${coreTools.length} of ${tools.length}):\n${toolGuide}\n...and ${otherToolsCount} more. Use these exact names!`,
-                            },
-                            pairedItem: i,
-                        });
+                        else {
+                            // No CDP URL provided
+                            returnData.push({
+                                json: {
+                                    success: true,
+                                    message: 'MCP session initialized (no browser connection)'
+                                },
+                                pairedItem: i,
+                            });
+                        }
                     }
                     else if (operation === 'close') {
                         await sessionManager.close();

package/package.json

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