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

package/dist/cli/index.js

@@ -11204,7 +11204,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: {
@@ -11243,47 +11244,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}`);
@@ -11355,6 +11390,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) {
@@ -11419,6 +11464,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)
@@ -11457,7 +11506,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}`);
@@ -11504,6 +11553,68 @@ function getCoolifyService() {
   return instance;
 }
 
+// src/cli/commands/create.ts
+async function createCommand2(options) {
+  const spinner = ora("Initializing Coolify connection...").start();
+  try {
+    const coolify = getCoolifyService();
+    const initResult = await coolify.init();
+    if (isErr(initResult)) {
+      spinner.fail(source_default.red(`Failed to initialize: ${initResult.error.message}`));
+      return;
+    }
+    let environmentUuid = options.environment;
+    if (!environmentUuid) {
+      spinner.text = "Fetching project environments...";
+      const envResult = await coolify.getProjectEnvironments(options.project);
+      if (isOk(envResult) && envResult.value.length > 0) {
+        environmentUuid = envResult.value[0].uuid;
+        const envName = envResult.value[0].name;
+        spinner.info(source_default.cyan(`Using environment: ${envName} (${environmentUuid.slice(0, 8)}...)`));
+      } else {
+        spinner.fail(source_default.red("No environments found for project. Please specify --environment <uuid>"));
+        return;
+      }
+    }
+    if (!environmentUuid) {
+      spinner.fail(source_default.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 = `${source_default.bold(`[${percent}%]`)} ${message}`;
+    });
+    if (isOk(result)) {
+      spinner.succeed(source_default.green(`Application created! UUID: ${source_default.cyan(result.value.uuid?.slice(0, 8))}`));
+      console.log(`  Full UUID: ${source_default.cyan(result.value.uuid)}`);
+      console.log(`  Name: ${source_default.cyan(options.name)}`);
+      console.log(`  Type: ${source_default.cyan(options.type || "public")}`);
+      console.log(`  Next steps:`);
+      console.log(`    1. Set environment variables: ${source_default.yellow("coolify-mcp env " + result.value.uuid?.slice(0, 8))}`);
+      console.log(`    2. Deploy application: ${source_default.yellow("coolify-mcp deploy " + result.value.uuid?.slice(0, 8))}`);
+    } else {
+      spinner.fail(source_default.red(`Creation failed: ${result.error.message}`));
+    }
+  } catch (error) {
+    spinner.fail(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
+
 // src/cli/commands/deploy.ts
 async function deployCommand(uuid, options) {
   const spinner = ora("Initializing Coolify connection...").start();
@@ -11590,11 +11701,12 @@ async function listCommand(options) {
       source_default.cyan("Name"),
       source_default.cyan("Status"),
       source_default.cyan("Server")
-    ]
+    ],
+    ...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"
@@ -11634,7 +11746,7 @@ Follow mode not yet implemented`));
 }
 
 // src/cli/commands/servers.ts
-async function serversCommand() {
+async function serversCommand(options = {}) {
   const coolify = getCoolifyService();
   const initResult = await coolify.init();
   if (isErr(initResult)) {
@@ -11651,11 +11763,11 @@ async function serversCommand() {
     console.log(source_default.yellow("No servers found"));
     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 ? source_default.green : source_default.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")
@@ -11665,6 +11777,96 @@ async function serversCommand() {
   console.log(source_default.gray(`Total: ${servers.length} server(s)`));
 }
 
+// src/cli/commands/projects.ts
+var import_cli_table33 = __toESM(require_table(), 1);
+async function projectsCommand(options = {}) {
+  const spinner = ora("Connecting to Coolify...").start();
+  try {
+    const coolify = getCoolifyService();
+    const initResult = await coolify.init();
+    if (isErr(initResult)) {
+      spinner.fail(source_default.red(`Failed to initialize: ${initResult.error.message}`));
+      return;
+    }
+    spinner.text = "Fetching projects...";
+    const result = await coolify.listProjects();
+    if (isOk(result)) {
+      spinner.succeed(source_default.green("Projects retrieved"));
+      const projects = result.value;
+      if (projects.length === 0) {
+        console.log(source_default.yellow("No projects found"));
+        return;
+      }
+      const table = new import_cli_table33.default({
+        head: [
+          source_default.cyan("UUID"),
+          source_default.cyan("Name"),
+          source_default.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(source_default.gray(`Total: ${projects.length} project(s)`));
+    } else {
+      spinner.fail(source_default.red(`Failed to fetch projects: ${result.error.message}`));
+    }
+  } catch (error) {
+    spinner.fail(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
+
+// src/cli/commands/environments.ts
+var import_cli_table34 = __toESM(require_table(), 1);
+async function environmentsCommand(projectUuid, options = {}) {
+  const spinner = ora("Connecting to Coolify...").start();
+  try {
+    const coolify = getCoolifyService();
+    const initResult = await coolify.init();
+    if (isErr(initResult)) {
+      spinner.fail(source_default.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(source_default.green("Environments retrieved"));
+      const environments = result.value;
+      if (environments.length === 0) {
+        console.log(source_default.yellow("No environments found for this project"));
+        return;
+      }
+      const table = new import_cli_table34.default({
+        head: [
+          source_default.cyan("UUID"),
+          source_default.cyan("Name"),
+          source_default.cyan("Description")
+        ],
+        ...options.full ? { colWidths: [36, 25, 40] } : {}
+      });
+      for (const env2 of environments) {
+        table.push([
+          options.full ? env2.uuid : env2.uuid.slice(0, 8),
+          env2.name,
+          env2.description || "-"
+        ]);
+      }
+      console.log(table.toString());
+      console.log(source_default.gray(`Total: ${environments.length} environment(s)`));
+    } else {
+      spinner.fail(source_default.red(`Failed to fetch environments: ${result.error.message}`));
+    }
+  } catch (error) {
+    spinner.fail(source_default.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
+
 // src/cli/commands/config.ts
 import { existsSync as existsSync2 } from "node:fs";
 async function configCommand(action, args) {
@@ -11767,18 +11969,253 @@ async function envCommand(uuid) {
   }
 }
 
+// src/cli/commands/update.ts
+async function updateCommand(options) {
+  console.log(source_default.cyan(`Updating application ${source_default.bold(options.uuid)}...`));
+  const service = getCoolifyService();
+  const initResult = await service.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red("Failed to initialize Coolify service"));
+    console.error(source_default.gray(initResult.error.message));
+    process.exit(1);
+  }
+  const updateOptions = {};
+  if (options.name)
+    updateOptions.name = options.name;
+  if (options.description)
+    updateOptions.description = options.description;
+  if (options.buildPack)
+    updateOptions.buildPack = options.buildPack;
+  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(source_default.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(source_default.red("Failed to update application"));
+    console.error(source_default.gray(result.error.message));
+    process.exit(1);
+  }
+  console.log(source_default.green("Application updated successfully"));
+  console.log(source_default.gray(`UUID: ${result.value.uuid}`));
+  console.log(source_default.gray(`Name: ${result.value.name}`));
+  if (result.value.description) {
+    console.log(source_default.gray(`Description: ${result.value.description}`));
+  }
+}
+
+// src/cli/commands/delete.ts
+async function deleteCommand(uuid, options = {}) {
+  const service = getCoolifyService();
+  const initResult = await service.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red("Failed to initialize Coolify service"));
+    console.error(source_default.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((resolve) => {
+      rl.question(source_default.yellow(`Are you sure you want to delete application ${source_default.bold(uuid)}? (yes/no): `), (ans) => {
+        rl.close();
+        resolve(ans.toLowerCase());
+      });
+    });
+    if (answer !== "yes" && answer !== "y") {
+      console.log(source_default.gray("Operation cancelled"));
+      process.exit(0);
+    }
+  }
+  console.log(source_default.cyan(`Deleting application ${source_default.bold(uuid)}...`));
+  const result = await service.deleteApplication(uuid);
+  if (isErr(result)) {
+    console.error(source_default.red("Failed to delete application"));
+    console.error(source_default.gray(result.error.message));
+    process.exit(1);
+  }
+  console.log(source_default.green("Application deleted successfully"));
+  if (result.value.message) {
+    console.log(source_default.gray(result.value.message));
+  }
+}
+
+// src/cli/commands/destinations.ts
+var import_cli_table35 = __toESM(require_table(), 1);
+async function destinationsCommand(serverUuid) {
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red(`Error: ${initResult.error.message}`));
+    return;
+  }
+  const result = await coolify.getServerDestinations(serverUuid);
+  if (isErr(result)) {
+    console.error(source_default.red(`Error: ${result.error.message}`));
+    return;
+  }
+  const destinations = result.value;
+  if (destinations.length === 0) {
+    console.log(source_default.yellow("No destinations found"));
+    return;
+  }
+  const table = new import_cli_table35.default({
+    head: [
+      source_default.cyan("UUID"),
+      source_default.cyan("Name"),
+      source_default.cyan("Network")
+    ]
+  });
+  for (const dest of destinations) {
+    table.push([
+      dest.uuid,
+      dest.name,
+      dest.network || "N/A"
+    ]);
+  }
+  console.log(table.toString());
+  console.log(source_default.gray(`Total: ${destinations.length} destination(s)`));
+}
+
+// src/cli/commands/show.ts
+async function showCommand(uuid) {
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red(`Error: ${initResult.error.message}`));
+    return;
+  }
+  const result = await coolify.listApplications();
+  if (isErr(result)) {
+    console.error(source_default.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(source_default.red(`Application not found: ${uuid}`));
+    return;
+  }
+  console.log(source_default.cyan("Application Details:"));
+  console.log("");
+  console.log(source_default.gray("UUID:       ") + source_default.white(app.uuid));
+  console.log(source_default.gray("Name:       ") + source_default.white(app.name));
+  console.log(source_default.gray("Status:     ") + source_default.white(app.status));
+  console.log(source_default.gray("Description:") + source_default.white(app.description || "N/A"));
+  console.log(source_default.gray("Repository: ") + source_default.white(app.git_repository || "N/A"));
+  console.log(source_default.gray("Branch:     ") + source_default.white(app.git_branch || "N/A"));
+  console.log(source_default.gray("Build Pack: ") + source_default.white(app.build_pack || "N/A"));
+  console.log(source_default.gray("Ports:      ") + source_default.white(app.ports_exposes || "N/A"));
+  console.log(source_default.gray("FQDN:       ") + source_default.white(app.fqdn || "N/A"));
+  console.log(source_default.gray("Dockerfile: ") + source_default.white(app.dockerfile_location || "N/A"));
+  console.log(source_default.gray("Base Dir:   ") + source_default.white(app.base_directory || "N/A"));
+  console.log("");
+  console.log(source_default.cyan("Destination:"));
+  if (app.destination) {
+    console.log(source_default.gray("  UUID:  ") + source_default.white(app.destination.uuid));
+    console.log(source_default.gray("  Name:  ") + source_default.white(app.destination.name));
+    if (app.destination.server) {
+      console.log(source_default.gray("  Server:") + source_default.white(` ${app.destination.server.name} (${app.destination.server.ip})`));
+    }
+  } else {
+    console.log(source_default.yellow("  No destination configured"));
+  }
+  console.log("");
+  console.log(source_default.cyan("Commands:"));
+  if (app.install_command)
+    console.log(source_default.gray("  Install: ") + source_default.white(app.install_command));
+  if (app.build_command)
+    console.log(source_default.gray("  Build:   ") + source_default.white(app.build_command));
+  if (app.start_command)
+    console.log(source_default.gray("  Start:   ") + source_default.white(app.start_command));
+}
+
+// src/cli/commands/deployments.ts
+var import_cli_table36 = __toESM(require_table(), 1);
+async function deploymentsCommand(uuid, options = {}) {
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isErr(initResult)) {
+    console.error(source_default.red(`Error: ${initResult.error.message}`));
+    return;
+  }
+  const result = await coolify.getApplicationDeploymentHistory(uuid);
+  if (isErr(result)) {
+    console.error(source_default.red(`Error: ${result.error.message}`));
+    return;
+  }
+  let deployments = result.value;
+  deployments = deployments.reverse();
+  if (options.limit) {
+    deployments = deployments.slice(0, options.limit);
+  }
+  if (deployments.length === 0) {
+    console.log(source_default.yellow("No deployments found"));
+    return;
+  }
+  const table = new import_cli_table36.default({
+    head: [
+      source_default.cyan("ID"),
+      source_default.cyan("UUID"),
+      source_default.cyan("Status"),
+      source_default.cyan("Commit"),
+      source_default.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(source_default.gray(`Total: ${deployments.length} deployment(s)`));
+}
+
 // src/cli/index.ts
 var program2 = new Command;
 program2.name("coolify-mcp").description("CLI for Coolify deployment management").version("0.1.0");
+program2.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(createCommand2);
 program2.command("config").description("Manage configuration").argument("[action]", "Action to perform (set, get, path)").option("--key <key>", 'Configuration key (for "set" action)').option("--value <value>", 'Configuration value (for "set" action)').action(configCommand);
-program2.command("list").description("List all applications").option("-t, --team <id>", "Filter by team ID").option("-p, --project <id>", "Filter by project ID").action(listCommand);
+program2.command("list").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);
 program2.command("deploy <uuid>").description("Deploy an application").option("-f, --force", "Force rebuild without cache").option("-t, --tag <tag>", "Deploy specific tag/version").action(deployCommand);
 program2.command("logs <uuid>").description("Get application logs").option("-n, --lines <number>", "Number of lines to retrieve", "50").option("-f, --follow", "Follow logs in real-time").action((uuid, options) => {
   const lines = parseInt(options.lines, 10);
   logsCommand(uuid, { lines, follow: options.follow });
 });
-program2.command("servers").description("List available servers").action(serversCommand);
+program2.command("servers").description("List available servers").option("--full", "Show full UUIDs instead of truncated").action((options) => serversCommand(options));
+program2.command("projects").description("List available projects").option("--full", "Show full UUIDs instead of truncated").action((options) => projectsCommand(options));
+program2.command("environments <projectUuid>").description("List environments for a project").option("--full", "Show full UUIDs instead of truncated").action((projectUuid, options) => environmentsCommand(projectUuid, options));
 program2.command("env <uuid>").description("Get environment variables for an application").action(envCommand);
+program2.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 }));
+program2.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));
+program2.command("destinations <serverUuid>").description("List available destinations for a server").action(destinationsCommand);
+program2.command("show <uuid>").description("Show detailed information about an application").action(showCommand);
+program2.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 });
+});
 program2.action(() => {
   console.log(source_default.cyan("Coolify MCP CLI"));
   console.log(source_default.gray(`Manage Coolify deployments from the command line

package/dist/coolify/index.d.ts

@@ -6,7 +6,7 @@
  * @module
  */
 import { type Result } from '@mks2508/no-throw';
-import { type ICoolifyAppOptions, type ICoolifyAppResult, type ICoolifyApplication, type ICoolifyDeleteResult, type ICoolifyDeployment, type ICoolifyDeployOptions, type ICoolifyDeployResult, type ICoolifyDestination, type ICoolifyLogs, type ICoolifyLogsOptions, type ICoolifyProject, type ICoolifyServer, type ICoolifyTeam, type ICoolifyUpdateOptions, type IProgressCallback } from './types.js';
+import { type ICoolifyAppOptions, type ICoolifyAppResult, type ICoolifyApplication, type ICoolifyDeleteResult, type ICoolifyDeployment, type ICoolifyDeployOptions, type ICoolifyDeployResult, type ICoolifyDestination, type ICoolifyEnvironment, type ICoolifyLogs, type ICoolifyLogsOptions, type ICoolifyProject, type ICoolifyServer, type ICoolifyTeam, type ICoolifyUpdateOptions, type IProgressCallback } from './types.js';
 /**
  * Environment variable from Coolify API.
  */
@@ -72,6 +72,14 @@ export declare class CoolifyService {
     /**
      * 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
@@ -118,6 +126,13 @@ export declare class CoolifyService {
      * @returns Result with projects list or error
      */
     listProjects(): Promise<Result<ICoolifyProject[], Error>>;
+    /**
+     * Gets environments for a project.
+     *
+     * @param projectUuid - Project UUID
+     * @returns Result with environments list or error
+     */
+    getProjectEnvironments(projectUuid: string): Promise<Result<ICoolifyEnvironment[], Error>>;
     /**
      * Lists all teams.
      *
@@ -197,5 +212,5 @@ export declare class CoolifyService {
  * @returns The CoolifyService instance
  */
 export declare function getCoolifyService(): CoolifyService;
-export type { ICoolifyServer, ICoolifyDestination, ICoolifyProject, ICoolifyTeam, ICoolifyApplication, ICoolifyDeployment, ICoolifyAppOptions, ICoolifyDeployOptions, ICoolifyUpdateOptions, ICoolifyLogsOptions, };
+export type { ICoolifyServer, ICoolifyDestination, ICoolifyProject, ICoolifyTeam, ICoolifyApplication, ICoolifyDeployment, ICoolifyAppOptions, ICoolifyAppResult, ICoolifyDeployOptions, ICoolifyDeployResult, ICoolifyDeleteResult, ICoolifyUpdateOptions, ICoolifyLogsOptions, ICoolifyLogs, IProgressCallback, } from './types.js';
 //# sourceMappingURL=index.d.ts.map