@masonator/coolify-mcp 0.1.0

package/dist/lib/mcp-server.js

@@ -0,0 +1,362 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoolifyMcpServer = void 0;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const coolify_client_js_1 = require("./coolify-client.js");
+const zod_1 = require("zod");
+class CoolifyMcpServer {
+    constructor(config) {
+        this.server = new mcp_js_1.McpServer({
+            name: 'coolify',
+            version: '0.1.0',
+        });
+        this.client = new coolify_client_js_1.CoolifyClient(config);
+        this.setupTools();
+    }
+    setupTools() {
+        this.server.tool('list_servers', 'List all Coolify servers', {}, async () => {
+            try {
+                const servers = await this.client.listServers();
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(servers) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+        this.server.tool('get_server', 'Get details about a specific Coolify server', { uuid: zod_1.z.string().describe('UUID of the server to get details for') }, async (params) => {
+            try {
+                const server = await this.client.getServer(params.uuid);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(server) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+        this.server.tool('get_server_resources', 'Get the current resources running on a specific Coolify server', { uuid: zod_1.z.string().describe('UUID of the server to get resources for') }, async (params) => {
+            try {
+                const resources = await this.client.getServerResources(params.uuid);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(resources) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+        this.server.tool('get_server_domains', 'Get the domains associated with a specific Coolify server', { uuid: zod_1.z.string().describe('UUID of the server to get domains for') }, async (params) => {
+            try {
+                const domains = await this.client.getServerDomains(params.uuid);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(domains) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+        this.server.tool('validate_server', 'Validate the connection to a specific Coolify server', { uuid: zod_1.z.string().describe('UUID of the server to validate') }, async (params) => {
+            try {
+                const result = await this.client.validateServer(params.uuid);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+        this.server.tool('list_projects', 'List all Coolify projects', {}, async () => {
+            try {
+                const projects = await this.client.listProjects();
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(projects) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+        this.server.tool('get_project', 'Get details about a specific Coolify project', { uuid: zod_1.z.string().describe('UUID of the project to get details for') }, async (params) => {
+            try {
+                const project = await this.client.getProject(params.uuid);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(project) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+        this.server.tool('create_project', 'Create a new Coolify project', {
+            name: zod_1.z.string().describe('Name of the project'),
+            description: zod_1.z.string().optional().describe('Optional description of the project'),
+        }, async (params) => {
+            try {
+                const result = await this.client.createProject(params);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+        this.server.tool('update_project', 'Update an existing Coolify project', {
+            uuid: zod_1.z.string().describe('UUID of the project to update'),
+            name: zod_1.z.string().optional().describe('New name for the project'),
+            description: zod_1.z.string().optional().describe('New description for the project'),
+        }, async (params) => {
+            try {
+                const { uuid, ...updateData } = params;
+                const result = await this.client.updateProject(uuid, updateData);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+        this.server.tool('delete_project', 'Delete a Coolify project', { uuid: zod_1.z.string().describe('UUID of the project to delete') }, async (params) => {
+            try {
+                const result = await this.client.deleteProject(params.uuid);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+        this.server.tool('get_project_environment', 'Get details about a specific environment in a project', {
+            project_uuid: zod_1.z.string().describe('UUID of the project'),
+            environment_name_or_uuid: zod_1.z.string().describe('Name or UUID of the environment'),
+        }, async (params) => {
+            try {
+                const environment = await this.client.getProjectEnvironment(params.project_uuid, params.environment_name_or_uuid);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(environment) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+        this.server.tool('list_environments', 'List all environments or environments for a specific project', {
+            project_uuid: zod_1.z
+                .string()
+                .optional()
+                .describe('Optional UUID of the project to list environments for'),
+        }, async (params) => {
+            try {
+                const environments = await this.client.listEnvironments(params.project_uuid);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(environments) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+        this.server.tool('get_environment', 'Get details about a specific environment', {
+            uuid: zod_1.z.string().describe('UUID of the environment to get details for'),
+        }, async (params) => {
+            try {
+                const environment = await this.client.getEnvironment(params.uuid);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(environment) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+        this.server.tool('create_environment', 'Create a new environment', {
+            name: zod_1.z.string().describe('Name of the environment'),
+            project_uuid: zod_1.z.string().describe('UUID of the project to create the environment in'),
+            variables: zod_1.z.record(zod_1.z.string()).optional().describe('Optional environment variables'),
+        }, async (params) => {
+            try {
+                const result = await this.client.createEnvironment(params);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+        this.server.tool('update_environment_variables', 'Update variables for a specific environment', {
+            uuid: zod_1.z.string().describe('UUID of the environment to update'),
+            variables: zod_1.z.record(zod_1.z.string()).describe('New environment variables'),
+        }, async (params) => {
+            try {
+                const result = await this.client.updateEnvironmentVariables(params.uuid, {
+                    variables: params.variables,
+                });
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+        this.server.tool('delete_environment', 'Delete an environment', {
+            uuid: zod_1.z.string().describe('UUID of the environment to delete'),
+        }, async (params) => {
+            try {
+                const result = await this.client.deleteEnvironment(params.uuid);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return {
+                    content: [{ type: 'text', text: errorMessage }],
+                    isError: true,
+                };
+            }
+        });
+    }
+    async start(transport) {
+        try {
+            await this.client.validateConnection();
+            await this.server.connect(transport);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Failed to start MCP server: ${errorMessage}`);
+        }
+    }
+    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 list_environments(params) {
+        return this.client.listEnvironments(params.project_uuid);
+    }
+    async get_environment(params) {
+        return this.client.getEnvironment(params.uuid);
+    }
+    async create_environment(params) {
+        return this.client.createEnvironment(params);
+    }
+    async update_environment_variables(params) {
+        return this.client.updateEnvironmentVariables(params.uuid, { variables: params.variables });
+    }
+    async delete_environment(params) {
+        return this.client.deleteEnvironment(params.uuid);
+    }
+}
+exports.CoolifyMcpServer = CoolifyMcpServer;

package/dist/types/coolify.d.ts

@@ -0,0 +1,69 @@
+export interface CoolifyConfig {
+    baseUrl: string;
+    accessToken: string;
+}
+export interface ServerInfo {
+    uuid: string;
+    name: string;
+    status: 'running' | 'stopped' | 'error';
+    version: string;
+    resources: {
+        cpu: number;
+        memory: number;
+        disk: number;
+    };
+}
+export interface ResourceStatus {
+    id: number;
+    uuid: string;
+    name: string;
+    type: string;
+    created_at: string;
+    updated_at: string;
+    status: string;
+}
+export type ServerResources = ResourceStatus[];
+export interface ErrorResponse {
+    error: string;
+    status: number;
+    message: string;
+}
+export interface ServerDomain {
+    ip: string;
+    domains: string[];
+}
+export interface ValidationResponse {
+    message: string;
+}
+export interface Environment {
+    id: number;
+    uuid: string;
+    name: string;
+    project_uuid: string;
+    variables?: Record<string, string>;
+    created_at: string;
+    updated_at: string;
+}
+export interface Project {
+    id: number;
+    uuid: string;
+    name: string;
+    description?: string;
+    environments?: Environment[];
+}
+export interface CreateProjectRequest {
+    name: string;
+    description?: string;
+}
+export interface UpdateProjectRequest {
+    name?: string;
+    description?: string;
+}
+export interface CreateEnvironmentRequest {
+    name: string;
+    project_uuid: string;
+    variables?: Record<string, string>;
+}
+export interface UpdateEnvironmentVariablesRequest {
+    variables: Record<string, string>;
+}

package/dist/types/coolify.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@masonator/coolify-mcp",
+  "scope": "@masonator",
+  "version": "0.1.0",
+  "description": "MCP server implementation for Coolify",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "coolify-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "format": "prettier --write .",
+    "prepare": "husky",
+    "prepublishOnly": "npm test && npm run lint",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "coolify",
+    "mcp",
+    "model-context-protocol"
+  ],
+  "author": "Stuart Mason",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.6.1",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.17.23",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "husky": "^9.0.11",
+    "jest": "^29.7.0",
+    "lint-staged": "^15.2.2",
+    "markdownlint-cli2": "^0.12.1",
+    "prettier": "^3.5.3",
+    "ts-jest": "^29.2.6",
+    "typescript": "^5.8.2"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}