Merge pull request #10 from StuMason/feature/environment-management

feat: implement environment management feature

Author: StuMason

.cursor/rules/801-feature-workflow.mdc

@@ -1,7 +1,6 @@
 ---
 description: FOLLOW feature development workflow WHEN implementing new features TO ensure consistent, tested, and documented changes
-globs: src/**/*.{ts,tsx}
-alwaysApply: true
+globs: src/**/*
 ---
 
 # Feature Development Workflow
@@ -17,7 +16,8 @@ alwaysApply: true
 - Locate and review feature documentation in docs/features directory
 - Follow documentation requirements systematically
 - IMPORTANT Commit frequently to trigger pre-commit hooks (linting, formatting, tests)
-- Push to remote remotr
+- CRITICAL Always stage ALL modified files after making changes
+- CRITICAL Always push changes to remote after committing
 - Add comprehensive tests for new functionality
 - Push completed work to remote for PR review
 
@@ -29,28 +29,36 @@ alwaysApply: true
 3. Review docs/features/002-server-info-resource.md
 4. Implement ServerInfo interface
 5. Add getServerInfo method with tests
-6. Commit to run hooks: "feat: add server info interface"
-7. Implement ServerStatus interface
-8. Add getServerStatus method with tests
-9. Commit to run hooks: "feat: add server status resource"
-10. Fix any linting issues
-11. Push to remote when complete
+6. git add . # Stage ALL changes
+7. Commit to run hooks: "feat: add server info interface"
+8. git push origin feature/server-info # Push changes immediately
+9. Implement ServerStatus interface
+10. Add getServerStatus method with tests
+11. git add . # Stage ALL changes again
+12. Commit to run hooks: "feat: add server status resource"
+13. git push origin feature/server-info # Push changes again
+14. Fix any linting issues
+15. git add . && git commit -m "fix: linting issues"
+16. git push origin feature/server-info
 </example>
 
 <example type="invalid">
 # Poor workflow
 1. Start coding without checking docs
 2. Make all changes in one big commit
 3. Skip tests or add them later
-4. Push directly to main
-5. Fix linting issues after PR
+4. Leave changes unstaged
+5. Forget to push changes to remote
+6. Push directly to main
+7. Fix linting issues after PR
 </example>
 
 ## Critical Points
 <critical>
 - ALWAYS work from feature documentation
-- 
 - NEVER skip tests for new functionality
 - Commit OFTEN to utilize pre-commit hooks
+- ALWAYS stage ALL modified files after making changes
+- ALWAYS push changes to remote after committing
 - Keep commits focused and well-described
 </critical> 

.cursor/rules/802-coolify-mcp-workflow.mdc

@@ -1,5 +1,5 @@
 ---
-description: FOLLOW Coolify MCP workflow WHEN implementing new Coolify API endpoints TO ensure consistent and tested MCP tools
+description: FOLLOW Coolify MCP workflow WHEN implementing new Coolify API endpoints TO ensure consistent and tested MCP
 globs: src/**/*.{ts,tsx}
 alwaysApply: false
 ---
@@ -13,7 +13,7 @@ alwaysApply: false
 
 ## Requirements
 1. Start by reviewing feature documentation in docs/features
