@mks2508/coolify-mks-cli-mcp 0.1.0

package/src/index.ts

@@ -0,0 +1,864 @@
+/**
+ * Coolify MCP Server - Entry point.
+ *
+ * Exports the MCP server with 21 tools for Coolify management.
+ *
+ * @module
+ */
+
+import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk'
+import { z } from 'zod'
+import { isOk, isErr } from '@mks2508/no-throw'
+import { getCoolifyService } from './coolify/index.js'
+
+// Create service instance
+const coolify = getCoolifyService()
+
+/**
+ * Coolify MCP Server with 21 tools for deployment management.
+ */
+export const coolifyServer = createSdkMcpServer({
+  name: 'coolify-mks-cli',
+  version: '0.1.0',
+  tools: [
+    // 1. deploy
+    tool(
+      'deploy',
+      `Deploy or redeploy an application to Coolify.
+
+Triggers a new deployment for the specified application UUID.
+Can force rebuild without cache if needed.`,
+      {
+        uuid: z.string().uuid().describe('Application UUID in Coolify'),
+        force: z.boolean().default(false).describe('Force rebuild without cache'),
+        tag: z.string().optional().describe('Deploy specific tag/version'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.deploy({ uuid: args.uuid, force: args.force, tag: args.tag })
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({
+                success: true,
+                deploymentUuid: result.value.deploymentUuid,
+                resourceUuid: result.value.resourceUuid,
+                message: 'Deployment started',
+              }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Deployment failed: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 2. get_env_vars
+    tool(
+      'get_env_vars',
+      `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.`,
+      {
+        uuid: z.string().uuid().describe('Application UUID'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.getEnvironmentVariables(args.uuid)
+
+        if (isOk(result)) {
+          const runtimeVars = result.value.filter(ev => ev.is_runtime)
+          const buildtimeVars = result.value.filter(ev => ev.is_buildtime)
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({
+                success: true,
+                total: result.value.length,
+                runtimeCount: runtimeVars.length,
+                buildtimeCount: buildtimeVars.length,
+                runtime: runtimeVars,
+                buildtime: buildtimeVars,
+              }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to get env vars: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 3. set_env_vars
+    tool(
+      'set_env_vars',
+      `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.`,
+      {
+        uuid: z.string().uuid().describe('Application UUID'),
+        envVars: z.record(z.string()).describe('Key-value pairs of environment variables'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.setEnvironmentVariables(args.uuid, args.envVars)
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: `Set ${Object.keys(args.envVars).length} environment variable(s). Use deploy tool to apply changes.`,
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to set env vars: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 4. get_deployment_status
+    tool(
+      'get_deployment_status',
+      `Get the current status of a Coolify application.
+
+Returns deployment state, health status, and resource usage.`,
+      {
+        uuid: z.string().uuid().describe('Application UUID'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.getApplicationStatus(args.uuid)
+
+        if (isOk(result)) {
+          return {
+            content: [{ type: 'text' as const, text: JSON.stringify({ status: result.value }, null, 2) }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to get status: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 4. list_applications
+    tool(
+      'list_applications',
+      `List all applications in Coolify.
+
+Optionally filter by team or project ID.`,
+      {
+        teamId: z.string().optional().describe('Filter by Team ID'),
+        projectId: z.string().optional().describe('Filter by Project ID'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.listApplications(args.teamId, args.projectId)
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({ success: true, count: result.value.length, applications: result.value }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to list applications: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 5. delete_application
+    tool(
+      'delete_application',
+      `Delete an application from Coolify.
+
+WARNING: This action is irreversible. All deployments, environment
+variables, domains, and history will be permanently deleted.`,
+      {
+        uuid: z.string().uuid().describe('Application UUID to delete'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.deleteApplication(args.uuid)
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({ success: true, message: `Application ${args.uuid} deleted successfully` }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to delete application: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 6. get_application_logs
+    tool(
+      'get_application_logs',
+      `Get logs for a Coolify application.
+
+Retrieve recent logs with optional tail limit.`,
+      {
+        uuid: z.string().uuid().describe('Application UUID'),
+        tail: z.number().optional().describe('Number of log lines to retrieve'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.getApplicationLogs(args.uuid, { tail: args.tail })
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({
+                success: true,
+                timestamp: result.value.timestamp,
+                logCount: result.value.logs.length,
+                logs: result.value.logs,
+              }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to get logs: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 7. start_application
+    tool(
+      'start_application',
+      `Start a stopped Coolify application.
+
+Use this to start applications that were previously stopped.`,
+      {
+        uuid: z.string().uuid().describe('Application UUID to start'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.startApplication(args.uuid)
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({ success: true, message: `Application ${args.uuid} started`, application: result.value }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to start application: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 8. stop_application
+    tool(
+      'stop_application',
+      `Stop a running Coolify application.
+
+WARNING: This will make the application temporarily unavailable.
+Containers will be stopped but not deleted.`,
+      {
+        uuid: z.string().uuid().describe('Application UUID to stop'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.stopApplication(args.uuid)
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({ success: true, message: `Application ${args.uuid} stopped`, application: result.value }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to stop application: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 9. restart_application
+    tool(
+      'restart_application',
+      `Restart a Coolify application.
+
+Equivalent to stopping and then starting the application.
+Useful to apply configuration changes or recover from errors.`,
+      {
+        uuid: z.string().uuid().describe('Application UUID to restart'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.restartApplication(args.uuid)
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({ success: true, message: `Application ${args.uuid} restarted`, application: result.value }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to restart application: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 10. get_deployment_history
+    tool(
+      'get_deployment_history',
+      `Get deployment history for a Coolify application.
+
+Returns list of all deployments with status, timestamps, and commit info.`,
+      {
+        uuid: z.string().uuid().describe('Application UUID'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.getApplicationDeploymentHistory(args.uuid)
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({ success: true, count: result.value.length, deployments: result.value }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to get deployment history: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 11. update_application
+    tool(
+      'update_application',
+      `Update configuration for a Coolify application.
+
+Can modify name, description, build settings, and commands.
+Redeploy after updating to apply changes.`,
+      {
+        uuid: z.string().uuid().describe('Application UUID'),
+        name: z.string().optional().describe('New application name'),
+        description: z.string().optional().describe('New description'),
+        buildPack: z.enum(['dockerfile', 'nixpacks', 'static']).optional().describe('Build pack type'),
+        gitBranch: z.string().optional().describe('Git branch to deploy'),
+        portsExposes: z.string().optional().describe('Ports to expose (comma-separated)'),
+        installCommand: z.string().optional().describe('Install command (nixpacks)'),
+        buildCommand: z.string().optional().describe('Build command'),
+        startCommand: z.string().optional().describe('Start command'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.updateApplication(args.uuid, {
+          name: args.name,
+          description: args.description,
+          buildPack: args.buildPack,
+          gitBranch: args.gitBranch,
+          portsExposes: args.portsExposes,
+          installCommand: args.installCommand,
+          buildCommand: args.buildCommand,
+          startCommand: args.startCommand,
+        })
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({
+                success: true,
+                message: `Application ${args.uuid} updated. Use deploy tool to apply changes.`,
+                application: result.value,
+              }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to update application: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 12. list_servers
+    tool(
+      'list_servers',
+      `List all available servers in Coolify.
+
+Returns server UUIDs, names, and IPs. Use server UUID when creating applications.`,
+      {},
+      async () => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.listServers()
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({ success: true, count: result.value.length, servers: result.value }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to list servers: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 13. get_server
+    tool(
+      'get_server',
+      `Get details of a specific Coolify server.
+
+Returns server information including name, IP, status, and configuration.`,
+      {
+        serverUuid: z.string().uuid().describe('Server UUID to get details for'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.getServer(args.serverUuid)
+
+        if (isOk(result)) {
+          return {
+            content: [{ type: 'text' as const, text: JSON.stringify({ success: true, server: result.value }, null, 2) }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to get server: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 14. list_projects
+    tool(
+      'list_projects',
+      `List all projects in Coolify.
+
+Returns project UUIDs, names, and associated environments.`,
+      {},
+      async () => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.listProjects()
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({ success: true, count: result.value.length, projects: result.value }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to list projects: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 15. list_teams
+    tool(
+      'list_teams',
+      `List all teams in Coolify.
+
+Returns team IDs, names, and configuration.`,
+      {},
+      async () => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.listTeams()
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({ success: true, count: result.value.length, teams: result.value }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to list teams: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 16. get_server_destinations
+    tool(
+      'get_server_destinations',
+      `Get available destinations for a Coolify server.
+
+Returns destination UUIDs needed when creating applications.
+Each destination represents a Docker network/environment on the server.`,
+      {
+        serverUuid: z.string().uuid().describe('Server UUID to get destinations for'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.getServerDestinations(args.serverUuid)
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({
+                success: true,
+                serverUuid: args.serverUuid,
+                count: result.value.length,
+                destinations: result.value,
+              }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to get destinations: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 17. create_application
+    tool(
+      'create_application',
+      `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.`,
+      {
+        name: z.string().describe('Application name'),
+        serverUuid: z.string().uuid().describe('Server UUID to deploy to'),
+        destinationUuid: z.string().uuid().describe('Destination UUID (Docker network)'),
+        githubRepoUrl: z.string().describe('GitHub repository URL (e.g., https://github.com/user/repo)'),
+        description: z.string().optional().describe('Application description'),
+        branch: z.string().default('main').describe('Git branch to deploy'),
+        buildPack: z.enum(['dockerfile', 'nixpacks', 'static']).default('nixpacks').describe('Build pack type'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        const result = await coolify.createApplication({
+          name: args.name,
+          description: args.description,
+          serverUuid: args.serverUuid,
+          destinationUuid: args.destinationUuid,
+          githubRepoUrl: args.githubRepoUrl,
+          branch: args.branch,
+          buildPack: args.buildPack,
+        })
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({
+                success: true,
+                message: `Application "${args.name}" created successfully`,
+                uuid: result.value.uuid,
+                nextSteps: [
+                  'Use set_env_vars to configure environment variables',
+                  'Use deploy to start the first deployment',
+                ],
+              }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to create application: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 18. get_resource_usage (placeholder - using status)
+    tool(
+      'get_resource_usage',
+      `Get resource usage for a Coolify application.
+
+Returns current resource consumption metrics.`,
+      {
+        uuid: z.string().uuid().describe('Application UUID'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        // For now, use getApplicationStatus - Coolify API doesn't have a separate resource usage endpoint
+        const result = await coolify.getApplicationStatus(args.uuid)
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({ success: true, status: result.value }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to get resource usage: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 19. health_check
+    tool(
+      'health_check',
+      `Check if Coolify API is accessible and credentials are valid.
+
+Returns connection status and API version info if available.`,
+      {},
+      async () => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify health check failed: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        // Try to list servers as a health check
+        const result = await coolify.listServers()
+
+        if (isOk(result)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({ success: true, status: 'healthy', message: 'Coolify API is accessible' }, null, 2),
+            }],
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Health check failed: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+
+    // 20. get_application_details (enhanced get_deployment_status)
+    tool(
+      'get_application_details',
+      `Get detailed information about a Coolify application.
+
+Returns full application configuration including name, description,
+build settings, environment, and deployment status.`,
+      {
+        uuid: z.string().uuid().describe('Application UUID'),
+      },
+      async (args) => {
+        const initResult = await coolify.init()
+        if (isErr(initResult)) {
+          return {
+            content: [{ type: 'text' as const, text: `Coolify not configured: ${initResult.error.message}` }],
+            isError: true,
+          }
+        }
+
+        // List all applications and filter by UUID to get full details
+        const result = await coolify.listApplications()
+
+        if (isOk(result)) {
+          const app = result.value.find((a) => a.uuid === args.uuid)
+          if (app) {
+            return {
+              content: [{ type: 'text' as const, text: JSON.stringify({ success: true, application: app }, null, 2) }],
+            }
+          }
+          return {
+            content: [{ type: 'text' as const, text: `Application ${args.uuid} not found` }],
+            isError: true,
+          }
+        }
+
+        return {
+          content: [{ type: 'text' as const, text: `Failed to get application details: ${result.error.message}` }],
+          isError: true,
+        }
+      }
+    ),
+  ],
+})
+
+// Auto-start server when running as main process (not when imported)
+if (import.meta.url === `file://${process.argv[1]}`) {
+  coolifyServer
+}
+
+// Re-export CoolifyService for library usage
+export { getCoolifyService } from './coolify/index.js'
+export type * from './coolify/index.js'