@mks2508/coolify-mks-cli-mcp 0.1.0

package/src/server/sse.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+/**
+ * Coolify MCP Server - SSE Transport.
+ *
+ * Entry point for running the MCP server with SSE transport.
+ * This is useful for web integrations and testing.
+ *
+ * @module
+ */
+
+import { createServer } from 'node:http'
+
+const PORT = process.env.PORT || 3000
+
+const httpServer = createServer((req, res) => {
+  // Set CORS headers
+  res.setHeader('Access-Control-Allow-Origin', '*')
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type')
+
+  if (req.method === 'OPTIONS') {
+    res.writeHead(200)
+    res.end()
+    return
+  }
+
+  // Health check endpoint
+  if (req.url === '/health') {
+    res.writeHead(200, { 'Content-Type': 'application/json' })
+    res.end(JSON.stringify({ status: 'healthy', server: 'coolify-mcp' }))
+    return
+  }
+
+  // SSE endpoint - Note: This is a placeholder for future SSE support
+  if (req.url === '/sse') {
+    res.writeHead(200, { 'Content-Type': 'application/json' })
+    res.end(JSON.stringify({ message: 'SSE not yet implemented. Use stdio transport.' }))
+    return
+  }
+
+  // 404
+  res.writeHead(404, { 'Content-Type': 'application/json' })
+  res.end(JSON.stringify({ error: 'Not found' }))
+})
+
+httpServer.listen(PORT, () => {
+  console.warn(`Coolify MCP Server (SSE placeholder) listening on port ${PORT}`)
+  console.warn(`Health check: http://localhost:${PORT}/health`)
+  console.warn(`Note: SSE transport not yet implemented. Use stdio for Claude Desktop.`)
+})

package/src/server/stdio.ts

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+/**
+ * Coolify MCP Server - Stdio Transport.
+ *
+ * Entry point for running the MCP server with stdio transport.
+ * This is the standard way to use the MCP server with Claude Desktop.
+ *
+ * Uses @modelcontextprotocol/sdk for proper MCP stdio server implementation.
+ *
+ * @module
+ */
+
+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 { getCoolifyService } from '../coolify/index.js'
+import { coolifyTools } from '../tools/definitions.js'
+import { handleToolCall } from '../tools/handlers.js'
+
+const coolify = getCoolifyService()
+
+const server = new Server(
+  {
+    name: 'coolify-mks-cli',
+    version: '0.1.0'
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+)
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: coolifyTools
+}))
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params
+
+  return await handleToolCall(name, args as Record<string, unknown>, coolify)
+})
+
+async function main() {
+  const transport = new StdioServerTransport()
+  await server.connect(transport)
+}
+
+main().catch((error) => {
+  console.error('Fatal error starting MCP server:', error)
+  process.exit(1)
+})

package/src/tools/definitions.ts

