@masonator/coolify-mcp 0.2.16 → 0.2.18

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

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[];
-    }>;
-}

package/dist/lib/mcp-server.js

@@ -1,423 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { CoolifyClient } from './coolify-client.js';
-import debug from 'debug';
-import { z } from 'zod';
-const log = debug('coolify:mcp');
-// Define valid service types
-const serviceTypes = [
-    'activepieces',
-    'appsmith',
-    'appwrite',
-    'authentik',
-    'babybuddy',
-    'budge',
-    'changedetection',
-    'chatwoot',
-    'classicpress-with-mariadb',
-    'classicpress-with-mysql',
-    'classicpress-without-database',
-    'cloudflared',
-    'code-server',
-    'dashboard',
-    'directus',
-    'directus-with-postgresql',
-    'docker-registry',
-    'docuseal',
-    'docuseal-with-postgres',
-    'dokuwiki',
-    'duplicati',
-    'emby',
-    'embystat',
-    'fider',
-    'filebrowser',
-    'firefly',
-    'formbricks',
-    'ghost',
-    'gitea',
-    'gitea-with-mariadb',
-    'gitea-with-mysql',
-    'gitea-with-postgresql',
-    'glance',
-    'glances',
-    'glitchtip',
-    'grafana',
-    'grafana-with-postgresql',
-    'grocy',
-    'heimdall',
-    'homepage',
-    'jellyfin',
-    'kuzzle',
-    'listmonk',
-    'logto',
-    'mediawiki',
-    'meilisearch',
-    'metabase',
-    'metube',
-    'minio',
-    'moodle',
-    'n8n',
-    'n8n-with-postgresql',
-    'next-image-transformation',
-    'nextcloud',
-    'nocodb',
-    'odoo',
-    'openblocks',
-    'pairdrop',
-    'penpot',
-    'phpmyadmin',
-    'pocketbase',
-    'posthog',
-    'reactive-resume',
-    'rocketchat',
-    'shlink',
-    'slash',
-    'snapdrop',
-    'statusnook',
-    'stirling-pdf',
-    'supabase',
-    'syncthing',
-    'tolgee',
-    'trigger',
-    'trigger-with-external-database',
-    'twenty',
-    'umami',
-    'unleash-with-postgresql',
-    'unleash-without-database',
-    'uptime-kuma',
-    'vaultwarden',
-    'vikunja',
-    'weblate',
-    'whoogle',
-    'wordpress-with-mariadb',
-    'wordpress-with-mysql',
-    'wordpress-without-database'
-];
-export class CoolifyMcpServer extends McpServer {
-    client;
-    constructor(config) {
-        super({
-            name: 'coolify',
-            version: '0.1.18',
-            capabilities: {
-                tools: true,
-                resources: true,
-                prompts: true
-            }
-        });
-        log('Initializing server with config: %o', config);
-        this.client = new CoolifyClient(config);
-        this.setupTools();
-    }
-    setupTools() {
-        log('Setting up tools');
-        this.tool('list_servers', 'List all Coolify servers', {}, async (_args, _extra) => {
-            const servers = await this.client.listServers();
-            return {
-                content: [{ type: 'text', text: JSON.stringify(servers, null, 2) }]
-            };
-        });
-        this.tool('get_server', 'Get details about a specific Coolify server', {
-            uuid: z.string().describe('UUID of the server to get details for')
-        }, async (args) => {
-            const server = await this.client.getServer(args.uuid);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(server, null, 2) }]
-            };
-        });
-        this.tool('get_server_resources', 'Get the current resources running on a specific Coolify server', {
-            uuid: z.string()
-        }, async (args, _extra) => {
-            const resources = await this.client.getServerResources(args.uuid);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(resources, null, 2) }]
-            };
-        });
-        this.tool('get_server_domains', 'Get domains for a specific Coolify server', {
-            uuid: z.string()
-        }, async (args, _extra) => {
-            const domains = await this.client.getServerDomains(args.uuid);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(domains, null, 2) }]
-            };
-        });
-        this.tool('validate_server', 'Validate a specific Coolify server', {
-            uuid: z.string()
-        }, async (args, _extra) => {
-            const validation = await this.client.validateServer(args.uuid);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(validation, null, 2) }]
-            };
-        });
-        this.tool('list_projects', 'List all Coolify projects', {}, async (_args, _extra) => {
-            const projects = await this.client.listProjects();
-            return {
-                content: [{ type: 'text', text: JSON.stringify(projects, null, 2) }]
-            };
-        });
-        this.tool('get_project', 'Get details about a specific Coolify project', {
-            uuid: z.string()
-        }, async (args, _extra) => {
-            const project = await this.client.getProject(args.uuid);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(project, null, 2) }]
-            };
-        });
-        this.tool('create_project', 'Create a new Coolify project', {
-            name: z.string(),
-            description: z.string().optional()
-        }, async (args, _extra) => {
-            const result = await this.client.createProject({
-                name: args.name,
-                description: args.description
-            });
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
-            };
-        });
-        this.tool('update_project', 'Update an existing Coolify project', {
-            uuid: z.string(),
-            name: z.string(),
-            description: z.string().optional()
-        }, async (args, _extra) => {
-            const { uuid, ...updateData } = args;
-            const result = await this.client.updateProject(uuid, updateData);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
-            };
-        });
-        this.tool('delete_project', 'Delete a Coolify project', {
-            uuid: z.string()
-        }, async (args, _extra) => {
-            const result = await this.client.deleteProject(args.uuid);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
-            };
-        });
-        this.tool('get_project_environment', 'Get environment details for a Coolify project', {
-            project_uuid: z.string(),
-            environment_name_or_uuid: z.string()
-        }, async (args, _extra) => {
-            const environment = await this.client.getProjectEnvironment(args.project_uuid, args.environment_name_or_uuid);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(environment, null, 2) }]
-            };
-        });
-        this.tool('list_databases', 'List all Coolify databases', {}, async (_args, _extra) => {
-            const databases = await this.client.listDatabases();
-            return {
-                content: [{ type: 'text', text: JSON.stringify(databases, null, 2) }]
-            };
-        });
-        this.tool('get_database', 'Get details about a specific Coolify database', {
-            uuid: z.string()
-        }, async (args, _extra) => {
-            const database = await this.client.getDatabase(args.uuid);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(database, null, 2) }]
-            };
-        });
-        this.tool('update_database', 'Update a Coolify database', {
-            uuid: z.string(),
-            data: z.record(z.unknown())
-        }, async (args, _extra) => {
-            const result = await this.client.updateDatabase(args.uuid, args.data);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
-            };
-        });
-        const deleteOptionsSchema = {
-            deleteConfigurations: z.boolean().optional(),
-            deleteVolumes: z.boolean().optional(),
-            dockerCleanup: z.boolean().optional(),
-            deleteConnectedNetworks: z.boolean().optional()
-        };
-        this.tool('delete_database', 'Delete a Coolify database', {
-            uuid: z.string(),
-            options: z.object(deleteOptionsSchema).optional()
-        }, async (args, _extra) => {
-            const result = await this.client.deleteDatabase(args.uuid, args.options);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
-            };
-        });
-        this.tool('deploy_application', 'Deploy a Coolify application', {
-            uuid: z.string()
-        }, async (args, _extra) => {
-            const result = await this.client.deployApplication(args.uuid);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
-            };
-        });
-        this.tool('list_services', 'List all Coolify services', {}, async (_args, _extra) => {
-            const services = await this.client.listServices();
-            return {
-                content: [{ type: 'text', text: JSON.stringify(services, null, 2) }]
-            };
-        });
-        this.tool('get_service', 'Get details about a specific Coolify service', {
-            uuid: z.string()
-        }, async (args, _extra) => {
-            const service = await this.client.getService(args.uuid);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(service, null, 2) }]
-            };
-        });
-        this.tool('create_service', 'Create a new Coolify service', {
-            type: z.enum(serviceTypes),
-            project_uuid: z.string(),
-            server_uuid: z.string(),
-            name: z.string().optional(),
-            description: z.string().optional(),
-            environment_name: z.string().optional(),
-            environment_uuid: z.string().optional(),
-            destination_uuid: z.string().optional(),
-            instant_deploy: z.boolean().optional()
-        }, async (args, _extra) => {
-            const result = await this.client.createService(args);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
-            };
-        });
-        this.tool('delete_service', 'Delete a Coolify service', {
-            uuid: z.string(),
-            options: z.object(deleteOptionsSchema).optional()
-        }, async (args, _extra) => {
-            const result = await this.client.deleteService(args.uuid, args.options);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
-            };
-        });
-    }
-    async connect(transport) {
-        log('Starting server...');
-        log('Validating connection...');
-        await this.client.validateConnection();
-        await super.connect(transport);
-        log('Server started successfully');
-    }
-    async list_servers() {
-        return this.client.listServers();
-    }
-    async get_server(uuid) {
-        return this.client.getServer(uuid);
-    }
-    async get_server_resources(uuid) {
-        return this.client.getServerResources(uuid);
-    }
-    async get_server_domains(uuid) {
-        return this.client.getServerDomains(uuid);
-    }
-    async validate_server(uuid) {
-        return this.client.validateServer(uuid);
-    }
-    async list_projects() {
-        return this.client.listProjects();
-    }
-    async get_project(uuid) {
-        return this.client.getProject(uuid);
-    }
-    async create_project(project) {
-        return this.client.createProject(project);
-    }
-    async update_project(uuid, project) {
-        return this.client.updateProject(uuid, project);
-    }
-    async delete_project(uuid) {
-        return this.client.deleteProject(uuid);
-    }
-    async get_project_environment(projectUuid, environmentNameOrUuid) {
-        return this.client.getProjectEnvironment(projectUuid, environmentNameOrUuid);
-    }
-    async deploy_application(params) {
-        return this.client.deployApplication(params.uuid);
-    }
-    async list_databases() {
-        return this.client.listDatabases();
-    }
-    async get_database(uuid) {
-        return this.client.getDatabase(uuid);
-    }
-    async update_database(uuid, data) {
-        return this.client.updateDatabase(uuid, data);
-    }
-    async delete_database(uuid, options) {
-        return this.client.deleteDatabase(uuid, options);
-    }
-    async list_services() {
-        return this.client.listServices();
-    }
-    async get_service(uuid) {
-        return this.client.getService(uuid);
-    }
-    async create_service(data) {
-        return this.client.createService(data);
-    }
-    async delete_service(uuid, options) {
-        return this.client.deleteService(uuid, options);
-    }
-    async resources_list() {
-        return {
-            resources: [
-                'coolify/servers/list',
-                'coolify/servers/{id}',
-                'coolify/servers/{id}/resources',
-                'coolify/servers/{id}/domains',
-                'coolify/servers/{id}/validate',
-                'coolify/projects/list',
-                'coolify/projects/{id}',
-                'coolify/projects/create',
-                'coolify/projects/{id}/update',
-                'coolify/projects/{id}/delete',
-                'coolify/projects/{id}/environments/{env}',
-                'coolify/databases/list',
-                'coolify/databases/{id}',
-                'coolify/databases/{id}/update',
-                'coolify/databases/{id}/delete',
-                'coolify/services/list',
-                'coolify/services/{id}',
-                'coolify/services/create',
-                'coolify/services/{id}/delete',
-                'coolify/applications/deploy/{id}'
-            ]
-        };
-    }
-    async prompts_list() {
-        return {
-            prompts: [
-                'Show me all Coolify servers in my instance',
-                'What\'s the status of server {uuid}?',
-                'Show me the resources running on server {uuid}',
-                'What domains are configured for server {uuid}?',
-                'Can you validate the connection to server {uuid}?',
-                'How much CPU and memory is server {uuid} using?',
-                'List all resources running on server {uuid}',
-                'Show me the current status of all servers',
-                'List all my Coolify projects',
-                'Create a new project called "{name}" with description "{description}"',
-                'Show me the details of project {uuid}',
-                'Update project {uuid} to change its name to "{name}"',
-                'Delete project {uuid}',
-                'Show me the environments in project {uuid}',
-                'Get details of the {env} environment in project {uuid}',
-                'What variables are set in the {env} environment of project {uuid}?',
-                'List all applications',
-                'Show me details of application {uuid}',
-                'Create a new application called "{name}"',
-                'Delete application {uuid}',
-                'Show me all running services',
-                'Create a new {type} service',
-                'What\'s the status of service {uuid}?',
-                'Delete service {uuid} and clean up its resources',
-                'List all databases',
-                'Show me the configuration of database {uuid}',
-                'Update database {uuid}',
-                'Delete database {uuid} and clean up volumes',
-                'Show me all active deployments',
-                'What\'s the status of deployment {uuid}?',
-                'Deploy application {uuid}',
-                'Force rebuild and deploy application {uuid}',
-                'List recent deployments for application {uuid}'
-            ]
-        };
-    }
-}