@masonator/coolify-mcp 0.2.15 → 0.2.17

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

@@ -1,76 +0,0 @@
-import { ServiceResources } from '../../resources/service-resources.js';
-import { jest } from '@jest/globals';
-jest.mock('../../lib/coolify-client.js');
-describe('ServiceResources', () => {
-    let mockClient;
-    let resources;
-    const mockService = {
-        id: 1,
-        uuid: 'test-uuid',
-        name: 'test-service',
-        description: 'test description',
-        type: 'code-server',
-        status: 'running',
-        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 = {
-            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.mockResolvedValue([mockService]);
-            const result = await resources.listServices();
-            expect(result).toEqual([mockService]);
-            expect(mockClient.listServices).toHaveBeenCalled();
-        });
-    });
-    describe('getService', () => {
-        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-uuid');
-        });
-    });
-    describe('createService', () => {
-        it('should create a new service', async () => {
-            const createData = {
-                name: 'new-service',
-                type: 'code-server',
-                project_uuid: 'project-uuid',
-                environment_name: 'test-env',
-                environment_uuid: 'env-uuid',
-                server_uuid: 'server-uuid',
-            };
-            const mockResponse = {
-                uuid: 'new-uuid',
-                domains: ['new-service.test.com'],
-            };
-            mockClient.createService.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.mockResolvedValue(mockResponse);
-            const result = await resources.deleteService('test-uuid');
-            expect(result).toEqual(mockResponse);
-            expect(mockClient.deleteService).toHaveBeenCalledWith('test-uuid', undefined);
-        });
-    });
-});

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

@@ -1,44 +0,0 @@
-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;
-    constructor(config: CoolifyConfig);
-    private request;
-    listServers(): Promise<ServerInfo[]>;
-    getServer(uuid: string): Promise<ServerInfo>;
-    getServerResources(uuid: string): Promise<ServerResources>;
-    getServerDomains(uuid: string): Promise<ServerDomain[]>;
-    validateServer(uuid: string): Promise<ValidationResponse>;
-    validateConnection(): Promise<void>;
-    listProjects(): Promise<Project[]>;
-    getProject(uuid: string): Promise<Project>;
-    createProject(project: CreateProjectRequest): Promise<{
-        uuid: string;
-    }>;
-    updateProject(uuid: string, project: UpdateProjectRequest): Promise<Project>;
-    deleteProject(uuid: string): Promise<{
-        message: string;
-    }>;
-    getProjectEnvironment(projectUuid: string, environmentNameOrUuid: string): Promise<Environment>;
-    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[];
-    }>;
-    deleteService(uuid: string, options?: DeleteServiceOptions): Promise<{
-        message: string;
-    }>;
-}

package/dist/lib/coolify-client.js

@@ -1,161 +0,0 @@
-export class CoolifyClient {
-    baseUrl;
-    accessToken;
-    constructor(config) {
-        if (!config.baseUrl) {
-            throw new Error('Coolify base URL is required');
-        }
-        if (!config.accessToken) {
-            throw new Error('Coolify access token is required');
-        }
-        this.baseUrl = config.baseUrl.replace(/\/$/, '');
-        this.accessToken = config.accessToken;
-    }
-    async request(path, options = {}) {
-        try {
-            const url = `${this.baseUrl}/api/v1${path}`;
-            const response = await fetch(url, {
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${this.accessToken}`,
-                },
-                ...options,
-            });
-            const data = await response.json();
-            if (!response.ok) {
-                const error = data;
-                throw new Error(error.message || `HTTP ${response.status}: ${response.statusText}`);
-            }
-            return data;
-        }
-        catch (error) {
-            if (error instanceof TypeError && error.message.includes('fetch')) {
-                throw new Error(`Failed to connect to Coolify server at ${this.baseUrl}. Please check if the server is running and the URL is correct.`);
-            }
-            throw error;
-        }
-    }
-    async listServers() {
-        return this.request('/servers');
-    }
-    async getServer(uuid) {
-        return this.request(`/servers/${uuid}`);
-    }
-    async getServerResources(uuid) {
-        return this.request(`/servers/${uuid}/resources`);
-    }
-    async getServerDomains(uuid) {
-        return this.request(`/servers/${uuid}/domains`);
-    }
-    async validateServer(uuid) {
-        return this.request(`/servers/${uuid}/validate`);
-    }
-    async validateConnection() {
-        try {
-            await this.listServers();
-        }
-        catch (error) {
-            throw new Error(`Failed to connect to Coolify server: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async listProjects() {
-        return this.request('/projects');
-    }
-    async getProject(uuid) {
-        return this.request(`/projects/${uuid}`);
-    }
-    async createProject(project) {
-        return this.request('/projects', {
-            method: 'POST',
-            body: JSON.stringify(project),
-        });
-    }
-    async updateProject(uuid, project) {
-        return this.request(`/projects/${uuid}`, {
-            method: 'PATCH',
-            body: JSON.stringify(project),
-        });
-    }
-    async deleteProject(uuid) {
-        return this.request(`/projects/${uuid}`, {
-            method: 'DELETE',
-        });
-    }
-    async getProjectEnvironment(projectUuid, environmentNameOrUuid) {
-        return this.request(`/projects/${projectUuid}/${environmentNameOrUuid}`);
-    }
-    async deployApplication(uuid) {
-        const response = await this.request(`/applications/${uuid}/deploy`, {
-            method: 'POST',
-        });
-        return response;
-    }
-    async listDatabases() {
-        return this.request('/databases');
-    }
-    async getDatabase(uuid) {
-        return this.request(`/databases/${uuid}`);
-    }
-    async updateDatabase(uuid, data) {
-        return this.request(`/databases/${uuid}`, {
-            method: 'PATCH',
-            body: JSON.stringify(data),
-        });
-    }
-    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 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,56 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
-import type { ServerInfo, ServerResources, ServerDomain, ValidationResponse, Project, CreateProjectRequest, UpdateProjectRequest, Environment, Deployment, Database, DatabaseUpdateRequest, Service, CreateServiceRequest, DeleteServiceOptions } from '../types/coolify.js';
-export declare class CoolifyMcpServer extends McpServer {
-    private client;
-    constructor(config: {
-        baseUrl: string;
-        accessToken: string;
-    });
-    private setupTools;
-    connect(transport: Transport): Promise<void>;
-    list_servers(): Promise<ServerInfo[]>;
-    get_server(uuid: string): Promise<ServerInfo>;
-    get_server_resources(uuid: string): Promise<ServerResources>;
-    get_server_domains(uuid: string): Promise<ServerDomain[]>;
-    validate_server(uuid: string): Promise<ValidationResponse>;
-    list_projects(): Promise<Project[]>;
-    get_project(uuid: string): Promise<Project>;
-    create_project(project: CreateProjectRequest): Promise<{
-        uuid: string;
-    }>;
-    update_project(uuid: string, project: UpdateProjectRequest): Promise<Project>;
-    delete_project(uuid: string): Promise<{
-        message: string;
-    }>;
-    get_project_environment(projectUuid: string, environmentNameOrUuid: string): Promise<Environment>;
-    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;
-    }>;
-    list_services(): Promise<Service[]>;
-    get_service(uuid: string): Promise<Service>;
-    create_service(data: CreateServiceRequest): Promise<{
-        uuid: string;
-        domains: string[];
-    }>;
-    delete_service(uuid: string, options?: DeleteServiceOptions): Promise<{
-        message: string;
-    }>;
-    resources_list(): Promise<{
-        resources: string[];
-    }>;
-    prompts_list(): Promise<{
-        prompts: string[];
-    }>;
-}