@forestnpm/n8n-nodes-forest 1.0.0

package/dist/nodes/Forest/forest.svg

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg id="Calque_1" data-name="Calque 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 35.93 36">
+  <defs>
+    <style>
+      .cls-1 {
+        fill: #183225;
+      }
+
+      .cls-1, .cls-2 {
+        stroke-width: 0px;
+      }
+
+      .cls-2 {
+        fill: #d5ee84;
+      }
+    </style>
+  </defs>
+  <g id="Isotype_only" data-name="Isotype only">
+    <rect class="cls-2" x="-.04" y="0" width="36" height="36" rx="6.75" ry="6.75"/>
+    <path class="cls-1" d="M17.96,9.86l7.82,7.16,2.31-2.12-10.13-9.28L7.84,14.91l2.31,2.11,7.81-7.16Z"/>
+    <path class="cls-1" d="M7.84,22.15l2.31,2.11,6.18-5.66v12.34h3.27v-12.32l6.18,5.65,2.31-2.11-10.13-9.28-10.12,9.28Z"/>
+  </g>
+</svg>

package/dist/nodes/Forest/listSearch.d.ts

@@ -0,0 +1,2 @@
+import type { ILoadOptionsFunctions, INodeListSearchResult } from 'n8n-workflow';
+export declare function getTools(this: ILoadOptionsFunctions, filter?: string, paginationToken?: string): Promise<INodeListSearchResult>;

package/dist/nodes/Forest/listSearch.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTools = getTools;
+const utils_1 = require("./utils");
+async function getTools(filter, paginationToken) {
+    const authentication = this.getNodeParameter('authentication');
+    const { headers, endpointUrl } = await (0, utils_1.getAuthHeadersAndEndpoint)(this, authentication);
+    // Return empty results if credentials are not configured yet
+    if (!endpointUrl) {
+        return { results: [] };
+    }
+    const node = this.getNode();
+    const client = await (0, utils_1.connectMcpClient)({
+        endpointUrl,
+        headers,
+        name: node.type,
+        version: node.typeVersion,
+    });
+    // Throw error if connection fails (e.g., auth error, network error)
+    if (!client.ok) {
+        throw (0, utils_1.mapToNodeOperationError)(node, client.error);
+    }
+    try {
+        const result = await client.result.listTools({ cursor: paginationToken });
+        const tools = filter
+            ? result.tools.filter((tool) => tool.name.toLowerCase().includes(filter.toLowerCase()))
+            : result.tools;
+        return {
+            results: tools.map((tool) => ({
+                name: tool.name,
+                value: tool.name,
+                description: tool.description,
+            })),
+            paginationToken: result.nextCursor,
+        };
+    }
+    finally {
+        await client.result.close();
+    }
+}

package/dist/nodes/Forest/resourceMapping.d.ts

@@ -0,0 +1,2 @@
+import type { ILoadOptionsFunctions, ResourceMapperFields } from 'n8n-workflow';
+export declare function getToolParameters(this: ILoadOptionsFunctions): Promise<ResourceMapperFields>;

