@masonator/coolify-mcp 1.5.0 → 2.0.0

package/README.md

@@ -9,41 +9,33 @@
 [![codecov](https://codecov.io/gh/StuMason/coolify-mcp/branch/main/graph/badge.svg)](https://codecov.io/gh/StuMason/coolify-mcp)
 [![MseeP.ai Security Assessment Badge](https://mseep.net/pr/stumason-coolify-mcp-badge.png)](https://mseep.ai/app/stumason-coolify-mcp)
 
-> **The most comprehensive MCP server for Coolify** - 67 tools, 7 workflow prompts, smart diagnostics, and batch operations for managing your self-hosted PaaS through AI assistants.
+> **The most comprehensive MCP server for Coolify** - 34 optimized tools, smart diagnostics, and batch operations for managing your self-hosted PaaS through AI assistants.
 
 A Model Context Protocol (MCP) server for [Coolify](https://coolify.io/), enabling AI assistants to manage and debug your Coolify instances through natural language.
 
 ## Features
 
-This MCP server provides **67 tools** and **7 workflow prompts** for **debugging, management, and deployment**:
-
-| Category             | Tools                                                                                                    |
-| -------------------- | -------------------------------------------------------------------------------------------------------- |
-| **Infrastructure**   | overview, mcp_version (all resources at once)                                                            |
-| **Diagnostics**      | diagnose_app, diagnose_server, find_issues (smart lookup by name/domain/IP)                              |
-| **Batch Operations** | restart_project_apps, bulk_env_update, stop_all_apps, redeploy_project                                   |
-| **Servers**          | list, get, validate, resources, domains                                                                  |
-| **Projects**         | list, get, create, update, delete                                                                        |
-| **Environments**     | list, get, create, delete                                                                                |
-| **Applications**     | list, get, update, delete, start, stop, restart, logs, env vars (CRUD), create (private-gh, private-key) |
-| **Databases**        | list, get, delete, start, stop, restart, backups (list, get), backup executions (list, get)              |
-| **Services**         | list, get, create, update, delete, start, stop, restart, env vars (list, create, delete)                 |
-| **Deployments**      | list, get, deploy, cancel, list by application                                                           |
-| **Private Keys**     | list, get, create, update, delete                                                                        |
-
-### Workflow Prompts
-
-Pre-built guided workflows that walk you through common tasks:
-
-| Prompt             | Description                                                 |
-| ------------------ | ----------------------------------------------------------- |
-| `debug-app`        | Debug an application - gathers logs, status, env vars       |
-| `health-check`     | Full infrastructure health analysis                         |
-| `deploy-app`       | Step-by-step deployment wizard from Git repository          |
-| `troubleshoot-ssl` | SSL/TLS certificate diagnosis workflow                      |
-| `restart-project`  | Safely restart all apps in a project with status monitoring |
-| `env-audit`        | Audit and compare environment variables across applications |
-| `backup-status`    | Check database backup status and history                    |
+This MCP server provides **34 token-optimized tools** for **debugging, management, and deployment**:
+
+| Category             | Tools                                                                                     |
+| -------------------- | ----------------------------------------------------------------------------------------- |
+| **Infrastructure**   | `get_infrastructure_overview`, `get_mcp_version`, `get_version`                           |
+| **Diagnostics**      | `diagnose_app`, `diagnose_server`, `find_issues`                                          |
+| **Batch Operations** | `restart_project_apps`, `bulk_env_update`, `stop_all_apps`, `redeploy_project`            |
+| **Servers**          | `list_servers`, `get_server`, `validate_server`, `server_resources`, `server_domains`     |
+| **Projects**         | `projects` (list, get, create, update, delete via action param)                           |
+| **Environments**     | `environments` (list, get, create, delete via action param)                               |
+| **Applications**     | `list_applications`, `get_application`, `application` (CRUD), `application_logs`          |
+| **Databases**        | `list_databases`, `get_database`, `database` (create 8 types, delete), `database_backups` |
+| **Services**         | `list_services`, `get_service`, `service` (create, update, delete)                        |
+| **Control**          | `control` (start/stop/restart for apps, databases, services)                              |
+| **Env Vars**         | `env_vars` (CRUD for application and service env vars)                                    |
+| **Deployments**      | `list_deployments`, `deploy`, `deployment` (get, cancel, list_for_app)                    |
+| **Private Keys**     | `private_keys` (list, get, create, update, delete via action param)                       |
+
+### v2.0.0 Token Diet
+
+v2.0.0 reduced token usage by **85%** (from ~43,000 to ~6,600 tokens) by consolidating related operations into single tools with action parameters. This prevents context window exhaustion in AI assistants.
 
 ## Installation
 

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

@@ -794,6 +794,87 @@ describe('CoolifyClient', () => {
             expect(result).toEqual(mockExecution);
             expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/db-uuid/backups/backup-uuid/executions/exec-uuid', expect.any(Object));
         });
+        it('should create a PostgreSQL database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'pg-uuid' }));
+            const result = await client.createPostgresql({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+                environment_name: 'production',
+                postgres_user: 'myuser',
+                postgres_db: 'mydb',
+            });
+            expect(result).toEqual({ uuid: 'pg-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/postgresql', expect.objectContaining({ method: 'POST' }));
+        });
+        it('should create a MySQL database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'mysql-uuid' }));
+            const result = await client.createMysql({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+                mysql_user: 'myuser',
+                mysql_database: 'mydb',
+            });
+            expect(result).toEqual({ uuid: 'mysql-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/mysql', expect.objectContaining({ method: 'POST' }));
+        });
+        it('should create a MariaDB database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'mariadb-uuid' }));
+            const result = await client.createMariadb({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+            });
+            expect(result).toEqual({ uuid: 'mariadb-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/mariadb', expect.objectContaining({ method: 'POST' }));
+        });
+        it('should create a MongoDB database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'mongo-uuid' }));
+            const result = await client.createMongodb({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+                mongo_initdb_root_username: 'admin',
+            });
+            expect(result).toEqual({ uuid: 'mongo-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/mongodb', expect.objectContaining({ method: 'POST' }));
+        });
+        it('should create a Redis database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'redis-uuid' }));
+            const result = await client.createRedis({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+                redis_password: 'secret',
+            });
+            expect(result).toEqual({ uuid: 'redis-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/redis', expect.objectContaining({ method: 'POST' }));
+        });
+        it('should create a KeyDB database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'keydb-uuid' }));
+            const result = await client.createKeydb({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+            });
+            expect(result).toEqual({ uuid: 'keydb-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/keydb', expect.objectContaining({ method: 'POST' }));
+        });
+        it('should create a ClickHouse database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'clickhouse-uuid' }));
+            const result = await client.createClickhouse({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+                clickhouse_admin_user: 'admin',
+            });
+            expect(result).toEqual({ uuid: 'clickhouse-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/clickhouse', expect.objectContaining({ method: 'POST' }));
+        });
+        it('should create a Dragonfly database', async () => {
+            mockFetch.mockResolvedValueOnce(mockResponse({ uuid: 'dragonfly-uuid' }));
+            const result = await client.createDragonfly({
+                server_uuid: 'server-uuid',
+                project_uuid: 'project-uuid',
+                dragonfly_password: 'secret',
+            });
+            expect(result).toEqual({ uuid: 'dragonfly-uuid' });
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:3000/api/v1/databases/dragonfly', expect.objectContaining({ method: 'POST' }));
+        });
     });
     // =========================================================================
     // Service endpoints - extended coverage

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

@@ -1,333 +1,132 @@
 /**
- * MCP Server Tests
+ * MCP Server Tests v2.0.0
  *
- * Tests for the MCP server layer, specifically:
- * - get_infrastructure_overview aggregation logic
- * - Verification that list tools always use summary mode
+ * Tests for the consolidated MCP tool layer.
+ * CoolifyClient methods are fully tested in coolify-client.test.ts (174 tests).
+ * These tests verify MCP server instantiation and structure.
  */
-import { jest, describe, it, expect, beforeEach } from '@jest/globals';
-// Create typed mock functions
-const mockListServers = jest.fn();
-const mockListProjects = jest.fn();
-const mockListApplications = jest.fn();
-const mockListDatabases = jest.fn();
-const mockListServices = jest.fn();
-const mockDiagnoseApplication = jest.fn();
-const mockDiagnoseServer = jest.fn();
-const mockFindInfrastructureIssues = jest.fn();
-const mockDeleteDatabase = jest.fn();
-// Mock the CoolifyClient module
-jest.mock('../lib/coolify-client.js', () => ({
-    CoolifyClient: jest.fn().mockImplementation(() => ({
-        listServers: mockListServers,
-        listProjects: mockListProjects,
-        listApplications: mockListApplications,
-        listDatabases: mockListDatabases,
-        listServices: mockListServices,
-        diagnoseApplication: mockDiagnoseApplication,
-        diagnoseServer: mockDiagnoseServer,
-        findInfrastructureIssues: mockFindInfrastructureIssues,
-        deleteDatabase: mockDeleteDatabase,
-        getVersion: jest.fn(),
-    })),
-}));
-// Import after mocking
+import { describe, it, expect, beforeEach } from '@jest/globals';
 import { CoolifyMcpServer } from '../lib/mcp-server.js';
-describe('CoolifyMcpServer', () => {
+describe('CoolifyMcpServer v2', () => {
+    let server;
     beforeEach(() => {
-        jest.clearAllMocks();
+        server = new CoolifyMcpServer({
+            baseUrl: 'http://localhost:3000',
+            accessToken: 'test-token',
+        });
     });
     describe('constructor', () => {
-        it('should create server instance with valid config', () => {
-            const server = new CoolifyMcpServer({
-                baseUrl: 'http://localhost:3000',
-                accessToken: 'test-token',
-            });
+        it('should create server instance', () => {
             expect(server).toBeInstanceOf(CoolifyMcpServer);
         });
-    });
-    describe('get_infrastructure_overview behavior', () => {
-        it('should call all list methods with summary: true for aggregation', async () => {
-            // Setup mock responses
-            mockListServers.mockResolvedValue([
-                { uuid: 'srv-1', name: 'server-1', ip: '10.0.0.1', status: 'running', is_reachable: true },
-            ]);
-            mockListProjects.mockResolvedValue([
-                { uuid: 'proj-1', name: 'project-1', description: 'Test' },
-            ]);
-            mockListApplications.mockResolvedValue([
-                { uuid: 'app-1', name: 'app-1', status: 'running', fqdn: 'https://app.com' },
-            ]);
-            mockListDatabases.mockResolvedValue([
-                { uuid: 'db-1', name: 'db-1', type: 'postgresql', status: 'running', is_public: false },
-            ]);
-            mockListServices.mockResolvedValue([
-                { uuid: 'svc-1', name: 'svc-1', type: 'redis', status: 'running' },
-            ]);
-            // Create server (this registers tools)
-            new CoolifyMcpServer({
-                baseUrl: 'http://localhost:3000',
-                accessToken: 'test-token',
-            });
-            // Simulate what get_infrastructure_overview does
-            await Promise.all([
-                mockListServers({ summary: true }),
-                mockListProjects({ summary: true }),
-                mockListApplications({ summary: true }),
-                mockListDatabases({ summary: true }),
-                mockListServices({ summary: true }),
-            ]);
-            // Verify all methods were called with summary: true
-            expect(mockListServers).toHaveBeenCalledWith({ summary: true });
-            expect(mockListProjects).toHaveBeenCalledWith({ summary: true });
-            expect(mockListApplications).toHaveBeenCalledWith({ summary: true });
-            expect(mockListDatabases).toHaveBeenCalledWith({ summary: true });
-            expect(mockListServices).toHaveBeenCalledWith({ summary: true });
-        });
-    });
-    describe('list tools use summary mode by default', () => {
-        beforeEach(() => {
-            // Create fresh server for each test
-            new CoolifyMcpServer({
-                baseUrl: 'http://localhost:3000',
-                accessToken: 'test-token',
-            });
-        });
-        it('list_servers should use summary: true', async () => {
-            mockListServers.mockResolvedValue([]);
-            // Call as the MCP tool would
-            await mockListServers({ page: undefined, per_page: undefined, summary: true });
-            expect(mockListServers).toHaveBeenCalledWith({
-                page: undefined,
-                per_page: undefined,
-                summary: true,
-            });
-        });
-        it('list_applications should use summary: true', async () => {
-            mockListApplications.mockResolvedValue([]);
-            await mockListApplications({ page: undefined, per_page: undefined, summary: true });
-            expect(mockListApplications).toHaveBeenCalledWith({
-                page: undefined,
-                per_page: undefined,
-                summary: true,
-            });
-        });
-        it('list_services should use summary: true', async () => {
-            mockListServices.mockResolvedValue([]);
-            await mockListServices({ page: undefined, per_page: undefined, summary: true });
-            expect(mockListServices).toHaveBeenCalledWith({
-                page: undefined,
-                per_page: undefined,
-                summary: true,
-            });
-        });
-        it('list_databases should use summary: true', async () => {
-            mockListDatabases.mockResolvedValue([]);
-            await mockListDatabases({ page: undefined, per_page: undefined, summary: true });
-            expect(mockListDatabases).toHaveBeenCalledWith({
-                page: undefined,
-                per_page: undefined,
-                summary: true,
-            });
-        });
-        it('list_projects should use summary: true', async () => {
-            mockListProjects.mockResolvedValue([]);
-            await mockListProjects({ page: undefined, per_page: undefined, summary: true });
-            expect(mockListProjects).toHaveBeenCalledWith({
-                page: undefined,
-                per_page: undefined,
-                summary: true,
-            });
-        });
-    });
-    describe('error handling', () => {
-        it('should handle client errors', async () => {
-            mockListServers.mockRejectedValue(new Error('Connection failed'));
-            await expect(mockListServers({ summary: true })).rejects.toThrow('Connection failed');
+        it('should be an MCP server with connect method', () => {
+            expect(typeof server.connect).toBe('function');
         });
     });
-    describe('diagnostic tools', () => {
-        beforeEach(() => {
-            new CoolifyMcpServer({
-                baseUrl: 'http://localhost:3000',
-                accessToken: 'test-token',
-            });
-        });
-        describe('diagnose_app', () => {
-            it('should call diagnoseApplication with the query', async () => {
-                mockDiagnoseApplication.mockResolvedValue({
-                    application: {
-                        uuid: 'app-uuid-123',
-                        name: 'test-app',
-                        status: 'running',
-                        fqdn: 'https://test.example.com',
-                        git_repository: 'org/repo',
-                        git_branch: 'main',
-                    },
-                    health: { status: 'healthy', issues: [] },
-                    logs: 'Application started',
-                    environment_variables: {
-                        count: 2,
-                        variables: [{ key: 'NODE_ENV', is_build_time: false }],
-                    },
-                    recent_deployments: [],
-                });
-                await mockDiagnoseApplication('test-app');
-                expect(mockDiagnoseApplication).toHaveBeenCalledWith('test-app');
-            });
-            it('should call diagnoseApplication with a domain', async () => {
-                mockDiagnoseApplication.mockResolvedValue({
-                    application: null,
-                    health: { status: 'unknown', issues: [] },
-                    logs: null,
-                    environment_variables: { count: 0, variables: [] },
-                    recent_deployments: [],
-                    errors: ['Application not found'],
-                });
-                await mockDiagnoseApplication('tidylinker.com');
-                expect(mockDiagnoseApplication).toHaveBeenCalledWith('tidylinker.com');
-            });
-            it('should call diagnoseApplication with a UUID', async () => {
-                mockDiagnoseApplication.mockResolvedValue({
-                    application: {
-                        uuid: 'xs0sgs4gog044s4k4c88kgsc',
-                        name: 'test-app',
-                        status: 'running',
-                        fqdn: null,
-                        git_repository: null,
-                        git_branch: null,
-                    },
-                    health: { status: 'healthy', issues: [] },
-                    logs: null,
-                    environment_variables: { count: 0, variables: [] },
-                    recent_deployments: [],
-                });
-                await mockDiagnoseApplication('xs0sgs4gog044s4k4c88kgsc');
-                expect(mockDiagnoseApplication).toHaveBeenCalledWith('xs0sgs4gog044s4k4c88kgsc');
-            });
-        });
-        describe('diagnose_server', () => {
-            it('should call diagnoseServer with the query', async () => {
-                mockDiagnoseServer.mockResolvedValue({
-                    server: {
-                        uuid: 'srv-uuid-123',
-                        name: 'production-server',
-                        ip: '192.168.1.100',
-                        status: 'running',
-                        is_reachable: true,
-                    },
-                    health: { status: 'healthy', issues: [] },
-                    resources: [],
-                    domains: [],
-                    validation: { message: 'Server is reachable' },
-                });
-                await mockDiagnoseServer('production-server');
-                expect(mockDiagnoseServer).toHaveBeenCalledWith('production-server');
-            });
-            it('should call diagnoseServer with an IP address', async () => {
-                mockDiagnoseServer.mockResolvedValue({
-                    server: {
-                        uuid: 'srv-uuid-123',
-                        name: 'production-server',
-                        ip: '192.168.1.100',
-                        status: 'running',
-                        is_reachable: true,
-                    },
-                    health: { status: 'healthy', issues: [] },
-                    resources: [],
-                    domains: [],
-                    validation: { message: 'Server is reachable' },
-                });
-                await mockDiagnoseServer('192.168.1.100');
-                expect(mockDiagnoseServer).toHaveBeenCalledWith('192.168.1.100');
-            });
-            it('should call diagnoseServer with a UUID', async () => {
-                mockDiagnoseServer.mockResolvedValue({
-                    server: {
-                        uuid: 'ggkk8w4c08gw48oowsg4g0oc',
-                        name: 'coolify-apps',
-                        ip: '10.0.0.1',
-                        status: 'running',
-                        is_reachable: true,
-                    },
-                    health: { status: 'healthy', issues: [] },
-                    resources: [],
-                    domains: [],
-                    validation: { message: 'Server is reachable' },
-                });
-                await mockDiagnoseServer('ggkk8w4c08gw48oowsg4g0oc');
-                expect(mockDiagnoseServer).toHaveBeenCalledWith('ggkk8w4c08gw48oowsg4g0oc');
-            });
-        });
-        describe('find_issues', () => {
-            it('should call findInfrastructureIssues', async () => {
-                mockFindInfrastructureIssues.mockResolvedValue({
-                    summary: {
-                        total_issues: 2,
-                        unhealthy_applications: 1,
-                        unhealthy_databases: 0,
-                        unhealthy_services: 1,
-                        unreachable_servers: 0,
-                    },
-                    issues: [
-                        {
-                            type: 'application',
-                            uuid: 'app-1',
-                            name: 'broken-app',
-                            issue: 'Application is unhealthy',
-                            status: 'exited:unhealthy',
-                        },
-                        {
-                            type: 'service',
-                            uuid: 'svc-1',
-                            name: 'broken-service',
-                            issue: 'Service has exited',
-                            status: 'exited',
-                        },
-                    ],
-                });
-                await mockFindInfrastructureIssues();
-                expect(mockFindInfrastructureIssues).toHaveBeenCalled();
-            });
-            it('should return empty issues when infrastructure is healthy', async () => {
-                mockFindInfrastructureIssues.mockResolvedValue({
-                    summary: {
-                        total_issues: 0,
-                        unhealthy_applications: 0,
-                        unhealthy_databases: 0,
-                        unhealthy_services: 0,
-                        unreachable_servers: 0,
-                    },
-                    issues: [],
-                });
-                const result = await mockFindInfrastructureIssues();
-                expect(result.summary.total_issues).toBe(0);
-                expect(result.issues).toHaveLength(0);
-            });
+    describe('client', () => {
+        it('should have client instance', () => {
+            const client = server['client'];
+            expect(client).toBeDefined();
         });
-        describe('delete_database', () => {
-            it('should call deleteDatabase with uuid', async () => {
-                mockDeleteDatabase.mockResolvedValue({ message: 'Database deletion request queued.' });
-                await mockDeleteDatabase('db-uuid-123');
-                expect(mockDeleteDatabase).toHaveBeenCalledWith('db-uuid-123');
-            });
-            it('should call deleteDatabase with delete_volumes option', async () => {
-                mockDeleteDatabase.mockResolvedValue({ message: 'Database deletion request queued.' });
-                await mockDeleteDatabase('db-uuid-123', { deleteVolumes: true });
-                expect(mockDeleteDatabase).toHaveBeenCalledWith('db-uuid-123', { deleteVolumes: true });
-            });
+        it('should have all required client methods', () => {
+            const client = server['client'];
+            // Core methods
+            expect(typeof client.getVersion).toBe('function');
+            // Server operations
+            expect(typeof client.listServers).toBe('function');
+            expect(typeof client.getServer).toBe('function');
+            expect(typeof client.getServerResources).toBe('function');
+            expect(typeof client.getServerDomains).toBe('function');
+            expect(typeof client.validateServer).toBe('function');
+            // Project operations
+            expect(typeof client.listProjects).toBe('function');
+            expect(typeof client.getProject).toBe('function');
+            expect(typeof client.createProject).toBe('function');
+            expect(typeof client.updateProject).toBe('function');
+            expect(typeof client.deleteProject).toBe('function');
+            // Environment operations
+            expect(typeof client.listProjectEnvironments).toBe('function');
+            expect(typeof client.getProjectEnvironment).toBe('function');
+            expect(typeof client.createProjectEnvironment).toBe('function');
+            expect(typeof client.deleteProjectEnvironment).toBe('function');
+            // Application operations
+            expect(typeof client.listApplications).toBe('function');
+            expect(typeof client.getApplication).toBe('function');
+            expect(typeof client.createApplicationPrivateGH).toBe('function');
+            expect(typeof client.createApplicationPrivateKey).toBe('function');
+            expect(typeof client.updateApplication).toBe('function');
+            expect(typeof client.deleteApplication).toBe('function');
+            expect(typeof client.getApplicationLogs).toBe('function');
+            // Control operations
+            expect(typeof client.startApplication).toBe('function');
+            expect(typeof client.stopApplication).toBe('function');
+            expect(typeof client.restartApplication).toBe('function');
+            expect(typeof client.startDatabase).toBe('function');
+            expect(typeof client.stopDatabase).toBe('function');
+            expect(typeof client.restartDatabase).toBe('function');
+            expect(typeof client.startService).toBe('function');
+            expect(typeof client.stopService).toBe('function');
+            expect(typeof client.restartService).toBe('function');
+            // Database operations
+            expect(typeof client.listDatabases).toBe('function');
+            expect(typeof client.getDatabase).toBe('function');
+            expect(typeof client.deleteDatabase).toBe('function');
+            expect(typeof client.createPostgresql).toBe('function');
+            expect(typeof client.createMysql).toBe('function');
+            expect(typeof client.createMariadb).toBe('function');
+            expect(typeof client.createMongodb).toBe('function');
+            expect(typeof client.createRedis).toBe('function');
+            expect(typeof client.createKeydb).toBe('function');
+            expect(typeof client.createClickhouse).toBe('function');
+            expect(typeof client.createDragonfly).toBe('function');
+            // Service operations
+            expect(typeof client.listServices).toBe('function');
+            expect(typeof client.getService).toBe('function');
+            expect(typeof client.createService).toBe('function');
+            expect(typeof client.updateService).toBe('function');
+            expect(typeof client.deleteService).toBe('function');
+            // Environment variable operations
+            expect(typeof client.listApplicationEnvVars).toBe('function');
+            expect(typeof client.createApplicationEnvVar).toBe('function');
+            expect(typeof client.updateApplicationEnvVar).toBe('function');
+            expect(typeof client.deleteApplicationEnvVar).toBe('function');
+            expect(typeof client.listServiceEnvVars).toBe('function');
+            expect(typeof client.createServiceEnvVar).toBe('function');
+            expect(typeof client.deleteServiceEnvVar).toBe('function');
+            // Deployment operations
+            expect(typeof client.listDeployments).toBe('function');
+            expect(typeof client.getDeployment).toBe('function');
+            expect(typeof client.deployByTagOrUuid).toBe('function');
+            expect(typeof client.listApplicationDeployments).toBe('function');
+            expect(typeof client.cancelDeployment).toBe('function');
+            // Private key operations
+            expect(typeof client.listPrivateKeys).toBe('function');
+            expect(typeof client.getPrivateKey).toBe('function');
+            expect(typeof client.createPrivateKey).toBe('function');
+            expect(typeof client.updatePrivateKey).toBe('function');
+            expect(typeof client.deletePrivateKey).toBe('function');
+            // Backup operations
+            expect(typeof client.listDatabaseBackups).toBe('function');
+            expect(typeof client.getDatabaseBackup).toBe('function');
+            expect(typeof client.listBackupExecutions).toBe('function');
+            expect(typeof client.getBackupExecution).toBe('function');
+            // Diagnostic operations
+            expect(typeof client.diagnoseApplication).toBe('function');
+            expect(typeof client.diagnoseServer).toBe('function');
+            expect(typeof client.findInfrastructureIssues).toBe('function');
+            // Batch operations
+            expect(typeof client.restartProjectApps).toBe('function');
+            expect(typeof client.bulkEnvUpdate).toBe('function');
+            expect(typeof client.stopAllApps).toBe('function');
+            expect(typeof client.redeployProjectApps).toBe('function');
         });
     });
-    describe('version tools', () => {
-        it('get_mcp_version should return correct version format', () => {
-            // The VERSION constant is '1.1.0' in mcp-server.ts
-            // This test verifies the expected output structure
-            const expectedResponse = {
-                version: '1.1.0',
-                name: '@masonator/coolify-mcp',
-            };
-            expect(expectedResponse.version).toBe('1.1.0');
-            expect(expectedResponse.name).toBe('@masonator/coolify-mcp');
+    describe('server configuration', () => {
+        it('should store baseUrl and accessToken in client', () => {
+            const client = server['client'];
+            // CoolifyClient stores base URL without /api/v1 suffix
+            expect(client['baseUrl']).toBe('http://localhost:3000');
+            expect(client['accessToken']).toBe('test-token');
         });
     });
 });

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

@@ -2,7 +2,7 @@
  * Coolify API Client
  * Complete HTTP client for the Coolify API v1
  */
-import type { CoolifyConfig, DeleteOptions, MessageResponse, UuidResponse, Server, ServerResource, ServerDomain, ServerValidation, CreateServerRequest, UpdateServerRequest, Project, CreateProjectRequest, UpdateProjectRequest, Environment, CreateEnvironmentRequest, Application, CreateApplicationPublicRequest, CreateApplicationPrivateGHRequest, CreateApplicationPrivateKeyRequest, CreateApplicationDockerfileRequest, CreateApplicationDockerImageRequest, CreateApplicationDockerComposeRequest, UpdateApplicationRequest, ApplicationActionResponse, EnvironmentVariable, EnvVarSummary, CreateEnvVarRequest, UpdateEnvVarRequest, BulkUpdateEnvVarsRequest, Database, UpdateDatabaseRequest, DatabaseBackup, BackupExecution, Service, CreateServiceRequest, UpdateServiceRequest, ServiceCreateResponse, Deployment, Team, TeamMember, PrivateKey, CreatePrivateKeyRequest, UpdatePrivateKeyRequest, CloudToken, CreateCloudTokenRequest, UpdateCloudTokenRequest, CloudTokenValidation, Version, ApplicationDiagnostic, ServerDiagnostic, InfrastructureIssuesReport, BatchOperationResult } from '../types/coolify.js';
+import type { CoolifyConfig, DeleteOptions, MessageResponse, UuidResponse, Server, ServerResource, ServerDomain, ServerValidation, CreateServerRequest, UpdateServerRequest, Project, CreateProjectRequest, UpdateProjectRequest, Environment, CreateEnvironmentRequest, Application, CreateApplicationPublicRequest, CreateApplicationPrivateGHRequest, CreateApplicationPrivateKeyRequest, CreateApplicationDockerfileRequest, CreateApplicationDockerImageRequest, CreateApplicationDockerComposeRequest, UpdateApplicationRequest, ApplicationActionResponse, EnvironmentVariable, EnvVarSummary, CreateEnvVarRequest, UpdateEnvVarRequest, BulkUpdateEnvVarsRequest, Database, UpdateDatabaseRequest, CreatePostgresqlRequest, CreateMysqlRequest, CreateMariadbRequest, CreateMongodbRequest, CreateRedisRequest, CreateKeydbRequest, CreateClickhouseRequest, CreateDragonflyRequest, CreateDatabaseResponse, DatabaseBackup, BackupExecution, Service, CreateServiceRequest, UpdateServiceRequest, ServiceCreateResponse, Deployment, Team, TeamMember, PrivateKey, CreatePrivateKeyRequest, UpdatePrivateKeyRequest, CloudToken, CreateCloudTokenRequest, UpdateCloudTokenRequest, CloudTokenValidation, Version, ApplicationDiagnostic, ServerDiagnostic, InfrastructureIssuesReport, BatchOperationResult } from '../types/coolify.js';
 export interface ListOptions {
     page?: number;
     per_page?: number;
@@ -114,6 +114,14 @@ export declare class CoolifyClient {
     startDatabase(uuid: string): Promise<MessageResponse>;
     stopDatabase(uuid: string): Promise<MessageResponse>;
     restartDatabase(uuid: string): Promise<MessageResponse>;
+    createPostgresql(data: CreatePostgresqlRequest): Promise<CreateDatabaseResponse>;
+    createMysql(data: CreateMysqlRequest): Promise<CreateDatabaseResponse>;
+    createMariadb(data: CreateMariadbRequest): Promise<CreateDatabaseResponse>;
+    createMongodb(data: CreateMongodbRequest): Promise<CreateDatabaseResponse>;
+    createRedis(data: CreateRedisRequest): Promise<CreateDatabaseResponse>;
+    createKeydb(data: CreateKeydbRequest): Promise<CreateDatabaseResponse>;
+    createClickhouse(data: CreateClickhouseRequest): Promise<CreateDatabaseResponse>;
+    createDragonfly(data: CreateDragonflyRequest): Promise<CreateDatabaseResponse>;
     listServices(options?: ListOptions): Promise<Service[] | ServiceSummary[]>;
     getService(uuid: string): Promise<Service>;
     createService(data: CreateServiceRequest): Promise<ServiceCreateResponse>;