n8n-nodes-smart-browser-automation 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ejaz Ullah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,203 @@
+# n8n-nodes-smart-browser-automation
+
+n8n community node for AI-driven browser automation using Model Context Protocol (MCP).
+
+## Features
+
+- **Two Modes**:
+  - **AI Agent Mode**: Let AI decide which browser tools to use (works with any AI model in n8n)
+  - **Manual Mode**: Choose specific browser tools from a dropdown list
+  
+- **MCP Integration**: Connect to MCP server once, reuse for all operations
+- **Browser Flexibility**: Auto-launch browser or connect via CDP (Chrome DevTools Protocol)
+- **Dynamic Tool Loading**: All MCP tools automatically available to AI agents
+- **Persistent Session**: Browser stays open across multiple operations
+
+## Installation
+
+### Community Node Installation
+
+1. In n8n, go to **Settings** > **Community Nodes**
+2. Click **Install** and enter: `n8n-nodes-smart-browser-automation`
+3. Install the node
+
+### Manual Installation (for development)
+
+```bash
+cd ~/.n8n/custom
+git clone https://github.com/Ejazullah42/n8n-nodes-smart-browser-automation.git
+cd n8n-nodes-smart-browser-automation
+npm install
+npm run build
+```
+
+Restart n8n to load the node.
+
+## Prerequisites
+
+1. **MCP Server**: You need a running MCP server (e.g., from `@ejazullah/smart-browser-automation`)
+2. **Node.js**: Version 18 or higher
+
+## Configuration
+
+### Credentials Setup
+
+Add new credentials for **Smart Browser Automation API**:
+
+1. **MCP Endpoint**: URL of your MCP server (e.g., `http://localhost:3000`)
+2. **Browser Mode**:
+   - **Auto Launch**: Automatically start a new browser
+   - **CDP Connection**: Connect to existing browser
+3. **CDP Endpoint** (if using CDP mode): WebSocket URL (e.g., `ws://localhost:9222`)
+
+## Usage
+
+### Mode 1: AI Agent (Automatic)
+
+Use with n8n's **AI Agent** node to let AI decide which browser tools to use:
+
+1. Add **Smart Browser Automation** node
+2. Select **Mode**: `AI Agent (Auto)`
+3. Operation: `Initialize Session`
+4. Connect to **AI Agent** node
+5. AI can now use all browser tools automatically
+
+**Example AI Agent Workflow**:
+```
+Trigger → AI Agent (with Smart Browser Automation tools)
+```
+
+AI Agent prompt: "Go to google.com and search for 'n8n automation', then extract the top 3 results"
+
+The AI will automatically:
+- Call `browser_navigate` to go to google.com
+- Call `browser_type` to enter search text
+- Call `browser_click` to submit
+- Call `browser_snapshot` to see results
+- Extract the data
+
+### Mode 2: Manual
+
+Choose specific tools yourself:
+
+1. Add **Smart Browser Automation** node
+2. Select **Mode**: `Manual`
+3. **Tool**: Select from dropdown (browser_navigate, browser_click, etc.)
+4. **Tool Arguments**: Provide JSON arguments
+
+**Example Manual Workflow**:
+```json
+{
+  "url": "https://google.com"
+}
+```
+
+## Available Browser Tools
+
+All MCP browser tools are dynamically loaded. Common tools include:
+
+- `browser_navigate` - Navigate to URL
+- `browser_click` - Click element
+- `browser_type` - Type text into input
+- `browser_snapshot` - Capture page accessibility tree
+- `browser_take_screenshot` - Take screenshot
+- `browser_evaluate` - Execute JavaScript
+- `browser_fill_form` - Fill multiple form fields
+- `browser_select_option` - Select dropdown option
+- `browser_hover` - Hover over element
+- And more...
+
+## Example Workflows
+
+### Example 1: AI-Driven Web Scraping
+
+```
+Webhook Trigger 
+  → Smart Browser (Initialize)
+  → AI Agent (GPT-4)
+    - Tools: Smart Browser Automation
+    - Prompt: "Scrape product prices from example.com"
+  → Database Node (Save results)
+```
+
+### Example 2: Manual Form Filling
+
+```
+Trigger
+  → Smart Browser (Manual Mode)
+    - Tool: browser_navigate
+    - Args: {"url": "https://form.com"}
+  → Smart Browser (Manual Mode)
+    - Tool: browser_fill_form
+    - Args: {"fields": [...]}
+  → Smart Browser (Manual Mode)
+    - Tool: browser_click
+    - Args: {"element": "Submit button"}
+```
+
+### Example 3: Testing with Multiple AI Models
+
+```
+Trigger
+  → Smart Browser (Initialize)
+  → Switch Node
+    - Route to OpenAI Agent
+    - Route to Claude Agent
+    - Route to Gemini Agent
+  (All can use the same browser session)
+```
+
+## Closing Browser Session
+
+Always close the session when done:
+
+1. **AI Agent Mode**: Set Operation to `Close Session`
+2. **Manual Mode**: Switch to AI Agent mode and close
+
+## Troubleshooting
+
+### Browser Not Connecting
+- Verify MCP server is running
+- Check MCP endpoint URL
+- For CDP mode, ensure browser is running with remote debugging
+
+### Tools Not Appearing
+- Click "Refresh" in the tool dropdown
+- Verify credentials are configured correctly
+- Check MCP server logs
+
+### AI Not Using Tools
+- Ensure AI Agent node has access to the tools
+- Check AI model supports function calling
+- Verify tool descriptions are clear
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Watch mode
+npm run dev
+
+# Lint
+npm run lint
+```
+
+## Links
+
+- [GitHub Repository](https://github.com/Ejazullah42/n8n-nodes-smart-browser-automation)
+- [Smart Browser Automation Library](https://github.com/Ejazullah42/smart-browser-automation)
+- [n8n Community Nodes](https://docs.n8n.io/integrations/community-nodes/)
+- [Model Context Protocol](https://modelcontextprotocol.io/)
+
+## License
+
+MIT
+
+## Author
+
+Ejaz Ullah - ejaz@doinger.com

package/dist/credentials/SmartBrowserAutomationApi.credentials.d.ts

@@ -0,0 +1,7 @@
+import { ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class SmartBrowserAutomationApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/SmartBrowserAutomationApi.credentials.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartBrowserAutomationApi = void 0;
+class SmartBrowserAutomationApi {
+    name = 'smartBrowserAutomationApi';
+    displayName = 'Smart Browser Automation API';
+    documentationUrl = 'https://github.com/Ejazullah42/smart-browser-automation';
+    properties = [
+        {
+            displayName: 'MCP Endpoint',
+            name: 'mcpEndpoint',
+            type: 'string',
+            default: 'http://localhost:3000',
+            required: true,
+            description: 'MCP server endpoint URL (set once, reused for all operations)',
+        },
+        {
+            displayName: 'Browser Mode',
+            name: 'browserMode',
+            type: 'options',
+            options: [
+                {
+                    name: 'Auto Launch',
+                    value: 'launch',
+                    description: 'Automatically launch a new browser instance',
+                },
+                {
+                    name: 'CDP Connection',
+                    value: 'cdp',
+                    description: 'Connect to existing browser via Chrome DevTools Protocol',
+                },
+            ],
+            default: 'launch',
+            description: 'How to connect to the browser',
+        },
+        {
+            displayName: 'CDP Endpoint',
+            name: 'cdpEndpoint',
+            type: 'string',
+            default: 'ws://localhost:9222',
+            displayOptions: {
+                show: {
+                    browserMode: ['cdp'],
+                },
+            },
+            description: 'Chrome DevTools Protocol WebSocket URL (supports dynamic URLs)',
+        },
+    ];
+}
+exports.SmartBrowserAutomationApi = SmartBrowserAutomationApi;

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

@@ -0,0 +1,21 @@
+interface MCPTool {
+    name: string;
+    description?: string;
+    inputSchema?: any;
+}
+declare class BrowserSessionManager {
+    private static instance;
+    private mcpClient;
+    private transport;
+    private isInitialized;
+    private config;
+    private tools;
+    private constructor();
+    static getInstance(): BrowserSessionManager;
+    initialize(mcpEndpoint: string, useCDP: boolean, cdpEndpoint?: string): Promise<MCPTool[]>;
+    callTool(toolName: string, toolArgs?: any): Promise<any>;
+    getTools(): MCPTool[];
+    close(): Promise<void>;
+    isReady(): boolean;
+}
+export default BrowserSessionManager;

package/dist/nodes/SmartBrowserAutomation/BrowserSessionManager.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+class BrowserSessionManager {
+    static instance;
+    mcpClient = null;
+    transport = null;
+    isInitialized = false;
+    config = {};
+    tools = [];
+    constructor() { }
+    static getInstance() {
+        if (!BrowserSessionManager.instance) {
+            BrowserSessionManager.instance = new BrowserSessionManager();
+        }
+        return BrowserSessionManager.instance;
+    }
+    async initialize(mcpEndpoint, useCDP, cdpEndpoint) {
+        // Only initialize if not already done or config changed
+        if (this.isInitialized &&
+            this.config.mcpEndpoint === mcpEndpoint &&
+            this.config.cdpEndpoint === cdpEndpoint) {
+            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: {} });
+        // Connect to MCP server
+        this.transport = new stdio_js_1.StdioClientTransport({
+            command: 'node',
+            args: [mcpEndpoint],
+            env: useCDP && cdpEndpoint ? { CDP_URL: cdpEndpoint } : undefined
+        });
+        await this.mcpClient.connect(this.transport);
+        // Fetch available tools from MCP server
+        const toolsResponse = await this.mcpClient.listTools();
+        this.tools = toolsResponse.tools || [];
+        this.config = { mcpEndpoint, cdpEndpoint };
+        this.isInitialized = true;
+        return this.tools;
+    }
+    async callTool(toolName, toolArgs) {
+        if (!this.mcpClient || !this.isInitialized) {
+            throw new Error('MCP client not initialized. Please configure credentials first.');
+        }
+        const result = await this.mcpClient.callTool({
+            name: toolName,
+            arguments: toolArgs || {}
+        });
+        return result;
+    }
+    getTools() {
+        return this.tools;
+    }
+    async close() {
+        if (this.mcpClient && this.transport) {
+            await this.mcpClient.close();
+            this.mcpClient = null;
+            this.transport = null;
+            this.isInitialized = false;
+            this.tools = [];
+        }
+    }
+    isReady() {
+        return this.isInitialized && this.mcpClient !== null;
+    }
+}
+exports.default = BrowserSessionManager;

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

@@ -0,0 +1,11 @@
+import { IExecuteFunctions, ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class SmartBrowserAutomation implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getAvailableTools(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    getTools?(this: IExecuteFunctions): Promise<any[]>;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

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

@@ -0,0 +1,216 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 = {
+        displayName: 'Smart Browser Automation',
+        name: 'smartBrowserAutomation',
+        group: ['transform'],
+        version: 1,
+        description: 'Browser automation with AI Agent mode (auto) or Manual mode (user choice)',
+        defaults: {
+            name: 'Browser Automation',
+        },
+        inputs: ['main'],
+        outputs: ['main'],
+        credentials: [
+            {
+                name: 'smartBrowserAutomationApi',
+                required: true,
+            },
+        ],
+        properties: [
+            {
+                displayName: 'Mode',
+                name: 'mode',
+                type: 'options',
+                noDataExpression: true,
+                options: [
+                    {
+                        name: 'AI Agent (Auto)',
+                        value: 'aiAgent',
+                        description: 'Let AI decide which tools to use - use this with AI Agent node',
+                    },
+                    {
+                        name: 'Manual',
+                        value: 'manual',
+                        description: 'Manually select tool and provide arguments',
+                    },
+                ],
+                default: 'aiAgent',
+                description: 'How to execute browser automation',
+            },
+            {
+                displayName: 'Tool Name or ID',
+                name: 'toolName',
+                type: 'options',
+                typeOptions: {
+                    loadOptionsMethod: 'getAvailableTools',
+                },
+                displayOptions: {
+                    show: {
+                        mode: ['manual'],
+                    },
+                },
+                default: '',
+                description: 'Select the browser automation tool to execute. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                required: true,
+            },
+            {
+                displayName: 'Tool Arguments',
+                name: 'toolArgs',
+                type: 'json',
+                displayOptions: {
+                    show: {
+                        mode: ['manual'],
+                    },
+                },
+                default: '{}',
+                description: 'Arguments for the selected tool in JSON format',
+            },
+            {
+                displayName: 'Operation',
+                name: 'operation',
+                type: 'options',
+                noDataExpression: true,
+                displayOptions: {
+                    show: {
+                        mode: ['aiAgent'],
+                    },
+                },
+                options: [
+                    {
+                        name: 'Initialize Session',
+                        value: 'initialize',
+                        description: 'Initialize browser session and load available tools',
+                        action: 'Initialize browser session and load available tools',
+                    },
+                    {
+                        name: 'Close Session',
+                        value: 'close',
+                        description: 'Close browser session and cleanup',
+                        action: 'Close browser session and cleanup',
+                    },
+                ],
+                default: 'initialize',
+            },
+            {
+                displayName: 'Verbose',
+                name: 'verbose',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to enable detailed logging',
+            },
+        ],
+    };
+    methods = {
+        loadOptions: {
+            // Populate tool dropdown in manual mode
+            async getAvailableTools() {
+                const credentials = await this.getCredentials('smartBrowserAutomationApi');
+                const sessionManager = BrowserSessionManager_1.default.getInstance();
+                const tools = await sessionManager.initialize(credentials.mcpEndpoint, credentials.browserMode === 'cdp', credentials.cdpEndpoint);
+                return tools.map((tool) => ({
+                    name: tool.name.split('_').map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(' '),
+                    value: tool.name,
+                }));
+            },
+        },
+    };
+    // Expose tools to AI Agent nodes
+    async getTools() {
+        const credentials = await this.getCredentials('smartBrowserAutomationApi');
+        return await (0, DynamicBrowserTools_1.createDynamicBrowserTools)(credentials);
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials('smartBrowserAutomationApi');
+        const sessionManager = BrowserSessionManager_1.default.getInstance();
+        const mode = this.getNodeParameter('mode', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (mode === 'manual') {
+                    // Manual mode: User selects tool and provides arguments
+                    const toolName = this.getNodeParameter('toolName', i);
+                    const toolArgsStr = this.getNodeParameter('toolArgs', i);
+                    const verbose = this.getNodeParameter('verbose', i, false);
+                    // Initialize session if not ready
+                    if (!sessionManager.isReady()) {
+                        await sessionManager.initialize(credentials.mcpEndpoint, credentials.browserMode === 'cdp', credentials.cdpEndpoint);
+                    }
+                    let toolArgs;
+                    try {
+                        toolArgs = JSON.parse(toolArgsStr);
+                    }
+                    catch (error) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid JSON in Tool Arguments: ${error.message} `);
+                    }
+                    if (verbose) {
+                        console.log(`Executing tool: ${toolName} with args: `, toolArgs);
+                    }
+                    const result = await sessionManager.callTool(toolName, toolArgs);
+                    returnData.push({
+                        json: {
+                            success: true,
+                            tool: toolName,
+                            result,
+                        },
+                        pairedItem: i,
+                    });
+                }
+                else {
+                    // AI Agent mode: Just initialize or close
+                    const operation = this.getNodeParameter('operation', i);
+                    if (operation === 'initialize') {
+                        const tools = await sessionManager.initialize(credentials.mcpEndpoint, credentials.browserMode === 'cdp', credentials.cdpEndpoint);
+                        returnData.push({
+                            json: {
+                                success: true,
+                                message: 'Browser session initialized. Tools are now available to AI Agent.',
+                                toolsCount: tools.length,
+                                tools: tools.map((t) => ({
+                                    name: t.name,
+                                    description: t.description
+                                })),
+                            },
+                            pairedItem: i,
+                        });
+                    }
+                    else if (operation === 'close') {
+                        await sessionManager.close();
+                        returnData.push({
+                            json: {
+                                success: true,
+                                message: 'Browser session closed',
+                            },
+                            pairedItem: i,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            success: false,
+                            error: error.message
+                        },
+                        pairedItem: i,
+                    });
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        return [returnData];
+    }
+}
+exports.SmartBrowserAutomation = SmartBrowserAutomation;

