@mks2508/coolify-mks-cli-mcp 0.1.0

package/src/tools/handlers.ts

@@ -0,0 +1,605 @@
+/**
+ * MCP Tool handlers for Coolify.
+ *
+ * Handles execution of all 21 Coolify MCP tools.
+ *
+ * @module
+ */
+
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'
+import { isOk, isErr } from '@mks2508/no-throw'
+import type { CoolifyService } from '../coolify/index.js'
+
+/**
+ * Handler function for tool calls.
+ *
+ * @param name - Tool name
+ * @param args - Tool arguments
+ * @param coolify - CoolifyService instance
+ * @returns Tool call result
+ */
+export async function handleToolCall(
+  name: string,
+  args: Record<string, unknown>,
+  coolify: CoolifyService
+): Promise<CallToolResult> {
+  const initResult = await coolify.init()
+  if (isErr(initResult)) {
+    return {
+      content: [{ type: 'text', text: `Coolify not configured: ${initResult.error.message}` }],
+      isError: true
+    }
+  }
+
+  switch (name) {
+    case 'deploy':
+      return handleDeploy(coolify, args as unknown as DeployArgs)
+    case 'get_env_vars':
+      return handleGetEnvVars(coolify, args as unknown as GetEnvVarsArgs)
+    case 'set_env_vars':
+      return handleSetEnvVars(coolify, args as unknown as SetEnvVarsArgs)
+    case 'get_deployment_status':
+      return handleGetDeploymentStatus(coolify, args as unknown as GetDeploymentStatusArgs)
+    case 'list_applications':
+      return handleListApplications(coolify, args as unknown as ListApplicationsArgs)
+    case 'delete_application':
+      return handleDeleteApplication(coolify, args as unknown as DeleteApplicationArgs)
+    case 'get_application_logs':
+      return handleGetApplicationLogs(coolify, args as unknown as GetApplicationLogsArgs)
+    case 'start_application':
+      return handleStartApplication(coolify, args as unknown as StartApplicationArgs)
+    case 'stop_application':
+      return handleStopApplication(coolify, args as unknown as StopApplicationArgs)
+    case 'restart_application':
+      return handleRestartApplication(coolify, args as unknown as RestartApplicationArgs)
+    case 'get_deployment_history':
+      return handleGetDeploymentHistory(coolify, args as unknown as GetDeploymentHistoryArgs)
+    case 'update_application':
+      return handleUpdateApplication(coolify, args as unknown as UpdateApplicationArgs)
+    case 'list_servers':
+      return handleListServers(coolify)
+    case 'get_server':
+      return handleGetServer(coolify, args as unknown as GetServerArgs)
+    case 'list_projects':
+      return handleListProjects(coolify)
+    case 'list_teams':
+      return handleListTeams(coolify)
+    case 'get_server_destinations':
+      return handleGetServerDestinations(coolify, args as unknown as GetServerDestinationsArgs)
+    case 'create_application':
+      return handleCreateApplication(coolify, args as unknown as CreateApplicationArgs)
+    case 'get_resource_usage':
+      return handleGetResourceUsage(coolify, args as unknown as GetResourceUsageArgs)
+    case 'health_check':
+      return handleHealthCheck(coolify)
+    case 'get_application_details':
+      return handleGetApplicationDetails(coolify, args as unknown as GetApplicationDetailsArgs)
+    default:
+      return {
+        content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+        isError: true
+      }
+  }
+}
+
+// Tool argument types
+interface DeployArgs {
+  uuid: string
+  force?: boolean
+  tag?: string
+}
+
+interface GetEnvVarsArgs {
+  uuid: string
+}
+
+interface SetEnvVarsArgs {
+  uuid: string
+  envVars: Record<string, string>
+}
+
+interface GetDeploymentStatusArgs {
+  uuid: string
+}
+
+interface ListApplicationsArgs {
+  teamId?: string
+  projectId?: string
+}
+
+interface DeleteApplicationArgs {
+  uuid: string
+}
+
+interface GetApplicationLogsArgs {
+  uuid: string
+  tail?: number
+}
+
+interface StartApplicationArgs {
+  uuid: string
+}
+
+interface StopApplicationArgs {
+  uuid: string
+}
+
+interface RestartApplicationArgs {
+  uuid: string
+}
+
+interface GetDeploymentHistoryArgs {
+  uuid: string
+}
+
+interface UpdateApplicationArgs {
+  uuid: string
+  name?: string
+  description?: string
+  buildPack?: 'dockerfile' | 'nixpacks' | 'static'
+  gitBranch?: string
+  portsExposes?: string
+  installCommand?: string
+  buildCommand?: string
+  startCommand?: string
+}
+
+interface GetServerArgs {
+  serverUuid: string
+}
+
+interface GetServerDestinationsArgs {
+  serverUuid: string
+}
+
+interface CreateApplicationArgs {
+  name: string
+  serverUuid: string
+  destinationUuid: string
+  githubRepoUrl: string
+  description?: string
+  branch?: string
+  buildPack?: 'dockerfile' | 'nixpacks' | 'static'
+}
+
+interface GetResourceUsageArgs {
+  uuid: string
+}
+
+interface GetApplicationDetailsArgs {
+  uuid: string
+}
+
+// Handler implementations
+async function handleDeploy(coolify: CoolifyService, args: DeployArgs): Promise<CallToolResult> {
+  const result = await coolify.deploy({
+    uuid: args.uuid,
+    force: args.force ?? false,
+    tag: args.tag
+  })
+
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          success: true,
+          deploymentUuid: result.value.deploymentUuid,
+          resourceUuid: result.value.resourceUuid,
+          message: 'Deployment started'
+        }, null, 2)
+      }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Deployment failed: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleGetEnvVars(coolify: CoolifyService, args: GetEnvVarsArgs): Promise<CallToolResult> {
+  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',
+        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', text: `Failed to get env vars: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleSetEnvVars(coolify: CoolifyService, args: SetEnvVarsArgs): Promise<CallToolResult> {
+  const result = await coolify.setEnvironmentVariables(args.uuid, args.envVars)
+
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: 'text',
+        text: `Set ${Object.keys(args.envVars).length} environment variable(s). Use deploy tool to apply changes.`
+      }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to set env vars: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleGetDeploymentStatus(coolify: CoolifyService, args: GetDeploymentStatusArgs): Promise<CallToolResult> {
+  const result = await coolify.getApplicationStatus(args.uuid)
+
+  if (isOk(result)) {
+    return {
+      content: [{ type: 'text', text: JSON.stringify({ status: result.value }, null, 2) }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to get status: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleListApplications(coolify: CoolifyService, args: ListApplicationsArgs): Promise<CallToolResult> {
+  const result = await coolify.listApplications(args.teamId, args.projectId)
+
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({ success: true, count: result.value.length, applications: result.value }, null, 2)
+      }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to list applications: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleDeleteApplication(coolify: CoolifyService, args: DeleteApplicationArgs): Promise<CallToolResult> {
+  const result = await coolify.deleteApplication(args.uuid)
+
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({ success: true, message: `Application ${args.uuid} deleted successfully` }, null, 2)
+      }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to delete application: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleGetApplicationLogs(coolify: CoolifyService, args: GetApplicationLogsArgs): Promise<CallToolResult> {
+  const result = await coolify.getApplicationLogs(args.uuid, { tail: args.tail })
+
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          success: true,
+          timestamp: result.value.timestamp,
+          logCount: result.value.logs.length,
+          logs: result.value.logs
+        }, null, 2)
+      }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to get logs: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleStartApplication(coolify: CoolifyService, args: StartApplicationArgs): Promise<CallToolResult> {
+  const result = await coolify.startApplication(args.uuid)
+
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({ success: true, message: `Application ${args.uuid} started`, application: result.value }, null, 2)
+      }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to start application: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleStopApplication(coolify: CoolifyService, args: StopApplicationArgs): Promise<CallToolResult> {
+  const result = await coolify.stopApplication(args.uuid)
+
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({ success: true, message: `Application ${args.uuid} stopped`, application: result.value }, null, 2)
+      }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to stop application: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleRestartApplication(coolify: CoolifyService, args: RestartApplicationArgs): Promise<CallToolResult> {
+  const result = await coolify.restartApplication(args.uuid)
+
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({ success: true, message: `Application ${args.uuid} restarted`, application: result.value }, null, 2)
+      }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to restart application: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleGetDeploymentHistory(coolify: CoolifyService, args: GetDeploymentHistoryArgs): Promise<CallToolResult> {
+  const result = await coolify.getApplicationDeploymentHistory(args.uuid)
+
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({ success: true, count: result.value.length, deployments: result.value }, null, 2)
+      }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to get deployment history: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleUpdateApplication(coolify: CoolifyService, args: UpdateApplicationArgs): Promise<CallToolResult> {
+  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',
+        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', text: `Failed to update application: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleListServers(coolify: CoolifyService): Promise<CallToolResult> {
+  const result = await coolify.listServers()
+
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({ success: true, count: result.value.length, servers: result.value }, null, 2)
+      }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to list servers: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleGetServer(coolify: CoolifyService, args: GetServerArgs): Promise<CallToolResult> {
+  const result = await coolify.getServer(args.serverUuid)
+
+  if (isOk(result)) {
+    return {
+      content: [{ type: 'text', text: JSON.stringify({ success: true, server: result.value }, null, 2) }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to get server: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleListProjects(coolify: CoolifyService): Promise<CallToolResult> {
+  const result = await coolify.listProjects()
+
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({ success: true, count: result.value.length, projects: result.value }, null, 2)
+      }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to list projects: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleListTeams(coolify: CoolifyService): Promise<CallToolResult> {
+  const result = await coolify.listTeams()
+
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({ success: true, count: result.value.length, teams: result.value }, null, 2)
+      }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to list teams: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleGetServerDestinations(coolify: CoolifyService, args: GetServerDestinationsArgs): Promise<CallToolResult> {
+  const result = await coolify.getServerDestinations(args.serverUuid)
+
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          success: true,
+          serverUuid: args.serverUuid,
+          count: result.value.length,
+          destinations: result.value
+        }, null, 2)
+      }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to get destinations: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleCreateApplication(coolify: CoolifyService, args: CreateApplicationArgs): Promise<CallToolResult> {
+  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',
+        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', text: `Failed to create application: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleGetResourceUsage(coolify: CoolifyService, args: GetResourceUsageArgs): Promise<CallToolResult> {
+  // 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', text: JSON.stringify({ success: true, status: result.value }, null, 2) }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to get resource usage: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleHealthCheck(coolify: CoolifyService): Promise<CallToolResult> {
+  // Try to list servers as a health check
+  const result = await coolify.listServers()
+
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({ success: true, status: 'healthy', message: 'Coolify API is accessible' }, null, 2)
+      }]
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Health check failed: ${result.error.message}` }],
+    isError: true
+  }
+}
+
+async function handleGetApplicationDetails(coolify: CoolifyService, args: GetApplicationDetailsArgs): Promise<CallToolResult> {
+  // 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', text: JSON.stringify({ success: true, application: app }, null, 2) }]
+      }
+    }
+    return {
+      content: [{ type: 'text', text: `Application ${args.uuid} not found` }],
+      isError: true
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: `Failed to get application details: ${result.error.message}` }],
+    isError: true
+  }
+}

package/src/utils/format.ts

@@ -0,0 +1,104 @@
+/**
+ * Formatting utilities for CLI output.
+ *
+ * Provides table formatting and color helpers.
+ *
+ * @module
+ */
+
+import Table from 'cli-table3'
+import chalk from 'chalk'
+
+/**
+ * Gets the terminal width.
+ *
+ * @returns Terminal column count
+ */
+function getTerminalWidth(): number {
+  return process.stdout.columns || 80
+}
+
+/**
+ * Creates a formatted table with headers.
+ *
+ * @param headers - Column headers
+ * @param colWidths - Optional column widths
+ * @returns Configured Table instance
+ */
+export function createTable(headers: string[], colWidths?: number[]) {
+  const columns = getTerminalWidth()
+
+  return new Table({
+    head: headers.map((h) => chalk.cyan(h)),
+    colWidths: colWidths || calculateColumnWidths(columns, headers.length),
+  })
+}
+
+/**
+ * Calculates column widths based on terminal width.
+ *
+ * @param totalWidth - Total terminal width
+ * @param numColumns - Number of columns
+ * @returns Array of column widths
+ */
+function calculateColumnWidths(totalWidth: number, numColumns: number): number[] {
+  const padding = 4
+  const availableWidth = totalWidth - padding * numColumns
+  const colWidth = Math.floor(availableWidth / numColumns)
+  return Array(numColumns).fill(colWidth)
+}
+
+/**
+ * Formats application status with colored indicator.
+ *
+ * @param status - Application status string
+ * @returns Formatted status string
+ */
+export function formatStatus(status: string): string {
+  const statusMap: Record<string, string> = {
+    running: chalk.green('● Running'),
+    'running:unknown': chalk.green('● Running'),
+    stopped: chalk.red('○ Stopped'),
+    'restarting': chalk.yellow('◐ Restarting'),
+    error: chalk.red('✗ Error'),
+    deploying: chalk.yellow('◐ Deploying'),
+  }
+
+  return statusMap[status] || status
+}
+
+/**
+ * Formats bytes to human-readable format.
+ *
+ * @param bytes - Number of bytes
+ * @returns Formatted string with unit
+ */
+export function formatBytes(bytes: number): string {
+  const units = ['B', 'KB', 'MB', 'GB', 'TB']
+  let i = 0
+  while (bytes >= 1024 && i < units.length - 1) {
+    bytes /= 1024
+    i++
+  }
+  return `${bytes.toFixed(1)} ${units[i]}`
+}
+
+/**
+ * Formats timestamp to relative time.
+ *
+ * @param timestamp - ISO timestamp string
+ * @returns Relative time string
+ */
+export function formatRelativeTime(timestamp: string): string {
+  const date = new Date(timestamp)
+  const now = new Date()
+  const diffMs = now.getTime() - date.getTime()
+  const diffMins = Math.floor(diffMs / 60000)
+  const diffHours = Math.floor(diffMs / 3600000)
+  const diffDays = Math.floor(diffMs / 86400000)
+
+  if (diffMins < 1) return 'just now'
+  if (diffMins < 60) return `${diffMins}m ago`
+  if (diffHours < 24) return `${diffHours}h ago`
+  return `${diffDays}d ago`
+}