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

package/dist/server/stdio.js

@@ -17148,7 +17148,8 @@ class CoolifyService {
       return { error: "Coolify not configured", status: 0, durationMs: Date.now() - startTime };
     }
     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: {
@@ -17187,47 +17188,81 @@ class CoolifyService {
     log.info(`Deploying application ${options.uuid || options.tag}`);
     onProgress?.(25, "Validating deployment configuration");
     onProgress?.(50, "Triggering build pipeline...");
-    const result = await this.request("/deploy", {
-      method: "POST",
-      body: JSON.stringify({
-        uuid: options.uuid,
-        tag: options.tag,
-        force: options.force ?? false
-      })
+    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(endpoint, {
+      method: "POST"
     });
     if (result.error) {
       log.error(`Deployment failed: ${result.error}`);
       return err(new Error(result.error));
     }
+    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
     });
   }
   async createApplication(options, onProgress) {
     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("/applications", {
+    const endpointMap = {
+      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";
+    const body = {
+      name: options.name,
+      description: options.description,
+      project_uuid: options.projectUuid,
+      environment_uuid: options.environmentUuid,
+      server_uuid: options.serverUuid
+    };
+    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;
+      }
+      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(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) {
       log.error(`Failed to create application: ${result.error}`);
@@ -17299,6 +17334,16 @@ class CoolifyService {
     }
     return ok(result.data || []);
   }
+  async getProjectEnvironments(projectUuid) {
+    log.info(`Getting environments for project ${projectUuid}`);
+    const result = await this.request(`/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 || []);
+  }
   async listTeams() {
     const result = await this.request("/teams");
     if (result.error) {
@@ -17363,6 +17408,10 @@ class CoolifyService {
       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(`/applications/${appUuid}`, {
       method: "PATCH",
       body: JSON.stringify(body)
@@ -17401,7 +17450,7 @@ class CoolifyService {
       return err(new Error(result.error));
     }
     log.success(`Deployment history retrieved for ${appUuid}`);
-    return ok(result.data || []);
+    return ok(result.data?.deployments || []);
   }
   async startApplication(appUuid) {
     log.info(`Starting application ${appUuid}`);
@@ -18225,8 +18274,10 @@ async function handleCreateApplication(coolify, args) {
   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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mks2508/coolify-mks-cli-mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "MCP server and CLI for Coolify deployment management",
   "type": "module",
   "main": "./dist/index.js",

package/src/cli/commands/create.ts

@@ -0,0 +1,116 @@
+/**
+ * Create command for CLI.
+ *
+ * @module
+ */
+
+import { isOk, isErr } from '@mks2508/no-throw'
+import ora from 'ora'
+import chalk from 'chalk'
+import { getCoolifyService } from '../../coolify/index.js'
+
+/**
+ * Create command options.
+ */
+interface ICreateOptions {
+  name: string
+  description?: string
+  server: string
+  project: string
+  environment?: string
+  repo?: string
+  branch?: string
+  type?: 'public' | 'private-github-app' | 'private-deploy-key' | 'dockerfile' | 'docker-image' | 'docker-compose'
+  buildPack?: 'dockerfile' | 'nixpacks' | 'static'
+  ports?: string
+  dockerImage?: string
+  dockerCompose?: string
+  dockerfileLocation?: string
+  baseDirectory?: string
+}
+
+/**
+ * Create command handler.
+ *
+ * @param options - Create options
+ */
+export async function createCommand(options: ICreateOptions) {
+  const spinner = ora('Initializing Coolify connection...').start()
+
+  try {
+    const coolify = getCoolifyService()
+    const initResult = await coolify.init()
+
+    if (isErr(initResult)) {
+      spinner.fail(chalk.red(`Failed to initialize: ${initResult.error.message}`))
+      return
+    }
+
+    // Auto-fetch environment UUID if not provided
+    let environmentUuid: string | undefined = options.environment
+
+    if (!environmentUuid) {
+      spinner.text = 'Fetching project environments...'
+
+      const envResult = await coolify.getProjectEnvironments(options.project)
+
+      if (isOk(envResult) && envResult.value.length > 0) {
+        // Use the first environment (usually "production")
+        environmentUuid = envResult.value[0].uuid
+        const envName = envResult.value[0].name
+        spinner.info(chalk.cyan(`Using environment: ${envName} (${environmentUuid.slice(0, 8)}...)`))
+      } else {
+        spinner.fail(chalk.red('No environments found for project. Please specify --environment <uuid>'))
+        return
+      }
+    }
+
+    // Ensure environmentUuid is defined before creating application
+    if (!environmentUuid) {
+      spinner.fail(chalk.red('Environment UUID is required'))
+      return
+    }
+
+    spinner.text = 'Creating application...'
+
+    const result = await coolify.createApplication(
+      {
+        name: options.name,
+        description: options.description,
+        projectUuid: options.project,
+        environmentUuid,
+        serverUuid: options.server,
+        type: options.type || 'public',
+        githubRepoUrl: options.repo,
+        branch: options.branch || 'main',
+        buildPack: options.buildPack || 'dockerfile',
+        portsExposes: options.ports || '3000',
+        dockerImage: options.dockerImage,
+        dockerCompose: options.dockerCompose,
+        dockerfileLocation: options.dockerfileLocation,
+        baseDirectory: options.baseDirectory,
+      },
+      (percent, message) => {
+        spinner.text = `${chalk.bold(`[${percent}%]`)} ${message}`
+      }
+    )
+
+    if (isOk(result)) {
+      spinner.succeed(
+        chalk.green(`Application created! UUID: ${chalk.cyan(result.value.uuid?.slice(0, 8))}`)
+      )
+      console.log(`  Full UUID: ${chalk.cyan(result.value.uuid)}`)
+      console.log(`  Name: ${chalk.cyan(options.name)}`)
+      console.log(`  Type: ${chalk.cyan(options.type || 'public')}`)
+      console.log(`  Next steps:`)
+      console.log(`    1. Set environment variables: ${chalk.yellow('coolify-mcp env ' + result.value.uuid?.slice(0, 8))}`)
+      console.log(`    2. Deploy application: ${chalk.yellow('coolify-mcp deploy ' + result.value.uuid?.slice(0, 8))}`)
+    } else {
+      spinner.fail(chalk.red(`Creation failed: ${result.error.message}`))
+    }
+  } catch (error) {
+    spinner.fail(
+      chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`)
+    )
+  }
+}

package/src/cli/commands/delete.ts

@@ -0,0 +1,69 @@
+/**
+ * Delete application command.
+ *
+ * Deletes an existing Coolify application.
+ *
+ * @module
+ */
+
+import { isErr } from '@mks2508/no-throw'
+import chalk from 'chalk'
+import { getCoolifyService } from '../../coolify/index.js'
+
+/**
+ * Executes the delete command.
+ *
+ * @param uuid - Application UUID
+ * @param options - Command options
+ */
+export async function deleteCommand(
+  uuid: string,
+  options: { force?: boolean; yes?: boolean } = {}
+): Promise<void> {
+  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)
+  }
+
+  if (!options.force && !options.yes) {
+    const readline = await import('readline')
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    })
+
+    const answer = await new Promise<string>((resolve) => {
+      rl.question(
+        chalk.yellow(`Are you sure you want to delete application ${chalk.bold(uuid)}? (yes/no): `),
+        (ans) => {
+          rl.close()
+          resolve(ans.toLowerCase())
+        }
+      )
+    })
+
+    if (answer !== 'yes' && answer !== 'y') {
+      console.log(chalk.gray('Operation cancelled'))
+      process.exit(0)
+    }
+  }
+
+  console.log(chalk.cyan(`Deleting application ${chalk.bold(uuid)}...`))
+
+  const result = await service.deleteApplication(uuid)
+
+  if (isErr(result)) {
+    console.error(chalk.red('Failed to delete application'))
+    console.error(chalk.gray(result.error.message))
+    process.exit(1)
+  }
+
+  console.log(chalk.green('Application deleted successfully'))
+  if (result.value.message) {
+    console.log(chalk.gray(result.value.message))
+  }
+}

