n8n-nodes-browser-smart-automation 0.1.0

package/nodes/mcp.dark.svg

@@ -0,0 +1,7 @@
+<svg width="180" height="180" viewBox="0 0 195 195" fill="none" xmlns="http://www.w3.org/2000/svg">
+	<g stroke="#fff" stroke-width="12" stroke-linecap="round">
+		<path d="M25 97.8528L92.8823 29.9706C102.255 20.598 117.451 20.598 126.823 29.9706V29.9706C136.196 39.3431 136.196 54.5391 126.823 63.9117L75.5581 115.177"/>
+		<path d="M76.2653 114.47L126.823 63.9117C136.196 54.5391 151.392 54.5391 160.765 63.9117L161.118 64.2652C170.491 73.6378 170.491 88.8338 161.118 98.2063L99.7248 159.6C96.6006 162.724 96.6006 167.789 99.7248 170.913L112.331 183.52"/>
+		<path d="M109.853 46.9411L59.6482 97.1457C50.2757 106.518 50.2757 121.714 59.6482 131.087V131.087C69.0208 140.459 84.2168 140.459 93.5894 131.087L143.794 80.8822"/>
+	</g>
+</svg>

package/nodes/mcp.svg

@@ -0,0 +1,7 @@
+<svg width="180" height="180" viewBox="0 0 195 195" fill="none" xmlns="http://www.w3.org/2000/svg">
+	<g stroke="#000" stroke-width="12" stroke-linecap="round">
+		<path d="M25 97.8528L92.8823 29.9706C102.255 20.598 117.451 20.598 126.823 29.9706V29.9706C136.196 39.3431 136.196 54.5391 126.823 63.9117L75.5581 115.177"/>
+		<path d="M76.2653 114.47L126.823 63.9117C136.196 54.5391 151.392 54.5391 160.765 63.9117L161.118 64.2652C170.491 73.6378 170.491 88.8338 161.118 98.2063L99.7248 159.6C96.6006 162.724 96.6006 167.789 99.7248 170.913L112.331 183.52"/>
+		<path d="M109.853 46.9411L59.6482 97.1457C50.2757 106.518 50.2757 121.714 59.6482 131.087V131.087C69.0208 140.459 84.2168 140.459 93.5894 131.087L143.794 80.8822"/>
+	</g>
+</svg>

package/nodes/shared/__test__/utils.test.ts

