@masonator/coolify-mcp 0.1.0 → 0.1.2

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

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

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const database_resources_js_1 = require("../../resources/database-resources.js");
+const coolify_client_js_1 = require("../../lib/coolify-client.js");
+jest.mock('../../lib/coolify-client.js');
+describe('DatabaseResources', () => {
+    let resources;
+    let mockClient;
+    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',
+    };
+    beforeEach(() => {
+        mockClient = new coolify_client_js_1.CoolifyClient({
+            baseUrl: 'http://test.coolify.io',
+            accessToken: 'test-token',
+        });
+        resources = new database_resources_js_1.DatabaseResources(mockClient);
+    });
+    describe('listDatabases', () => {
+        it('should return a list of databases', async () => {
+            mockClient.listDatabases = jest.fn().mockResolvedValue([mockDatabase]);
+            const result = await resources.listDatabases();
+            expect(result).toEqual([mockDatabase]);
+            expect(mockClient.listDatabases).toHaveBeenCalled();
+        });
+    });
+    describe('getDatabase', () => {
+        it('should return a specific database', async () => {
+            mockClient.getDatabase = jest.fn().mockResolvedValue(mockDatabase);
+            const result = await resources.getDatabase('test-db-uuid');
+            expect(result).toEqual(mockDatabase);
+            expect(mockClient.getDatabase).toHaveBeenCalledWith('test-db-uuid');
+        });
+    });
+    describe('updateDatabase', () => {
+        it('should update a database', async () => {
+            const updateData = {
+                name: 'updated-db',
+                description: 'Updated description',
+            };
+            mockClient.updateDatabase = jest.fn().mockResolvedValue({ ...mockDatabase, ...updateData });
+            const result = await resources.updateDatabase('test-db-uuid', updateData);
+            expect(result).toEqual({ ...mockDatabase, ...updateData });
+            expect(mockClient.updateDatabase).toHaveBeenCalledWith('test-db-uuid', updateData);
+        });
+    });
+    describe('deleteDatabase', () => {
+        it('should delete a database', async () => {
+            const mockResponse = { message: 'Database deleted' };
+            mockClient.deleteDatabase = jest.fn().mockResolvedValue(mockResponse);
+            const options = {
+                deleteConfigurations: true,
+                deleteVolumes: true,
+            };
+            const result = await resources.deleteDatabase('test-db-uuid', options);
+            expect(result).toEqual(mockResponse);
+            expect(mockClient.deleteDatabase).toHaveBeenCalledWith('test-db-uuid', options);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const deployment_resources_js_1 = require("../../resources/deployment-resources.js");
+const coolify_client_js_1 = require("../../lib/coolify-client.js");
+jest.mock('../../lib/coolify-client.js');
+describe('DeploymentResources', () => {
+    let resources;
+    let mockClient;
+    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',
+    };
+    beforeEach(() => {
+        mockClient = new coolify_client_js_1.CoolifyClient({
+            baseUrl: 'http://test.coolify.io',
+            accessToken: 'test-token',
+        });
+        resources = new deployment_resources_js_1.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 = jest.fn().mockResolvedValue(mockDeployment);
+            const result = await resources.deploy({ uuid: 'test-app-uuid', forceRebuild: true });
+            expect(result).toEqual(mockDeployment);
+            expect(mockClient.deployApplication).toHaveBeenCalledWith('test-app-uuid');
+        });
+        it('should handle deployment errors', async () => {
+            const error = new Error('Failed to deploy application');
+            mockClient.deployApplication = jest.fn().mockRejectedValue(error);
+            await expect(resources.deploy({ uuid: 'test-app-uuid' })).rejects.toThrow('Failed to deploy application');
+        });
+    });
+});

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

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

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const service_resources_js_1 = require("../../resources/service-resources.js");
+const coolify_client_js_1 = require("../../lib/coolify-client.js");
+jest.mock('../../lib/coolify-client.js');
+describe('ServiceResources', () => {
+    let resources;
+    let mockClient;
+    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'],
+    };
+    beforeEach(() => {
+        mockClient = new coolify_client_js_1.CoolifyClient({
+            baseUrl: 'http://test.coolify.io',
+            accessToken: 'test-token',
+        });
+        resources = new service_resources_js_1.ServiceResources(mockClient);
+    });
+    describe('listServices', () => {
+        it('should return a list of services', async () => {
+            mockClient.listServices = jest.fn().mockResolvedValue([mockService]);
+            const result = await resources.listServices();
+            expect(result).toEqual([mockService]);
+            expect(mockClient.listServices).toHaveBeenCalled();
+        });
+    });
+    describe('getService', () => {
+        it('should return a specific service', async () => {
+            mockClient.getService = jest.fn().mockResolvedValue(mockService);
+            const result = await resources.getService('test-service-uuid');
+            expect(result).toEqual(mockService);
+            expect(mockClient.getService).toHaveBeenCalledWith('test-service-uuid');
+        });
+    });
+    describe('createService', () => {
+        it('should create a 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'],
+            };
+            mockClient.createService = jest.fn().mockResolvedValue(mockResponse);
+            const result = await resources.createService(createData);
+            expect(result).toEqual(mockResponse);
+            expect(mockClient.createService).toHaveBeenCalledWith(createData);
+        });
+    });
+    describe('deleteService', () => {
+        it('should delete a service', async () => {
+            const mockResponse = { message: 'Service deleted' };
+            mockClient.deleteService = jest.fn().mockResolvedValue(mockResponse);
+            const options = {
+                deleteConfigurations: true,
+                deleteVolumes: true,
+            };
+            const result = await resources.deleteService('test-service-uuid', options);
+            expect(result).toEqual(mockResponse);
+            expect(mockClient.deleteService).toHaveBeenCalledWith('test-service-uuid', options);
+        });
+    });
+});

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

