@pagelines/n8n-mcp 0.3.0 → 0.3.2

package/dist/n8n-client.test.js

@@ -1,295 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { N8nClient } from './n8n-client.js';
-// Mock fetch globally
-const mockFetch = vi.fn();
-global.fetch = mockFetch;
-describe('N8nClient', () => {
-    let client;
-    beforeEach(() => {
-        client = new N8nClient({
-            apiUrl: 'https://n8n.example.com',
-            apiKey: 'test-api-key',
-        });
-        mockFetch.mockReset();
-    });
-    describe('constructor', () => {
-        it('normalizes URL by removing trailing slash', () => {
-            const clientWithSlash = new N8nClient({
-                apiUrl: 'https://n8n.example.com/',
-                apiKey: 'key',
-            });
-            // Access private property for testing
-            expect(clientWithSlash.baseUrl).toBe('https://n8n.example.com');
-        });
-    });
-    describe('listWorkflows', () => {
-        it('calls correct endpoint', async () => {
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                text: async () => JSON.stringify({ data: [] }),
-            });
-            await client.listWorkflows();
-            expect(mockFetch).toHaveBeenCalledWith('https://n8n.example.com/api/v1/workflows', expect.objectContaining({
-                method: 'GET',
-                headers: expect.objectContaining({
-                    'X-N8N-API-KEY': 'test-api-key',
-                }),
-            }));
-        });
-        it('includes query params when provided', async () => {
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                text: async () => JSON.stringify({ data: [] }),
-            });
-            await client.listWorkflows({ active: true, limit: 10 });
-            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('active=true'), expect.any(Object));
-            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('limit=10'), expect.any(Object));
-        });
-    });
-    describe('patchWorkflow', () => {
-        const mockWorkflow = {
-            id: '1',
-            name: 'test_workflow',
-            active: false,
-            nodes: [
-                {
-                    id: 'node1',
-                    name: 'existing_node',
-                    type: 'n8n-nodes-base.set',
-                    typeVersion: 1,
-                    position: [0, 0],
-                    parameters: { param1: 'value1', param2: 'value2' },
-                },
-            ],
-            connections: {},
-            createdAt: '2024-01-01',
-            updatedAt: '2024-01-01',
-        };
-        beforeEach(() => {
-            // Mock GET workflow
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                text: async () => JSON.stringify(mockWorkflow),
-            });
-            // Mock PUT workflow
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                text: async () => JSON.stringify(mockWorkflow),
-            });
-        });
-        it('warns when updateNode would remove parameters', async () => {
-            const { warnings } = await client.patchWorkflow('1', [
-                {
-                    type: 'updateNode',
-                    nodeName: 'existing_node',
-                    properties: {
-                        parameters: { newParam: 'newValue' }, // Missing param1, param2
-                    },
-                },
-            ]);
-            expect(warnings).toContainEqual(expect.stringContaining('remove parameters'));
-            expect(warnings).toContainEqual(expect.stringContaining('param1'));
-        });
-        it('warns when removing non-existent node', async () => {
-            const { warnings } = await client.patchWorkflow('1', [
-                {
-                    type: 'removeNode',
-                    nodeName: 'nonexistent_node',
-                },
-            ]);
-            expect(warnings).toContainEqual(expect.stringContaining('not found'));
-        });
-        it('adds node correctly', async () => {
-            mockFetch.mockReset();
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                text: async () => JSON.stringify(mockWorkflow),
-            });
-            const updatedWorkflow = {
-                ...mockWorkflow,
-                nodes: [
-                    ...mockWorkflow.nodes,
-                    {
-                        id: 'new-id',
-                        name: 'new_node',
-                        type: 'n8n-nodes-base.code',
-                        typeVersion: 1,
-                        position: [100, 100],
-                        parameters: {},
-                    },
-                ],
-            };
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                text: async () => JSON.stringify(updatedWorkflow),
-            });
-            const { workflow } = await client.patchWorkflow('1', [
-                {
-                    type: 'addNode',
-                    node: {
-                        name: 'new_node',
-                        type: 'n8n-nodes-base.code',
-                        typeVersion: 1,
-                        position: [100, 100],
-                        parameters: {},
-                    },
-                },
-            ]);
-            // Verify PUT was called with the new node
-            const putCall = mockFetch.mock.calls[1];
-            const putBody = JSON.parse(putCall[1].body);
-            expect(putBody.nodes).toHaveLength(2);
-            expect(putBody.nodes[1].name).toBe('new_node');
-        });
-        it('adds connection correctly', async () => {
-            mockFetch.mockReset();
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                text: async () => JSON.stringify(mockWorkflow),
-            });
-            const updatedWorkflow = {
-                ...mockWorkflow,
-                connections: {
-                    existing_node: {
-                        main: [[{ node: 'target_node', type: 'main', index: 0 }]],
-                    },
-                },
-            };
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                text: async () => JSON.stringify(updatedWorkflow),
-            });
-            await client.patchWorkflow('1', [
-                {
-                    type: 'addConnection',
-                    from: 'existing_node',
-                    to: 'target_node',
-                },
-            ]);
-            const putCall = mockFetch.mock.calls[1];
-            const putBody = JSON.parse(putCall[1].body);
-            expect(putBody.connections.existing_node.main[0][0].node).toBe('target_node');
-        });
-    });
-    describe('error handling', () => {
-        it('throws on non-ok response', async () => {
-            mockFetch.mockResolvedValueOnce({
-                ok: false,
-                status: 404,
-                text: async () => 'Not found',
-            });
-            await expect(client.getWorkflow('999')).rejects.toThrow('n8n API error (404)');
-        });
-    });
-    describe('listNodeTypes', () => {
-        it('calls correct endpoint', async () => {
-            const mockNodeTypes = [
-                {
-                    name: 'n8n-nodes-base.webhook',
-                    displayName: 'Webhook',
-                    description: 'Starts workflow on webhook call',
-                    group: ['trigger'],
-                    version: 2,
-                },
-                {
-                    name: 'n8n-nodes-base.set',
-                    displayName: 'Set',
-                    description: 'Set values',
-                    group: ['transform'],
-                    version: 3,
-                },
-            ];
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                text: async () => JSON.stringify(mockNodeTypes),
-            });
-            const result = await client.listNodeTypes();
-            expect(mockFetch).toHaveBeenCalledWith('https://n8n.example.com/api/v1/nodes', expect.objectContaining({
-                method: 'GET',
-                headers: expect.objectContaining({
-                    'X-N8N-API-KEY': 'test-api-key',
-                }),
-            }));
-            expect(result).toHaveLength(2);
-            expect(result[0].name).toBe('n8n-nodes-base.webhook');
-            expect(result[1].name).toBe('n8n-nodes-base.set');
-        });
-    });
-    describe('updateWorkflow', () => {
-        it('strips disallowed properties before sending to API', async () => {
-            const fullWorkflow = {
-                id: '123',
-                name: 'test_workflow',
-                active: true,
-                nodes: [{ id: 'n1', name: 'node1', type: 'test', typeVersion: 1, position: [0, 0], parameters: {} }],
-                connections: {},
-                settings: { timezone: 'UTC' },
-                createdAt: '2024-01-01T00:00:00.000Z',
-                updatedAt: '2024-01-02T00:00:00.000Z',
-                versionId: 'v1',
-                staticData: undefined,
-                tags: [{ id: 't1', name: 'tag1' }],
-            };
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                text: async () => JSON.stringify(fullWorkflow),
-            });
-            await client.updateWorkflow('123', fullWorkflow);
-            // Verify the request body does NOT contain disallowed properties
-            const putCall = mockFetch.mock.calls[0];
-            const putBody = JSON.parse(putCall[1].body);
-            // These should be stripped
-            expect(putBody.id).toBeUndefined();
-            expect(putBody.createdAt).toBeUndefined();
-            expect(putBody.updatedAt).toBeUndefined();
-            expect(putBody.active).toBeUndefined();
-            expect(putBody.versionId).toBeUndefined();
-            // These should be preserved
-            expect(putBody.name).toBe('test_workflow');
-            expect(putBody.nodes).toHaveLength(1);
-            expect(putBody.connections).toEqual({});
-            expect(putBody.settings).toEqual({ timezone: 'UTC' });
-            expect(putBody.staticData).toBeUndefined();
-            expect(putBody.tags).toEqual([{ id: 't1', name: 'tag1' }]);
-        });
-        it('works with partial workflow (only some fields)', async () => {
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                text: async () => JSON.stringify({ id: '123', name: 'updated' }),
-            });
-            await client.updateWorkflow('123', { name: 'updated', nodes: [] });
-            const putCall = mockFetch.mock.calls[0];
-            const putBody = JSON.parse(putCall[1].body);
-            expect(putBody.name).toBe('updated');
-            expect(putBody.nodes).toEqual([]);
-        });
-        it('handles workflow from formatWorkflow (simulating workflow_format apply)', async () => {
-            // This simulates the exact scenario that caused the bug:
-            // workflow_format returns a full N8nWorkflow object with id, createdAt, etc.
-            const formattedWorkflow = {
-                id: 'zbB1fCxWgZXgpjB1',
-                name: 'my_workflow',
-                active: false,
-                nodes: [],
-                connections: {},
-                createdAt: '2024-01-01T00:00:00.000Z',
-                updatedAt: '2024-01-02T00:00:00.000Z',
-            };
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                text: async () => JSON.stringify(formattedWorkflow),
-            });
-            // This should NOT throw "must NOT have additional properties"
-            await client.updateWorkflow('zbB1fCxWgZXgpjB1', formattedWorkflow);
-            const putCall = mockFetch.mock.calls[0];
-            const putBody = JSON.parse(putCall[1].body);
-            // Critical: these must NOT be in the request body
-            expect(putBody.id).toBeUndefined();
-            expect(putBody.createdAt).toBeUndefined();
-            expect(putBody.updatedAt).toBeUndefined();
-            expect(putBody.active).toBeUndefined();
-            // Only allowed properties should be sent
-            expect(Object.keys(putBody).sort()).toEqual(['connections', 'name', 'nodes']);
-        });
-    });
-});

