Merge pull request #12 from StuMason/feature/service-management

feat: add service management feature

Author: StuMason

docs/features/007-service-management.md

@@ -80,25 +80,25 @@ Implementation of one-click service management features through MCP resources, a
 
 ## Implementation Checklist
 
-- [ ] Basic Service Management
+- [x] Basic Service Management
 
-  - [ ] List services resource
-  - [ ] Get service details
-  - [ ] Create service
-  - [ ] Delete service
+  - [x] List services resource
+  - [x] Get service details
+  - [x] Create service
+  - [x] Delete service
 
-- [ ] Service Type Support
+- [x] Service Type Support
 
-  - [ ] Development tools deployment
-  - [ ] CMS system deployment
-  - [ ] Monitoring tools deployment
-  - [ ] Collaboration tools deployment
-  - [ ] Database tools deployment
+  - [x] Development tools deployment
+  - [x] CMS system deployment
+  - [x] Monitoring tools deployment
+  - [x] Collaboration tools deployment
+  - [x] Database tools deployment
 
-- [ ] Resource Testing
-  - [ ] Unit tests for service operations
-  - [ ] Integration tests with mock data
-  - [ ] Live test with real Coolify instance
+- [x] Resource Testing
+  - [x] Unit tests for service operations
+  - [x] Integration tests with mock data
+  - [x] Live test with real Coolify instance
 
 ## Dependencies
 

src/__tests__/coolify-client.test.ts

@@ -461,4 +461,135 @@ describe('CoolifyClient', () => {
       await expect(client.getDatabase('invalid-uuid')).rejects.toThrow(errorMessage);
     });
   });
+
+  describe('Service Management', () => {
+    const mockService = {
+      id: 1,
+      uuid: 'test-service-uuid',
+      name: 'test-service',
+      description: 'Test service',
+      type: 'code-server' as const,
+      status: 'running' as const,
+      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(() => {
+      mockFetch.mockClear();
+    });
+
+    it('should list services', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve([mockService]),
+      });
+
+      const result = await client.listServices();
+
+      expect(result).toEqual([mockService]);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://test.coolify.io/api/v1/services',
+        expect.objectContaining({
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'Bearer test-token',
+          },
+        }),
+      );
+    });
+
+    it('should get service details', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockService),
+      });
+
+      const result = await client.getService('test-service-uuid');
+
+      expect(result).toEqual(mockService);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://test.coolify.io/api/v1/services/test-service-uuid',
+        expect.objectContaining({
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'Bearer test-token',
+          },
+        }),
+      );
+    });
+
+    it('should create service', async () => {
+      const createData = {
+        type: 'code-server' as const,
+        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'],
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockResponse),
+      });
+
+      const result = await client.createService(createData);
+
+      expect(result).toEqual(mockResponse);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://test.coolify.io/api/v1/services',
+        expect.objectContaining({
+          method: 'POST',
+          body: JSON.stringify(createData),
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'Bearer test-token',
+          },
+        }),
+      );
+    });
+
+    it('should delete service', async () => {
+      const mockResponse = { message: 'Service deleted' };
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockResponse),
+      });
+
+      const result = await client.deleteService('test-service-uuid', {
+        deleteConfigurations: true,
+        deleteVolumes: true,
+      });
+
+      expect(result).toEqual(mockResponse);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://test.coolify.io/api/v1/services/test-service-uuid?delete_configurations=true&delete_volumes=true',
+        expect.objectContaining({
+          method: 'DELETE',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'Bearer test-token',
+          },
+        }),
+      );
+    });
+
+    it('should handle service errors', async () => {
+      const errorMessage = 'Service not found';
+      mockFetch.mockRejectedValue(new Error(errorMessage));
+
+      await expect(client.getService('invalid-uuid')).rejects.toThrow(errorMessage);
+    });
+  });
 });

src/__tests__/mcp-server.test.ts

@@ -271,4 +271,87 @@ describe('CoolifyMcpServer', () => {
       await expect(server.get_database('invalid-uuid')).rejects.toThrow(errorMessage);
     });
   });