@@ -0,0 +1,318 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { mockDeep } from 'jest-mock-extended';
+import type { IExecuteFunctions } from 'n8n-workflow';
+
+import type { McpAuthenticationOption, McpServerTransport } from '../types';
+import { connectMcpClient, getAuthHeaders, tryRefreshOAuth2Token } from '../utils';
+
+jest.mock('@modelcontextprotocol/sdk/client/index.js');
+jest.mock('@modelcontextprotocol/sdk/client/streamableHttp.js');
+jest.mock('@modelcontextprotocol/sdk/client/sse.js');
+
+const MockedClient = Client as jest.MockedClass<typeof Client>;
+const MockedHTTPTransport = StreamableHTTPClientTransport as jest.MockedClass<
+	typeof StreamableHTTPClientTransport
+>;
+const MockedSSETransport = SSEClientTransport as jest.MockedClass<typeof SSEClientTransport>;
+
+describe('utils', () => {
+	describe('tryRefreshOAuth2Token', () => {
+		it('should refresh an OAuth2 token without headers', async () => {
+			const ctx = mockDeep<IExecuteFunctions>();
+			ctx.helpers.refreshOAuth2Token.mockResolvedValue({
+				access_token: 'new-access-token',
+			});
+
+			const headers = await tryRefreshOAuth2Token(ctx, 'mcpOAuth2Api');
+
+			expect(headers).toEqual({ Authorization: 'Bearer new-access-token' });
+		});
+
+		it('should refresh an OAuth2 token with headers', async () => {
+			const ctx = mockDeep<IExecuteFunctions>();
+			ctx.helpers.refreshOAuth2Token.mockResolvedValue({
+				access_token: 'new-access-token',
+			});
+
+			const headers = await tryRefreshOAuth2Token(ctx, 'mcpOAuth2Api', {
+				Foo: 'bar',
+				Authorization: 'Bearer old-access-token',
+			});
+
+			expect(headers).toEqual({
+				Foo: 'bar',
+				Authorization: 'Bearer new-access-token',
+			});
+		});
+
+		it('should return null if the authentication method is not oAuth2Api', async () => {
+			const ctx = mockDeep<IExecuteFunctions>();
+
+			const headers = await tryRefreshOAuth2Token(ctx, 'headerAuth');
+
+			expect(headers).toBeNull();
+		});
+
+		it('should return null if the refreshOAuth2Token returns no access_token', async () => {
+			const ctx = mockDeep<IExecuteFunctions>();
+			ctx.helpers.refreshOAuth2Token.mockResolvedValue({
+				access_token: null,
+			});
+
+			const headers = await tryRefreshOAuth2Token(ctx, 'mcpOAuth2Api');
+
+			expect(headers).toBeNull();
+		});
+
+		it('should return null if the refreshOAuth2Token throws an error', async () => {
+			const ctx = mockDeep<IExecuteFunctions>();
+			ctx.helpers.refreshOAuth2Token.mockRejectedValue(new Error('Failed to refresh OAuth2 token'));
+
+			const headers = await tryRefreshOAuth2Token(ctx, 'mcpOAuth2Api');
+
+			expect(headers).toBeNull();
+		});
+	});
+
+	describe('getAuthHeaders', () => {
+		it('should return the headers for mcpOAuth2Api', async () => {
+			const ctx = mockDeep<IExecuteFunctions>();
+			ctx.getCredentials.mockResolvedValue({
+				oauthTokenData: {
+					access_token: 'access-token',
+				},
+			});
+
+			const result = await getAuthHeaders(ctx, 'mcpOAuth2Api');
+
+			expect(result).toEqual({ headers: { Authorization: 'Bearer access-token' } });
+		});
+
+		it('should return the headers for headerAuth', async () => {
+			const ctx = mockDeep<IExecuteFunctions>();
+			ctx.getCredentials.mockResolvedValue({
+				name: 'Foo',
+				value: 'bar',
+			});
+
+			const result = await getAuthHeaders(ctx, 'headerAuth');
+
+			expect(result).toEqual({ headers: { Foo: 'bar' } });
+		});
+
+		it('should return the headers for bearerAuth', async () => {
+			const ctx = mockDeep<IExecuteFunctions>();
+			ctx.getCredentials.mockResolvedValue({
+				token: 'access-token',
+			});
+
+			const result = await getAuthHeaders(ctx, 'bearerAuth');
+
+			expect(result).toEqual({ headers: { Authorization: 'Bearer access-token' } });
+		});
+
+		it('should return the headers for multipleHeadersAuth', async () => {
+			const ctx = mockDeep<IExecuteFunctions>();
+			ctx.getCredentials.mockResolvedValue({
+				headers: {
+					values: [
+						{ name: 'Foo', value: 'bar' },
+						{ name: 'Test', value: '123' },
+					],
+				},
+			});
+
+			const result = await getAuthHeaders(ctx, 'multipleHeadersAuth');
+
+			expect(result).toEqual({ headers: { Foo: 'bar', Test: '123' } });
+		});
+
+		it('should return an empty object for none', async () => {
+			const ctx = mockDeep<IExecuteFunctions>();
+
+			const result = await getAuthHeaders(ctx, 'none');
+
+			expect(result).toEqual({});
+		});
+
+		it('should return an empty object for an unknown authentication method', async () => {
+			const ctx = mockDeep<IExecuteFunctions>();
+
+			const result = await getAuthHeaders(ctx, 'unknown' as McpAuthenticationOption);
+
+			expect(result).toEqual({});
+		});
+
+		it.each([
+			'headerAuth',
+			'bearerAuth',
+			'mcpOAuth2Api',
+			'multipleHeadersAuth',
+		] as McpAuthenticationOption[])(
+			'should return an empty object for %s when it fails',
+			async (authentication) => {
+				const ctx = mockDeep<IExecuteFunctions>();
+				ctx.getCredentials.mockRejectedValue(new Error('Failed to get credentials'));
+
+				const result = await getAuthHeaders(ctx, authentication);
+
+				expect(result).toEqual({});
+			},
+		);
+	});
+
+	describe('connectMcpClient', () => {
+		const mockClient = {
+			connect: jest.fn(),
+		};
+
+		beforeEach(() => {
+			jest.resetAllMocks();
+			const mockHttpTransport = {} as unknown as StreamableHTTPClientTransport;
+			const mockSSETransport = {} as unknown as SSEClientTransport;
+			MockedClient.mockImplementation(() => mockClient as unknown as Client);
+			MockedHTTPTransport.mockImplementation(() => mockHttpTransport);
+			MockedSSETransport.mockImplementation(() => mockSSETransport);
+		});
+
+		describe.each([
+			['httpStreamable', StreamableHTTPClientTransport],
+			['sse', SSEClientTransport],
+		] as Array<
+			[McpServerTransport, typeof StreamableHTTPClientTransport | typeof SSEClientTransport]
+		>)('%s transport', (transport, Transport) => {
+			it('should retry on 401 and succeed', async () => {
+				const unauthorizedError = new Error('Request failed with status 401');
+				const onUnauthorized = jest.fn().mockResolvedValue({ Authorization: 'Bearer new-token' });
+				mockClient.connect
+					.mockRejectedValueOnce(unauthorizedError)
+					.mockResolvedValueOnce(undefined);
+
+				const result = await connectMcpClient({
+					serverTransport: transport,
+					endpointUrl: 'https://example.com',
+					headers: { Authorization: 'Bearer old-token' },
+					name: 'test-client',
+					version: 1,
+					onUnauthorized,
+				});
+
+				expect(result.ok).toBe(true);
+				expect(mockClient.connect).toHaveBeenCalledTimes(2);
+				expect(onUnauthorized).toHaveBeenCalledWith({ Authorization: 'Bearer old-token' });
+				expect(Transport).toHaveBeenCalledTimes(2);
+				expect(Transport).toHaveBeenNthCalledWith(
+					1,
+					expect.any(URL),
+					expect.objectContaining({
+						requestInit: expect.objectContaining({
+							headers: expect.objectContaining({
+								Authorization: 'Bearer old-token',
+							}),
+						}),
+					}),
+				);
+				expect(Transport).toHaveBeenNthCalledWith(
+					2,
+					expect.any(URL),
+					expect.objectContaining({
+						requestInit: expect.objectContaining({
+							headers: expect.objectContaining({
+								Authorization: 'Bearer new-token',
+							}),
+						}),
+					}),
+				);
+			});
+
+			it('should not retry on not 401', async () => {
+				const error = new Error('Internal Server Error');
+				mockClient.connect.mockRejectedValueOnce(error);
+
+				const result = await connectMcpClient({
+					serverTransport: transport,
+					endpointUrl: 'https://example.com',
+					headers: { Authorization: 'Bearer old-token' },
+					name: 'test-client',
+					version: 1,
+				});
+
+				expect(result.ok).toBe(false);
+				if (!result.ok) {
+					expect(result.error.type).toBe('connection');
+				}
+				expect(mockClient.connect).toHaveBeenCalledTimes(1);
+				expect(Transport).toHaveBeenCalledTimes(1);
+			});
+
+			it('should not retry when onUnauthorized is not provided', async () => {
+				const error = new Error('Request failed with status 401');
+				mockClient.connect.mockRejectedValueOnce(error);
+
+				const result = await connectMcpClient({
+					serverTransport: transport,
+					endpointUrl: 'https://example.com',
+					headers: { Authorization: 'Bearer old-token' },
+					name: 'test-client',
+					version: 1,
+				});
+
+				expect(result.ok).toBe(false);
+				if (!result.ok) {
+					expect(result.error.type).toBe('auth');
+				}
+				expect(mockClient.connect).toHaveBeenCalledTimes(1);
+				expect(Transport).toHaveBeenCalledTimes(1);
+			});
+
+			it('should not retry when onUnauthorized returns null', async () => {
+				const error = new Error('Request failed with status 401');
+				const onUnauthorized = jest.fn().mockResolvedValue(null);
+				mockClient.connect.mockRejectedValueOnce(error);
+
+				const result = await connectMcpClient({
+					serverTransport: transport,
+					endpointUrl: 'https://example.com',
+					headers: { Authorization: 'Bearer old-token' },
+					name: 'test-client',
+					version: 1,
+					onUnauthorized,
+				});
+
+				expect(result.ok).toBe(false);
+				if (!result.ok) {
+					expect(result.error.type).toBe('auth');
+				}
+				expect(mockClient.connect).toHaveBeenCalledTimes(1);
+				expect(Transport).toHaveBeenCalledTimes(1);
+				expect(onUnauthorized).toHaveBeenCalledWith({ Authorization: 'Bearer old-token' });
+			});
+
+			it('should not retry more than once', async () => {
+				const error = new Error('Request failed with status 401');
+				mockClient.connect.mockRejectedValue(error);
+				const onUnauthorized = jest.fn().mockResolvedValue({ Authorization: 'Bearer new-token' });
+
+				const result = await connectMcpClient({
+					serverTransport: transport,
+					endpointUrl: 'https://example.com',
+					headers: { Authorization: 'Bearer old-token' },
+					name: 'test-client',
+					version: 1,
+					onUnauthorized,
+				});
+
+				expect(result.ok).toBe(false);
+				if (!result.ok) {
+					expect(result.error.type).toBe('auth');
+				}
+				expect(mockClient.connect).toHaveBeenCalledTimes(2);
+				expect(Transport).toHaveBeenCalledTimes(2);
+				expect(onUnauthorized).toHaveBeenCalledTimes(1);
+				expect(onUnauthorized).toHaveBeenCalledWith({ Authorization: 'Bearer old-token' });
+			});
+		});
+	});
+});