package/dist/nodes/Forest/resourceMapping.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToolParameters = getToolParameters;
+const utils_1 = require("./utils");
+function jsonSchemaTypeToFieldType(type) {
+    const primaryType = Array.isArray(type) ? type[0] : type;
+    switch (primaryType) {
+        case 'string':
+            return 'string';
+        case 'number':
+        case 'integer':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'array':
+            return 'array';
+        case 'object':
+            return 'object';
+        default:
+            return 'string';
+    }
+}
+function convertJsonSchemaToResourceMapperFields(schema, requiredFields = []) {
+    const fields = [];
+    if (schema.type !== 'object' || !schema.properties) {
+        return fields;
+    }
+    for (const [key, value] of Object.entries(schema.properties)) {
+        if (typeof value === 'boolean')
+            continue;
+        const propertySchema = value;
+        const displayName = propertySchema.description ? `${key} - ${propertySchema.description}` : key;
+        const fieldType = jsonSchemaTypeToFieldType(propertySchema.type || 'string');
+        const field = {
+            id: key,
+            displayName,
+            type: fieldType,
+            required: requiredFields.includes(key),
+            defaultMatch: false,
+            canBeUsedToMatch: false,
+            display: true,
+        };
+        // Set default value for object and array types
+        if (fieldType === 'object') {
+            field.defaultValue = '{}';
+        }
+        else if (fieldType === 'array') {
+            field.defaultValue = '[]';
+        }
+        if (propertySchema.enum &&
+            Array.isArray(propertySchema.enum) &&
+            propertySchema.enum.length > 0) {
+            field.type = 'options';
+            field.options = propertySchema.enum.map((value) => ({
+                name: String(value),
+                value,
+            }));
+        }
+        fields.push(field);
+    }
+    return fields;
+}
+async function getToolParameters() {
+    const toolId = this.getNodeParameter('tool.value');
+    // Return empty fields if no tool is selected yet
+    if (!toolId) {
+        return { fields: [] };
+    }
+    const authentication = this.getNodeParameter('authentication');
+    const node = this.getNode();
+    const { headers, endpointUrl } = await (0, utils_1.getAuthHeadersAndEndpoint)(this, authentication);
+    if (!endpointUrl) {
+        return { fields: [] };
+    }
+    const client = await (0, utils_1.connectMcpClient)({
+        endpointUrl,
+        headers,
+        name: node.type,
+        version: node.typeVersion,
+    });
+    // Return empty fields if connection fails (e.g., auth error, network error)
+    if (!client.ok) {
+        return { fields: [] };
+    }
+    try {
+        const tools = await (0, utils_1.getAllTools)(client.result);
+        const tool = tools.find((t) => t.name === toolId);
+        // Return empty fields if tool not found
+        if (!tool) {
+            return { fields: [] };
+        }
+        const schema = tool.inputSchema;
+        const requiredFields = Array.isArray(schema.required) ? schema.required : [];
+        const fields = convertJsonSchemaToResourceMapperFields(schema, requiredFields);
+        return { fields };
+    }
+    finally {
+        await client.result.close();
+    }
+}

package/dist/nodes/Forest/types.d.ts

@@ -0,0 +1,7 @@
+import type { JSONSchema7 } from 'json-schema';
+export type McpTool = {
+    name: string;
+    description?: string;
+    inputSchema: JSONSchema7;
+};
+export type McpAuthenticationOption = 'bearerAuth' | 'mcpOAuth2Api';

package/dist/nodes/Forest/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nodes/Forest/utils.d.ts

@@ -0,0 +1,38 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { IExecuteFunctions, ILoadOptionsFunctions, INode } from 'n8n-workflow';
+import { NodeOperationError } from 'n8n-workflow';
+import type { McpAuthenticationOption, McpTool } from './types';
+export type Result<T, E> = {
+    ok: true;
+    result: T;
+} | {
+    ok: false;
+    error: E;
+};
+export declare function cleanParameters<T>(obj: T): T;
+export declare function getAllTools(client: Client, cursor?: string): Promise<McpTool[]>;
+type ConnectMcpClientError = {
+    type: 'invalid_url';
+    error: Error;
+} | {
+    type: 'connection';
+    error: Error;
+} | {
+    type: 'auth';
+    error: Error;
+} | {
+    type: 'not_found';
+    error: Error;
+};
+export declare function mapToNodeOperationError(node: INode, error: ConnectMcpClientError): NodeOperationError;
+export declare function connectMcpClient({ headers, endpointUrl, name, version, }: {
+    endpointUrl: string;
+    headers?: Record<string, string>;
+    name: string;
+    version: number;
+}): Promise<Result<Client, ConnectMcpClientError>>;
+export declare function getAuthHeadersAndEndpoint(ctx: Pick<IExecuteFunctions | ILoadOptionsFunctions, 'getCredentials'>, authentication: McpAuthenticationOption): Promise<{
+    headers?: Record<string, string>;
+    endpointUrl?: string;
+}>;
+export {};

