@masonator/coolify-mcp 0.2.16 → 0.2.18

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@masonator/coolify-mcp",
-  "version": "0.2.16",
+  "version": "0.2.18",
   "description": "Model Context Protocol server for Coolify",
   "type": "module",
-  "exports": "./dist/index.js",
-  "bin": "./dist/index.js",
+  "main": "./dist/index.js",
+  "bin": {
+    "coolify-mcp": "./dist/index.js"
+  },
   "files": [
     "dist"
   ],

package/dist/__tests__/coolify-client.test.d.ts

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

package/dist/__tests__/coolify-client.test.js

@@ -1,208 +0,0 @@
-import { jest } from '@jest/globals';
-import { CoolifyClient } from '../lib/coolify-client.js';
-const mockFetch = jest.fn();
-describe('CoolifyClient', () => {
-    let client;
-    const mockServers = [
-        {
-            id: 1,
-            uuid: 'test-uuid',
-            name: 'test-server',
-            status: 'running',
-        },
-    ];
-    const mockServerInfo = {
-        id: 1,
-        uuid: 'test-uuid',
-        name: 'test-server',
-        status: 'running',
-    };
-    const mockServerResources = {
-        resources: [
-            {
-                name: 'memory',
-                value: '2GB',
-            },
-            {
-                name: 'disk',
-                value: '20GB',
-            },
-        ],
-    };
-    const mockService = {
-        id: 1,
-        uuid: 'test-uuid',
-        name: 'test-service',
-        type: 'code-server',
-        status: 'running',
-        created_at: '2024-01-01',
-        updated_at: '2024-01-01',
-    };
-    const errorResponse = {
-        message: 'Resource not found',
-    };
-    beforeEach(() => {
-        mockFetch.mockClear();
-        global.fetch = mockFetch;
-        client = new CoolifyClient({
-            baseUrl: 'http://localhost:3000',
-            accessToken: 'test-api-key',
-        });
-    });
-    describe('listServers', () => {
-        it('should return a list of servers', async () => {
-            mockFetch.mockImplementationOnce(async () => ({
-                ok: true,
-                json: async () => mockServers,
-            }));
-            const servers = await client.listServers();
-            expect(servers).toEqual(mockServers);
-            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/servers', {
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: 'Bearer test-api-key',
-                },
-            });
-        });
-        it('should handle errors', async () => {
-            mockFetch.mockImplementationOnce(() => Promise.resolve({
-                ok: false,
-                json: async () => errorResponse,
-            }));
-            await expect(client.listServers()).rejects.toThrow('Resource not found');
-        });
-    });
-    describe('getServer', () => {
-        it('should get server info', async () => {
-            mockFetch.mockImplementationOnce(() => Promise.resolve({
-                ok: true,
-                json: async () => mockServerInfo,
-            }));
-            const result = await client.getServer('test-uuid');
-            expect(result).toEqual(mockServerInfo);
-            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/servers/test-uuid', {
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: 'Bearer test-api-key',
-                },
-            });
-        });
-        it('should handle errors', async () => {
-            mockFetch.mockImplementationOnce(() => Promise.resolve({
-                ok: false,
-                json: async () => errorResponse,
-            }));
-            await expect(client.getServer('test-uuid')).rejects.toThrow('Resource not found');
-        });
-    });
-    describe('getServerResources', () => {
-        it('should get server resources', async () => {
-            mockFetch.mockImplementationOnce(() => Promise.resolve({
-                ok: true,
-                json: async () => mockServerResources,
-            }));
-            const result = await client.getServerResources('test-uuid');
-            expect(result).toEqual(mockServerResources);
-            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/servers/test-uuid/resources', {
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: 'Bearer test-api-key',
-                },
-            });
-        });
-        it('should handle errors', async () => {
-            mockFetch.mockImplementationOnce(() => Promise.resolve({
-                ok: false,
-                json: async () => errorResponse,
-            }));
-            await expect(client.getServerResources('test-uuid')).rejects.toThrow('Resource not found');
-        });
-    });
-    describe('listServices', () => {
-        it('should list services', async () => {
-            mockFetch.mockImplementationOnce(() => Promise.resolve({
-                ok: true,
-                json: () => Promise.resolve([mockService]),
-            }));
-            const result = await client.listServices();
-            expect(result).toEqual([mockService]);
-            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/services', {
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: 'Bearer test-api-key',
-                },
-            });
-        });
-    });
-    describe('getService', () => {
-        it('should get service info', async () => {
-            mockFetch.mockImplementationOnce(() => Promise.resolve({
-                ok: true,
-                json: () => Promise.resolve(mockService),
-            }));
-            const result = await client.getService('test-uuid');
-            expect(result).toEqual(mockService);
-            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/services/test-uuid', {
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: 'Bearer test-api-key',
-                },
-            });
-        });
-    });
-    describe('createService', () => {
-        it('should create a service', async () => {
-            mockFetch.mockImplementationOnce(() => Promise.resolve({
-                ok: true,
-                json: () => Promise.resolve({
-                    uuid: 'test-uuid',
-                    domains: ['test.com'],
-                }),
-            }));
-            const createData = {
-                name: 'test-service',
-                type: 'code-server',
-                project_uuid: 'project-uuid',
-                environment_uuid: 'env-uuid',
-                server_uuid: 'server-uuid',
-            };
-            const result = await client.createService(createData);
-            expect(result).toEqual({
-                uuid: 'test-uuid',
-                domains: ['test.com'],
-            });
-            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/services', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: 'Bearer test-api-key',
-                },
-                body: JSON.stringify(createData),
-            });
-        });
-    });
-    describe('deleteService', () => {
-        it('should delete a service', async () => {
-            mockFetch.mockImplementationOnce(() => Promise.resolve({
-                ok: true,
-                json: () => Promise.resolve({ message: 'Service deleted' }),
-            }));
-            const result = await client.deleteService('test-uuid');
-            expect(result).toEqual({ message: 'Service deleted' });
-            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/services/test-uuid', {
-                method: 'DELETE',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: 'Bearer test-api-key',
-                },
-            });
-        });
-    });
-    describe('error handling', () => {
-        it('should handle network errors', async () => {
-            const errorMessage = 'Network error';
-            mockFetch.mockImplementationOnce(() => Promise.reject(new Error(errorMessage)));
-            await expect(client.listServers()).rejects.toThrow(errorMessage);
-        });
-    });
-});