package/nodes/shared/descriptions.ts

@@ -0,0 +1,65 @@
+import type { IDisplayOptions, INodeCredentialDescription, INodeProperties } from 'n8n-workflow';
+
+export const transportSelect = ({
+	defaultOption,
+	displayOptions,
+}: {
+	defaultOption: 'sse' | 'httpStreamable';
+	displayOptions?: IDisplayOptions;
+}): INodeProperties => ({
+	displayName: 'Server Transport',
+	name: 'serverTransport',
+	type: 'options',
+	options: [
+		{
+			name: 'HTTP Streamable',
+			value: 'httpStreamable',
+		},
+		{
+			name: 'Server Sent Events (Deprecated)',
+			value: 'sse',
+		},
+	],
+	default: defaultOption,
+	description: 'The transport used by your endpoint',
+	displayOptions,
+});
+
+export const credentials: INodeCredentialDescription[] = [
+	{
+		name: 'httpBearerAuth',
+		required: true,
+		displayOptions: {
+			show: {
+				authentication: ['bearerAuth'],
+			},
+		},
+	},
+	{
+		name: 'httpHeaderAuth',
+		required: true,
+		displayOptions: {
+			show: {
+				authentication: ['headerAuth'],
+			},
+		},
+	},
+	{
+		name: 'mcpOAuth2Api',
+		required: true,
+		displayOptions: {
+			show: {
+				authentication: ['mcpOAuth2Api'],
+			},
+		},
+	},
+	{
+		name: 'httpMultipleHeadersAuth',
+		required: true,
+		displayOptions: {
+			show: {
+				authentication: ['multipleHeadersAuth'],
+			},
+		},
+	},
+];