package/dist/nodes/SmartBrowserAutomation/tools/DynamicBrowserTools.d.ts

@@ -0,0 +1 @@
+export declare function createDynamicBrowserTools(credentials: any): Promise<any[]>;

package/dist/nodes/SmartBrowserAutomation/tools/DynamicBrowserTools.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDynamicBrowserTools = createDynamicBrowserTools;
+const BrowserSessionManager_1 = __importDefault(require("../BrowserSessionManager"));
+// Convert MCP tool schema to n8n properties
+function mcpSchemaToN8nProperties(mcpSchema) {
+    const properties = [];
+    if (!mcpSchema || !mcpSchema.properties) {
+        return properties;
+    }
+    for (const [key, value] of Object.entries(mcpSchema.properties)) {
+        const prop = value;
+        const nodeProperty = {
+            displayName: key.charAt(0).toUpperCase() + key.slice(1).replace(/_/g, ' '),
+            name: key,
+            type: 'string',
+            default: '',
+            description: prop.description || '',
+            required: mcpSchema.required?.includes(key) || false,
+        };
+        // Map types from JSON Schema to n8n types
+        if (prop.type === 'boolean') {
+            nodeProperty.type = 'boolean';
+            nodeProperty.default = false;
+        }
+        else if (prop.type === 'number' || prop.type === 'integer') {
+            nodeProperty.type = 'number';
+            nodeProperty.default = 0;
+        }
+        else if (prop.type === 'object' || prop.type === 'array') {
+            nodeProperty.type = 'json';
+            nodeProperty.default = prop.type === 'array' ? '[]' : '{}';
+        }
+        // Handle enums
+        if (prop.enum && Array.isArray(prop.enum)) {
+            nodeProperty.type = 'options';
+            nodeProperty.options = prop.enum.map((val) => ({
+                name: String(val),
+                value: val,
+            }));
+        }
+        properties.push(nodeProperty);
+    }
+    return properties;
+}
+// Create n8n tool instances from MCP tools
+async function createDynamicBrowserTools(credentials) {
+    const sessionManager = BrowserSessionManager_1.default.getInstance();
+    // Initialize and get MCP tools
+    const mcpTools = await sessionManager.initialize(credentials.mcpEndpoint, credentials.browserMode === 'cdp', credentials.cdpEndpoint);
+    // Create n8n tool for each MCP tool
+    const n8nTools = mcpTools.map((mcpTool) => {
+        const toolName = mcpTool.name;
+        const displayName = toolName
+            .split('_')
+            .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+            .join(' ');
+        return {
+            name: toolName,
+            displayName: displayName,
+            description: mcpTool.description || `Execute ${displayName} browser action`,
+            properties: mcpSchemaToN8nProperties(mcpTool.inputSchema),
+            async execute(toolInput) {
+                try {
+                    const result = await sessionManager.callTool(toolName, toolInput);
+                    return {
+                        success: true,
+                        result: JSON.stringify(result, null, 2),
+                    };
+                }
+                catch (error) {
+                    return {
+                        success: false,
+                        error: error.message || 'Unknown error occurred',
+                    };
+                }
+            }
+        };
+    });
+    return n8nTools;
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "n8n-nodes-smart-browser-automation",
+  "version": "1.0.0",
+  "description": "n8n node for AI-driven browser automation using MCP",
+  "keywords": [
+    "n8n-community-node-package",
+    "browser-automation",
+    "ai",
+    "mcp",
+    "playwright"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/Ejazullah42/n8n-nodes-smart-browser-automation",
+  "author": {
+    "name": "Ejaz Ullah",
+    "email": "ejaz@doinger.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ejazullah42/n8n-nodes-smart-browser-automation.git"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "format": "prettier nodes credentials --write",
+    "lint": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\"",
+    "lintfix": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" --fix",
+    "prepublishOnly": "npm run build && npm run lint"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/SmartBrowserAutomationApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/SmartBrowserAutomation/SmartBrowserAutomation.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@typescript-eslint/parser": "^6.13.0",
+    "eslint": "^8.55.0",
+    "eslint-plugin-n8n-nodes-base": "^1.16.1",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "^1.0.0",
+    "prettier": "^3.1.0",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.17.0"
+  }
+}