@@ -1,4 +1,4 @@
-import { CoolifyConfig, ServerInfo, ServerResources, ServerDomain, ValidationResponse, Project, CreateProjectRequest, UpdateProjectRequest, Environment, CreateEnvironmentRequest, UpdateEnvironmentVariablesRequest } from '../types/coolify.js';
+import { CoolifyConfig, ServerInfo, ServerResources, ServerDomain, ValidationResponse, Project, CreateProjectRequest, UpdateProjectRequest, Environment, Deployment, Database, DatabaseUpdateRequest, Service, CreateServiceRequest, DeleteServiceOptions } from '../types/coolify.js';
 export declare class CoolifyClient {
     private baseUrl;
     private accessToken;
@@ -20,13 +20,25 @@ export declare class CoolifyClient {
         message: string;
     }>;
     getProjectEnvironment(projectUuid: string, environmentNameOrUuid: string): Promise<Environment>;
-    listEnvironments(projectUuid?: string): Promise<Environment[]>;
-    getEnvironment(uuid: string): Promise<Environment>;
-    createEnvironment(environment: CreateEnvironmentRequest): Promise<{
+    deployApplication(uuid: string): Promise<Deployment>;
+    listDatabases(): Promise<Database[]>;
+    getDatabase(uuid: string): Promise<Database>;
+    updateDatabase(uuid: string, data: DatabaseUpdateRequest): Promise<Database>;
+    deleteDatabase(uuid: string, options?: {
+        deleteConfigurations?: boolean;
+        deleteVolumes?: boolean;
+        dockerCleanup?: boolean;
+        deleteConnectedNetworks?: boolean;
+    }): Promise<{
+        message: string;
+    }>;
+    listServices(): Promise<Service[]>;
+    getService(uuid: string): Promise<Service>;
+    createService(data: CreateServiceRequest): Promise<{
         uuid: string;
+        domains: string[];
     }>;
-    deleteEnvironment(uuid: string): Promise<{
+    deleteService(uuid: string, options?: DeleteServiceOptions): Promise<{
         message: string;
     }>;
-    updateEnvironmentVariables(uuid: string, variables: UpdateEnvironmentVariablesRequest): Promise<Environment>;
 }

package/dist/lib/coolify-client.js

@@ -85,28 +85,78 @@ class CoolifyClient {
     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 deployApplication(uuid) {
+        const response = await this.request(`/applications/${uuid}/deploy`, {
+            method: 'POST',
+        });
+        return response;
     }
-    async getEnvironment(uuid) {
-        return this.request(`/environments/${uuid}`);
+    async listDatabases() {
+        return this.request('/databases');
     }
-    async createEnvironment(environment) {
-        return this.request('/environments', {
-            method: 'POST',
-            body: JSON.stringify(environment),
+    async getDatabase(uuid) {
+        return this.request(`/databases/${uuid}`);
+    }
+    async updateDatabase(uuid, data) {
+        return this.request(`/databases/${uuid}`, {
+            method: 'PATCH',
+            body: JSON.stringify(data),
         });
     }
-    async deleteEnvironment(uuid) {
-        return this.request(`/environments/${uuid}`, {
+    async deleteDatabase(uuid, options) {
+        const queryParams = new URLSearchParams();
+        if (options) {
+            if (options.deleteConfigurations !== undefined) {
+                queryParams.set('delete_configurations', options.deleteConfigurations.toString());
+            }
+            if (options.deleteVolumes !== undefined) {
+                queryParams.set('delete_volumes', options.deleteVolumes.toString());
+            }
+            if (options.dockerCleanup !== undefined) {
+                queryParams.set('docker_cleanup', options.dockerCleanup.toString());
+            }
+            if (options.deleteConnectedNetworks !== undefined) {
+                queryParams.set('delete_connected_networks', options.deleteConnectedNetworks.toString());
+            }
+        }
+        const queryString = queryParams.toString();
+        const url = queryString ? `/databases/${uuid}?${queryString}` : `/databases/${uuid}`;
+        return this.request(url, {
             method: 'DELETE',
         });
     }
-    async updateEnvironmentVariables(uuid, variables) {
-        return this.request(`/environments/${uuid}/variables`, {
-            method: 'PUT',
-            body: JSON.stringify(variables),
+    async listServices() {
+        return this.request('/services');
+    }
+    async getService(uuid) {
+        return this.request(`/services/${uuid}`);
+    }
+    async createService(data) {
+        return this.request('/services', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+    }
+    async deleteService(uuid, options) {
+        const queryParams = new URLSearchParams();
+        if (options) {
+            if (options.deleteConfigurations !== undefined) {
+                queryParams.set('delete_configurations', options.deleteConfigurations.toString());
+            }
+            if (options.deleteVolumes !== undefined) {
+                queryParams.set('delete_volumes', options.deleteVolumes.toString());
+            }
+            if (options.dockerCleanup !== undefined) {
+                queryParams.set('docker_cleanup', options.dockerCleanup.toString());
+            }
+            if (options.deleteConnectedNetworks !== undefined) {
+                queryParams.set('delete_connected_networks', options.deleteConnectedNetworks.toString());
+            }
+        }
+        const queryString = queryParams.toString();
+        const url = queryString ? `/services/${uuid}?${queryString}` : `/services/${uuid}`;
+        return this.request(url, {
+            method: 'DELETE',
         });
     }
 }

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

@@ -1,8 +1,12 @@
-import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
-import { CoolifyConfig, ServerInfo, ServerResources, ServerDomain, ValidationResponse, Project, CreateProjectRequest, UpdateProjectRequest, Environment, CreateEnvironmentRequest } from '../types/coolify.js';
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport';
+import { CoolifyConfig, ServerInfo, ServerResources, ServerDomain, ValidationResponse, Project, CreateProjectRequest, UpdateProjectRequest, Environment, Deployment, Database, DatabaseUpdateRequest, Service, CreateServiceRequest, DeleteServiceOptions } from '../types/coolify.js';
 export declare class CoolifyMcpServer {
     private server;
     private client;
+    private databaseResources;
+    private deploymentResources;
+    private applicationResources;
+    private serviceResources;
     constructor(config: CoolifyConfig);
     private setupTools;
     start(transport: Transport): Promise<void>;
@@ -21,22 +25,27 @@ export declare class CoolifyMcpServer {
         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<{
+    deploy_application(params: {
         uuid: string;
+    }): Promise<Deployment>;
+    list_databases(): Promise<Database[]>;
+    get_database(uuid: string): Promise<Database>;
+    update_database(uuid: string, data: DatabaseUpdateRequest): Promise<Database>;
+    delete_database(uuid: string, options?: {
+        deleteConfigurations?: boolean;
+        deleteVolumes?: boolean;
+        dockerCleanup?: boolean;
+        deleteConnectedNetworks?: boolean;
+    }): Promise<{
+        message: string;
     }>;
-    update_environment_variables(params: {
+    list_services(): Promise<Service[]>;
+    get_service(uuid: string): Promise<Service>;
+    create_service(data: CreateServiceRequest): Promise<{
         uuid: string;
-        variables: Record<string, string>;
-    }): Promise<Environment>;
-    delete_environment(params: {
-        uuid: string;
-    }): Promise<{
+        domains: string[];
+    }>;
+    delete_service(uuid: string, options?: DeleteServiceOptions): Promise<{
         message: string;
     }>;
 }