package/nodes/shared/helpers.ts

@@ -0,0 +1,31 @@
+
+import type { IWebhookFunctions } from 'n8n-workflow';
+import { NodeConnectionTypes } from 'n8n-workflow';
+import type { Tool } from '@langchain/core/tools';
+
+export async function getConnectedTools(
+    context: IWebhookFunctions,
+    includeBuiltIn: boolean = true
+): Promise<Tool[]> {
+    const tools: Tool[] = [];
+    
+    try {
+        // Get tools from connected nodes via the 'Tools' input connection
+        const connectedTools = (await context.getInputConnectionData(
+            NodeConnectionTypes.AiTool,
+            0,
+        )) as Tool[] | Tool | undefined;
+
+        if (connectedTools) {
+            if (Array.isArray(connectedTools)) {
+                tools.push(...connectedTools);
+            } else {
+                tools.push(connectedTools);
+            }
+        }
+    } catch (error) {
+        // No tools connected or error retrieving them - return empty array
+    }
+
+    return tools;
+}

package/nodes/shared/httpProxyAgent.ts

@@ -0,0 +1,11 @@
+
+import type { RequestInit, Response } from 'node-fetch';
+
+// Simple pass-through fetch since we don't have the original proxy logic.
+// In a real n8n node, you might want to integrate with n8n's proxy settings.
+export async function proxyFetch(url: string | URL, init?: RequestInit): Promise<Response> {
+    // @ts-ignore - native fetch vs node-fetch types mismatch might occur, but for now we try global fetch or assume node-fetch is available
+    // If running in Node 18+, global fetch exists. 
+    // n8n environments often have fetch.
+    return (globalThis.fetch as unknown as typeof fetch)(url as any, init as any);
+}