package/dist/__tests__/mcp-server.test.d.ts

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

package/dist/__tests__/mcp-server.test.js

@@ -1,282 +0,0 @@
-import { CoolifyMcpServer } from '../lib/mcp-server.js';
-import { jest } from '@jest/globals';
-describe('CoolifyMcpServer', () => {
-    const mockConfig = {
-        baseUrl: 'https://coolify.test',
-        accessToken: 'test-token',
-    };
-    let server;
-    beforeEach(() => {
-        server = new CoolifyMcpServer(mockConfig);
-        // Mock validateConnection to prevent actual HTTP calls
-        jest.spyOn(server['client'], 'validateConnection').mockResolvedValue();
-    });
-    describe('get_server_resources', () => {
-        it('should call client getServerResources', async () => {
-            // Mock the method before calling it
-            const mockResources = [
-                {
-                    id: 1,
-                    uuid: 'test-resource-uuid',
-                    name: 'test-resource',
-                    type: 'application',
-                    created_at: '2024-03-20T00:00:00Z',
-                    updated_at: '2024-03-20T00:00:00Z',
-                    status: 'running',
-                },
-            ];
-            const spy = jest
-                .spyOn(server['client'], 'getServerResources')
-                .mockResolvedValue(mockResources);
-            await server.get_server_resources('test-uuid');
-            expect(spy).toHaveBeenCalledWith('test-uuid');
-        });
-    });
-    describe('validate_server', () => {
-        it('should call client validateServer', async () => {
-            // Mock the method before calling it
-            const mockValidation = {
-                message: 'Server is valid',
-            };
-            const spy = jest.spyOn(server['client'], 'validateServer').mockResolvedValue(mockValidation);
-            await server.validate_server('test-uuid');
-            expect(spy).toHaveBeenCalledWith('test-uuid');
-        });
-    });
-    describe('list_projects', () => {
-        it('should call client listProjects', async () => {
-            const mockProjects = [
-                {
-                    id: 1,
-                    uuid: 'test-project-uuid',
-                    name: 'test-project',
-                    description: 'Test project description',
-                    environments: [],
-                },
-            ];
-            const spy = jest.spyOn(server['client'], 'listProjects').mockResolvedValue(mockProjects);
-            await server.list_projects();
-            expect(spy).toHaveBeenCalled();
-        });
-    });
-    describe('get_project', () => {
-        it('should call client getProject', async () => {
-            const mockProject = {
-                id: 1,
-                uuid: 'test-project-uuid',
-                name: 'test-project',
-                description: 'Test project description',
-                environments: [],
-            };
-            const spy = jest.spyOn(server['client'], 'getProject').mockResolvedValue(mockProject);
-            await server.get_project('test-project-uuid');
-            expect(spy).toHaveBeenCalledWith('test-project-uuid');
-        });
-    });
-    describe('create_project', () => {
-        it('should call client createProject', async () => {
-            const mockResponse = { uuid: 'new-project-uuid' };
-            const createRequest = {
-                name: 'New Project',
-                description: 'New project description',
-            };
-            const spy = jest.spyOn(server['client'], 'createProject').mockResolvedValue(mockResponse);
-            await server.create_project(createRequest);
-            expect(spy).toHaveBeenCalledWith(createRequest);
-        });
-    });
-    describe('update_project', () => {
-        it('should call client updateProject', async () => {
-            const mockProject = {
-                id: 1,
-                uuid: 'test-project-uuid',
-                name: 'Updated Project',
-                description: 'Updated description',
-                environments: [],
-            };
-            const updateRequest = {
-                name: 'Updated Project',
-                description: 'Updated description',
-            };
-            const spy = jest.spyOn(server['client'], 'updateProject').mockResolvedValue(mockProject);
-            await server.update_project('test-project-uuid', updateRequest);
-            expect(spy).toHaveBeenCalledWith('test-project-uuid', updateRequest);
-        });
-    });
-    describe('delete_project', () => {
-        it('should call client deleteProject', async () => {
-            const mockResponse = { message: 'Project deleted successfully' };
-            const spy = jest.spyOn(server['client'], 'deleteProject').mockResolvedValue(mockResponse);
-            await server.delete_project('test-project-uuid');
-            expect(spy).toHaveBeenCalledWith('test-project-uuid');
-        });
-    });
-    describe('get_project_environment', () => {
-        it('should call client getProjectEnvironment', async () => {
-            const mockEnvironment = {
-                id: 1,
-                uuid: 'test-env-uuid',
-                name: 'test-env',
-                project_uuid: 'test-project-uuid',
-                variables: { KEY: 'value' },
-                created_at: '2024-03-06T12:00:00Z',
-                updated_at: '2024-03-06T12:00:00Z',
-            };
-            const spy = jest
-                .spyOn(server['client'], 'getProjectEnvironment')
-                .mockResolvedValue(mockEnvironment);
-            await server.get_project_environment('test-project-uuid', 'test-env-uuid');
-            expect(spy).toHaveBeenCalledWith('test-project-uuid', 'test-env-uuid');
-        });
-    });
-    describe('deploy_application', () => {
-        it('should deploy an application', async () => {
-            const mockDeployment = {
-                id: 1,
-                uuid: 'test-deployment-uuid',
-                application_uuid: 'test-app-uuid',
-                status: 'running',
-                created_at: '2024-03-20T12:00:00Z',
-                updated_at: '2024-03-20T12:00:00Z',
-            };
-            jest.spyOn(server['client'], 'deployApplication').mockResolvedValue(mockDeployment);
-            const result = await server.deploy_application({ uuid: 'test-app-uuid' });
-            expect(result).toEqual(mockDeployment);
-            expect(server['client'].deployApplication).toHaveBeenCalledWith('test-app-uuid');
-        });
-        it('should handle errors when deploying an application', async () => {
-            const error = new Error('Failed to deploy application');
-            jest.spyOn(server['client'], 'deployApplication').mockRejectedValue(error);
-            await expect(server.deploy_application({ uuid: 'test-app-uuid' })).rejects.toThrow('Failed to deploy application');
-        });
-    });
-    describe('Database Management', () => {
-        const mockDatabase = {
-            id: 1,
-            uuid: 'test-db-uuid',
-            name: 'test-db',
-            description: 'Test database',
-            type: 'postgresql',
-            status: 'running',
-            created_at: '2024-03-06T12:00:00Z',
-            updated_at: '2024-03-06T12:00:00Z',
-            is_public: false,
-            image: 'postgres:latest',
-            postgres_user: 'postgres',
-            postgres_password: 'test123',
-            postgres_db: 'testdb',
-        };
-        it('should list databases', async () => {
-            const spy = jest.spyOn(server['client'], 'listDatabases').mockResolvedValue([mockDatabase]);
-            const result = await server.list_databases();
-            expect(result).toEqual([mockDatabase]);
-            expect(spy).toHaveBeenCalled();
-        });
-        it('should get database details', async () => {
-            const spy = jest.spyOn(server['client'], 'getDatabase').mockResolvedValue(mockDatabase);
-            const result = await server.get_database('test-db-uuid');
-            expect(result).toEqual(mockDatabase);
-            expect(spy).toHaveBeenCalledWith('test-db-uuid');
-        });
-        it('should update database', async () => {
-            const updateData = {
-                name: 'updated-db',
-                description: 'Updated description',
-            };
-            const spy = jest
-                .spyOn(server['client'], 'updateDatabase')
-                .mockResolvedValue({ ...mockDatabase, ...updateData, type: 'postgresql' });
-            const result = await server.update_database('test-db-uuid', updateData);
-            expect(result).toEqual({
-                ...mockDatabase,
-                ...updateData,
-                type: 'postgresql',
-            });
-            expect(spy).toHaveBeenCalledWith('test-db-uuid', updateData);
-        });
-        it('should delete database', async () => {
-            const mockResponse = { message: 'Database deleted' };
-            const spy = jest.spyOn(server['client'], 'deleteDatabase').mockResolvedValue(mockResponse);
-            const result = await server.delete_database('test-db-uuid', {
-                deleteConfigurations: true,
-                deleteVolumes: true,
-            });
-            expect(result).toEqual(mockResponse);
-            expect(spy).toHaveBeenCalledWith('test-db-uuid', {
-                deleteConfigurations: true,
-                deleteVolumes: true,
-            });
-        });
-        it('should handle database errors', async () => {
-            const errorMessage = 'Database not found';
-            jest.spyOn(server['client'], 'getDatabase').mockRejectedValue(new Error(errorMessage));
-            await expect(server.get_database('invalid-uuid')).rejects.toThrow(errorMessage);
-        });
-    });
-    describe('Service Management', () => {
-        const mockService = {
-            id: 1,
-            uuid: 'test-service-uuid',
-            name: 'test-service',
-            description: 'Test service',
-            type: 'code-server',
-            status: 'running',
-            created_at: '2024-03-06T12:00:00Z',
-            updated_at: '2024-03-06T12:00:00Z',
-            project_uuid: 'test-project-uuid',
-            environment_name: 'production',
-            environment_uuid: 'test-env-uuid',
-            server_uuid: 'test-server-uuid',
-            domains: ['test-service.example.com'],
-        };
-        it('should list services', async () => {
-            const spy = jest.spyOn(server['client'], 'listServices').mockResolvedValue([mockService]);
-            const result = await server.list_services();
-            expect(result).toEqual([mockService]);
-            expect(spy).toHaveBeenCalled();
-        });
-        it('should get service details', async () => {
-            const spy = jest.spyOn(server['client'], 'getService').mockResolvedValue(mockService);
-            const result = await server.get_service('test-service-uuid');
-            expect(result).toEqual(mockService);
-            expect(spy).toHaveBeenCalledWith('test-service-uuid');
-        });
-        it('should create service', async () => {
-            const createData = {
-                type: 'code-server',
-                name: 'test-service',
-                description: 'Test service',
-                project_uuid: 'test-project-uuid',
-                environment_name: 'production',
-                server_uuid: 'test-server-uuid',
-                instant_deploy: true,
-            };
-            const mockResponse = {
-                uuid: 'test-service-uuid',
-                domains: ['test-service.example.com'],
-            };
-            const spy = jest.spyOn(server['client'], 'createService').mockResolvedValue(mockResponse);
-            const result = await server.create_service(createData);
-            expect(result).toEqual(mockResponse);
-            expect(spy).toHaveBeenCalledWith(createData);
-        });
-        it('should delete service', async () => {
-            const mockResponse = { message: 'Service deleted' };
-            const spy = jest.spyOn(server['client'], 'deleteService').mockResolvedValue(mockResponse);
-            const result = await server.delete_service('test-service-uuid', {
-                deleteConfigurations: true,
-                deleteVolumes: true,
-            });
-            expect(result).toEqual(mockResponse);
-            expect(spy).toHaveBeenCalledWith('test-service-uuid', {
-                deleteConfigurations: true,
-                deleteVolumes: true,
-            });
-        });
-        it('should handle service errors', async () => {
-            const errorMessage = 'Service not found';
-            jest.spyOn(server['client'], 'getService').mockRejectedValue(new Error(errorMessage));
-            await expect(server.get_service('invalid-uuid')).rejects.toThrow(errorMessage);
-        });
-    });
-});