-2. Verify endpoint exists in openapi.yaml specification
+2. Verify endpoint exists in docs/openapi-chunks/* 
 3. Follow existing implementation patterns:
    - Add types to src/types/coolify.ts
    - Add client method to src/lib/coolify-client.ts

docs/features/004-environment-management.md

@@ -2,52 +2,59 @@
 
 ## Context
 
-Environment management within projects - allows setting up different environments (dev, staging, prod).
+Environment management within projects - allows retrieving environment information and deploying applications within environments.
 
 ## API Endpoints Used
 
-- GET `/environments` (Line ~1200)
+- GET `/projects/{uuid}/{environment_name_or_uuid}`
 
-  - Lists all environments
-  - Query params: project_uuid (optional)
-  - Response: Array of Environment objects
+  - Get environment details by project UUID and environment name/UUID
+  - Response: Environment object
   - Auth: Bearer token required
 
-- POST `/environments` (Line ~1250)
-
-  - Create new environment
-  - Request body: {
-    name: string,
-    project_uuid: string,
-    variables?: Record<string, string>
-    }
-  - Response: Environment object
+- POST `/applications/{uuid}/deploy`
+  - Deploy an application using its UUID
+  - Response: Deployment object
   - Auth: Bearer token required
 
-- GET `/environments/{uuid}` (Line ~1300)
+Note: Environment creation and management is handled through the Projects API. Environments are created and configured as part of project setup.
 
-  - Get environment details
-  - Response: Environment object with variables
-  - Auth: Bearer token required
+## Implementation Status
 
-- DELETE `/environments/{uuid}` (Line ~1350)
+### Completed
 
-  - Delete environment
-  - Response: 204 No Content
-  - Auth: Bearer token required
+- [x] Environment Detail Resource
 
-- PUT `/environments/{uuid}/variables` (Line ~1400)
-  - Update environment variables
-  - Request body: { variables: Record<string, string> }
-  - Response: Updated Environment object
-  - Auth: Bearer token required
+  - [x] GET project environment endpoint implemented
+  - [x] Client method: `getProjectEnvironment`
+  - [x] MCP tool: `get_project_environment`
+
+- [x] Application Deployment
+  - [x] Deploy application endpoint implemented
+  - [x] Client method: `deployApplication`
+  - [x] MCP tool: `deploy_application`
 
-## Implementation Checklist
+### Environment Schema
 
-- [x] Environment List Resource
-- [x] Environment Management Tools
+```typescript
+interface Environment {
+  id: number;
+  name: string;
+  project_id: number;
+  created_at: string;
+  updated_at: string;
+  description: string;
+}
+```
 
 ## Dependencies
 
 - ADR 001 (Core Server Setup)
 - ADR 003 (Project Management)
+
+## Notes
+
+- Environment management is tightly coupled with projects in the Coolify API
+- Environment variables are managed at the application level during application creation/updates
+- Direct environment CRUD operations are not available through dedicated endpoints
+- Environment information can be retrieved through the project endpoints

src/__tests__/coolify-client.test.ts

@@ -1,11 +1,5 @@
 import { CoolifyClient } from '../lib/coolify-client.js';
-import type {
-  ServerInfo,
-  ServerResources,
-  Environment,
-  Application,
-  CreateApplicationRequest,
-} from '../types/coolify.js';
+import type { ServerInfo, ServerResources, Environment, Deployment } from '../types/coolify.js';
 
 // Mock fetch globally
 const mockFetch = jest.fn();
@@ -300,158 +294,51 @@ describe('CoolifyClient', () => {
     });
   });
 
-  describe('Application Management', () => {
-    const mockApplication: Application = {
-      id: 1,
-      uuid: 'test-app-uuid',
-      name: 'test-app',
-      environment_uuid: 'test-env-uuid',
-      project_uuid: 'test-project-uuid',
-      git_repository: 'https://github.com/test/repo',
-      git_branch: 'main',
-      build_pack: 'nixpacks',
-      ports_exposes: '3000',
-      status: 'running',
-      created_at: '2024-03-05T12:00:00Z',
-      updated_at: '2024-03-05T12:00:00Z',
-    };
-
-    describe('listApplications', () => {
-      it('should fetch all applications when no environment UUID is provided', async () => {
-        mockFetch.mockResolvedValueOnce({
-          ok: true,
-          json: async () => [mockApplication],
-        });
-
-        const result = await client.listApplications();
-
-        expect(result).toEqual([mockApplication]);
-        expect(mockFetch).toHaveBeenCalledWith(
-          'http://test.coolify.io/api/v1/applications',
-          expect.objectContaining({
-            headers: expect.objectContaining({
-              Authorization: 'Bearer test-token',
-            }),
-          }),
-        );
-      });
-
-      it('should fetch applications filtered by environment UUID', async () => {
-        mockFetch.mockResolvedValueOnce({
-          ok: true,
-          json: async () => [mockApplication],
-        });
-
-        const result = await client.listApplications('test-env-uuid');
-
-        expect(result).toEqual([mockApplication]);
-        expect(mockFetch).toHaveBeenCalledWith(
-          'http://test.coolify.io/api/v1/applications?environment_uuid=test-env-uuid',
-          expect.objectContaining({
-            headers: expect.objectContaining({
-              Authorization: 'Bearer test-token',
-            }),
-          }),
-        );
-      });
-    });
-
-    describe('getApplication', () => {
-      it('should fetch application details successfully', async () => {
-        mockFetch.mockResolvedValueOnce({
-          ok: true,
-          json: async () => mockApplication,
-        });
-
-        const result = await client.getApplication('test-app-uuid');
+  describe('deployApplication', () => {
+    it('should deploy an application', async () => {
+      const mockDeployment: Deployment = {
+        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',
+      };
 
-        expect(result).toEqual(mockApplication);
-        expect(mockFetch).toHaveBeenCalledWith(
-          'http://test.coolify.io/api/v1/applications/test-app-uuid',
-          expect.objectContaining({
-            headers: expect.objectContaining({
-              Authorization: 'Bearer test-token',
-            }),
-          }),
-        );
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockDeployment),
       });
-    });
-
-    describe('createApplication', () => {
-      it('should create a new application successfully', async () => {
-        mockFetch.mockResolvedValueOnce({
-          ok: true,
-          json: async () => mockApplication,
-        });
 
-        const createRequest: CreateApplicationRequest = {
-          project_uuid: 'test-project-uuid',
-          environment_uuid: 'test-env-uuid',
-          git_repository: 'https://github.com/test/repo',
-          git_branch: 'main',
-          build_pack: 'nixpacks',
-          ports_exposes: '3000',
-          name: 'test-app',
-        };
-
-        const result = await client.createApplication(createRequest);
-
-        expect(result).toEqual(mockApplication);
-        expect(mockFetch).toHaveBeenCalledWith(
-          'http://test.coolify.io/api/v1/applications/public',
-          expect.objectContaining({
-            method: 'POST',
-            body: JSON.stringify(createRequest),
-            headers: expect.objectContaining({
-              Authorization: 'Bearer test-token',
-            }),
+      const result = await client.deployApplication('test-app-uuid');
+      expect(result).toEqual(mockDeployment);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://test.coolify.io/api/v1/applications/test-app-uuid/deploy',
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-token',
+            'Content-Type': 'application/json',
           }),
-        );
-      });
+        }),
+      );
     });
 
-    describe('deleteApplication', () => {
-      it('should delete an application successfully', async () => {
-        mockFetch.mockResolvedValueOnce({
-          ok: true,
-          json: async () => ({}),
-        });
-
-        await client.deleteApplication('test-app-uuid');
+    it('should handle errors when deploying an application', async () => {
+      const errorResponse = {
+        error: 'Error',
+        status: 500,
+        message: 'Failed to deploy application',
+      };
 
-        expect(mockFetch).toHaveBeenCalledWith(
-          'http://test.coolify.io/api/v1/applications/test-app-uuid',
-          expect.objectContaining({
-            method: 'DELETE',
-            headers: expect.objectContaining({
-              Authorization: 'Bearer test-token',
-            }),
-          }),
-        );
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        json: () => Promise.resolve(errorResponse),
       });
-    });
 
-    describe('deployApplication', () => {
-      it('should make a POST request to deploy an application', async () => {
-        const mockDeployment = { id: 'test-deployment' };
-        mockFetch.mockResolvedValueOnce({
-          ok: true,
-          json: async () => mockDeployment,
-        });
-
-        const result = await client.deployApplication('test-app-uuid');
-
-        expect(mockFetch).toHaveBeenCalledWith(
-          'http://test.coolify.io/api/v1/applications/test-app-uuid/deploy',
-          expect.objectContaining({
-            method: 'POST',
-            headers: expect.objectContaining({
-              Authorization: 'Bearer test-token',
-            }),
-          }),
-        );
-        expect(result).toEqual(mockDeployment);
-      });
+      await expect(client.deployApplication('test-app-uuid')).rejects.toThrow(
+        'Failed to deploy application',
+      );
     });
   });
 });