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

package/src/coolify/index.ts

@@ -301,10 +301,13 @@ export class CoolifyService {
       if (options.portsExposes) {
         body.ports_exposes = options.portsExposes
       }
-      // Dockerfile configuration
+      // Dockerfile / Docker Compose configuration
       if (options.dockerfileLocation) {
         body.dockerfile_location = options.dockerfileLocation
       }
+      if (options.dockerComposeLocation) {
+        body.docker_compose_location = options.dockerComposeLocation
+      }
       if (options.baseDirectory) {
         body.base_directory = options.baseDirectory
       }
@@ -390,6 +393,100 @@ export class CoolifyService {
     return ok(result.data || [])
   }
 
+  /**
+   * Sets a single environment variable for an application.
+   * Uses PATCH if variable exists, POST if it doesn't.
+   *
+   * @param appUuid - Application UUID
+   * @param key - Variable name
+   * @param value - Variable value
+   * @param isBuildTime - Whether the variable is available at build time (only for new vars)
+   * @returns Result indicating success or error
+   */
+  async setEnvironmentVariable(
+    appUuid: string,
+    key: string,
+    value: string,
+    isBuildTime: boolean = false
+  ): Promise<Result<void, Error>> {
+    log.info(`Setting environment variable ${key} for ${appUuid}`)
+
+    // Check if variable already exists
+    const existingVars = await this.getEnvironmentVariables(appUuid)
+    if (isErr(existingVars)) {
+      return err(existingVars.error)
+    }
+
+    const exists = existingVars.value.some(ev => ev.key === key)
+
+    if (exists) {
+      // Use PATCH to update existing variable
+      log.debug(`Variable ${key} exists, using PATCH to update`)
+      const result = await this.request<{ uuid: string }>(`/applications/${appUuid}/envs`, {
+        method: 'PATCH',
+        body: JSON.stringify({ key, value }),
+      })
+
+      if (result.error) {
+        log.error(`Failed to update env var: ${result.error}`)
+        return err(new Error(result.error))
+      }
+    } else {
+      // Use POST to create new variable
+      log.debug(`Variable ${key} does not exist, using POST to create`)
+      const result = await this.request<{ uuid: string }>(`/applications/${appUuid}/envs`, {
+        method: 'POST',
+        body: JSON.stringify({ key, value }),
+      })
+
+      if (result.error) {
+        log.error(`Failed to create env var: ${result.error}`)
+        return err(new Error(result.error))
+      }
+    }
+
+    log.success(`Environment variable ${key} set for ${appUuid}`)
+    return ok(undefined)
+  }
+
+  /**
+   * Deletes an environment variable from an application.
+   *
+   * @param appUuid - Application UUID
+   * @param key - Variable name to delete
+   * @returns Result indicating success or error
+   */
+  async deleteEnvironmentVariable(
+    appUuid: string,
+    key: string
+  ): Promise<Result<void, Error>> {
+    log.info(`Deleting environment variable ${key} from ${appUuid}`)
+
+    // First get all env vars to find the UUID of the one to delete
+    const envVarsResult = await this.getEnvironmentVariables(appUuid)
+    if (isErr(envVarsResult)) {
+      return err(envVarsResult.error)
+    }
+
+    const envVar = envVarsResult.value.find(ev => ev.key === key)
+    if (!envVar) {
+      log.error(`Environment variable ${key} not found`)
+      return err(new Error(`Environment variable ${key} not found`))
+    }
+
+    const result = await this.request(`/applications/${appUuid}/envs/${envVar.uuid}`, {
+      method: 'DELETE',
+    })
+
+    if (result.error) {
+      log.error(`Failed to delete env var: ${result.error}`)
+      return err(new Error(result.error))
+    }
+
+    log.success(`Environment variable ${key} deleted from ${appUuid}`)
+    return ok(undefined)
+  }
+
   /**
    * Gets the status of an application.
    *
@@ -462,6 +559,33 @@ export class CoolifyService {
     return ok(result.data || [])
   }
 
+  /**
+   * Creates a new project.
+   *
+   * @param name - Project name
+   * @param description - Optional project description
+   * @returns Result with created project or error
+   */
+  async createProject(
+    name: string,
+    description?: string
+  ): Promise<Result<ICoolifyProject, Error>> {
+    log.info(`Creating project: ${name}`)
+
+    const result = await this.request<ICoolifyProject>('/projects', {
+      method: 'POST',
+      body: JSON.stringify({ name, description: description || '' }),
+    })
+
+    if (result.error) {
+      log.error(`Failed to create project: ${result.error}`)
+      return err(new Error(result.error))
+    }
+
+    log.success(`Project created: ${result.data?.uuid}`)
+    return ok(result.data!)
+  }
+
   /**
    * Gets environments for a project.
    *
@@ -601,6 +725,9 @@ export class CoolifyService {
     if (options.startCommand) body.start_command = options.startCommand
     if (options.dockerfileLocation) body.dockerfile_location = options.dockerfileLocation
     if (options.baseDirectory) body.base_directory = options.baseDirectory
+    if (options.domains) body.domains = options.domains
+    if (options.isForceHttpsEnabled !== undefined) body.is_force_https_enabled = options.isForceHttpsEnabled
+    if (options.isAutoDeployEnabled !== undefined) body.is_auto_deploy_enabled = options.isAutoDeployEnabled
 
     const result = await this.request<ICoolifyApplication>(`/applications/${appUuid}`, {
       method: 'PATCH',
@@ -635,16 +762,25 @@ export class CoolifyService {
 
     const endpoint = `/applications/${appUuid}/logs${params.toString() ? `?${params.toString()}` : ''}`
 
-    const result = await this.request<{ logs: string[] }>(endpoint)
+    const result = await this.request<{ logs: string | string[] }>(endpoint)
 
     if (result.error) {
       log.error(`Failed to get logs: ${result.error}`)
       return err(new Error(result.error))
     }
 
+    // Coolify API returns logs as a single newline-delimited string for
+    // docker-compose apps, but as string[] for single-container apps.
+    const rawLogs = result.data?.logs
+    const logsArray: string[] = Array.isArray(rawLogs)
+      ? rawLogs
+      : typeof rawLogs === 'string'
+        ? rawLogs.split('\n').filter((l: string) => l.length > 0)
+        : []
+
     log.success(`Logs retrieved for application: ${appUuid}`)
     return ok({
-      logs: result.data?.logs || [],
+      logs: logsArray,
       timestamp: new Date().toISOString(),
     })
   }
@@ -743,6 +879,79 @@ export class CoolifyService {
     log.success(`Application restarted: ${appUuid}`)
     return ok(result.data as ICoolifyApplication)
   }
+
+  /**
+   * Lists all active and queued deployments.
+   *
+   * @returns Result with deployments list or error
+   */
+  async listDeployments(): Promise<Result<ICoolifyDeployment[], Error>> {
+    log.info('Listing active deployments')
+
+    const result = await this.request<ICoolifyDeployment[]>('/deployments')
+
+    if (result.error) {
+      log.error(`Failed to list deployments: ${result.error}`)
+      return err(new Error(result.error))
+    }
+
+    log.success(`Listed ${result.data?.length || 0} active deployments`)
+    return ok(result.data || [])
+  }
+
+  /**
+   * Gets detailed information about a specific deployment.
+   *
+   * @param deploymentUuid - Deployment UUID
+   * @returns Result with deployment details or error
+   */
+  async getDeployment(
+    deploymentUuid: string
+  ): Promise<Result<ICoolifyDeployment, Error>> {
+    log.info(`Getting deployment details for ${deploymentUuid}`)
+
+    const result = await this.request<ICoolifyDeployment>(`/deployments/${deploymentUuid}`)
+
+    if (result.error) {
+      log.error(`Failed to get deployment: ${result.error}`)
+      return err(new Error(result.error))
+    }
+
+    log.success(`Deployment details retrieved: ${deploymentUuid}`)
+    return ok(result.data as ICoolifyDeployment)
+  }
+
+  /**
+   * Gets deployment history for a specific application.
+   *
+   * @param appUuid - Application UUID
+   * @param skip - Number of deployments to skip
+   * @param take - Number of deployments to return
+   * @returns Result with deployments list or error
+   */
+  async getApplicationDeployments(
+    appUuid: string,
+    skip: number = 0,
+    take: number = 10
+  ): Promise<Result<ICoolifyDeployment[], Error>> {
+    log.info(`Getting deployments for application ${appUuid}`)
+
+    const params = new URLSearchParams()
+    if (skip > 0) params.set('skip', skip.toString())
+    if (take !== 10) params.set('take', take.toString())
+
+    const endpoint = `/applications/${appUuid}/deployments${params.toString() ? `?${params.toString()}` : ''}`
+    const result = await this.request<{ count: number; deployments: ICoolifyDeployment[] }>(endpoint)
+
+    if (result.error) {
+      log.error(`Failed to get application deployments: ${result.error}`)
+      return err(new Error(result.error))
+    }
+
+    const deployments = result.data?.deployments || []
+    log.success(`Retrieved ${deployments.length} deployments for ${appUuid}`)
+    return ok(deployments)
+  }
 }
 
 let instance: CoolifyService | null = null