package/src/cli/commands/deployments.ts

@@ -0,0 +1,77 @@
+/**
+ * Deployments command for CLI.
+ *
+ * Shows deployment history for an application.
+ *
+ * @module
+ */
+
+import { isErr } from '@mks2508/no-throw'
+import chalk from 'chalk'
+import Table from 'cli-table3'
+import { getCoolifyService } from '../../coolify/index.js'
+import { formatStatus } from '../../utils/format.js'
+
+/**
+ * Deployments command handler.
+ *
+ * @param uuid - Application UUID
+ * @param options - Command options
+ */
+export async function deploymentsCommand(
+  uuid: string,
+  options: { full?: boolean; limit?: number } = {}
+) {
+  const coolify = getCoolifyService()
+  const initResult = await coolify.init()
+
+  if (isErr(initResult)) {
+    console.error(chalk.red(`Error: ${initResult.error.message}`))
+    return
+  }
+
+  const result = await coolify.getApplicationDeploymentHistory(uuid)
+
+  if (isErr(result)) {
+    console.error(chalk.red(`Error: ${result.error.message}`))
+    return
+  }
+
+  let deployments = result.value
+
+  // Show most recent first
+  deployments = deployments.reverse()
+
+  if (options.limit) {
+    deployments = deployments.slice(0, options.limit)
+  }
+
+  if (deployments.length === 0) {
+    console.log(chalk.yellow('No deployments found'))
+    return
+  }
+
+  const table = new Table({
+    head: [
+      chalk.cyan('ID'),
+      chalk.cyan('UUID'),
+      chalk.cyan('Status'),
+      chalk.cyan('Commit'),
+      chalk.cyan('Created'),
+    ],
+    ...(options.full ? { colWidths: [8, 36, 20, 10, 20] } : {}),
+  })
+
+  for (const dep of deployments) {
+    table.push([
+      String(dep.id),
+      options.full ? dep.uuid : dep.uuid.slice(0, 8),
+      formatStatus(dep.status),
+      dep.commit?.slice(0, 7) || '-',
+      new Date(dep.created_at).toLocaleString(),
+    ])
+  }
+
+  console.log(table.toString())
+  console.log(chalk.gray(`Total: ${deployments.length} deployment(s)`))
+}