package/dist/nodes/Forest/utils.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanParameters = cleanParameters;
+exports.getAllTools = getAllTools;
+exports.mapToNodeOperationError = mapToNodeOperationError;
+exports.connectMcpClient = connectMcpClient;
+exports.getAuthHeadersAndEndpoint = getAuthHeadersAndEndpoint;
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const n8n_workflow_1 = require("n8n-workflow");
+function cleanParameters(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        const cleanedArray = obj
+            .map((item) => cleanParameters(item))
+            .filter((item) => item !== undefined);
+        return cleanedArray;
+    }
+    if (typeof obj === 'object') {
+        const cleaned = {};
+        for (const [key, value] of Object.entries(obj)) {
+            const cleanedValue = cleanParameters(value);
+            // Skip undefined values and empty objects
+            if (cleanedValue !== undefined) {
+                if (typeof cleanedValue === 'object' &&
+                    cleanedValue !== null &&
+                    !Array.isArray(cleanedValue) &&
+                    Object.keys(cleanedValue).length === 0) {
+                    // Skip empty objects
+                    continue;
+                }
+                cleaned[key] = cleanedValue;
+            }
+        }
+        return cleaned;
+    }
+    return obj;
+}
+function createResultOk(result) {
+    return { ok: true, result };
+}
+function createResultError(error) {
+    return { ok: false, error };
+}
+async function getAllTools(client, cursor) {
+    const { tools, nextCursor } = await client.listTools({ cursor });
+    if (nextCursor) {
+        return tools.concat(await getAllTools(client, nextCursor));
+    }
+    return tools;
+}
+function normalizeAndValidateUrl(input) {
+    const withProtocol = !/^https?:\/\//i.test(input) ? `https://${input}` : input;
+    try {
+        return createResultOk(new URL(withProtocol));
+    }
+    catch (error) {
+        return createResultError(error);
+    }
+}
+function errorHasCode(error, code) {
+    return (!!error &&
+        typeof error === 'object' &&
+        (('code' in error && Number(error.code) === code) ||
+            ('message' in error &&
+                typeof error.message === 'string' &&
+                error.message.includes(code.toString()))));
+}
+function isUnauthorizedError(error) {
+    return errorHasCode(error, 401);
+}
+function isForbiddenError(error) {
+    return errorHasCode(error, 403);
+}
+function isNotFoundError(error) {
+    return errorHasCode(error, 404);
+}
+function mapToNodeOperationError(node, error) {
+    switch (error.type) {
+        case 'invalid_url':
+            return new n8n_workflow_1.NodeOperationError(node, error.error, {
+                message: 'Could not connect to your Forest MCP server. The provided URL is invalid.',
+            });
+        case 'auth':
+            return new n8n_workflow_1.NodeOperationError(node, error.error, {
+                message: 'Could not connect to your Forest MCP server. Authentication failed.',
+            });
+        case 'not_found':
+            return new n8n_workflow_1.NodeOperationError(node, error.error, {
+                message: 'MCP server not found. The MCP server has not been setup on your Forest agent. See https://docs.forestadmin.com/developer-guide-agents-nodejs/agent-customization/ai/mcp-server',
+            });
+        case 'connection':
+        default:
+            return new n8n_workflow_1.NodeOperationError(node, error.error, {
+                message: 'Could not connect to your Forest MCP server',
+            });
+    }
+}
+async function connectMcpClient({ headers, endpointUrl, name, version, }) {
+    const endpoint = normalizeAndValidateUrl(endpointUrl);
+    if (!endpoint.ok) {
+        return createResultError({ type: 'invalid_url', error: endpoint.error });
+    }
+    const client = new index_js_1.Client({ name, version: version.toString() }, { capabilities: {} });
+    try {
+        const transport = new streamableHttp_js_1.StreamableHTTPClientTransport(endpoint.result, {
+            requestInit: { headers },
+        });
+        await client.connect(transport);
+        return createResultOk(client);
+    }
+    catch (error) {
+        if (isUnauthorizedError(error) || isForbiddenError(error)) {
+            return createResultError({ type: 'auth', error: error });
+        }
+        else if (isNotFoundError(error)) {
+            return createResultError({ type: 'not_found', error: error });
+        }
+        else {
+            return createResultError({ type: 'connection', error: error });
+        }
+    }
+}
+async function getAuthHeadersAndEndpoint(ctx, authentication) {
+    var _a, _b, _c, _d, _e;
+    switch (authentication) {
+        case 'bearerAuth': {
+            let result = null;
+            try {
+                result = await ctx.getCredentials('forestMcpApi');
+            }
+            catch {
+                // Credentials not configured or not accessible
+                return {};
+            }
+            if (!result)
+                return {};
+            const serverUrl = ((_a = result.serverUrl) === null || _a === void 0 ? void 0 : _a.trim()) || '';
+            const endpointUrl = serverUrl.endsWith('/mcp') ? serverUrl : `${serverUrl}/mcp`;
+            const token = ((_b = result.token) === null || _b === void 0 ? void 0 : _b.trim()) || '';
+            if (!token) {
+                return {};
+            }
+            return {
+                headers: { Authorization: `Bearer ${token}` },
+                endpointUrl,
+            };
+        }
+        case 'mcpOAuth2Api':
+        default: {
+            let result = null;
+            try {
+                // n8n automatically refreshes the token if expired when getCredentials is called
+                result = await ctx.getCredentials('forestMcpOAuth2Api');
+            }
+            catch (error) {
+                // This can happen if:
+                // - Credentials not configured
+                // - Token refresh failed (refresh_token expired or invalid)
+                // - OAuth server is unreachable
+                console.error('Failed to get OAuth2 credentials:', error);
+                return {};
+            }
+            if (!result)
+                return {};
+            const serverUrl = ((_c = result.serverUrl) === null || _c === void 0 ? void 0 : _c.trim()) || '';
+            const endpointUrl = serverUrl.endsWith('/mcp') ? serverUrl : `${serverUrl}/mcp`;
+            // Check if oauthTokenData exists and has an access_token
+            const accessToken = ((_e = (_d = result.oauthTokenData) === null || _d === void 0 ? void 0 : _d.access_token) === null || _e === void 0 ? void 0 : _e.trim()) || '';
+            if (!accessToken) {
+                // OAuth2 credentials exist but token data is not available yet
+                // This can happen if:
+                // - User hasn't completed the OAuth flow
+                // - Token refresh failed and n8n cleared the token data
+                return {};
+            }
+            return {
+                headers: { Authorization: `Bearer ${accessToken}` },
+                endpointUrl,
+            };
+        }
+    }
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+	"name": "@forestnpm/n8n-nodes-forest",
+	"version": "1.0.0",
+	"description": "n8n community node for Forest",
+	"keywords": [
+		"n8n-community-node-package"
+	],
+	"license": "MIT",
+	"homepage": "",
+	"author": {
+		"name": "Pierre Merlet",
+		"email": "pierre.merlet@forestadmin.com"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/ForestAdmin/n8n-nodes-forest.git"
+	},
+	"engines": {
+		"node": ">=18.10",
+		"pnpm": ">=9.1"
+	},
+	"main": "index.js",
+	"scripts": {
+		"preinstall": "npx only-allow pnpm",
+		"build": "node esbuild.config.mjs && gulp build:icons",
+		"dev": "tsc --watch",
+		"format": "prettier nodes credentials --write",
+		"lint": "eslint nodes credentials package.json",
+		"lintfix": "eslint nodes credentials package.json --fix",
+		"prepublishOnly": "pnpm build && pnpm lint -c .eslintrc.prepublish.js nodes credentials package.json"
+	},
+	"files": [
+		"dist"
+	],
+	"n8n": {
+		"n8nNodesApiVersion": 1,
+		"credentials": [
+			"dist/credentials/ForestMcpApi.credentials.js",
+			"dist/credentials/ForestMcpOAuth2Api.credentials.js"
+		],
+		"nodes": [
+			"dist/nodes/Forest/Forest.node.js"
+		]
+	},
+	"devDependencies": {
+		"@modelcontextprotocol/sdk": "^1.12.1",
+		"@n8n/eslint-plugin-community-nodes": "^0.7.0",
+		"@types/json-schema": "^7.0.15",
+		"@types/node": "^22.0.0",
+		"@typescript-eslint/parser": "^7.15.0",
+		"esbuild": "^0.27.3",
+		"eslint": "^8.56.0",
+		"eslint-plugin-n8n-nodes-base": "^1.16.1",
+		"gulp": "^4.0.2",
+		"jsonc-eslint-parser": "^2.4.2",
+		"n8n-workflow": "*",
+		"prettier": "^3.3.2",
+		"typescript": "^5.5.3",
+		"zod": "^3.24.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"peerDependencies": {
+		"n8n-workflow": "*"
+	},
+	"packageManager": "pnpm@9.15.9"
+}