@mks2508/coolify-mks-cli-mcp 0.1.0 → 0.2.0

package/src/cli/commands/show.ts

@@ -0,0 +1,74 @@
+/**
+ * Show command for CLI.
+ *
+ * Shows detailed information about an application.
+ *
+ * @module
+ */
+
+import { isErr } from '@mks2508/no-throw'
+import chalk from 'chalk'
+import { getCoolifyService } from '../../coolify/index.js'
+import type { ICoolifyApplication } from '../../coolify/types.js'
+
+/**
+ * Show command handler.
+ *
+ * @param uuid - Application UUID
+ */
+export async function showCommand(uuid: string) {
+  const coolify = getCoolifyService()
+  const initResult = await coolify.init()
+
+  if (isErr(initResult)) {
+    console.error(chalk.red(`Error: ${initResult.error.message}`))
+    return
+  }
+
+  // We need to add getApplication method to CoolifyService
+  // For now, use listApplications and filter
+  const result = await coolify.listApplications()
+
+  if (isErr(result)) {
+    console.error(chalk.red(`Error: ${result.error.message}`))
+    return
+  }
+
+  const apps = result.value
+  const app = apps.find(a => a.uuid === uuid || a.uuid.startsWith(uuid))
+
+  if (!app) {
+    console.error(chalk.red(`Application not found: ${uuid}`))
+    return
+  }
+
+  console.log(chalk.cyan('Application Details:'))
+  console.log('')
+  console.log(chalk.gray('UUID:       ') + chalk.white(app.uuid))
+  console.log(chalk.gray('Name:       ') + chalk.white(app.name))
+  console.log(chalk.gray('Status:     ') + chalk.white(app.status))
+  console.log(chalk.gray('Description:') + chalk.white(app.description || 'N/A'))
+  console.log(chalk.gray('Repository: ') + chalk.white(app.git_repository || 'N/A'))
+  console.log(chalk.gray('Branch:     ') + chalk.white(app.git_branch || 'N/A'))
+  console.log(chalk.gray('Build Pack: ') + chalk.white(app.build_pack || 'N/A'))
+  console.log(chalk.gray('Ports:      ') + chalk.white(app.ports_exposes || 'N/A'))
+  console.log(chalk.gray('FQDN:       ') + chalk.white(app.fqdn || 'N/A'))
+  console.log(chalk.gray('Dockerfile: ') + chalk.white(app.dockerfile_location || 'N/A'))
+  console.log(chalk.gray('Base Dir:   ') + chalk.white(app.base_directory || 'N/A'))
+  console.log('')
+  console.log(chalk.cyan('Destination:'))
+  if (app.destination) {
+    console.log(chalk.gray('  UUID:  ') + chalk.white(app.destination.uuid))
+    console.log(chalk.gray('  Name:  ') + chalk.white(app.destination.name))
+    if (app.destination.server) {
+      console.log(chalk.gray('  Server:') + chalk.white(` ${app.destination.server.name} (${app.destination.server.ip})`))
+    }
+  } else {
+    console.log(chalk.yellow('  No destination configured'))
+  }
+  console.log('')
+  console.log(chalk.cyan('Commands:'))
+  if (app.install_command) console.log(chalk.gray('  Install: ') + chalk.white(app.install_command))
+  if (app.build_command) console.log(chalk.gray('  Build:   ') + chalk.white(app.build_command))
+  if (app.start_command) console.log(chalk.gray('  Start:   ') + chalk.white(app.start_command))
+}

package/src/cli/commands/update.ts