@@ -0,0 +1,435 @@
+/**
+ * MCP Tool definitions for Coolify.
+ *
+ * Defines all 21 tools with their input schemas.
+ *
+ * @module
+ */
+
+import type { Tool } from '@modelcontextprotocol/sdk/types.js'
+
+/**
+ * All Coolify MCP tool definitions.
+ */
+export const coolifyTools: Tool[] = [
+  {
+    name: 'deploy',
+    description: `Deploy or redeploy an application to Coolify.
+
+Triggers a new deployment for the specified application UUID.
+Can force rebuild without cache if needed.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        uuid: {
+          type: 'string' as const,
+          description: 'Application UUID in Coolify',
+          format: 'uuid'
+        },
+        force: {
+          type: 'boolean' as const,
+          description: 'Force rebuild without cache',
+          default: false
+        },
+        tag: {
+          type: 'string' as const,
+          description: 'Deploy specific tag/version'
+        }
+      },
+      required: ['uuid']
+    }
+  },
+  {
+    name: 'get_env_vars',
+    description: `Get environment variables for a Coolify application.
+
+Returns all environment variables with metadata including whether
+they are runtime or buildtime, and if they are required.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        uuid: {
+          type: 'string' as const,
+          description: 'Application UUID',
+          format: 'uuid'
+        }
+      },
+      required: ['uuid']
+    }
+  },
+  {
+    name: 'set_env_vars',
+    description: `Set environment variables for a Coolify application.
+
+Updates or adds environment variables. Existing vars not in the
+input are preserved. Redeploy after setting to apply changes.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        uuid: {
+          type: 'string' as const,
+          description: 'Application UUID',
+          format: 'uuid'
+        },
+        envVars: {
+          type: 'object' as const,
+          description: 'Key-value pairs of environment variables',
+          additionalProperties: { type: 'string' as const }
+        }
+      },
+      required: ['uuid', 'envVars']
+    }
+  },
+  {
+    name: 'get_deployment_status',
+    description: `Get the current status of a Coolify application.
+
+Returns deployment state, health status, and resource usage.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        uuid: {
+          type: 'string' as const,
+          description: 'Application UUID',
+          format: 'uuid'
+        }
+      },
+      required: ['uuid']
+    }
+  },
+  {
+    name: 'list_applications',
+    description: `List all applications in Coolify.
+
+Optionally filter by team or project ID.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        teamId: {
+          type: 'string' as const,
+          description: 'Filter by Team ID'
+        },
+        projectId: {
+          type: 'string' as const,
+          description: 'Filter by Project ID'
+        }
+      }
+    }
+  },
+  {
+    name: 'delete_application',
+    description: `Delete an application from Coolify.
+
+WARNING: This action is irreversible. All deployments, environment
+variables, domains, and history will be permanently deleted.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        uuid: {
+          type: 'string' as const,
+          description: 'Application UUID to delete',
+          format: 'uuid'
+        }
+      },
+      required: ['uuid']
+    }
+  },
+  {
+    name: 'get_application_logs',
+    description: `Get logs for a Coolify application.
+
+Retrieve recent logs with optional tail limit.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        uuid: {
+          type: 'string' as const,
+          description: 'Application UUID',
+          format: 'uuid'
+        },
+        tail: {
+          type: 'number' as const,
+          description: 'Number of log lines to retrieve'
+        }
+      },
+      required: ['uuid']
+    }
+  },
+  {
+    name: 'start_application',
+    description: `Start a stopped Coolify application.
+
+Use this to start applications that were previously stopped.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        uuid: {
+          type: 'string' as const,
+          description: 'Application UUID to start',
+          format: 'uuid'
+        }
+      },
+      required: ['uuid']
+    }
+  },
+  {
+    name: 'stop_application',
+    description: `Stop a running Coolify application.
+
+WARNING: This will make the application temporarily unavailable.
+Containers will be stopped but not deleted.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        uuid: {
+          type: 'string' as const,
+          description: 'Application UUID to stop',
+          format: 'uuid'
+        }
+      },
+      required: ['uuid']
+    }
+  },
+  {
+    name: 'restart_application',
+    description: `Restart a Coolify application.
+
+Equivalent to stopping and then starting the application.
+Useful to apply configuration changes or recover from errors.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        uuid: {
+          type: 'string' as const,
+          description: 'Application UUID to restart',
+          format: 'uuid'
+        }
+      },
+      required: ['uuid']
+    }
+  },
+  {
+    name: 'get_deployment_history',
+    description: `Get deployment history for a Coolify application.
+
+Returns list of all deployments with status, timestamps, and commit info.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        uuid: {
+          type: 'string' as const,
+          description: 'Application UUID',
+          format: 'uuid'
+        }
+      },
+      required: ['uuid']
+    }
+  },
+  {
+    name: 'update_application',
+    description: `Update configuration for a Coolify application.
+
+Can modify name, description, build settings, and commands.
+Redeploy after updating to apply changes.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        uuid: {
+          type: 'string' as const,
+          description: 'Application UUID',
+          format: 'uuid'
+        },
+        name: {
+          type: 'string' as const,
+          description: 'New application name'
+        },
+        description: {
+          type: 'string' as const,
+          description: 'New description'
+        },
+        buildPack: {
+          type: 'string' as const,
+          description: 'Build pack type',
+          enum: ['dockerfile', 'nixpacks', 'static']
+        },
+        gitBranch: {
+          type: 'string' as const,
+          description: 'Git branch to deploy'
+        },
+        portsExposes: {
+          type: 'string' as const,
+          description: 'Ports to expose (comma-separated)'
+        },
+        installCommand: {
+          type: 'string' as const,
+          description: 'Install command (nixpacks)'
+        },
+        buildCommand: {
+          type: 'string' as const,
+          description: 'Build command'
+        },
+        startCommand: {
+          type: 'string' as const,
+          description: 'Start command'
+        }
+      },
+      required: ['uuid']
+    }
+  },
+  {
+    name: 'list_servers',
+    description: `List all available servers in Coolify.
+
+Returns server UUIDs, names, and IPs. Use server UUID when creating applications.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {}
+    }
+  },
+  {
+    name: 'get_server',
+    description: `Get details of a specific Coolify server.
+
+Returns server information including name, IP, status, and configuration.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        serverUuid: {
+          type: 'string' as const,
+          description: 'Server UUID to get details for',
+          format: 'uuid'
+        }
+      },
+      required: ['serverUuid']
+    }
+  },
+  {
+    name: 'list_projects',
+    description: `List all projects in Coolify.
+
+Returns project UUIDs, names, and associated environments.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {}
+    }
+  },
+  {
+    name: 'list_teams',
+    description: `List all teams in Coolify.
+
+Returns team IDs, names, and configuration.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {}
+    }
+  },
+  {
+    name: 'get_server_destinations',
+    description: `Get available destinations for a Coolify server.
+
+Returns destination UUIDs needed when creating applications.
+Each destination represents a Docker network/environment on the server.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        serverUuid: {
+          type: 'string' as const,
+          description: 'Server UUID to get destinations for',
+          format: 'uuid'
+        }
+      },
+      required: ['serverUuid']
+    }
+  },
+  {
+    name: 'create_application',
+    description: `Create a new application in Coolify from a GitHub repository.
+
+Requires server UUID and destination UUID (get them from list_servers and get_server_destinations).
+The GitHub repository must be accessible via the configured GitHub App.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        name: {
+          type: 'string' as const,
+          description: 'Application name'
+        },
+        serverUuid: {
+          type: 'string' as const,
+          description: 'Server UUID to deploy to',
+          format: 'uuid'
+        },
+        destinationUuid: {
+          type: 'string' as const,
+          description: 'Destination UUID (Docker network)',
+          format: 'uuid'
+        },
+        githubRepoUrl: {
+          type: 'string' as const,
+          description: 'GitHub repository URL (e.g., https://github.com/user/repo)'
+        },
+        description: {
+          type: 'string' as const,
+          description: 'Application description'
+        },
+        branch: {
+          type: 'string' as const,
+          description: 'Git branch to deploy',
+          default: 'main'
+        },
+        buildPack: {
+          type: 'string' as const,
+          description: 'Build pack type',
+          enum: ['dockerfile', 'nixpacks', 'static'],
+          default: 'nixpacks'
+        }
+      },
+      required: ['name', 'serverUuid', 'destinationUuid', 'githubRepoUrl']
+    }
+  },
+  {
+    name: 'get_resource_usage',
+    description: `Get resource usage for a Coolify application.
+
+Returns current resource consumption metrics.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        uuid: {
+          type: 'string' as const,
+          description: 'Application UUID',
+          format: 'uuid'
+        }
+      },
+      required: ['uuid']
+    }
+  },
+  {
+    name: 'health_check',
+    description: `Check if Coolify API is accessible and credentials are valid.
+
+Returns connection status and API version info if available.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {}
+    }
+  },
+  {
+    name: 'get_application_details',
+    description: `Get detailed information about a Coolify application.
+
+Returns full application configuration including name, description,
+build settings, environment, and deployment status.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        uuid: {
+          type: 'string' as const,
+          description: 'Application UUID',
+          format: 'uuid'
+        }
+      },
+      required: ['uuid']
+    }
+  }
+]