index.ts•6 kB
#!/usr/bin/env node
/**
* Coolify MCP Server - Unified Version
* Model Context Protocol server for Coolify deployment platform integration
*
* Optimized with consolidated tools to stay within 128 tool limit:
* - Application Management (1 tool)
* - Environment & Configuration (1 tool)
* - System Management (1 tool)
* - Documentation (1 tool)
*
* Total: 4 tools (was 19)
*
* Reference: https://coolify.io/docs/api
*/
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
CallToolRequestSchema,
ListToolsRequestSchema,
} from '@modelcontextprotocol/sdk/types.js';
import { z } from 'zod';
import * as dotenv from 'dotenv';
// Load environment variables
dotenv.config();
// Import Coolify API client
import { CoolifyApiClient } from './utils/coolify-client';
// Import unified tool handlers
import {
applicationManagementTool,
handleApplicationManagement,
} from './tools/applications-unified';
import {
environmentConfigurationTool,
handleEnvironmentConfiguration,
} from './tools/environment-unified';
import {
systemManagementTool,
handleSystemManagement,
} from './tools/system-unified';
import {
documentationTool,
handleDocumentation,
} from './tools/documentation-unified';
// Configuration schema
const ConfigSchema = z.object({
COOLIFY_BASE_URL: z.string().url().describe('Base URL of your Coolify instance (e.g., https://coolify.yourdomain.com)'),
COOLIFY_API_TOKEN: z.string().min(1).describe('API token from Coolify (generated in Keys & Tokens section)'),
COOLIFY_TEAM_ID: z.string().optional().describe('Optional team ID to scope API requests'),
});
class CoolifyMCPServer {
private server: Server;
private coolifyClient: CoolifyApiClient | null = null;
constructor() {
this.server = new Server(
{
name: 'coolify-mcp-server',
version: '1.1.0',
},
{
capabilities: {
tools: {},
},
}
);
this.setupErrorHandling();
this.setupHandlers();
}
private setupErrorHandling(): void {
process.on('SIGINT', async () => {
console.error('Received SIGINT, shutting down gracefully...');
await this.server.close();
process.exit(0);
});
process.on('SIGTERM', async () => {
console.error('Received SIGTERM, shutting down gracefully...');
await this.server.close();
process.exit(0);
});
}
private async initializeCoolifyClient(): Promise<void> {
try {
const config = ConfigSchema.parse({
COOLIFY_BASE_URL: process.env.COOLIFY_BASE_URL,
COOLIFY_API_TOKEN: process.env.COOLIFY_API_TOKEN,
COOLIFY_TEAM_ID: process.env.COOLIFY_TEAM_ID,
});
this.coolifyClient = new CoolifyApiClient({
baseUrl: config.COOLIFY_BASE_URL,
apiToken: config.COOLIFY_API_TOKEN,
teamId: config.COOLIFY_TEAM_ID || undefined,
});
// Test connection
const isConnected = await this.coolifyClient.testConnection();
if (!isConnected) {
throw new Error('Failed to connect to Coolify instance');
}
console.error('✅ Successfully connected to Coolify instance');
} catch (error) {
console.error('❌ Failed to initialize Coolify client:', error);
throw error;
}
}
private setupHandlers(): void {
// List available tools (only 4 unified tools)
this.server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: [
applicationManagementTool,
environmentConfigurationTool,
systemManagementTool,
documentationTool,
],
};
});
// Handle tool calls
this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
if (!this.coolifyClient) {
await this.initializeCoolifyClient();
}
if (!this.coolifyClient) {
throw new Error('Coolify client not initialized');
}
const { name, arguments: args } = request.params;
try {
switch (name) {
case 'coolify_application_management':
return await handleApplicationManagement(this.coolifyClient, args);
case 'coolify_environment_configuration':
return await handleEnvironmentConfiguration(this.coolifyClient, args);
case 'coolify_system_management':
return await handleSystemManagement(this.coolifyClient, args);
case 'coolify_documentation':
return await handleDocumentation(this.coolifyClient, args);
default:
throw new Error(`Unknown tool: ${name}`);
}
} catch (error) {
console.error(`Error handling tool call ${name}:`, error);
return {
content: [
{
type: 'text',
text: `❌ Error: ${error instanceof Error ? error.message : 'Unknown error occurred'}`,
},
],
};
}
});
}
async run(): Promise<void> {
console.error('🚀 Starting Coolify MCP Server (Unified)...');
const transport = new StdioServerTransport();
await this.server.connect(transport);
console.error('✅ Coolify MCP Server is running');
console.error('📖 Available unified tools (4 total):');
console.error(' 📱 Application Management: deploy, get, list, status, start, stop, restart, create');
console.error(' ⚙️ Environment Configuration: env vars, domains, logs');
console.error(' 🖥️ System Management: servers, teams, services, health check');
console.error(' 📚 Documentation: search, topics, API reference, troubleshooting');
console.error('🌐 Coolify Documentation: https://coolify.io/docs/');
}
}
// Start the server
const server = new CoolifyMCPServer();
server.run().catch((error) => {
console.error('Failed to start server:', error);
process.exit(1);
});