@@ -0,0 +1,81 @@
+/**
+ * Update application command.
+ *
+ * Updates an existing Coolify application configuration.
+ *
+ * @module
+ */
+
+import { isErr } from '@mks2508/no-throw'
+import chalk from 'chalk'
+import { getCoolifyService } from '../../coolify/index.js'
+import type { ICoolifyUpdateOptions } from '../../coolify/types.js'
+
+/**
+ * Options for the update command.
+ */
+interface IUpdateCommandOptions {
+  uuid: string
+  name?: string
+  description?: string
+  buildPack?: string
+  gitBranch?: string
+  ports?: string
+  installCommand?: string
+  buildCommand?: string
+  startCommand?: string
+  dockerfileLocation?: string
+  baseDirectory?: string
+}
+
+/**
+ * Executes the update command.
+ *
+ * @param options - Command options
+ */
+export async function updateCommand(options: IUpdateCommandOptions): Promise<void> {
+  console.log(chalk.cyan(`Updating application ${chalk.bold(options.uuid)}...`))
+
+  const service = getCoolifyService()
+  const initResult = await service.init()
+
+  if (isErr(initResult)) {
+    console.error(chalk.red('Failed to initialize Coolify service'))
+    console.error(chalk.gray(initResult.error.message))
+    process.exit(1)
+  }
+
+  const updateOptions: ICoolifyUpdateOptions = {}
+
+  if (options.name) updateOptions.name = options.name
+  if (options.description) updateOptions.description = options.description
+  if (options.buildPack) updateOptions.buildPack = options.buildPack as 'dockerfile' | 'nixpacks' | 'static'
+  if (options.gitBranch) updateOptions.gitBranch = options.gitBranch
+  if (options.ports) updateOptions.portsExposes = options.ports
+  if (options.installCommand) updateOptions.installCommand = options.installCommand
+  if (options.buildCommand) updateOptions.buildCommand = options.buildCommand
+  if (options.startCommand) updateOptions.startCommand = options.startCommand
+  if (options.dockerfileLocation) updateOptions.dockerfileLocation = options.dockerfileLocation
+  if (options.baseDirectory) updateOptions.baseDirectory = options.baseDirectory
+
+  if (Object.keys(updateOptions).length === 0) {
+    console.warn(chalk.yellow('No update options provided. Use --help to see available options.'))
+    process.exit(0)
+  }
+
+  const result = await service.updateApplication(options.uuid, updateOptions)
+
+  if (isErr(result)) {
+    console.error(chalk.red('Failed to update application'))
+    console.error(chalk.gray(result.error.message))
+    process.exit(1)
+  }
+
+  console.log(chalk.green('Application updated successfully'))
+  console.log(chalk.gray(`UUID: ${result.value.uuid}`))
+  console.log(chalk.gray(`Name: ${result.value.name}`))
+
+  if (result.value.description) {
+    console.log(chalk.gray(`Description: ${result.value.description}`))
+  }
+}

package/src/cli/index.ts

@@ -9,12 +9,20 @@
 
 import { Command } from 'commander'
 import chalk from 'chalk'
+import { createCommand } from './commands/create.js'
 import { deployCommand } from './commands/deploy.js'
 import { listCommand } from './commands/list.js'
 import { logsCommand } from './commands/logs.js'
 import { serversCommand } from './commands/servers.js'
+import { projectsCommand } from './commands/projects.js'
+import { environmentsCommand } from './commands/environments.js'
 import { configCommand } from './commands/config.js'
 import { envCommand } from './commands/env.js'
+import { updateCommand } from './commands/update.js'
+import { deleteCommand } from './commands/delete.js'
+import { destinationsCommand } from './commands/destinations.js'
+import { showCommand } from './commands/show.js'
+import { deploymentsCommand } from './commands/deployments.js'
 
 const program = new Command()
 
@@ -23,6 +31,26 @@ program
   .description('CLI for Coolify deployment management')
   .version('0.1.0')
 
+// Create application
+program
+  .command('create')
+  .description('Create a new application')
+  .option('--name <name>', 'Application name')
+  .option('--description <desc>', 'Application description')
+  .option('--server <uuid>', 'Server UUID')
+  .option('--project <uuid>', 'Project UUID')
+  .option('--environment <uuid>', 'Environment UUID (auto-fetched if not provided)')
+  .option('--repo <url>', 'Git repository URL')
+  .option('--branch <branch>', 'Git branch', 'main')
+  .option('--type <type>', 'Application type (public, private-github-app, private-deploy-key, dockerfile, docker-image, docker-compose)', 'public')
+  .option('--build-pack <pack>', 'Build pack (dockerfile, nixpacks, static)', 'dockerfile')
+  .option('--ports <ports>', 'Ports to expose (default: 3000)', '3000')
+  .option('--docker-image <image>', 'Docker image (for docker-image type)')
+  .option('--docker-compose <content>', 'Docker Compose content (for docker-compose type)')
+  .option('--dockerfile-location <path>', 'Dockerfile location (e.g., "apps/haidodocs/Dockerfile")')
+  .option('--base-directory <dir>', 'Base directory for build context (default: "/")', '/')
+  .action(createCommand)
+
 // Config command
 program
   .command('config')