package/dist/__tests__/resources/application-resources.test.d.ts

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

package/dist/__tests__/resources/application-resources.test.js

@@ -1,33 +0,0 @@
-import { ApplicationResources } from '../../resources/application-resources.js';
-import { jest } from '@jest/globals';
-jest.mock('../../lib/coolify-client.js');
-describe('ApplicationResources', () => {
-    let resources;
-    let mockClient;
-    beforeEach(() => {
-        mockClient = {
-            deployApplication: jest.fn(),
-        };
-        resources = new ApplicationResources(mockClient);
-    });
-    describe('listApplications', () => {
-        it('should throw not implemented error', async () => {
-            await expect(resources.listApplications()).rejects.toThrow('Not implemented');
-        });
-    });
-    describe('getApplication', () => {
-        it('should throw not implemented error', async () => {
-            await expect(resources.getApplication('test-id')).rejects.toThrow('Not implemented');
-        });
-    });
-    describe('createApplication', () => {
-        it('should throw not implemented error', async () => {
-            await expect(resources.createApplication({ name: 'test-app' })).rejects.toThrow('Not implemented');
-        });
-    });
-    describe('deleteApplication', () => {
-        it('should throw not implemented error', async () => {
-            await expect(resources.deleteApplication('test-id')).rejects.toThrow('Not implemented');
-        });
-    });
-});