package/src/cli/commands/destinations.ts

@@ -0,0 +1,60 @@
+/**
+ * Destinations command for CLI.
+ *
+ * Lists available destinations for a server.
+ *
+ * @module
+ */
+
+import { isErr } from '@mks2508/no-throw'
+import chalk from 'chalk'
+import Table from 'cli-table3'
+import { getCoolifyService } from '../../coolify/index.js'
+
+/**
+ * Destinations command handler.
+ *
+ * @param serverUuid - Server UUID
+ */
+export async function destinationsCommand(serverUuid: string) {
+  const coolify = getCoolifyService()
+  const initResult = await coolify.init()
+
+  if (isErr(initResult)) {
+    console.error(chalk.red(`Error: ${initResult.error.message}`))
+    return
+  }
+
+  const result = await coolify.getServerDestinations(serverUuid)
+
+  if (isErr(result)) {
+    console.error(chalk.red(`Error: ${result.error.message}`))
+    return
+  }
+
+  const destinations = result.value
+
+  if (destinations.length === 0) {
+    console.log(chalk.yellow('No destinations found'))
+    return
+  }
+
+  const table = new Table({
+    head: [
+      chalk.cyan('UUID'),
+      chalk.cyan('Name'),
+      chalk.cyan('Network'),
+    ],
+  })
+
+  for (const dest of destinations) {
+    table.push([
+      dest.uuid,
+      dest.name,
+      dest.network || 'N/A',
+    ])
+  }
+
+  console.log(table.toString())
+  console.log(chalk.gray(`Total: ${destinations.length} destination(s)`))
+}

package/src/cli/commands/environments.ts