@@ -38,6 +66,7 @@ program
   .description('List all applications')
   .option('-t, --team <id>', 'Filter by team ID')
   .option('-p, --project <id>', 'Filter by project ID')
+  .option('--full', 'Show full UUIDs instead of truncated')
   .action(listCommand)
 
 // Deploy application
@@ -63,7 +92,22 @@ program
 program
   .command('servers')
   .description('List available servers')
-  .action(serversCommand)
+  .option('--full', 'Show full UUIDs instead of truncated')
+  .action((options) => serversCommand(options))
+
+// Projects command
+program
+  .command('projects')
+  .description('List available projects')
+  .option('--full', 'Show full UUIDs instead of truncated')
+  .action((options) => projectsCommand(options))
+
+// Environments command
+program
+  .command('environments <projectUuid>')
+  .description('List environments for a project')
+  .option('--full', 'Show full UUIDs instead of truncated')
+  .action((projectUuid, options) => environmentsCommand(projectUuid, options))
 
 // Env vars command
 program
@@ -71,6 +115,53 @@ program
   .description('Get environment variables for an application')
   .action(envCommand)
 
+// Update application
+program
+  .command('update <uuid>')
+  .description('Update an application configuration')
+  .option('--name <name>', 'Application name')
+  .option('--description <desc>', 'Application description')
+  .option('--build-pack <pack>', 'Build pack (dockerfile, nixpacks, static)')
+  .option('--git-branch <branch>', 'Git branch')
+  .option('--ports <ports>', 'Ports to expose (e.g., 3000)')
+  .option('--install-command <cmd>', 'Install command (nixpacks)')
+  .option('--build-command <cmd>', 'Build command')
+  .option('--start-command <cmd>', 'Start command')
+  .option('--dockerfile-location <path>', 'Dockerfile location (e.g., "apps/haidodocs/Dockerfile")')
+  .option('--base-directory <dir>', 'Base directory for build context (e.g., "/")')
+  .action((uuid, options) => updateCommand({ uuid, ...options }))
+
+// Delete application
+program
+  .command('delete <uuid>')
+  .description('Delete an application')
+  .option('-f, --force', 'Skip confirmation prompt')
+  .option('-y, --yes', 'Skip confirmation prompt (alias for --force)')
+  .action((uuid, options) => deleteCommand(uuid, options))
+
+// Destinations command
+program
+  .command('destinations <serverUuid>')
+  .description('List available destinations for a server')
+  .action(destinationsCommand)
+
+// Show application details
+program
+  .command('show <uuid>')
+  .description('Show detailed information about an application')
+  .action(showCommand)
+
+// Deployments history
+program
+  .command('deployments <uuid>')
+  .description('Show deployment history for an application')
+  .option('--full', 'Show full UUIDs')
+  .option('-n, --limit <number>', 'Limit number of deployments shown', '10')
+  .action((uuid, options) => {
+    const limit = parseInt(options.limit, 10)
+    deploymentsCommand(uuid, { full: options.full, limit })
+  })
+
 // Show help by default
 program.action(() => {
   console.log(chalk.cyan('Coolify MCP CLI'))

package/src/coolify/index.ts

@@ -18,6 +18,7 @@ import {
   type ICoolifyDeployOptions,
   type ICoolifyDeployResult,
   type ICoolifyDestination,
+  type ICoolifyEnvironment,
   type ICoolifyLogs,
   type ICoolifyLogsOptions,
   type ICoolifyProject,
@@ -137,7 +138,9 @@ export class CoolifyService {
     }
 
     try {
-      const url = `${this.baseUrl}/api/v1${endpoint}`
+      const baseUrl = this.baseUrl.replace(/\/+$/, '')
+      const url = `${baseUrl}/api/v1${endpoint}`
+
       const response = await fetch(url, {
         ...options,
         headers: {
@@ -197,16 +200,22 @@ export class CoolifyService {
     onProgress?.(25, 'Validating deployment configuration')
     onProgress?.(50, 'Triggering build pipeline...')
 
+    // Build query parameters for deploy endpoint
+    const params = new URLSearchParams()
+    if (options.uuid) params.set('uuid', options.uuid)
+    if (options.tag) params.set('tag', options.tag)
+    if (options.force) params.set('force', 'true')
+
+    const endpoint = `/deploy${params.toString() ? `?${params.toString()}` : ''}`
+
     const result = await this.request<{
-      resource_uuid: string
-      deployment_uuid: string
-    }>('/deploy', {
+      deployments: Array<{
+        message: string
+        resource_uuid: string
+        deployment_uuid: string
+      }>
+    }>(endpoint, {
       method: 'POST',
-      body: JSON.stringify({
-        uuid: options.uuid,
-        tag: options.tag,
-        force: options.force ?? false,
-      }),
     })
 
     if (result.error) {
@@ -214,20 +223,37 @@ export class CoolifyService {
       return err(new Error(result.error))
     }
 
+    // Response is { deployments: [{ message, resource_uuid, deployment_uuid }] }
+    const deployments = result.data?.deployments || []
+    if (deployments.length === 0) {
+      log.error('No deployments started')
+      return err(new Error('No deployments started - check application configuration'))
+    }
+
+    const deployment = deployments[0]
+
     onProgress?.(90, 'Build started on Coolify server')
     onProgress?.(100, 'Deployment triggered')
 
-    log.success(`Deployment started: ${result.data?.deployment_uuid}`)
+    log.success(`Deployment started: ${deployment.deployment_uuid}`)
     return ok({
       success: true,
-      deploymentUuid: result.data?.deployment_uuid,
-      resourceUuid: result.data?.resource_uuid,
+      deploymentUuid: deployment.deployment_uuid,
+      resourceUuid: deployment.resource_uuid,
     })
   }
 
   /**
    * Creates a new application in Coolify.
    *
+   * Uses type-specific endpoints for different application types:
+   * - /applications/public - Public Git repository
+   * - /applications/private-github-app - Private repo with GitHub App
+   * - /applications/private-deploy-key - Private repo with deploy key
+   * - /applications/dockerfile - Dockerfile-based application
+   * - /applications/docker-image - Docker image
+   * - /applications/docker-compose - Docker Compose application
+   *
    * @param options - Application options
    * @param onProgress - Optional progress callback (0-100, message, step)
    * @returns Result with application UUID or error
@@ -238,26 +264,59 @@ export class CoolifyService {
   ): Promise<Result<ICoolifyAppResult, Error>> {
     onProgress?.(5, `Preparing app "${options.name}"`)
 
-    log.info(`Creating application ${options.name}`)
+    const appType = options.type || 'public'
+    log.info(`Creating application ${options.name} (type: ${appType})`)
 
     onProgress?.(25, `Validating server ${options.serverUuid.slice(0, 8)}...`)
     onProgress?.(50, 'Sending creation request to Coolify API...')
 
-    const result = await this.request<{ uuid: string }>('/applications', {
+    // Determine endpoint based on application type
+    const endpointMap: Record<string, string> = {
+      'public': '/applications/public',
+      'private-github-app': '/applications/private-github-app',
+      'private-deploy-key': '/applications/private-deploy-key',
+      'dockerfile': '/applications/dockerfile',
+      'docker-image': '/applications/docker-image',
+      'docker-compose': '/applications/docker-compose',
+    }
+
+    const endpoint = endpointMap[appType] || '/applications/public'
+
+    // Build request body based on application type
+    const body: Record<string, unknown> = {
+      name: options.name,
+      description: options.description,
+      project_uuid: options.projectUuid,
+      environment_uuid: options.environmentUuid,
+      server_uuid: options.serverUuid,
+    }
+
+    // Type-specific fields
+    if (appType === 'public' || appType === 'private-github-app' || appType === 'private-deploy-key') {
+      if (options.githubRepoUrl) {
+        body.git_repository = options.githubRepoUrl
+      }
+      body.git_branch = options.branch || 'main'
+      body.build_pack = options.buildPack || 'dockerfile'
+      if (options.portsExposes) {
+        body.ports_exposes = options.portsExposes
+      }
+      // Dockerfile configuration
+      if (options.dockerfileLocation) {
+        body.dockerfile_location = options.dockerfileLocation
+      }
+      if (options.baseDirectory) {
+        body.base_directory = options.baseDirectory
+      }
+    } else if (appType === 'docker-image' && options.dockerImage) {
+      body.docker_image = options.dockerImage
+    } else if (appType === 'docker-compose' && options.dockerCompose) {
+      body.docker_compose = options.dockerCompose
+    }
+
+    const result = await this.request<{ uuid: string }>(endpoint, {
       method: 'POST',
-      body: JSON.stringify({
-        name: options.name,
-        description: options.description,
-        server_uuid: options.serverUuid,
-        destination_uuid: options.destinationUuid,
-        project_uuid: options.serverUuid,
-        environment_name: 'production',
-        git_repository: options.githubRepoUrl,
-        git_branch: options.branch || 'main',
-        build_pack: options.buildPack || 'nixpacks',
-        ports_exposes: '3000',
-        instant_deploy: false,
-      }),
+      body: JSON.stringify(body),
     })
 
     if (result.error) {
@@ -403,6 +462,30 @@ export class CoolifyService {
     return ok(result.data || [])
   }
 
+  /**
+   * Gets environments for a project.
+   *
+   * @param projectUuid - Project UUID
+   * @returns Result with environments list or error
+   */
+  async getProjectEnvironments(
+    projectUuid: string
+  ): Promise<Result<ICoolifyEnvironment[], Error>> {
+    log.info(`Getting environments for project ${projectUuid}`)
+
+    const result = await this.request<{ environments: ICoolifyEnvironment[] }>(
+      `/projects/${projectUuid}`
+    )
+
+    if (result.error) {
+      log.error(`Failed to get environments: ${result.error}`)
+      return err(new Error(result.error))
+    }
+
+    log.success(`Environments retrieved for project ${projectUuid}`)
+    return ok(result.data?.environments || [])
+  }
+
   /**
    * Lists all teams.
    *
@@ -516,6 +599,8 @@ export class CoolifyService {
     if (options.installCommand) body.install_command = options.installCommand
     if (options.buildCommand) body.build_command = options.buildCommand
     if (options.startCommand) body.start_command = options.startCommand
+    if (options.dockerfileLocation) body.dockerfile_location = options.dockerfileLocation
+    if (options.baseDirectory) body.base_directory = options.baseDirectory
 
     const result = await this.request<ICoolifyApplication>(`/applications/${appUuid}`, {
       method: 'PATCH',
@@ -575,7 +660,8 @@ export class CoolifyService {
   ): Promise<Result<ICoolifyDeployment[], Error>> {
     log.info(`Getting deployment history for ${appUuid}`)
 
-    const result = await this.request<ICoolifyDeployment[]>(`/applications/${appUuid}/deployments`)
+    // According to Coolify API docs, endpoint is /applications/{app_uuid}/deployments
+    const result = await this.request<{ deployments: ICoolifyDeployment[] }>(`/applications/${appUuid}/deployments`)
 
     if (result.error) {
       log.error(`Failed to get deployment history: ${result.error}`)
@@ -583,7 +669,7 @@ export class CoolifyService {
     }
 
     log.success(`Deployment history retrieved for ${appUuid}`)
-    return ok(result.data || [])
+    return ok(result.data?.deployments || [])
   }
 
   /**

package/src/coolify/types.ts

@@ -21,6 +21,17 @@ export interface ICoolifyDeployOptions {
   onProgress?: IProgressCallback
 }
 
+/**
+ * Application types supported by Coolify.
+ */
+export type TCoolifyApplicationType =
+  | 'public'
+  | 'private-github-app'
+  | 'private-deploy-key'
+  | 'dockerfile'
+  | 'docker-image'
+  | 'docker-compose'
+
 /**
  * Options for creating a Coolify application.
  */
@@ -29,18 +40,32 @@ export interface ICoolifyAppOptions {
   name: string
   /** Application description */
   description?: string
+  /** Project UUID */
+  projectUuid: string
+  /** Environment UUID */
+  environmentUuid: string
   /** Server UUID */
   serverUuid: string
-  /** Destination UUID */
-  destinationUuid: string
-  /** GitHub repository URL */
-  githubRepoUrl: string
+  /** Application type */
+  type?: TCoolifyApplicationType
+  /** GitHub repository URL (for git-based apps) */
+  githubRepoUrl?: string
   /** Git branch */
   branch?: string
   /** Build pack type */
   buildPack?: 'dockerfile' | 'nixpacks' | 'static'
+  /** Ports to expose */
+  portsExposes?: string
+  /** Docker image (for docker-image type) */
+  dockerImage?: string
+  /** Docker Compose content (for docker-compose type) */
+  dockerCompose?: string
   /** Environment variables */
   envVars?: Record<string, string>
+  /** Dockerfile location (path relative to repo root, e.g., "apps/haidodocs/Dockerfile") */
+  dockerfileLocation?: string
+  /** Base directory for build context (default: "/") */
+  baseDirectory?: string
 }
 
 /**
@@ -63,6 +88,10 @@ export interface ICoolifyUpdateOptions {
   buildCommand?: string
   /** Start command */
   startCommand?: string
+  /** Dockerfile location (path relative to repo root, e.g., "apps/haidodocs/Dockerfile") */
+  dockerfileLocation?: string
+  /** Base directory for build context (default: "/") */
+  baseDirectory?: string
 }
 
 /**
@@ -173,6 +202,10 @@ export interface ICoolifyApplication {
   build_pack?: string | null
   /** Ports exposed */
   ports_exposes?: string | null
+  /** Dockerfile location */
+  dockerfile_location?: string | null
+  /** Base directory */
+  base_directory?: string | null
   /** Server status (boolean) */
   server_status?: boolean
   /** Environment ID */
@@ -259,6 +292,8 @@ export interface ICoolifyProject {
  * Environment within a project from API (snake_case).
  */
 export interface ICoolifyEnvironment {
+  /** Environment UUID (needed for API calls) */
+  uuid: string
   /** Environment ID */
   id: number
   /** Environment name */

package/src/index.ts

@@ -684,12 +684,13 @@ Each destination represents a Docker network/environment on the server.`,
       '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).
+Requires server UUID, project UUID, and environment UUID.
 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)'),
+        projectUuid: z.string().uuid().describe('Project UUID'),
+        environmentUuid: z.string().uuid().describe('Environment UUID'),
         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'),
@@ -707,8 +708,10 @@ The GitHub repository must be accessible via the configured GitHub App.`,
         const result = await coolify.createApplication({
           name: args.name,
           description: args.description,
+          projectUuid: args.projectUuid,
+          environmentUuid: args.environmentUuid,
           serverUuid: args.serverUuid,
-          destinationUuid: args.destinationUuid,
+          type: 'public',
           githubRepoUrl: args.githubRepoUrl,
           branch: args.branch,
           buildPack: args.buildPack,

package/src/tools/handlers.ts

@@ -155,7 +155,8 @@ interface GetServerDestinationsArgs {
 interface CreateApplicationArgs {
   name: string
   serverUuid: string
-  destinationUuid: string
+  projectUuid: string
+  environmentUuid: string
   githubRepoUrl: string
   description?: string
   branch?: string
@@ -516,8 +517,10 @@ async function handleCreateApplication(coolify: CoolifyService, args: CreateAppl
   const result = await coolify.createApplication({
     name: args.name,
     description: args.description,
+    projectUuid: args.projectUuid,
+    environmentUuid: args.environmentUuid,
     serverUuid: args.serverUuid,
-    destinationUuid: args.destinationUuid,
+    type: 'public',
     githubRepoUrl: args.githubRepoUrl,
     branch: args.branch,
     buildPack: args.buildPack