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

package/dist/server/stdio.js

@@ -17252,6 +17252,9 @@ class CoolifyService {
       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;
       }
@@ -17303,6 +17306,58 @@ class CoolifyService {
     log.success(`Environment variables retrieved for ${appUuid}`);
     return ok(result.data || []);
   }
+  async setEnvironmentVariable(appUuid, key, value, isBuildTime = false) {
+    log.info(`Setting environment variable ${key} for ${appUuid}`);
+    const existingVars = await this.getEnvironmentVariables(appUuid);
+    if (isErr(existingVars)) {
+      return err(existingVars.error);
+    }
+    const exists = existingVars.value.some((ev) => ev.key === key);
+    if (exists) {
+      log.debug(`Variable ${key} exists, using PATCH to update`);
+      const result = await this.request(`/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 {
+      log.debug(`Variable ${key} does not exist, using POST to create`);
+      const result = await this.request(`/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);
+  }
+  async deleteEnvironmentVariable(appUuid, key) {
+    log.info(`Deleting environment variable ${key} from ${appUuid}`);
+    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);
+  }
   async getApplicationStatus(appUuid) {
     const result = await this.request(`/applications/${appUuid}`);
     if (result.error) {
@@ -17334,6 +17389,19 @@ class CoolifyService {
     }
     return ok(result.data || []);
   }
+  async createProject(name, description) {
+    log.info(`Creating project: ${name}`);
+    const result = await this.request("/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);
+  }
   async getProjectEnvironments(projectUuid) {
     log.info(`Getting environments for project ${projectUuid}`);
     const result = await this.request(`/projects/${projectUuid}`);
@@ -17412,6 +17480,12 @@ class CoolifyService {
       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(`/applications/${appUuid}`, {
       method: "PATCH",
       body: JSON.stringify(body)
@@ -17436,9 +17510,12 @@ class CoolifyService {
       log.error(`Failed to get logs: ${result.error}`);
       return err(new Error(result.error));
     }
+    const rawLogs = result.data?.logs;
+    const logsArray = Array.isArray(rawLogs) ? rawLogs : typeof rawLogs === "string" ? rawLogs.split(`
+`).filter((l) => l.length > 0) : [];
     log.success(`Logs retrieved for application: ${appUuid}`);
     return ok({
-      logs: result.data?.logs || [],
+      logs: logsArray,
       timestamp: new Date().toISOString()
     });
   }
@@ -17488,6 +17565,43 @@ class CoolifyService {
     log.success(`Application restarted: ${appUuid}`);
     return ok(result.data);
   }
+  async listDeployments() {
+    log.info("Listing active deployments");
+    const result = await this.request("/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 || []);
+  }
+  async getDeployment(deploymentUuid) {
+    log.info(`Getting deployment details for ${deploymentUuid}`);
+    const result = await this.request(`/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);
+  }
+  async getApplicationDeployments(appUuid, skip = 0, take = 10) {
+    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(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);
+  }
 }
 var instance = null;
 function getCoolifyService() {
@@ -17716,7 +17830,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",
@@ -17737,7 +17851,7 @@ Redeploy after updating to apply changes.`,
         buildPack: {
           type: "string",
           description: "Build pack type",
-          enum: ["dockerfile", "nixpacks", "static"]
+          enum: ["dockerfile", "nixpacks", "static", "dockercompose"]
         },
         gitBranch: {
           type: "string",
@@ -17758,11 +17872,54 @@ Redeploy after updating to apply changes.`,
         startCommand: {
           type: "string",
           description: "Start command"
+        },
+        domains: {
+          type: "string",
+          description: 'Domains/FQDN - comma separated list with protocol (e.g., "https://app.example.com,https://www.example.com")'
+        },
+        isForceHttpsEnabled: {
+          type: "boolean",
+          description: "Force HTTPS redirect"
+        },
+        isAutoDeployEnabled: {
+          type: "boolean",
+          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",
+      properties: {
+        uuid: {
+          type: "string",
+          description: "Application UUID",
+          format: "uuid"
+        },
+        domains: {
+          type: "string",
+          description: 'Domains/FQDN - comma separated list with protocol (e.g., "https://app.example.com,https://www.example.com")'
+        },
+        forceHttps: {
+          type: "boolean",
+          description: "Force HTTPS redirect (default: true)",
+          default: true
+        }
+      },
+      required: ["uuid", "domains"]
+    }
+  },
   {
     name: "list_servers",
     description: `List all available servers in Coolify.
@@ -17867,11 +18024,49 @@ The GitHub repository must be accessible via the configured GitHub App.`,
         buildPack: {
           type: "string",
           description: "Build pack type",
-          enum: ["dockerfile", "nixpacks", "static"],
+          enum: ["dockerfile", "nixpacks", "static", "dockercompose"],
           default: "nixpacks"
+        },
+        type: {
+          type: "string",
+          description: "Application type",
+          enum: ["public", "private-github-app", "private-deploy-key", "dockerfile", "docker-image", "docker-compose"],
+          default: "public"
+        },
+        dockerComposeLocation: {
+          type: "string",
+          description: "Docker Compose file location relative to repo root (for dockercompose buildPack)"
+        },
+        dockerfileLocation: {
+          type: "string",
+          description: "Dockerfile location relative to repo root"
+        },
+        baseDirectory: {
+          type: "string",
+          description: 'Base directory for build context (default: "/")'
+        }
+      },
+      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",
+      properties: {
+        name: {
+          type: "string",
+          description: "Project name"
+        },
+        description: {
+          type: "string",
+          description: "Project description"
         }
       },
-      required: ["name", "serverUuid", "destinationUuid", "githubRepoUrl"]
+      required: ["name"]
     }
   },
   {
@@ -17901,6 +18096,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",
+      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",
+      properties: {
+        deploymentUuid: {
+          type: "string",
+          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",
+      properties: {
+        uuid: {
+          type: "string",
+          description: "Application UUID",
+          format: "uuid"
+        },
+        skip: {
+          type: "number",
+          description: "Number of deployments to skip (pagination)",
+          default: 0
+        },
+        take: {
+          type: "number",
+          description: "Number of deployments to return (default: 10)",
+          default: 10
+        }
+      },
+      required: ["uuid"]
+    }
+  },
   {
     name: "get_application_details",
     description: `Get detailed information about a Coolify application.
@@ -17955,6 +18206,8 @@ async function handleToolCall(name, args, coolify) {
       return handleGetDeploymentHistory(coolify, args);
     case "update_application":
       return handleUpdateApplication(coolify, args);
+    case "set_domains":
+      return handleSetDomains(coolify, args);
     case "list_servers":
       return handleListServers(coolify);
     case "get_server":
@@ -17967,12 +18220,20 @@ async function handleToolCall(name, args, coolify) {
       return handleGetServerDestinations(coolify, args);
     case "create_application":
       return handleCreateApplication(coolify, args);
+    case "create_project":
+      return handleCreateProject(coolify, args);
     case "get_resource_usage":
       return handleGetResourceUsage(coolify, args);
     case "health_check":
       return handleHealthCheck(coolify);
     case "get_application_details":
       return handleGetApplicationDetails(coolify, args);
+    case "list_deployments":
+      return handleListDeployments(coolify);
+    case "get_deployment":
+      return handleGetDeployment(coolify, args);
+    case "get_application_deployments":
+      return handleGetApplicationDeployments(coolify, args);
     default:
       return {
         content: [{ type: "text", text: `Unknown tool: ${name}` }],
@@ -18174,7 +18435,10 @@ async function handleUpdateApplication(coolify, args) {
     portsExposes: args.portsExposes,
     installCommand: args.installCommand,
     buildCommand: args.buildCommand,
-    startCommand: args.startCommand
+    startCommand: args.startCommand,
+    domains: args.domains,
+    isForceHttpsEnabled: args.isForceHttpsEnabled,
+    isAutoDeployEnabled: args.isAutoDeployEnabled
   });
   if (isOk(result)) {
     return {
@@ -18193,6 +18457,35 @@ async function handleUpdateApplication(coolify, args) {
     isError: true
   };
 }
+async function handleSetDomains(coolify, args) {
+  const result = await coolify.updateApplication(args.uuid, {
+    domains: args.domains,
+    isForceHttpsEnabled: args.forceHttps ?? true
+  });
+  if (isOk(result)) {
+    const domainList = args.domains.split(",").map((d) => d.trim());
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          message: `Domains configured for application ${args.uuid}`,
+          domains: domainList,
+          forceHttps: args.forceHttps ?? true,
+          nextSteps: [
+            "Ensure DNS records point to your server IP",
+            "Use deploy tool to apply domain changes",
+            "SSL certificates will be auto-generated via Let's Encrypt"
+          ]
+        }, null, 2)
+      }]
+    };
+  }
+  return {
+    content: [{ type: "text", text: `Failed to set domains: ${result.error.message}` }],
+    isError: true
+  };
+}
 async function handleListServers(coolify) {
   const result = await coolify.listServers();
   if (isOk(result)) {
@@ -18277,10 +18570,13 @@ async function handleCreateApplication(coolify, args) {
     projectUuid: args.projectUuid,
     environmentUuid: args.environmentUuid,
     serverUuid: args.serverUuid,
-    type: "public",
+    type: args.type || "public",
     githubRepoUrl: args.githubRepoUrl,
     branch: args.branch,
-    buildPack: args.buildPack
+    buildPack: args.buildPack,
+    dockerComposeLocation: args.dockerComposeLocation,
+    dockerfileLocation: args.dockerfileLocation,
+    baseDirectory: args.baseDirectory
   });
   if (isOk(result)) {
     return {
@@ -18303,6 +18599,25 @@ async function handleCreateApplication(coolify, args) {
     isError: true
   };
 }
+async function handleCreateProject(coolify, args) {
+  const result = await coolify.createProject(args.name, args.description);
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          message: `Project "${args.name}" created successfully`,
+          uuid: result.value.uuid
+        }, null, 2)
+      }]
+    };
+  }
+  return {
+    content: [{ type: "text", text: `Failed to create project: ${result.error.message}` }],
+    isError: true
+  };
+}
 async function handleGetResourceUsage(coolify, args) {
   const result = await coolify.getApplicationStatus(args.uuid);
   if (isOk(result)) {
@@ -18349,6 +18664,62 @@ async function handleGetApplicationDetails(coolify, args) {
     isError: true
   };
 }
+async function handleListDeployments(coolify) {
+  const result = await coolify.listDeployments();
+  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 list deployments: ${result.error.message}` }],
+    isError: true
+  };
+}
+async function handleGetDeployment(coolify, args) {
+  const result = await coolify.getDeployment(args.deploymentUuid);
+  if (isOk(result)) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          deployment: result.value
+        }, null, 2)
+      }]
+    };
+  }
+  return {
+    content: [{ type: "text", text: `Failed to get deployment: ${result.error.message}` }],
+    isError: true
+  };
+}
+async function handleGetApplicationDeployments(coolify, args) {
+  const result = await coolify.getApplicationDeployments(args.uuid, args.skip, args.take);
+  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 application deployments: ${result.error.message}` }],
+    isError: true
+  };
+}
 
 // src/server/stdio.ts
 var coolify = getCoolifyService();

package/dist/tools/definitions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/tools/definitions.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAA;AAE9D;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,IAAI,EAqa9B,CAAA"}
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/tools/definitions.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAA;AAE9D;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,IAAI,EA8iB9B,CAAA"}

package/dist/tools/handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/tools/handlers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAA;AAExE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEzD;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,cAAc,CAAC,CA0DzB"}
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/tools/handlers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAA;AAExE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEzD;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,cAAc,CAAC,CAoEzB"}

package/package.json

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

package/src/cli/commands/env.ts

@@ -8,12 +8,19 @@ import { isErr } from '@mks2508/no-throw'
 import chalk from 'chalk'
 import { getCoolifyService } from '../../coolify/index.js'
 
+interface IEnvCommandOptions {
+  set?: string
+  delete?: string
+  buildtime?: boolean
+}
+
 /**
  * Env vars command handler.
  *
  * @param uuid - Application UUID
+ * @param options - Command options
  */
-export async function envCommand(uuid: string) {
+export async function envCommand(uuid: string, options: IEnvCommandOptions = {}) {
   const coolify = getCoolifyService()
   const initResult = await coolify.init()
 
@@ -22,6 +29,41 @@ export async function envCommand(uuid: string) {
     return
   }
 
+  // Handle --set KEY=VALUE
+  if (options.set) {
+    const [key, ...valueParts] = options.set.split('=')
+    const value = valueParts.join('=') // Handle values with = in them
+
+    if (!key || value === undefined) {
+      console.error(chalk.red('Error: Invalid format. Use --set KEY=VALUE'))
+      return
+    }
+
+    const result = await coolify.setEnvironmentVariable(uuid, key, value, options.buildtime ?? false)
+
+    if (isErr(result)) {
+      console.error(chalk.red(`Error: ${result.error.message}`))
+      return
+    }
+
+    console.log(chalk.green(`✓ Set ${chalk.bold(key)} for ${uuid.slice(0, 8)}`))
+    return
+  }
+
+  // Handle --delete KEY
+  if (options.delete) {
+    const result = await coolify.deleteEnvironmentVariable(uuid, options.delete)
+
+    if (isErr(result)) {
+      console.error(chalk.red(`Error: ${result.error.message}`))
+      return
+    }
+
+    console.log(chalk.green(`✓ Deleted ${chalk.bold(options.delete)} from ${uuid.slice(0, 8)}`))
+    return
+  }
+
+  // Default: list env vars
   const result = await coolify.getEnvironmentVariables(uuid)
 
   if (isErr(result)) {

package/src/cli/index.ts

@@ -112,8 +112,11 @@ program
 // Env vars command
 program
   .command('env <uuid>')
-  .description('Get environment variables for an application')
-  .action(envCommand)
+  .description('Manage environment variables for an application')
+  .option('--set <KEY=VALUE>', 'Set an environment variable')
+  .option('--delete <KEY>', 'Delete an environment variable')
+  .option('--buildtime', 'Mark variable as build-time only (use with --set)')
+  .action((uuid, options) => envCommand(uuid, options))
 
 // Update application
 program