@masonator/coolify-mcp 0.1.0

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

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_server_js_1 = require("../lib/mcp-server.js");
+const globals_1 = require("@jest/globals");
+describe('CoolifyMcpServer', () => {
+    const mockConfig = {
+        baseUrl: 'https://coolify.test',
+        accessToken: 'test-token',
+    };
+    let server;
+    beforeEach(() => {
+        server = new mcp_server_js_1.CoolifyMcpServer(mockConfig);
+        // Mock validateConnection to prevent actual HTTP calls
+        globals_1.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 = globals_1.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 = globals_1.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 = globals_1.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 = globals_1.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 = globals_1.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 = globals_1.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 = globals_1.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-environment',
+                project_uuid: 'test-project-uuid',
+                created_at: '2024-03-19T12:00:00Z',
+                updated_at: '2024-03-19T12:00:00Z',
+            };
+            const spy = globals_1.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('Environment Management', () => {
+        const mockEnvironment = {
+            id: 1,
+            uuid: 'test-env-uuid',
+            name: 'test-environment',
+            project_uuid: 'test-project-uuid',
+            variables: { KEY: 'value' },
+            created_at: '2024-03-19T12:00:00Z',
+            updated_at: '2024-03-19T12:00:00Z',
+        };
+        describe('list_environments', () => {
+            it('should call client listEnvironments without project UUID', async () => {
+                const spy = globals_1.jest
+                    .spyOn(server['client'], 'listEnvironments')
+                    .mockResolvedValue([mockEnvironment]);
+                await server.list_environments({});
+                expect(spy).toHaveBeenCalledWith(undefined);
+            });
+            it('should call client listEnvironments with project UUID', async () => {
+                const spy = globals_1.jest
+                    .spyOn(server['client'], 'listEnvironments')
+                    .mockResolvedValue([mockEnvironment]);
+                await server.list_environments({ project_uuid: 'test-project-uuid' });
+                expect(spy).toHaveBeenCalledWith('test-project-uuid');
+            });
+        });
+        describe('get_environment', () => {
+            it('should call client getEnvironment', async () => {
+                const spy = globals_1.jest
+                    .spyOn(server['client'], 'getEnvironment')
+                    .mockResolvedValue(mockEnvironment);
+                await server.get_environment({ uuid: 'test-env-uuid' });
+                expect(spy).toHaveBeenCalledWith('test-env-uuid');
+            });
+        });
+        describe('create_environment', () => {
+            it('should call client createEnvironment', async () => {
+                const createRequest = {
+                    name: 'test-environment',
+                    project_uuid: 'test-project-uuid',
+                    variables: { KEY: 'value' },
+                };
+                const mockResponse = { uuid: 'test-env-uuid' };
+                const spy = globals_1.jest
+                    .spyOn(server['client'], 'createEnvironment')
+                    .mockResolvedValue(mockResponse);
+                await server.create_environment(createRequest);
+                expect(spy).toHaveBeenCalledWith(createRequest);
+            });
+        });
+        describe('update_environment_variables', () => {
+            it('should call client updateEnvironmentVariables', async () => {
+                const updateRequest = {
+                    variables: { NEW_KEY: 'new-value' },
+                };
+                const spy = globals_1.jest
+                    .spyOn(server['client'], 'updateEnvironmentVariables')
+                    .mockResolvedValue({ ...mockEnvironment, variables: updateRequest.variables });
+                await server.update_environment_variables({
+                    uuid: 'test-env-uuid',
+                    variables: updateRequest.variables,
+                });
+                expect(spy).toHaveBeenCalledWith('test-env-uuid', updateRequest);
+            });
+        });
+        describe('delete_environment', () => {
+            it('should call client deleteEnvironment', async () => {
+                const mockResponse = { message: 'Environment deleted successfully' };
+                const spy = globals_1.jest
+                    .spyOn(server['client'], 'deleteEnvironment')
+                    .mockResolvedValue(mockResponse);
+                await server.delete_environment({ uuid: 'test-env-uuid' });
+                expect(spy).toHaveBeenCalledWith('test-env-uuid');
+            });
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const mcp_server_js_1 = require("./lib/mcp-server.js");
+async function main() {
+    const config = {
+        baseUrl: process.env.COOLIFY_BASE_URL || 'http://localhost:3000',
+        accessToken: process.env.COOLIFY_ACCESS_TOKEN || '',
+    };
+    if (!config.accessToken) {
+        throw new Error('COOLIFY_ACCESS_TOKEN environment variable is required');
+    }
+    const server = new mcp_server_js_1.CoolifyMcpServer(config);
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.start(transport);
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/lib/coolify-client.d.ts

@@ -0,0 +1,32 @@
+import { CoolifyConfig, ServerInfo, ServerResources, ServerDomain, ValidationResponse, Project, CreateProjectRequest, UpdateProjectRequest, Environment, CreateEnvironmentRequest, UpdateEnvironmentVariablesRequest } from '../types/coolify.js';
+export declare class CoolifyClient {
+    private baseUrl;
+    private accessToken;
+    constructor(config: CoolifyConfig);
+    private request;
+    listServers(): Promise<ServerInfo[]>;
+    getServer(uuid: string): Promise<ServerInfo>;
+    getServerResources(uuid: string): Promise<ServerResources>;
+    getServerDomains(uuid: string): Promise<ServerDomain[]>;
+    validateServer(uuid: string): Promise<ValidationResponse>;
+    validateConnection(): Promise<void>;
+    listProjects(): Promise<Project[]>;
+    getProject(uuid: string): Promise<Project>;
+    createProject(project: CreateProjectRequest): Promise<{
+        uuid: string;
+    }>;
+    updateProject(uuid: string, project: UpdateProjectRequest): Promise<Project>;
+    deleteProject(uuid: string): Promise<{
+        message: string;
+    }>;
+    getProjectEnvironment(projectUuid: string, environmentNameOrUuid: string): Promise<Environment>;
+    listEnvironments(projectUuid?: string): Promise<Environment[]>;
+    getEnvironment(uuid: string): Promise<Environment>;
+    createEnvironment(environment: CreateEnvironmentRequest): Promise<{
+        uuid: string;
+    }>;
+    deleteEnvironment(uuid: string): Promise<{
+        message: string;
+    }>;
+    updateEnvironmentVariables(uuid: string, variables: UpdateEnvironmentVariablesRequest): Promise<Environment>;
+}

package/dist/lib/coolify-client.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoolifyClient = void 0;
+class CoolifyClient {
+    constructor(config) {
+        if (!config.baseUrl) {
+            throw new Error('Coolify base URL is required');
+        }
+        if (!config.accessToken) {
+            throw new Error('Coolify access token is required');
+        }
+        this.baseUrl = config.baseUrl.replace(/\/$/, '');
+        this.accessToken = config.accessToken;
+    }
+    async request(path, options = {}) {
+        try {
+            const url = `${this.baseUrl}/api/v1${path}`;
+            const response = await fetch(url, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.accessToken}`,
+                },
+                ...options,
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                const error = data;
+                throw new Error(error.message || `HTTP ${response.status}: ${response.statusText}`);
+            }
+            return data;
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message.includes('fetch')) {
+                throw new Error(`Failed to connect to Coolify server at ${this.baseUrl}. Please check if the server is running and the URL is correct.`);
+            }
+            throw error;
+        }
+    }
+    async listServers() {
+        return this.request('/servers');
+    }
+    async getServer(uuid) {
+        return this.request(`/servers/${uuid}`);
+    }
+    async getServerResources(uuid) {
+        return this.request(`/servers/${uuid}/resources`);
+    }
+    async getServerDomains(uuid) {
+        return this.request(`/servers/${uuid}/domains`);
+    }
+    async validateServer(uuid) {
+        return this.request(`/servers/${uuid}/validate`);
+    }
+    async validateConnection() {
+        try {
+            await this.listServers();
+        }
+        catch (error) {
+            throw new Error(`Failed to connect to Coolify server: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async listProjects() {
+        return this.request('/projects');
+    }
+    async getProject(uuid) {
+        return this.request(`/projects/${uuid}`);
+    }
+    async createProject(project) {
+        return this.request('/projects', {
+            method: 'POST',
+            body: JSON.stringify(project),
+        });
+    }
+    async updateProject(uuid, project) {
+        return this.request(`/projects/${uuid}`, {
+            method: 'PATCH',
+            body: JSON.stringify(project),
+        });
+    }
+    async deleteProject(uuid) {
+        return this.request(`/projects/${uuid}`, {
+            method: 'DELETE',
+        });
+    }
+    async getProjectEnvironment(projectUuid, environmentNameOrUuid) {
+        return this.request(`/projects/${projectUuid}/${environmentNameOrUuid}`);
+    }
+    async listEnvironments(projectUuid) {
+        const path = projectUuid ? `/environments?project_uuid=${projectUuid}` : '/environments';
+        return this.request(path);
+    }
+    async getEnvironment(uuid) {
+        return this.request(`/environments/${uuid}`);
+    }
+    async createEnvironment(environment) {
+        return this.request('/environments', {
+            method: 'POST',
+            body: JSON.stringify(environment),
+        });
+    }
+    async deleteEnvironment(uuid) {
+        return this.request(`/environments/${uuid}`, {
+            method: 'DELETE',
+        });
+    }
+    async updateEnvironmentVariables(uuid, variables) {
+        return this.request(`/environments/${uuid}/variables`, {
+            method: 'PUT',
+            body: JSON.stringify(variables),
+        });
+    }
+}
+exports.CoolifyClient = CoolifyClient;

package/dist/lib/mcp-server.d.ts

@@ -0,0 +1,42 @@
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { CoolifyConfig, ServerInfo, ServerResources, ServerDomain, ValidationResponse, Project, CreateProjectRequest, UpdateProjectRequest, Environment, CreateEnvironmentRequest } from '../types/coolify.js';
+export declare class CoolifyMcpServer {
+    private server;
+    private client;
+    constructor(config: CoolifyConfig);
+    private setupTools;
+    start(transport: Transport): Promise<void>;
+    list_servers(): Promise<ServerInfo[]>;
+    get_server(uuid: string): Promise<ServerInfo>;
+    get_server_resources(uuid: string): Promise<ServerResources>;
+    get_server_domains(uuid: string): Promise<ServerDomain[]>;
+    validate_server(uuid: string): Promise<ValidationResponse>;
+    list_projects(): Promise<Project[]>;
+    get_project(uuid: string): Promise<Project>;
+    create_project(project: CreateProjectRequest): Promise<{
+        uuid: string;
+    }>;
+    update_project(uuid: string, project: UpdateProjectRequest): Promise<Project>;
+    delete_project(uuid: string): Promise<{
+        message: string;
+    }>;
+    get_project_environment(projectUuid: string, environmentNameOrUuid: string): Promise<Environment>;
+    list_environments(params: {
+        project_uuid?: string;
+    }): Promise<Environment[]>;
+    get_environment(params: {
+        uuid: string;
+    }): Promise<Environment>;
+    create_environment(params: CreateEnvironmentRequest): Promise<{
+        uuid: string;
+    }>;
+    update_environment_variables(params: {
+        uuid: string;
+        variables: Record<string, string>;
+    }): Promise<Environment>;
+    delete_environment(params: {
+        uuid: string;
+    }): Promise<{
+        message: string;
+    }>;
+}