@@ -0,0 +1,72 @@
+/**
+ * Environments command for CLI.
+ *
+ * @module
+ */
+
+import { isOk, isErr } from '@mks2508/no-throw'
+import ora from 'ora'
+import chalk from 'chalk'
+import Table from 'cli-table3'
+import { getCoolifyService } from '../../coolify/index.js'
+
+/**
+ * Environments command handler.
+ *
+ * @param projectUuid - Project UUID to get environments for
+ * @param options - Command options
+ */
+export async function environmentsCommand(projectUuid: string, options: { full?: boolean } = {}) {
+  const spinner = ora('Connecting to Coolify...').start()
+
+  try {
+    const coolify = getCoolifyService()
+    const initResult = await coolify.init()
+
+    if (isErr(initResult)) {
+      spinner.fail(chalk.red(`Failed to initialize: ${initResult.error.message}`))
+      return
+    }
+
+    spinner.text = `Fetching environments for project ${projectUuid.slice(0, 8)}...`
+
+    const result = await coolify.getProjectEnvironments(projectUuid)
+
+    if (isOk(result)) {
+      spinner.succeed(chalk.green('Environments retrieved'))
+
+      const environments = result.value
+
+      if (environments.length === 0) {
+        console.log(chalk.yellow('No environments found for this project'))
+        return
+      }
+
+      const table = new Table({
+        head: [
+          chalk.cyan('UUID'),
+          chalk.cyan('Name'),
+          chalk.cyan('Description'),
+        ],
+        ...(options.full ? { colWidths: [36, 25, 40] } : {}),
+      })
+
+      for (const env of environments) {
+        table.push([
+          options.full ? env.uuid : env.uuid.slice(0, 8),
+          env.name,
+          env.description || '-',
+        ])
+      }
+
+      console.log(table.toString())
+      console.log(chalk.gray(`Total: ${environments.length} environment(s)`))
+    } else {
+      spinner.fail(chalk.red(`Failed to fetch environments: ${result.error.message}`))
+    }
+  } catch (error) {
+    spinner.fail(
+      chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`)
+    )
+  }
+}

package/src/cli/commands/list.ts

@@ -15,7 +15,7 @@ import { formatStatus } from '../../utils/format.js'
  *
  * @param options - List options
  */
-export async function listCommand(options: { team?: string; project?: string }) {
+export async function listCommand(options: { team?: string; project?: string; full?: boolean }) {
   const coolify = getCoolifyService()
   const initResult = await coolify.init()
 
@@ -46,12 +46,12 @@ export async function listCommand(options: { team?: string; project?: string })
       chalk.cyan('Status'),
       chalk.cyan('Server')
     ],
-    // Sin anchos fijos, dejar que cli-table3 auto-ajuste
+    ...(options.full ? { colWidths: [36, 30, 20, 10] } : {}),
   })
 
   for (const app of apps) {
     table.push([
-      app.uuid,
+      options.full ? app.uuid : app.uuid.slice(0, 8),
       app.name,
       formatStatus(app.status),
       app.destination?.server?.name || 'N/A',

package/src/cli/commands/projects.ts

@@ -0,0 +1,69 @@
+/**
+ * Projects command for CLI.
+ *
+ * @module
+ */
+
+import { isOk, isErr } from '@mks2508/no-throw'
+import ora from 'ora'
+import chalk from 'chalk'
+import Table from 'cli-table3'
+import { getCoolifyService } from '../../coolify/index.js'
+
+/**
+ * Projects command handler.
+ */
+export async function projectsCommand(options: { full?: boolean } = {}) {
+  const spinner = ora('Connecting to Coolify...').start()
+
+  try {
+    const coolify = getCoolifyService()
+    const initResult = await coolify.init()
+
+    if (isErr(initResult)) {
+      spinner.fail(chalk.red(`Failed to initialize: ${initResult.error.message}`))
+      return
+    }
+
+    spinner.text = 'Fetching projects...'
+
+    const result = await coolify.listProjects()
+
+    if (isOk(result)) {
+      spinner.succeed(chalk.green('Projects retrieved'))
+
+      const projects = result.value
+
+      if (projects.length === 0) {
+        console.log(chalk.yellow('No projects found'))
+        return
+      }
+
+      const table = new Table({
+        head: [
+          chalk.cyan('UUID'),
+          chalk.cyan('Name'),
+          chalk.cyan('Description'),
+        ],
+        ...(options.full ? { colWidths: [36, 30, 40] } : {}),
+      })
+
+      for (const project of projects) {
+        table.push([
+          options.full ? project.uuid : project.uuid.slice(0, 8),
+          project.name,
+          project.description || '-',
+        ])
+      }
+
+      console.log(table.toString())
+      console.log(chalk.gray(`Total: ${projects.length} project(s)`))
+    } else {
+      spinner.fail(chalk.red(`Failed to fetch projects: ${result.error.message}`))
+    }
+  } catch (error) {
+    spinner.fail(
+      chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`)
+    )
+  }
+}

package/src/cli/commands/servers.ts

@@ -12,7 +12,7 @@ import { createTable } from '../../utils/format.js'
 /**
  * Servers command handler.
  */
-export async function serversCommand() {
+export async function serversCommand(options: { full?: boolean } = {}) {
   const coolify = getCoolifyService()
   const initResult = await coolify.init()
 
@@ -35,12 +35,12 @@ export async function serversCommand() {
     return
   }
 
-  const table = createTable(['UUID', 'Name', 'IP', 'Status'], [36, 25, 20, 15])
+  const table = createTable(['UUID', 'Name', 'IP', 'Status'], [options.full ? 36 : 8, 25, 20, 15])
 
   for (const server of servers) {
     const statusColor = server.is_usable ? chalk.green : chalk.red
     table.push([
-      server.uuid.slice(0, 8),
+      options.full ? server.uuid : server.uuid.slice(0, 8),
       server.name,
       server.ip || 'N/A',
       statusColor(server.is_usable ? '● Usable' : '○ Unusable'),