n8n-nodes-browser-smart-automation 0.1.2 → 0.1.5

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

@@ -1,318 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,31 +0,0 @@
-
-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

@@ -1,11 +0,0 @@
-
-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

@@ -1,13 +0,0 @@
-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

@@ -1,9 +0,0 @@
-/**
- * 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

@@ -1,20 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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';