package/dist/response-format.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/response-format.test.js

@@ -1,291 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { formatWorkflowResponse, formatExecutionResponse, formatExecutionListResponse, cleanResponse, stringifyResponse, } from './response-format.js';
-const createWorkflow = (overrides = {}) => ({
-    id: '1',
-    name: 'test_workflow',
-    active: false,
-    nodes: [
-        {
-            id: 'node1',
-            name: 'webhook_trigger',
-            type: 'n8n-nodes-base.webhook',
-            typeVersion: 1,
-            position: [0, 0],
-            parameters: { path: 'test', httpMethod: 'POST' },
-        },
-        {
-            id: 'node2',
-            name: 'set_data',
-            type: 'n8n-nodes-base.set',
-            typeVersion: 1,
-            position: [200, 0],
-            parameters: { values: { string: [{ name: 'key', value: 'value' }] } },
-            credentials: { httpBasicAuth: { id: '1', name: 'My Auth' } },
-        },
-    ],
-    connections: {
-        webhook_trigger: {
-            main: [[{ node: 'set_data', type: 'main', index: 0 }]],
-        },
-    },
-    createdAt: '2024-01-01T00:00:00.000Z',
-    updatedAt: '2024-01-02T00:00:00.000Z',
-    ...overrides,
-});
-const createExecution = (overrides = {}) => ({
-    id: 'exec1',
-    workflowId: '1',
-    finished: true,
-    mode: 'manual',
-    startedAt: '2024-01-01T00:00:00.000Z',
-    stoppedAt: '2024-01-01T00:00:05.000Z',
-    status: 'success',
-    data: {
-        resultData: {
-            runData: {
-                webhook_trigger: [{ data: { main: [[{ json: { test: 'data' } }]] } }],
-                set_data: [{ data: { main: [[{ json: { key: 'value' } }]] } }],
-            },
-        },
-    },
-    ...overrides,
-});
-describe('formatWorkflowResponse', () => {
-    describe('summary format', () => {
-        it('returns minimal workflow info', () => {
-            const workflow = createWorkflow();
-            const result = formatWorkflowResponse(workflow, 'summary');
-            expect(result.id).toBe('1');
-            expect(result.name).toBe('test_workflow');
-            expect(result.active).toBe(false);
-            expect(result.nodeCount).toBe(2);
-            expect(result.connectionCount).toBe(1);
-            expect(result.updatedAt).toBe('2024-01-02T00:00:00.000Z');
-            expect(result.nodeTypes).toContain('n8n-nodes-base.webhook');
-            expect(result.nodeTypes).toContain('n8n-nodes-base.set');
-            // Should not have full nodes or connections
-            expect(result.nodes).toBeUndefined();
-            expect(result.connections).toBeUndefined();
-        });
-    });
-    describe('compact format', () => {
-        it('returns nodes without parameters', () => {
-            const workflow = createWorkflow();
-            const result = formatWorkflowResponse(workflow, 'compact');
-            expect(result.id).toBe('1');
-            expect(result.name).toBe('test_workflow');
-            expect(result.nodes).toHaveLength(2);
-            // Nodes should have name, type, position but no parameters
-            expect(result.nodes[0].name).toBe('webhook_trigger');
-            expect(result.nodes[0].type).toBe('n8n-nodes-base.webhook');
-            expect(result.nodes[0].position).toEqual([0, 0]);
-            expect(result.nodes[0].hasCredentials).toBe(false);
-            expect(result.nodes[0].parameters).toBeUndefined();
-            // Second node has credentials
-            expect(result.nodes[1].hasCredentials).toBe(true);
-        });
-        it('simplifies connections to node -> [targets] map', () => {
-            const workflow = createWorkflow();
-            const result = formatWorkflowResponse(workflow, 'compact');
-            expect(result.connections).toEqual({
-                webhook_trigger: ['set_data'],
-            });
-        });
-        it('marks disabled nodes', () => {
-            const workflow = createWorkflow({
-                nodes: [
-                    {
-                        id: 'node1',
-                        name: 'disabled_node',
-                        type: 'n8n-nodes-base.set',
-                        typeVersion: 1,
-                        position: [0, 0],
-                        parameters: {},
-                        disabled: true,
-                    },
-                ],
-            });
-            const result = formatWorkflowResponse(workflow, 'compact');
-            expect(result.nodes[0].disabled).toBe(true);
-        });
-    });
-    describe('full format', () => {
-        it('returns complete workflow', () => {
-            const workflow = createWorkflow();
-            const result = formatWorkflowResponse(workflow, 'full');
-            expect(result).toEqual(workflow);
-            expect(result.nodes[0].parameters).toEqual({ path: 'test', httpMethod: 'POST' });
-        });
-    });
-    describe('default format', () => {
-        it('defaults to compact', () => {
-            const workflow = createWorkflow();
-            const result = formatWorkflowResponse(workflow);
-            // Should be compact (no parameters)
-            expect(result.nodes[0].parameters).toBeUndefined();
-        });
-    });
-});
-describe('formatExecutionResponse', () => {
-    describe('summary format', () => {
-        it('returns minimal execution info', () => {
-            const execution = createExecution();
-            const result = formatExecutionResponse(execution, 'summary');
-            expect(result.id).toBe('exec1');
-            expect(result.workflowId).toBe('1');
-            expect(result.status).toBe('success');
-            expect(result.mode).toBe('manual');
-            expect(result.durationMs).toBe(5000);
-            expect(result.hasError).toBe(false);
-            // Should not have runData
-            expect(result.data).toBeUndefined();
-        });
-        it('includes error message when present', () => {
-            const execution = createExecution({
-                status: 'error',
-                data: {
-                    resultData: {
-                        error: { message: 'Something went wrong' },
-                    },
-                },
-            });
-            const result = formatExecutionResponse(execution, 'summary');
-            expect(result.hasError).toBe(true);
-            expect(result.errorMessage).toBe('Something went wrong');
-        });
-    });
-    describe('compact format', () => {
-        it('returns execution without runData but with node summaries', () => {
-            const execution = createExecution();
-            const result = formatExecutionResponse(execution, 'compact');
-            expect(result.id).toBe('exec1');
-            expect(result.status).toBe('success');
-            expect(result.finished).toBe(true);
-            // Should have node result summaries
-            expect(result.nodeResults).toHaveLength(2);
-            expect(result.nodeResults[0].nodeName).toBe('webhook_trigger');
-            expect(result.nodeResults[0].itemCount).toBe(1);
-            // Should not have full runData
-            expect(result.data).toBeUndefined();
-        });
-        it('includes error in compact format', () => {
-            const execution = createExecution({
-                status: 'error',
-                data: {
-                    resultData: {
-                        error: { message: 'Failed' },
-                    },
-                },
-            });
-            const result = formatExecutionResponse(execution, 'compact');
-            expect(result.error).toEqual({ message: 'Failed' });
-        });
-    });
-    describe('full format', () => {
-        it('returns complete execution with runData', () => {
-            const execution = createExecution();
-            const result = formatExecutionResponse(execution, 'full');
-            expect(result).toEqual(execution);
-            expect(result.data?.resultData?.runData).toBeDefined();
-        });
-    });
-});
-describe('formatExecutionListResponse', () => {
-    const executions = [
-        { id: '1', workflowId: 'w1', status: 'success', startedAt: '2024-01-01', mode: 'manual' },
-        { id: '2', workflowId: 'w1', status: 'error', startedAt: '2024-01-02', mode: 'webhook' },
-    ];
-    it('summary returns id, status, startedAt only', () => {
-        const result = formatExecutionListResponse(executions, 'summary');
-        expect(result).toHaveLength(2);
-        expect(result[0]).toEqual({ id: '1', status: 'success', startedAt: '2024-01-01' });
-        expect(result[0].workflowId).toBeUndefined();
-        expect(result[0].mode).toBeUndefined();
-    });
-    it('compact and full return same as input', () => {
-        const compactResult = formatExecutionListResponse(executions, 'compact');
-        const fullResult = formatExecutionListResponse(executions, 'full');
-        expect(compactResult).toEqual(executions);
-        expect(fullResult).toEqual(executions);
-    });
-});
-describe('cleanResponse', () => {
-    it('removes null values', () => {
-        const obj = { a: 1, b: null, c: 'test' };
-        const result = cleanResponse(obj);
-        expect(result).toEqual({ a: 1, c: 'test' });
-    });
-    it('removes undefined values', () => {
-        const obj = { a: 1, b: undefined, c: 'test' };
-        const result = cleanResponse(obj);
-        expect(result).toEqual({ a: 1, c: 'test' });
-    });
-    it('removes empty objects', () => {
-        const obj = { a: 1, b: {}, c: 'test' };
-        const result = cleanResponse(obj);
-        expect(result).toEqual({ a: 1, c: 'test' });
-    });
-    it('removes empty arrays', () => {
-        const obj = { a: 1, b: [], c: 'test' };
-        const result = cleanResponse(obj);
-        expect(result).toEqual({ a: 1, c: 'test' });
-    });
-    it('handles nested objects', () => {
-        const obj = { a: { b: null, c: 1 }, d: { e: {} } };
-        const result = cleanResponse(obj);
-        expect(result).toEqual({ a: { c: 1 } });
-    });
-    it('handles arrays', () => {
-        const arr = [{ a: 1, b: null }, { c: 2 }];
-        const result = cleanResponse(arr);
-        expect(result).toEqual([{ a: 1 }, { c: 2 }]);
-    });
-});
-describe('stringifyResponse', () => {
-    it('minifies by default', () => {
-        const obj = { a: 1, b: 'test' };
-        const result = stringifyResponse(obj);
-        expect(result).toBe('{"a":1,"b":"test"}');
-        expect(result).not.toContain('\n');
-    });
-    it('can pretty print when minify=false', () => {
-        const obj = { a: 1 };
-        const result = stringifyResponse(obj, false);
-        expect(result).toContain('\n');
-    });
-    it('cleans null values before stringifying', () => {
-        const obj = { a: 1, b: null };
-        const result = stringifyResponse(obj);
-        expect(result).toBe('{"a":1}');
-    });
-});
-describe('token reduction estimates', () => {
-    it('compact format significantly reduces workflow size', () => {
-        const workflow = createWorkflow({
-            nodes: Array.from({ length: 10 }, (_, i) => ({
-                id: `node${i}`,
-                name: `node_${i}`,
-                type: 'n8n-nodes-base.set',
-                typeVersion: 1,
-                position: [i * 200, 0],
-                parameters: {
-                    values: {
-                        string: Array.from({ length: 10 }, (_, j) => ({
-                            name: `param_${j}`,
-                            value: `This is a long value that takes up tokens ${j}`,
-                        })),
-                    },
-                },
-            })),
-        });
-        const fullJson = JSON.stringify(workflow);
-        const compactJson = stringifyResponse(formatWorkflowResponse(workflow, 'compact'));
-        const summaryJson = stringifyResponse(formatWorkflowResponse(workflow, 'summary'));
-        // Compact should be significantly smaller than full
-        expect(compactJson.length).toBeLessThan(fullJson.length * 0.5);
-        // Summary should be smallest
-        expect(summaryJson.length).toBeLessThan(compactJson.length);
-        console.log(`Full: ${fullJson.length} chars, Compact: ${compactJson.length} chars, Summary: ${summaryJson.length} chars`);
-        console.log(`Reduction: ${Math.round((1 - compactJson.length / fullJson.length) * 100)}% (compact), ${Math.round((1 - summaryJson.length / fullJson.length) * 100)}% (summary)`);
-    });
-});

package/dist/validators.test.d.ts

@@ -1 +0,0 @@
-export {};