index-original.ts•9.33 kB
#!/usr/bin/env node
/**
* Coolify MCP Server
* Model Context Protocol server for Coolify deployment platform integration
*
* This server provides tools for:
* - Application deployment and management
* - Environment variable configuration
* - Domain and SSL certificate management
* - Log retrieval and monitoring
* - Server and team management
*
* 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 all tool handlers
import {
deployApplicationTool,
getApplicationTool,
listApplicationsTool,
getApplicationStatusTool,
stopApplicationTool,
startApplicationTool,
restartApplicationTool,
handleDeployApplication,
handleGetApplication,
handleListApplications,
handleGetApplicationStatus,
handleStopApplication,
handleStartApplication,
handleRestartApplication,
} from './tools/applications';
import {
updateEnvironmentVariablesTool,
getEnvironmentVariablesTool,
setDomainTool,
getApplicationLogsTool,
handleUpdateEnvironmentVariables,
handleGetEnvironmentVariables,
handleSetDomain,
handleGetApplicationLogs,
} from './tools/environment';
import {
getServersTool,
getTeamsTool,
testConnectionTool,
getServicesTool,
handleGetServers,
handleGetTeams,
handleTestConnection,
handleGetServices,
} from './tools/system';
import {
searchDocumentationTool,
getDocumentationTool,
getApiReferenceTool,
getTroubleshootingTool,
handleSearchDocumentation,
handleGetDocumentation,
handleGetApiReference,
handleGetTroubleshooting,
} from './tools/documentation';
// 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.0.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
this.server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: [
// Application management tools
deployApplicationTool,
getApplicationTool,
listApplicationsTool,
getApplicationStatusTool,
stopApplicationTool,
startApplicationTool,
restartApplicationTool,
// Environment and domain tools
updateEnvironmentVariablesTool,
getEnvironmentVariablesTool,
setDomainTool,
getApplicationLogsTool,
// System management tools
getServersTool,
getTeamsTool,
testConnectionTool,
getServicesTool,
// Documentation tools
searchDocumentationTool,
getDocumentationTool,
getApiReferenceTool,
getTroubleshootingTool,
],
};
});
// 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) {
// Application management
case 'coolify_deploy_application':
return await handleDeployApplication(this.coolifyClient, args as any);
case 'coolify_get_application':
return await handleGetApplication(this.coolifyClient, args as any);
case 'coolify_list_applications':
return await handleListApplications(this.coolifyClient, args as any);
case 'coolify_get_application_status':
return await handleGetApplicationStatus(this.coolifyClient, args as any);
case 'coolify_stop_application':
return await handleStopApplication(this.coolifyClient, args as any);
case 'coolify_start_application':
return await handleStartApplication(this.coolifyClient, args as any);
case 'coolify_restart_application':
return await handleRestartApplication(this.coolifyClient, args as any);
// Environment and domain management
case 'coolify_update_environment_variables':
return await handleUpdateEnvironmentVariables(this.coolifyClient, args as any);
case 'coolify_get_environment_variables':
return await handleGetEnvironmentVariables(this.coolifyClient, args as any);
case 'coolify_set_domain':
return await handleSetDomain(this.coolifyClient, args as any);
case 'coolify_get_application_logs':
return await handleGetApplicationLogs(this.coolifyClient, args as any);
// System management
case 'coolify_get_servers':
return await handleGetServers(this.coolifyClient, args as any);
case 'coolify_get_teams':
return await handleGetTeams(this.coolifyClient, args as any);
case 'coolify_test_connection':
return await handleTestConnection(this.coolifyClient, args as any);
case 'coolify_get_services':
return await handleGetServices(this.coolifyClient, args as any);
// Documentation tools
case 'search_documentation':
return await handleSearchDocumentation({ params: { arguments: args } }, this.coolifyClient);
case 'get_documentation':
return await handleGetDocumentation({ params: { arguments: args } }, this.coolifyClient);
case 'get_api_reference':
return await handleGetApiReference({ params: { arguments: args } }, this.coolifyClient);
case 'get_troubleshooting':
return await handleGetTroubleshooting({ params: { arguments: args } }, this.coolifyClient);
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...');
const transport = new StdioServerTransport();
await this.server.connect(transport);
console.error('✅ Coolify MCP Server is running');
console.error('📖 Available tools:');
console.error(' Application Management: deploy, get, list, status, start, stop, restart');
console.error(' Environment & Domains: update env vars, set domain, get logs');
console.error(' System Management: get servers, teams, services, test connection');
console.error(' Documentation: search docs, get docs, 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);
});