package/nodes/shared/logWrapper.ts

@@ -0,0 +1,13 @@
+import type { DynamicTool } from '@langchain/core/tools';
+import type { ISupplyDataFunctions } from 'n8n-workflow';
+
+/**
+ * Wraps a LangChain tool with logging functionality for n8n
+ */
+export function logWrapper(
+	tool: DynamicTool,
+	context: ISupplyDataFunctions,
+): DynamicTool {
+	// Simply return the tool as-is since we don't have full n8n logging infrastructure
+	return tool;
+}

package/nodes/shared/schemaParsing.ts

@@ -0,0 +1,9 @@
+/**
+ * Utility for parsing JSON schemas for n8n resource mapping
+ */
+export function convertJsonSchemaToZod(schema: any): any {
+	// This is a simplified stub - real implementation would convert JSON Schema to Zod schema
+	// For now, return a passthrough that accepts any object
+	const { z } = require('zod');
+	return z.any();
+}

package/nodes/shared/sharedFields.ts

@@ -0,0 +1,20 @@
+import type { INodeProperties } from 'n8n-workflow';
+
+/**
+ * Returns a connection hint notice field for AI nodes
+ */
+export function getConnectionHintNoticeField(
+	connectionTypes: string[],
+): INodeProperties {
+	return {
+		displayName: '',
+		name: 'notice',
+		type: 'notice',
+		default: '',
+		displayOptions: {
+			show: {
+				'@version': [{ _cnd: { gte: 1 } }],
+			},
+		},
+	};
+}

package/nodes/shared/types.ts

@@ -0,0 +1,12 @@
+import type { JSONSchema7 } from 'json-schema';
+
+export type McpTool = { name: string; description?: string; inputSchema: JSONSchema7 };
+
+export type McpServerTransport = 'sse' | 'httpStreamable';
+
+export type McpAuthenticationOption =
+	| 'none'
+	| 'headerAuth'
+	| 'bearerAuth'
+	| 'mcpOAuth2Api'
+	| 'multipleHeadersAuth';