package/dist/__tests__/resources/database-resources.test.d.ts

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

package/dist/__tests__/resources/database-resources.test.js

@@ -1,68 +0,0 @@
-import { DatabaseResources } from '../../resources/database-resources.js';
-import { jest } from '@jest/globals';
-jest.mock('../../lib/coolify-client.js');
-describe('DatabaseResources', () => {
-    let mockClient;
-    let resources;
-    const mockDatabase = {
-        id: 1,
-        uuid: 'test-uuid',
-        name: 'test-db',
-        description: 'test description',
-        type: 'postgresql',
-        status: 'running',
-        created_at: '2024-01-01',
-        updated_at: '2024-01-01',
-        is_public: false,
-        image: 'postgres:latest',
-        postgres_user: 'test',
-        postgres_password: 'test',
-        postgres_db: 'test',
-    };
-    beforeEach(() => {
-        mockClient = {
-            listDatabases: jest.fn(),
-            getDatabase: jest.fn(),
-            updateDatabase: jest.fn(),
-            deleteDatabase: jest.fn(),
-        };
-        resources = new DatabaseResources(mockClient);
-    });
-    describe('listDatabases', () => {
-        it('should return a list of databases', async () => {
-            mockClient.listDatabases.mockResolvedValue([mockDatabase]);
-            const result = await resources.listDatabases();
-            expect(result).toEqual([mockDatabase]);
-            expect(mockClient.listDatabases).toHaveBeenCalled();
-        });
-    });
-    describe('getDatabase', () => {
-        it('should return a database by uuid', async () => {
-            mockClient.getDatabase.mockResolvedValue(mockDatabase);
-            const result = await resources.getDatabase('test-uuid');
-            expect(result).toEqual(mockDatabase);
-            expect(mockClient.getDatabase).toHaveBeenCalledWith('test-uuid');
-        });
-    });
-    describe('updateDatabase', () => {
-        it('should update a database', async () => {
-            const updateData = {
-                name: 'updated-db',
-                description: 'updated description',
-            };
-            mockClient.updateDatabase.mockResolvedValue({ ...mockDatabase, ...updateData });
-            const result = await resources.updateDatabase('test-uuid', updateData);
-            expect(result).toEqual({ ...mockDatabase, ...updateData });
-            expect(mockClient.updateDatabase).toHaveBeenCalledWith('test-uuid', updateData);
-        });
-    });
-    describe('deleteDatabase', () => {
-        it('should delete a database', async () => {
-            const mockResponse = { message: 'Database deleted successfully' };
-            mockClient.deleteDatabase.mockResolvedValue(mockResponse);
-            const result = await resources.deleteDatabase('test-uuid', {});
-            expect(result).toEqual(mockResponse);
-            expect(mockClient.deleteDatabase).toHaveBeenCalledWith('test-uuid', {});
-        });
-    });
-});

