@masonator/coolify-mcp 0.1.2 → 0.1.4

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

@@ -1,7 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const mcp_server_js_1 = require("../lib/mcp-server.js");
-const globals_1 = require("@jest/globals");
+import { CoolifyMcpServer } from '../lib/mcp-server.js';
+import { jest } from '@jest/globals';
 describe('CoolifyMcpServer', () => {
     const mockConfig = {
         baseUrl: 'https://coolify.test',
@@ -9,9 +7,9 @@ describe('CoolifyMcpServer', () => {
     };
     let server;
     beforeEach(() => {
-        server = new mcp_server_js_1.CoolifyMcpServer(mockConfig);
+        server = new CoolifyMcpServer(mockConfig);
         // Mock validateConnection to prevent actual HTTP calls
-        globals_1.jest.spyOn(server['client'], 'validateConnection').mockResolvedValue();
+        jest.spyOn(server['client'], 'validateConnection').mockResolvedValue();
     });
     describe('get_server_resources', () => {
         it('should call client getServerResources', async () => {
@@ -27,7 +25,7 @@ describe('CoolifyMcpServer', () => {
                     status: 'running',
                 },
             ];
-            const spy = globals_1.jest
+            const spy = jest
                 .spyOn(server['client'], 'getServerResources')
                 .mockResolvedValue(mockResources);
             await server.get_server_resources('test-uuid');
@@ -40,7 +38,7 @@ describe('CoolifyMcpServer', () => {
             const mockValidation = {
                 message: 'Server is valid',
             };
-            const spy = globals_1.jest.spyOn(server['client'], 'validateServer').mockResolvedValue(mockValidation);
+            const spy = jest.spyOn(server['client'], 'validateServer').mockResolvedValue(mockValidation);
             await server.validate_server('test-uuid');
             expect(spy).toHaveBeenCalledWith('test-uuid');
         });
@@ -56,7 +54,7 @@ describe('CoolifyMcpServer', () => {
                     environments: [],
                 },
             ];
-            const spy = globals_1.jest.spyOn(server['client'], 'listProjects').mockResolvedValue(mockProjects);
+            const spy = jest.spyOn(server['client'], 'listProjects').mockResolvedValue(mockProjects);
             await server.list_projects();
             expect(spy).toHaveBeenCalled();
         });
@@ -70,7 +68,7 @@ describe('CoolifyMcpServer', () => {
                 description: 'Test project description',
                 environments: [],
             };
-            const spy = globals_1.jest.spyOn(server['client'], 'getProject').mockResolvedValue(mockProject);
+            const spy = jest.spyOn(server['client'], 'getProject').mockResolvedValue(mockProject);
             await server.get_project('test-project-uuid');
             expect(spy).toHaveBeenCalledWith('test-project-uuid');
         });
@@ -82,7 +80,7 @@ describe('CoolifyMcpServer', () => {
                 name: 'New Project',
                 description: 'New project description',
             };
-            const spy = globals_1.jest.spyOn(server['client'], 'createProject').mockResolvedValue(mockResponse);
+            const spy = jest.spyOn(server['client'], 'createProject').mockResolvedValue(mockResponse);
             await server.create_project(createRequest);
             expect(spy).toHaveBeenCalledWith(createRequest);
         });
@@ -100,7 +98,7 @@ describe('CoolifyMcpServer', () => {
                 name: 'Updated Project',
                 description: 'Updated description',
             };
-            const spy = globals_1.jest.spyOn(server['client'], 'updateProject').mockResolvedValue(mockProject);
+            const spy = jest.spyOn(server['client'], 'updateProject').mockResolvedValue(mockProject);
             await server.update_project('test-project-uuid', updateRequest);
             expect(spy).toHaveBeenCalledWith('test-project-uuid', updateRequest);
         });
@@ -108,7 +106,7 @@ describe('CoolifyMcpServer', () => {
     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);
+            const spy = jest.spyOn(server['client'], 'deleteProject').mockResolvedValue(mockResponse);
             await server.delete_project('test-project-uuid');
             expect(spy).toHaveBeenCalledWith('test-project-uuid');
         });
@@ -124,7 +122,7 @@ describe('CoolifyMcpServer', () => {
                 created_at: '2024-03-06T12:00:00Z',
                 updated_at: '2024-03-06T12:00:00Z',
             };
-            const spy = globals_1.jest
+            const spy = jest
                 .spyOn(server['client'], 'getProjectEnvironment')
                 .mockResolvedValue(mockEnvironment);
             await server.get_project_environment('test-project-uuid', 'test-env-uuid');
@@ -141,14 +139,14 @@ describe('CoolifyMcpServer', () => {
                 created_at: '2024-03-20T12:00:00Z',
                 updated_at: '2024-03-20T12:00:00Z',
             };
-            globals_1.jest.spyOn(server['client'], 'deployApplication').mockResolvedValue(mockDeployment);
+            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');
-            globals_1.jest.spyOn(server['client'], 'deployApplication').mockRejectedValue(error);
+            jest.spyOn(server['client'], 'deployApplication').mockRejectedValue(error);
             await expect(server.deploy_application({ uuid: 'test-app-uuid' })).rejects.toThrow('Failed to deploy application');
         });
     });