+
+  describe('Service Management', () => {
+    const mockService = {
+      id: 1,
+      uuid: 'test-service-uuid',
+      name: 'test-service',
+      description: 'Test service',
+      type: 'code-server' as const,
+      status: 'running' as const,
+      created_at: '2024-03-06T12:00:00Z',
+      updated_at: '2024-03-06T12:00:00Z',
+      project_uuid: 'test-project-uuid',
+      environment_name: 'production',
+      environment_uuid: 'test-env-uuid',
+      server_uuid: 'test-server-uuid',
+      domains: ['test-service.example.com'],
+    };
+
+    it('should list services', async () => {
+      const spy = jest.spyOn(server['client'], 'listServices').mockResolvedValue([mockService]);
+
+      const result = await server.list_services();
+
+      expect(result).toEqual([mockService]);
+      expect(spy).toHaveBeenCalled();
+    });
+
+    it('should get service details', async () => {
+      const spy = jest.spyOn(server['client'], 'getService').mockResolvedValue(mockService);
+
+      const result = await server.get_service('test-service-uuid');
+
+      expect(result).toEqual(mockService);
+      expect(spy).toHaveBeenCalledWith('test-service-uuid');
+    });
+
+    it('should create service', async () => {
+      const createData = {
+        type: 'code-server' as const,
+        name: 'test-service',
+        description: 'Test service',
+        project_uuid: 'test-project-uuid',
+        environment_name: 'production',
+        server_uuid: 'test-server-uuid',
+        instant_deploy: true,
+      };
+
+      const mockResponse = {
+        uuid: 'test-service-uuid',
+        domains: ['test-service.example.com'],
+      };
+
+      const spy = jest.spyOn(server['client'], 'createService').mockResolvedValue(mockResponse);
+
+      const result = await server.create_service(createData);
+
+      expect(result).toEqual(mockResponse);
+      expect(spy).toHaveBeenCalledWith(createData);
+    });
+
+    it('should delete service', async () => {
+      const mockResponse = { message: 'Service deleted' };
+      const spy = jest.spyOn(server['client'], 'deleteService').mockResolvedValue(mockResponse);
+
+      const result = await server.delete_service('test-service-uuid', {
+        deleteConfigurations: true,
+        deleteVolumes: true,
+      });
+
+      expect(result).toEqual(mockResponse);
+      expect(spy).toHaveBeenCalledWith('test-service-uuid', {
+        deleteConfigurations: true,
+        deleteVolumes: true,
+      });
+    });
+
+    it('should handle service errors', async () => {
+      const errorMessage = 'Service not found';
+      jest.spyOn(server['client'], 'getService').mockRejectedValue(new Error(errorMessage));
+
+      await expect(server.get_service('invalid-uuid')).rejects.toThrow(errorMessage);
+    });
+  });
 });

src/lib/coolify-client.ts

@@ -12,6 +12,9 @@ import {
   Deployment,
   Database,
   DatabaseUpdateRequest,
+  Service,
+  CreateServiceRequest,
+  DeleteServiceOptions,
 } from '../types/coolify.js';
 
 export class CoolifyClient {
@@ -178,5 +181,45 @@ export class CoolifyClient {
     });
   }
 
+  async listServices(): Promise<Service[]> {
+    return this.request<Service[]>('/services');
+  }
+
+  async getService(uuid: string): Promise<Service> {
+    return this.request<Service>(`/services/${uuid}`);
+  }
+
+  async createService(data: CreateServiceRequest): Promise<{ uuid: string; domains: string[] }> {
+    return this.request<{ uuid: string; domains: string[] }>('/services', {
+      method: 'POST',
+      body: JSON.stringify(data),
+    });
+  }
+
+  async deleteService(uuid: string, options?: DeleteServiceOptions): Promise<{ message: string }> {
+    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<{ message: string }>(url, {
+      method: 'DELETE',
+    });
+  }
+
   // Add more methods as needed for other endpoints
 }