package/dist/__tests__/resources/deployment-resources.test.d.ts

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

package/dist/__tests__/resources/deployment-resources.test.js

@@ -1,46 +0,0 @@
-import { DeploymentResources } from '../../resources/deployment-resources.js';
-import { jest } from '@jest/globals';
-jest.mock('../../lib/coolify-client.js');
-describe('DeploymentResources', () => {
-    let mockClient;
-    let resources;
-    const mockDeployment = {
-        id: 1,
-        uuid: 'test-uuid',
-        status: 'running',
-        created_at: '2024-01-01',
-        updated_at: '2024-01-01',
-        application_uuid: 'app-uuid',
-        environment_uuid: 'env-uuid',
-    };
-    beforeEach(() => {
-        mockClient = {
-            deployApplication: jest.fn(),
-        };
-        resources = new DeploymentResources(mockClient);
-    });
-    describe('listDeployments', () => {
-        it('should throw not implemented error', async () => {
-            await expect(resources.listDeployments()).rejects.toThrow('Not implemented');
-        });
-    });
-    describe('getDeployment', () => {
-        it('should throw not implemented error', async () => {
-            await expect(resources.getDeployment('test-id')).rejects.toThrow('Not implemented');
-        });
-    });
-    describe('deploy', () => {
-        it('should deploy an application', async () => {
-            mockClient.deployApplication.mockResolvedValue(mockDeployment);
-            const result = await resources.deploy({ uuid: 'test-uuid' });
-            expect(result).toEqual(mockDeployment);
-            expect(mockClient.deployApplication).toHaveBeenCalledWith('test-uuid');
-        });
-        it('should handle deployment errors', async () => {
-            const error = new Error('Deployment failed');
-            mockClient.deployApplication.mockRejectedValue(error);
-            await expect(resources.deploy({ uuid: 'test-uuid' })).rejects.toThrow('Deployment failed');
-            expect(mockClient.deployApplication).toHaveBeenCalledWith('test-uuid');
-        });
-    });
-});

package/dist/__tests__/resources/service-resources.test.d.ts

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