@@ -169,13 +167,13 @@ describe('CoolifyMcpServer', () => {
             postgres_db: 'testdb',
         };
         it('should list databases', async () => {
-            const spy = globals_1.jest.spyOn(server['client'], 'listDatabases').mockResolvedValue([mockDatabase]);
+            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 = globals_1.jest.spyOn(server['client'], 'getDatabase').mockResolvedValue(mockDatabase);
+            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');
@@ -185,7 +183,7 @@ describe('CoolifyMcpServer', () => {
                 name: 'updated-db',
                 description: 'Updated description',
             };
-            const spy = globals_1.jest
+            const spy = jest
                 .spyOn(server['client'], 'updateDatabase')
                 .mockResolvedValue({ ...mockDatabase, ...updateData, type: 'postgresql' });
             const result = await server.update_database('test-db-uuid', updateData);
@@ -198,7 +196,7 @@ describe('CoolifyMcpServer', () => {
         });
         it('should delete database', async () => {
             const mockResponse = { message: 'Database deleted' };
-            const spy = globals_1.jest.spyOn(server['client'], 'deleteDatabase').mockResolvedValue(mockResponse);
+            const spy = jest.spyOn(server['client'], 'deleteDatabase').mockResolvedValue(mockResponse);
             const result = await server.delete_database('test-db-uuid', {
                 deleteConfigurations: true,
                 deleteVolumes: true,
@@ -211,7 +209,7 @@ describe('CoolifyMcpServer', () => {
         });
         it('should handle database errors', async () => {
             const errorMessage = 'Database not found';
-            globals_1.jest.spyOn(server['client'], 'getDatabase').mockRejectedValue(new Error(errorMessage));
+            jest.spyOn(server['client'], 'getDatabase').mockRejectedValue(new Error(errorMessage));
             await expect(server.get_database('invalid-uuid')).rejects.toThrow(errorMessage);
         });
     });
@@ -232,13 +230,13 @@ describe('CoolifyMcpServer', () => {
             domains: ['test-service.example.com'],
         };
         it('should list services', async () => {
-            const spy = globals_1.jest.spyOn(server['client'], 'listServices').mockResolvedValue([mockService]);
+            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 = globals_1.jest.spyOn(server['client'], 'getService').mockResolvedValue(mockService);
+            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');
@@ -257,14 +255,14 @@ describe('CoolifyMcpServer', () => {
                 uuid: 'test-service-uuid',
                 domains: ['test-service.example.com'],
             };
-            const spy = globals_1.jest.spyOn(server['client'], 'createService').mockResolvedValue(mockResponse);
+            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 = globals_1.jest.spyOn(server['client'], 'deleteService').mockResolvedValue(mockResponse);
+            const spy = jest.spyOn(server['client'], 'deleteService').mockResolvedValue(mockResponse);
             const result = await server.delete_service('test-service-uuid', {
                 deleteConfigurations: true,
                 deleteVolumes: true,
@@ -277,7 +275,7 @@ describe('CoolifyMcpServer', () => {
         });
         it('should handle service errors', async () => {
             const errorMessage = 'Service not found';
-            globals_1.jest.spyOn(server['client'], 'getService').mockRejectedValue(new Error(errorMessage));
+            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.js

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const application_resources_js_1 = require("../../resources/application-resources.js");
-const coolify_client_js_1 = require("../../lib/coolify-client.js");
+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 = new coolify_client_js_1.CoolifyClient({
-            baseUrl: 'http://test.coolify.io',
-            accessToken: 'test-token',
-        });
-        resources = new application_resources_js_1.ApplicationResources(mockClient);
+        mockClient = {
+            deployApplication: jest.fn(),
+        };
+        resources = new ApplicationResources(mockClient);
     });
     describe('listApplications', () => {
         it('should throw not implemented error', async () => {

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

@@ -1,72 +1,68 @@
-"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");
+import { DatabaseResources } from '../../resources/database-resources.js';
+import { jest } from '@jest/globals';
 jest.mock('../../lib/coolify-client.js');
 describe('DatabaseResources', () => {
-    let resources;
     let mockClient;
+    let resources;
     const mockDatabase = {
         id: 1,
-        uuid: 'test-db-uuid',
+        uuid: 'test-uuid',
         name: 'test-db',
-        description: 'Test database',
+        description: 'test description',
         type: 'postgresql',
         status: 'running',
-        created_at: '2024-03-06T12:00:00Z',
-        updated_at: '2024-03-06T12:00:00Z',
+        created_at: '2024-01-01',
+        updated_at: '2024-01-01',
         is_public: false,
         image: 'postgres:latest',
-        postgres_user: 'postgres',
-        postgres_password: 'test123',
-        postgres_db: 'testdb',
+        postgres_user: 'test',
+        postgres_password: 'test',
+        postgres_db: 'test',
     };
     beforeEach(() => {
-        mockClient = new coolify_client_js_1.CoolifyClient({
-            baseUrl: 'http://test.coolify.io',
-            accessToken: 'test-token',
-        });
-        resources = new database_resources_js_1.DatabaseResources(mockClient);
+        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 = jest.fn().mockResolvedValue([mockDatabase]);
+            mockClient.listDatabases.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');
+        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-db-uuid');
+            expect(mockClient.getDatabase).toHaveBeenCalledWith('test-uuid');
         });
     });
     describe('updateDatabase', () => {
         it('should update a database', async () => {
             const updateData = {
                 name: 'updated-db',
-                description: 'Updated description',
+                description: 'updated description',
             };
-            mockClient.updateDatabase = jest.fn().mockResolvedValue({ ...mockDatabase, ...updateData });
-            const result = await resources.updateDatabase('test-db-uuid', updateData);
+            mockClient.updateDatabase.mockResolvedValue({ ...mockDatabase, ...updateData });
+            const result = await resources.updateDatabase('test-uuid', updateData);
             expect(result).toEqual({ ...mockDatabase, ...updateData });
-            expect(mockClient.updateDatabase).toHaveBeenCalledWith('test-db-uuid', updateData);
+            expect(mockClient.updateDatabase).toHaveBeenCalledWith('test-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);
+            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-db-uuid', options);
+            expect(mockClient.deleteDatabase).toHaveBeenCalledWith('test-uuid', {});
         });
     });
 });

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

@@ -1,25 +1,23 @@
-"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");
+import { DeploymentResources } from '../../resources/deployment-resources.js';
+import { jest } from '@jest/globals';
 jest.mock('../../lib/coolify-client.js');
 describe('DeploymentResources', () => {
-    let resources;
     let mockClient;
+    let resources;
     const mockDeployment = {
         id: 1,
-        uuid: 'test-deployment-uuid',
-        application_uuid: 'test-app-uuid',
+        uuid: 'test-uuid',
         status: 'running',
-        created_at: '2024-03-20T12:00:00Z',
-        updated_at: '2024-03-20T12:00:00Z',
+        created_at: '2024-01-01',
+        updated_at: '2024-01-01',
+        application_uuid: 'app-uuid',
+        environment_uuid: 'env-uuid',
     };
     beforeEach(() => {
-        mockClient = new coolify_client_js_1.CoolifyClient({
-            baseUrl: 'http://test.coolify.io',
-            accessToken: 'test-token',
-        });
-        resources = new deployment_resources_js_1.DeploymentResources(mockClient);
+        mockClient = {
+            deployApplication: jest.fn(),
+        };
+        resources = new DeploymentResources(mockClient);
     });
     describe('listDeployments', () => {
         it('should throw not implemented error', async () => {
@@ -33,15 +31,16 @@ describe('DeploymentResources', () => {
     });
     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 });
+            mockClient.deployApplication.mockResolvedValue(mockDeployment);
+            const result = await resources.deploy({ uuid: 'test-uuid' });
             expect(result).toEqual(mockDeployment);
-            expect(mockClient.deployApplication).toHaveBeenCalledWith('test-app-uuid');
+            expect(mockClient.deployApplication).toHaveBeenCalledWith('test-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');
+            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.js

@@ -1,65 +1,64 @@
-"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");
+import { ServiceResources } from '../../resources/service-resources.js';
+import { jest } from '@jest/globals';
 jest.mock('../../lib/coolify-client.js');
 describe('ServiceResources', () => {
-    let resources;
     let mockClient;
+    let resources;
     const mockService = {
         id: 1,
-        uuid: 'test-service-uuid',
+        uuid: 'test-uuid',
         name: 'test-service',
-        description: 'Test service',
+        description: 'test description',
         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'],
+        created_at: '2024-01-01',
+        updated_at: '2024-01-01',
+        project_uuid: 'project-uuid',
+        environment_name: 'test-env',
+        environment_uuid: 'env-uuid',
+        server_uuid: 'server-uuid',
+        domains: ['test.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);
+        mockClient = {
+            listServices: jest.fn(),
+            getService: jest.fn(),
+            createService: jest.fn(),
+            deleteService: jest.fn(),
+        };
+        resources = new ServiceResources(mockClient);
     });
     describe('listServices', () => {
         it('should return a list of services', async () => {
-            mockClient.listServices = jest.fn().mockResolvedValue([mockService]);
+            mockClient.listServices.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');
+        it('should return a service by uuid', async () => {
+            mockClient.getService.mockResolvedValue(mockService);
+            const result = await resources.getService('test-uuid');
             expect(result).toEqual(mockService);
-            expect(mockClient.getService).toHaveBeenCalledWith('test-service-uuid');
+            expect(mockClient.getService).toHaveBeenCalledWith('test-uuid');
         });
     });
     describe('createService', () => {
-        it('should create a service', async () => {
+        it('should create a new service', async () => {
             const createData = {
+                name: 'new-service',
                 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,
+                project_uuid: 'project-uuid',
+                environment_name: 'test-env',
+                environment_uuid: 'env-uuid',
+                server_uuid: 'server-uuid',
             };
             const mockResponse = {
-                uuid: 'test-service-uuid',
-                domains: ['test-service.example.com'],
+                uuid: 'new-uuid',
+                domains: ['new-service.test.com'],
             };
-            mockClient.createService = jest.fn().mockResolvedValue(mockResponse);
+            mockClient.createService.mockResolvedValue(mockResponse);
             const result = await resources.createService(createData);
             expect(result).toEqual(mockResponse);
             expect(mockClient.createService).toHaveBeenCalledWith(createData);
@@ -68,14 +67,10 @@ describe('ServiceResources', () => {
     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);
+            mockClient.deleteService.mockResolvedValue(mockResponse);
+            const result = await resources.deleteService('test-uuid');
             expect(result).toEqual(mockResponse);
-            expect(mockClient.deleteService).toHaveBeenCalledWith('test-service-uuid', options);
+            expect(mockClient.deleteService).toHaveBeenCalledWith('test-uuid', undefined);
         });
     });
 });

package/dist/index.js

@@ -1,8 +1,6 @@
 #!/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");
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CoolifyMcpServer } from './lib/mcp-server.js';
 async function main() {
     const config = {
         baseUrl: process.env.COOLIFY_BASE_URL || 'http://localhost:3000',
@@ -11,8 +9,8 @@ async function main() {
     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();
+    const server = new CoolifyMcpServer(config);
+    const transport = new StdioServerTransport();
     await server.start(transport);
 }
 main().catch((error) => {

package/dist/lib/coolify-client.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoolifyClient = void 0;
-class CoolifyClient {
+export class CoolifyClient {
     constructor(config) {
         if (!config.baseUrl) {
             throw new Error('Coolify base URL is required');
@@ -160,4 +157,3 @@ class CoolifyClient {
         });
     }
 }
-exports.CoolifyClient = CoolifyClient;

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

@@ -1,4 +1,4 @@
-import { Transport } from '@modelcontextprotocol/sdk/shared/transport';
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
 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;
@@ -8,7 +8,7 @@ export declare class CoolifyMcpServer {
     private applicationResources;
     private serviceResources;
     constructor(config: CoolifyConfig);
-    private setupTools;
+    private setupHandlers;
     start(transport: Transport): Promise<void>;
     list_servers(): Promise<ServerInfo[]>;
     get_server(uuid: string): Promise<ServerInfo>;