@@ -768,7 +977,12 @@ export type {
   ICoolifyApplication,
   ICoolifyDeployment,
   ICoolifyAppOptions,
+  ICoolifyAppResult,
   ICoolifyDeployOptions,
+  ICoolifyDeployResult,
+  ICoolifyDeleteResult,
   ICoolifyUpdateOptions,
   ICoolifyLogsOptions,
-}
+  ICoolifyLogs,
+  IProgressCallback,
+} from './types.js'

package/src/coolify/types.ts

@@ -46,6 +46,8 @@ export interface ICoolifyAppOptions {
   environmentUuid: string
   /** Server UUID */
   serverUuid: string
+  /** Destination UUID (optional, for specific destination targeting) */
+  destinationUuid?: string
   /** Application type */
   type?: TCoolifyApplicationType
   /** GitHub repository URL (for git-based apps) */
@@ -53,13 +55,15 @@ export interface ICoolifyAppOptions {
   /** Git branch */
   branch?: string
   /** Build pack type */
-  buildPack?: 'dockerfile' | 'nixpacks' | 'static'
+  buildPack?: 'dockerfile' | 'nixpacks' | 'static' | 'dockercompose'
   /** Ports to expose */
   portsExposes?: string
   /** Docker image (for docker-image type) */
   dockerImage?: string
   /** Docker Compose content (for docker-compose type) */
   dockerCompose?: string
+  /** Docker Compose file location relative to repo root (for dockercompose buildPack) */
+  dockerComposeLocation?: string
   /** Environment variables */
   envVars?: Record<string, string>
   /** Dockerfile location (path relative to repo root, e.g., "apps/haidodocs/Dockerfile") */
@@ -77,7 +81,7 @@ export interface ICoolifyUpdateOptions {
   /** Application description */
   description?: string
   /** Build pack type */
-  buildPack?: 'dockerfile' | 'nixpacks' | 'static'
+  buildPack?: 'dockerfile' | 'nixpacks' | 'static' | 'dockercompose'
   /** Git branch */
   gitBranch?: string
   /** Ports to expose */
@@ -92,6 +96,12 @@ export interface ICoolifyUpdateOptions {
   dockerfileLocation?: string
   /** Base directory for build context (default: "/") */
   baseDirectory?: string
+  /** Domains/FQDN - comma separated list of domains with protocol (e.g., "https://app.example.com,https://www.example.com") */
+  domains?: string
+  /** Force HTTPS redirect */
+  isForceHttpsEnabled?: boolean
+  /** Enable auto deploy on git push */
+  isAutoDeployEnabled?: boolean
 }
 
 /**

package/src/index.ts

@@ -455,7 +455,7 @@ 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'),
+        buildPack: z.enum(['dockerfile', 'nixpacks', 'static', 'dockercompose']).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)'),
@@ -694,7 +694,11 @@ The GitHub repository must be accessible via the configured GitHub App.`,
         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'),
+        buildPack: z.enum(['dockerfile', 'nixpacks', 'static', 'dockercompose']).default('nixpacks').describe('Build pack type'),
+        type: z.enum(['public', 'private-github-app', 'private-deploy-key', 'dockerfile', 'docker-image', 'docker-compose']).default('public').describe('Application type'),
+        dockerComposeLocation: z.string().optional().describe('Docker Compose file location relative to repo root'),
+        dockerfileLocation: z.string().optional().describe('Dockerfile location relative to repo root'),
+        baseDirectory: z.string().optional().describe('Base directory for build context'),
       },
       async (args) => {
         const initResult = await coolify.init()
@@ -711,10 +715,13 @@ The GitHub repository must be accessible via the configured GitHub App.`,
           projectUuid: args.projectUuid,
           environmentUuid: args.environmentUuid,
           serverUuid: args.serverUuid,
-          type: 'public',
+          type: args.type as any,
           githubRepoUrl: args.githubRepoUrl,
           branch: args.branch,
           buildPack: args.buildPack,
+          dockerComposeLocation: args.dockerComposeLocation,
+          dockerfileLocation: args.dockerfileLocation,
+          baseDirectory: args.baseDirectory,
         })
 
         if (isOk(result)) {

package/src/tools/definitions.ts

@@ -229,7 +229,7 @@ Returns list of all deployments with status, timestamps, and commit info.`,
     name: 'update_application',
     description: `Update configuration for a Coolify application.
 
-Can modify name, description, build settings, and commands.
+Can modify name, description, build settings, commands, and domains.
 Redeploy after updating to apply changes.`,
     inputSchema: {
       type: 'object' as const,
@@ -250,7 +250,7 @@ Redeploy after updating to apply changes.`,
         buildPack: {
           type: 'string' as const,
           description: 'Build pack type',
-          enum: ['dockerfile', 'nixpacks', 'static']
+          enum: ['dockerfile', 'nixpacks', 'static', 'dockercompose']
         },
         gitBranch: {
           type: 'string' as const,
@@ -271,11 +271,54 @@ Redeploy after updating to apply changes.`,
         startCommand: {
           type: 'string' as const,
           description: 'Start command'
+        },
+        domains: {
+          type: 'string' as const,
+          description: 'Domains/FQDN - comma separated list with protocol (e.g., "https://app.example.com,https://www.example.com")'
+        },
+        isForceHttpsEnabled: {
+          type: 'boolean' as const,
+          description: 'Force HTTPS redirect'
+        },
+        isAutoDeployEnabled: {
+          type: 'boolean' as const,
+          description: 'Enable auto deploy on git push'
         }
       },
       required: ['uuid']
     }
   },
+  {
+    name: 'set_domains',
+    description: `Set domains/FQDN for a Coolify application.
+
+Configure custom domains for your application. Coolify automatically handles SSL certificates via Let's Encrypt.
+
+Domain format:
+- Use FQDN with protocol: https://app.example.com
+- Multiple domains separated by comma: https://app.example.com,https://www.example.com
+- Can include port mapping: https://api.example.com:3000`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        uuid: {
+          type: 'string' as const,
+          description: 'Application UUID',
+          format: 'uuid'
+        },
+        domains: {
+          type: 'string' as const,
+          description: 'Domains/FQDN - comma separated list with protocol (e.g., "https://app.example.com,https://www.example.com")'
+        },
+        forceHttps: {
+          type: 'boolean' as const,
+          description: 'Force HTTPS redirect (default: true)',
+          default: true
+        }
+      },
+      required: ['uuid', 'domains']
+    }
+  },
   {
     name: 'list_servers',
     description: `List all available servers in Coolify.
@@ -380,11 +423,49 @@ The GitHub repository must be accessible via the configured GitHub App.`,
         buildPack: {
           type: 'string' as const,
           description: 'Build pack type',
-          enum: ['dockerfile', 'nixpacks', 'static'],
+          enum: ['dockerfile', 'nixpacks', 'static', 'dockercompose'],
           default: 'nixpacks'
+        },
+        type: {
+          type: 'string' as const,
+          description: 'Application type',
+          enum: ['public', 'private-github-app', 'private-deploy-key', 'dockerfile', 'docker-image', 'docker-compose'],
+          default: 'public'
+        },
+        dockerComposeLocation: {
+          type: 'string' as const,
+          description: 'Docker Compose file location relative to repo root (for dockercompose buildPack)'
+        },
+        dockerfileLocation: {
+          type: 'string' as const,
+          description: 'Dockerfile location relative to repo root'
+        },
+        baseDirectory: {
+          type: 'string' as const,
+          description: 'Base directory for build context (default: "/")'
         }
       },
-      required: ['name', 'serverUuid', 'destinationUuid', 'githubRepoUrl']
+      required: ['name', 'serverUuid', 'githubRepoUrl']
+    }
+  },
+  {
+    name: 'create_project',
+    description: `Create a new project in Coolify.
+
+Projects organize applications into logical groups. Each project has one or more environments (e.g., production, staging).`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        name: {
+          type: 'string' as const,
+          description: 'Project name'
+        },
+        description: {
+          type: 'string' as const,
+          description: 'Project description'
+        }
+      },
+      required: ['name']
     }
   },
   {
@@ -414,6 +495,62 @@ Returns connection status and API version info if available.`,
       properties: {}
     }
   },
+  {
+    name: 'list_deployments',
+    description: `List all active and queued deployments across all applications.
+
+Returns deployments that are currently in progress or waiting in queue.
+Useful for monitoring ongoing builds and deployments.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {}
+    }
+  },
+  {
+    name: 'get_deployment',
+    description: `Get detailed information about a specific deployment.
+
+Returns deployment status, logs, timestamps, and error messages if any.
+Use deployment UUID from list_deployments or get_application_deployments.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        deploymentUuid: {
+          type: 'string' as const,
+          description: 'Deployment UUID'
+        }
+      },
+      required: ['deploymentUuid']
+    }
+  },
+  {
+    name: 'get_application_deployments',
+    description: `Get deployment history for a specific application.
+
+Returns list of all deployments with status, timestamps, commit info, and logs.
+Useful for debugging failed deployments and tracking deployment history.`,
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        uuid: {
+          type: 'string' as const,
+          description: 'Application UUID',
+          format: 'uuid'
+        },
+        skip: {
+          type: 'number' as const,
+          description: 'Number of deployments to skip (pagination)',
+          default: 0
+        },
+        take: {
+          type: 'number' as const,
+          description: 'Number of deployments to return (default: 10)',
+          default: 10
+        }
+      },
+      required: ['uuid']
+    }
+  },
   {
     name: 'get_application_details',
     description: `Get detailed information about a Coolify application.