n8n-nodes-smart-browser-automation 1.3.2 → 1.5.0

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

@@ -15,6 +15,7 @@ declare class BrowserSessionManager {
     initialize(mcpEndpoint: string, useCDP: boolean, cdpEndpoint?: string): Promise<MCPTool[]>;
     callTool(toolName: string, toolArgs?: any): Promise<any>;
     getTools(): MCPTool[];
+    listTools(): Promise<MCPTool[]>;
     close(): Promise<void>;
     isReady(): boolean;
 }

package/dist/nodes/SmartBrowserAutomation/BrowserSessionManager.js

@@ -67,6 +67,7 @@ class BrowserSessionManager {
         this.config = { mcpEndpoint, cdpEndpoint };
         // Fetch available tools from MCP server
         const toolsResponse = await this.mcpClient.listTools();
+        await this.mcpClient.callTool({ name: 'browser_connect_cdp', arguments: { cdpEndpoint: cdpEndpoint || '' } });
         this.tools = toolsResponse.tools;
         return this.tools;
     }
@@ -93,6 +94,12 @@ class BrowserSessionManager {
     getTools() {
         return this.tools;
     }
+    async listTools() {
+        if (!this.mcpClient || !this.isInitialized) {
+            throw new Error('MCP session not initialized. Call initialize() first.');
+        }
+        return this.tools;
+    }
     async close() {
         if (this.mcpClient && this.transport) {
             await this.mcpClient.close();

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

@@ -6,6 +6,5 @@ export declare class SmartBrowserAutomation implements INodeType {
             getAvailableTools(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
         };
     };
-    getTools(this: IExecuteFunctions): Promise<any[]>;
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
 }

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

@@ -4,15 +4,15 @@ 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 BrowserSessionManager_1 = __importDefault(require("./BrowserSessionManager"));
-const DynamicBrowserTools_1 = require("./tools/DynamicBrowserTools");
 class SmartBrowserAutomation {
     description = {
         displayName: 'Smart Browser Automation',
         name: 'smartBrowserAutomation',
         group: ['transform'],
         version: 1,
-        description: 'Browser automation with AI Agent mode (auto) or Manual mode (user choice)',
+        description: 'AI-powered browser automation via MCP Playwright server',
         defaults: {
             name: 'Browser Automation',
         },
@@ -27,6 +27,14 @@ class SmartBrowserAutomation {
         ],
         usableAsTool: true,
         properties: [
+            {
+                displayName: 'CDP Endpoint Override',
+                name: 'cdpOverride',
+                type: 'string',
+                default: '',
+                placeholder: 'wss://gridnew.doingerp.com/devtools/...',
+                description: 'Override CDP endpoint from credentials. Use this to connect to a specific browser instance.',
+            },
             {
                 displayName: 'Operation',
                 name: 'operation',
@@ -34,201 +42,174 @@ class SmartBrowserAutomation {
                 noDataExpression: true,
                 options: [
                     {
-                        name: 'Initialize Session',
-                        value: 'initialize',
-                        description: 'Initialize browser session and load available tools',
-                        action: 'Initialize browser session and load available tools',
+                        name: 'All Tools',
+                        value: 'listTools',
+                        description: 'Get all available browser tools from MCP server',
+                        action: 'List all browser tools',
                     },
                     {
-                        name: 'Close Session',
-                        value: 'close',
-                        description: 'Close browser session and cleanup',
-                        action: 'Close browser session and cleanup',
+                        name: 'Click',
+                        value: 'browser_click',
+                        description: 'Click an element',
+                        action: 'Click element',
                     },
-                ],
-                default: 'initialize',
-            },
-            {
-                displayName: 'Options',
-                name: 'options',
-                type: 'collection',
-                placeholder: 'Add Option',
-                default: {},
-                options: [
                     {
-                        displayName: 'CDP Endpoint',
-                        name: 'cdpUrl',
-                        type: 'string',
-                        default: '',
-                        placeholder: 'wss://gridnew.doingerp.com/devtools/...',
-                        description: 'Browser CDP endpoint to connect to. If not provided, MCP server will launch a new browser.',
+                        name: 'Connect to Browser',
+                        value: 'browser_connect_cdp',
+                        description: 'Connect to browser via CDP',
+                        action: 'Connect to browser via CDP',
                     },
                     {
-                        displayName: 'Verbose Logging',
-                        name: 'verbose',
-                        type: 'boolean',
-                        default: false,
-                        description: 'Whether to enable detailed logging',
+                        name: 'Navigate',
+                        value: 'browser_navigate',
+                        description: 'Navigate to a URL',
+                        action: 'Navigate to URL',
+                    },
+                    {
+                        name: 'Take Snapshot',
+                        value: 'browser_snapshot',
+                        description: 'Capture page accessibility snapshot',
+                        action: 'Take snapshot',
+                    },
+                    {
+                        name: 'Type',
+                        value: 'browser_type',
+                        description: 'Type text into an element',
+                        action: 'Type text',
                     },
                 ],
+                default: 'browser_connect_cdp',
+            },
+            {
+                displayName: 'Tool Parameters',
+                name: 'toolParameters',
+                type: 'json',
+                required: true,
+                displayOptions: {
+                    show: {
+                        operation: [
+                            'browser_connect_cdp',
+                            'browser_navigate',
+                            'browser_click',
+                            'browser_type',
+                            'browser_snapshot',
+                        ],
+                    },
+                },
+                default: '{}',
+                description: 'Parameters to pass to the browser tool in JSON format',
             },
         ],
     };
     methods = {
         loadOptions: {
-            // Populate tool dropdown in manual mode
             async getAvailableTools() {
                 try {
                     const credentials = await this.getCredentials('smartBrowserAutomationApi');
                     const sessionManager = BrowserSessionManager_1.default.getInstance();
-                    const tools = await sessionManager.initialize(credentials.mcpEndpoint, credentials.browserMode === 'cdp', credentials.cdpEndpoint);
-                    const nodeTools = [
-                        {
-                            name: 'Connect to Browser (CDP)',
-                            value: 'browser_connect_cdp',
-                            description: 'Connect to a browser via CDP URL',
-                        },
-                    ];
-                    if (tools && tools.length > 0) {
-                        nodeTools.push(...tools.map((tool) => ({
-                            name: tool.name.split('_').map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(' '),
-                            value: tool.name,
-                        })));
-                    }
-                    return nodeTools;
+                    await sessionManager.initialize(credentials.mcpEndpoint, false, '');
+                    const tools = await sessionManager.listTools();
+                    return tools.map((tool) => ({
+                        name: tool.name.split('_').map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(' '),
+                        value: tool.name,
+                        description: tool.description || '',
+                    }));
                 }
                 catch (error) {
                     return [
-                        { name: 'Connect to Browser (CDP)', value: 'browser_connect_cdp' },
-                        { name: `Error loading MCP tools: ${error.message}`, value: 'error' }
+                        { name: `Error loading tools: ${error.message}`, value: 'error' }
                     ];
                 }
             },
         },
     };
-    // Expose tools to AI Agent nodes
-    async getTools() {
-        const sessionManager = BrowserSessionManager_1.default.getInstance();
-        const credentials = await this.getCredentials('smartBrowserAutomationApi');
-        console.log('[getTools] Starting to fetch tools...');
-        // Check if session is already initialized
-        if (!sessionManager.isReady()) {
-            console.log('[getTools] Session not ready, initializing...');
-            try {
-                await sessionManager.initialize(credentials.mcpEndpoint, credentials.browserMode === 'cdp', credentials.cdpEndpoint);
-                console.log('[getTools] Session initialized successfully');
-            }
-            catch (error) {
-                console.error('[getTools] Failed to initialize session:', error.message);
-                // Return minimal tools if initialization fails
-                return [];
-            }
-        }
-        // Get all individual MCP tools
-        const mcpTools = await (0, DynamicBrowserTools_1.createDynamicBrowserTools)(credentials);
-        console.log(`[getTools] Fetched ${mcpTools.length} MCP tools`);
-        // Add custom CDP connection tool
-        const connectTool = {
-            name: 'browser_connect_cdp',
-            displayName: 'Connect to Browser (CDP)',
-            description: 'Connect to a specific browser instance using a CDP endpoint URL',
-            properties: [
-                {
-                    displayName: 'Endpoint URL',
-                    name: 'endpoint',
-                    type: 'string',
-                    default: '',
-                    required: true,
-                    description: 'The wss:// or http:// CDP endpoint',
-                },
-            ],
-            async execute(input) {
-                const sessionManager = BrowserSessionManager_1.default.getInstance();
-                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}.` }],
-                    isError: false,
-                    toolName: 'browser_connect_cdp'
-                };
-            }
-        };
-        return [...mcpTools, connectTool];
-    }
     async execute() {
-        const items = this.getInputData();
         const returnData = [];
         const credentials = await this.getCredentials('smartBrowserAutomationApi');
         const sessionManager = BrowserSessionManager_1.default.getInstance();
-        for (let i = 0; i < items.length; i++) {
+        // Get CDP override or use from credentials
+        const cdpOverride = this.getNodeParameter('cdpOverride', 0, '');
+        const operation = this.getNodeParameter('operation', 0);
+        try {
+            // Initialize session if not ready
+            if (!sessionManager.isReady()) {
+                const cdpUrl = cdpOverride || credentials.cdpEndpoint || '';
+                await sessionManager.initialize(credentials.mcpEndpoint, !!cdpUrl, cdpUrl);
+            }
+            // Handle listTools operation
+            if (operation === 'listTools') {
+                const tools = await sessionManager.listTools();
+                returnData.push({
+                    json: { tools },
+                });
+                return [returnData];
+            }
+            // Handle tool execution
+            let toolParams;
             try {
-                const options = this.getNodeParameter('options', i, {});
-                const verbose = options.verbose || false;
-                const operation = this.getNodeParameter('operation', i);
-                if (operation === 'initialize') {
-                    const cdpUrl = credentials.cdpEndpoint;
-                    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 {
-                            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) {
-                            returnData.push({
-                                json: {
-                                    success: false,
-                                    error: `Failed to connect: ${error.message}`
-                                },
-                                pairedItem: i,
-                            });
-                        }
+                const rawParams = this.getNodeParameter('toolParameters', 0);
+                if (rawParams === undefined || rawParams === null) {
+                    toolParams = {};
+                }
+                else if (typeof rawParams === 'string') {
+                    if (!rawParams || rawParams.trim() === '') {
+                        toolParams = {};
                     }
                     else {
-                        // No CDP URL provided
-                        returnData.push({
-                            json: {
-                                success: true,
-                                message: 'MCP session initialized (no browser connection)'
-                            },
-                            pairedItem: i,
-                        });
+                        toolParams = JSON.parse(rawParams);
                     }
                 }
-                else if (operation === 'close') {
-                    await sessionManager.close();
-                    returnData.push({
-                        json: {
-                            success: true,
-                            message: 'Browser session closed',
-                        },
-                        pairedItem: i,
-                    });
+                else if (typeof rawParams === 'object') {
+                    // Handle object input (when used as a tool in AI Agent)
+                    toolParams = rawParams;
+                }
+                else {
+                    try {
+                        toolParams = JSON.parse(JSON.stringify(rawParams));
+                    }
+                    catch (parseError) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid parameter type: ${typeof rawParams}`);
+                    }
+                }
+                // Ensure toolParams is an object
+                if (typeof toolParams !== 'object' ||
+                    toolParams === null ||
+                    Array.isArray(toolParams)) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Tool parameters must be a JSON object');
                 }
             }
             catch (error) {
-                if (this.continueOnFail()) {
-                    returnData.push({
-                        json: {
-                            success: false,
-                            error: error.message
-                        },
-                        pairedItem: i,
-                    });
-                }
-                else {
-                    throw error;
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to parse tool parameters: ${error.message}. Make sure the parameters are valid JSON.`);
+            }
+            // Special handling for browser_connect_cdp
+            if (operation === 'browser_connect_cdp') {
+                const endpoint = toolParams.endpoint || cdpOverride || credentials.cdpEndpoint;
+                if (!endpoint) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'CDP endpoint is required. Provide it in tool parameters or CDP Endpoint Override field.');
                 }
+                // Reinitialize with new CDP endpoint
+                await sessionManager.close();
+                await sessionManager.initialize(credentials.mcpEndpoint, true, endpoint);
+                returnData.push({
+                    json: {
+                        result: {
+                            content: [{ type: 'text', text: `Connected to browser at ${endpoint}` }],
+                            isError: false,
+                        }
+                    },
+                });
+                return [returnData];
             }
+            // Execute the tool via MCP
+            const result = await sessionManager.callTool(operation, toolParams);
+            returnData.push({
+                json: { result },
+            });
+            return [returnData];
+        }
+        catch (error) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to execute operation: ${error.message}`);
         }
-        return [returnData];
     }
 }
 exports.SmartBrowserAutomation = SmartBrowserAutomation;

package/package.json

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