@mks2508/coolify-mks-cli-mcp 0.6.2 → 0.8.0

package/src/coolify/index.ts

@@ -32,6 +32,10 @@ import {
   type ICoolifyTeam,
   type ICoolifyUpdateOptions,
   type ICoolifyVersion,
+  type ICoolifyInfrastructureTree,
+  type ICoolifyProjectNode,
+  type ICoolifyEnvironmentNode,
+  type ICoolifyResource,
   type IProgressCallback,
 } from "./types.js";
 
@@ -333,18 +337,20 @@ export class CoolifyService {
       server_uuid: options.serverUuid,
     };
 
+    // Git repository — applies to all types that have a repo URL
+    if (options.githubRepoUrl) {
+      // Coolify expects 'user/repo' format, not full URL
+      body.git_repository = options.githubRepoUrl
+        .replace(/^https?:\/\/github\.com\//, "")
+        .replace(/\.git$/, "");
+    }
+
     // Type-specific fields
     if (
       appType === "public" ||
       appType === "private-github-app" ||
       appType === "private-deploy-key"
     ) {
-      if (options.githubRepoUrl) {
-        // Coolify expects 'user/repo' format, not full URL
-        body.git_repository = options.githubRepoUrl
-          .replace(/^https?:\/\/github\.com\//, "")
-          .replace(/\.git$/, "");
-      }
       if (options.githubAppUuid) {
         body.github_app_uuid = options.githubAppUuid;
       }
@@ -410,7 +416,7 @@ export class CoolifyService {
     for (const [key, value] of Object.entries(envVars)) {
       const result = await this.request(`/applications/${appUuid}/envs`, {
         method: "POST",
-        body: JSON.stringify({ key, value, is_preview: false }),
+        body: JSON.stringify({ key, value, is_preview: false, is_buildtime: false }),
       });
 
       if (result.error && result.error.includes("already exists")) {
@@ -425,7 +431,7 @@ export class CoolifyService {
           });
           const repost = await this.request(`/applications/${appUuid}/envs`, {
             method: "POST",
-            body: JSON.stringify({ key, value, is_preview: false }),
+            body: JSON.stringify({ key, value, is_preview: false, is_buildtime: false }),
           });
           if (repost.error) {
             log.error(`Failed to update env var ${key}: ${repost.error}`);
@@ -484,9 +490,9 @@ export class CoolifyService {
     appUuid: string,
     key: string,
     value: string,
-    _isBuildTime: boolean = false,
+    isBuildTime: boolean = false,
   ): Promise<Result<void, Error>> {
-    log.info(`Setting environment variable ${key} for ${appUuid}`);
+    log.info(`Setting environment variable ${key} for ${appUuid} (buildtime: ${isBuildTime})`);
 
     // Check if variable already exists
     const existingVars = await this.getEnvironmentVariables(appUuid);
@@ -503,7 +509,11 @@ export class CoolifyService {
         `/applications/${appUuid}/envs`,
         {
           method: "PATCH",
-          body: JSON.stringify({ key, value }),
+          body: JSON.stringify({
+            key,
+            value,
+            is_buildtime: isBuildTime,
+          }),
         },
       );
 
@@ -518,7 +528,11 @@ export class CoolifyService {
         `/applications/${appUuid}/envs`,
         {
           method: "POST",
-          body: JSON.stringify({ key, value }),
+          body: JSON.stringify({
+            key,
+            value,
+            is_buildtime: isBuildTime,
+          }),
         },
       );
 
@@ -910,6 +924,24 @@ export class CoolifyService {
       body.is_force_https_enabled = options.isForceHttpsEnabled;
     if (options.isAutoDeployEnabled !== undefined)
       body.is_auto_deploy_enabled = options.isAutoDeployEnabled;
+    if (options.healthCheckEnabled !== undefined)
+      body.health_check_enabled = options.healthCheckEnabled;
+    if (options.healthCheckPath)
+      body.health_check_path = options.healthCheckPath;
+    if (options.healthCheckPort)
+      body.health_check_port = String(options.healthCheckPort);
+    if (options.healthCheckMethod)
+      body.health_check_method = options.healthCheckMethod;
+    if (options.healthCheckInterval)
+      body.health_check_interval = options.healthCheckInterval;
+    if (options.healthCheckTimeout)
+      body.health_check_timeout = options.healthCheckTimeout;
+    if (options.healthCheckRetries)
+      body.health_check_retries = options.healthCheckRetries;
+    if (options.healthCheckStartPeriod)
+      body.health_check_start_period = options.healthCheckStartPeriod;
+    if (options.healthCheckReturnCode)
+      body.health_check_return_code = options.healthCheckReturnCode;
 
     const result = await this.request<ICoolifyApplication>(
       `/applications/${appUuid}`,
@@ -1620,6 +1652,186 @@ export class CoolifyService {
     return ok({ success: true, message: "Service deleted" });
   }
 
+  /**
+   * Gets the full infrastructure tree: Projects → Environments → Resources.
+   *
+   * Fetches all projects, apps, databases, and services in parallel,
+   * then groups them by environment_id into a hierarchical tree.
+   *
+   * @returns Result with the full infrastructure tree or error
+   */
+  async getInfrastructureTree(): Promise<
+    Result<ICoolifyInfrastructureTree, Error>
+  > {
+    log.info("Building infrastructure tree");
+
+    // Fetch all data in parallel
+    const [projectsResult, appsResult, dbsResult, svcsResult, serversResult] =
+      await Promise.all([
+        this.listProjects(),
+        this.listApplications(),
+        this.listDatabases(),
+        this.listServices(),
+        this.listServers(),
+      ]);
+
+    if (isErr(projectsResult)) return err(projectsResult.error);
+    if (isErr(appsResult)) return err(appsResult.error);
+    if (isErr(serversResult)) return err(serversResult.error);
+
+    const projects = projectsResult.value;
+    const apps = appsResult.value;
+    const dbs = isErr(dbsResult) ? [] : dbsResult.value;
+    const svcs = isErr(svcsResult) ? [] : svcsResult.value;
+    const servers = serversResult.value;
+
+    // Fetch environments for each project in parallel
+    const envResults = await Promise.allSettled(
+      projects.map((p) => this.getProjectEnvironments(p.uuid)),
+    );
+
+    // Build environment_id → { projectUuid, envName, envUuid } mapping
+    const envIdMap = new Map<
+      number,
+      { projectUuid: string; envName: string; envUuid: string }
+    >();
+
+    for (let i = 0; i < projects.length; i++) {
+      const envResult = envResults[i];
+      if (envResult.status === "fulfilled" && !isErr(envResult.value)) {
+        for (const env of envResult.value.value) {
+          envIdMap.set(env.id, {
+            projectUuid: projects[i].uuid,
+            envName: env.name,
+            envUuid: env.uuid,
+          });
+        }
+      }
+    }
+
+    // Build project nodes
+    const projectNodes: ICoolifyProjectNode[] = projects.map((p) => ({
+      uuid: p.uuid,
+      name: p.name,
+      description: p.description,
+      environments: [],
+    }));
+
+    const projectMap = new Map<string, ICoolifyProjectNode>();
+    for (const node of projectNodes) {
+      projectMap.set(node.uuid, node);
+    }
+
+    // Populate environments from envIdMap
+    const envNodeMap = new Map<number, ICoolifyEnvironmentNode>();
+    for (const [envId, info] of envIdMap) {
+      const project = projectMap.get(info.projectUuid);
+      if (!project) continue;
+
+      let envNode = project.environments.find((e) => e.id === envId);
+      if (!envNode) {
+        envNode = {
+          id: envId,
+          uuid: info.envUuid,
+          name: info.envName,
+          resources: [],
+        };
+        project.environments.push(envNode);
+      }
+      envNodeMap.set(envId, envNode);
+    }
+
+    // Assign apps to environments
+    for (const app of apps) {
+      const envNode = app.environment_id
+        ? envNodeMap.get(app.environment_id)
+        : undefined;
+      const resource: ICoolifyResource = {
+        uuid: app.uuid,
+        name: app.name,
+        kind: "app",
+        status: app.status,
+        fqdn: app.fqdn,
+      };
+      if (envNode) {
+        envNode.resources.push(resource);
+      }
+    }
+
+    // Assign databases to environments
+    for (const db of dbs) {
+      const envNode = (db as any).environment_id
+        ? envNodeMap.get((db as any).environment_id)
+        : undefined;
+      const resource: ICoolifyResource = {
+        uuid: db.uuid,
+        name: db.name,
+        kind: "database",
+        status: db.status,
+        dbType: db.type,
+      };
+      if (envNode) {
+        envNode.resources.push(resource);
+      }
+    }
+
+    // Assign services to environments
+    for (const svc of svcs) {
+      const envNode = (svc as any).environment_id
+        ? envNodeMap.get((svc as any).environment_id)
+        : undefined;
+      const resource: ICoolifyResource = {
+        uuid: svc.uuid,
+        name: svc.name,
+        kind: "service",
+        status: svc.status,
+      };
+      if (envNode) {
+        envNode.resources.push(resource);
+      }
+    }
+
+    // Filter out empty projects
+    const populatedProjects = projectNodes.filter(
+      (p) => p.environments.some((e) => e.resources.length > 0),
+    );
+
+    // Aggregate counts
+    const allStatuses = [
+      ...apps.map((a) => a.status),
+      ...dbs.map((d) => d.status),
+      ...svcs.map((s) => s.status),
+    ];
+    const counts = {
+      projects: populatedProjects.length,
+      apps: apps.length,
+      databases: dbs.length,
+      services: svcs.length,
+      healthy: allStatuses.filter((s) => s.includes("healthy")).length,
+      running: allStatuses.filter(
+        (s) => s.startsWith("running") && !s.includes("healthy"),
+      ).length,
+      stopped: allStatuses.filter((s) => s.includes("exited")).length,
+      unhealthy: allStatuses.filter((s) => s.includes("unhealthy")).length,
+    };
+
+    const server = servers[0] || { name: "Unknown" };
+
+    log.success(
+      `Infrastructure tree built: ${counts.projects} projects, ${counts.apps} apps, ${counts.databases} dbs, ${counts.services} svcs`,
+    );
+
+    return ok({
+      server: {
+        name: server.name,
+        ip: server.ip,
+        uuid: server.uuid,
+      },
+      projects: populatedProjects,
+      counts,
+    });
+  }
+
   /**
    * Starts a service.
    * Note: Coolify API uses GET for service start/stop/restart.
@@ -2295,6 +2507,35 @@ export class CoolifyService {
   // Smart Resolution Helpers
   // ===========================================================================
 
+  /**
+   * Gets full application details by UUID.
+   *
+   * Makes a direct GET request to /api/v1/applications/{uuid} which returns
+   * complete application data including project_uuid and environment_uuid.
+   *
+   * @param appUuid - Application UUID
+   * @returns Result with full application details or error
+   */
+  async getApplication(
+    appUuid: string,
+  ): Promise<Result<ICoolifyApplication, Error>> {
+    log.info(`Getting application details: ${appUuid}`);
+
+    const result = await this.request<ICoolifyApplication>(
+      `/applications/${appUuid}`,
+    );
+
+    if (result.error) {
+      return err(new Error(result.error));
+    }
+
+    if (!result.data) {
+      return err(new Error("Application not found"));
+    }
+
+    return ok(result.data);
+  }
+
   /**
    * Resolves an application by UUID, name, or domain (FQDN).
    *
@@ -2878,4 +3119,8 @@ export type {
   ICoolifyLogsOptions,
   ICoolifyLogs,
   IProgressCallback,
+  ICoolifyInfrastructureTree,
+  ICoolifyProjectNode,
+  ICoolifyEnvironmentNode,
+  ICoolifyResource,
 } from "./types.js";

package/src/coolify/types.ts

@@ -106,6 +106,24 @@ export interface ICoolifyUpdateOptions {
   isForceHttpsEnabled?: boolean;
   /** Enable auto deploy on git push */
   isAutoDeployEnabled?: boolean;
+  /** Enable health check for the application */
+  healthCheckEnabled?: boolean;
+  /** Health check endpoint path (e.g., "/health") */
+  healthCheckPath?: string;
+  /** Health check port (defaults to application port) */
+  healthCheckPort?: string | number;
+  /** Health check HTTP method (e.g., "GET") */
+  healthCheckMethod?: string;
+  /** Health check interval in seconds */
+  healthCheckInterval?: number;
+  /** Health check timeout in seconds */
+  healthCheckTimeout?: number;
+  /** Number of retries before marking unhealthy */
+  healthCheckRetries?: number;
+  /** Grace period in seconds before health checks start */
+  healthCheckStartPeriod?: number;
+  /** Expected HTTP return code for healthy status */
+  healthCheckReturnCode?: number;
 }
 
 /**
@@ -224,8 +242,16 @@ export interface ICoolifyApplication {
   base_directory?: string | null;
   /** Server status (boolean) */
   server_status?: boolean;
-  /** Environment ID */
+  /** Environment ID (numeric) */
   environment_id?: number;
+  /** Project UUID */
+  project_uuid?: string;
+  /** Environment UUID */
+  environment_uuid?: string;
+  /** Source type (e.g., "App\\Models\\GithubApp", "App\\Models\\DeployKey") */
+  source_type?: string;
+  /** Type (legacy, may be null) */
+  type?: string;
   /** Destination info */
   destination?: {
     uuid: string;
@@ -361,6 +387,8 @@ export interface ICoolifyDatabase {
   status: string;
   version?: string;
   description?: string | null;
+  /** Environment ID (numeric, for grouping under projects) */
+  environment_id?: number;
   destination?: {
     uuid: string;
     name: string;
@@ -382,6 +410,8 @@ export interface ICoolifyService {
   status: string;
   version?: string;
   description?: string | null;
+  /** Environment ID (numeric, for grouping under projects) */
+  environment_id?: number;
   project_uuid?: string;
   environment_uuid?: string;
   server_uuid?: string;
@@ -439,3 +469,75 @@ export interface ICoolifyVersion {
   latest_version?: string;
   is_latest?: boolean;
 }
+
+/**
+ * A resource (app, database, or service) within an environment.
+ */
+export interface ICoolifyResource {
+  /** Resource UUID */
+  uuid: string;
+  /** Resource name */
+  name: string;
+  /** Resource type: app, database, or service */
+  kind: "app" | "database" | "service";
+  /** Current status */
+  status: string;
+  /** FQDN/domain if configured */
+  fqdn?: string | null;
+  /** Database engine type (only for databases) */
+  dbType?: string;
+}
+
+/**
+ * An environment within a project, containing resources.
+ */
+export interface ICoolifyEnvironmentNode {
+  /** Environment ID (numeric) */
+  id: number;
+  /** Environment UUID */
+  uuid: string;
+  /** Environment name (e.g., "production", "staging") */
+  name: string;
+  /** Resources in this environment */
+  resources: ICoolifyResource[];
+}
+
+/**
+ * A project node in the infrastructure tree.
+ */
+export interface ICoolifyProjectNode {
+  /** Project UUID */
+  uuid: string;
+  /** Project name */
+  name: string;
+  /** Project description */
+  description?: string | null;
+  /** Environments in this project */
+  environments: ICoolifyEnvironmentNode[];
+}
+
+/**
+ * Full infrastructure tree: projects → environments → resources.
+ * Also includes global server info and aggregate counts.
+ */
+export interface ICoolifyInfrastructureTree {
+  /** Server info */
+  server: {
+    name: string;
+    ip?: string;
+    uuid?: string;
+  };
+  /** Projects with their environments and resources */
+  projects: ICoolifyProjectNode[];
+  /** Aggregate counts */
+  counts: {
+    projects: number;
+    apps: number;
+    databases: number;
+    services: number;
+    healthy: number;
+    running: number;
+    stopped: number;
+    unhealthy: number;
+  };
+}

package/src/examples/demo-ui.ts

@@ -0,0 +1,78 @@
+#!/usr/bin/env bun
+/**
+ * Demo script showing new CLI UI features.
+ *
+ * @module
+ */
+
+import { highlightEnvBlock, createEnvTable, createChangeSummary } from "../cli/ui/index.js";
+
+const sampleEnvVars = [
+  {
+    key: "DATABASE_URL",
+    value: "postgresql://user:pass@localhost:5432/mydb",
+    is_runtime: true,
+    is_buildtime: false,
+    is_required: true,
+  },
+  {
+    key: "API_KEY",
+    value: "sk_test_1234567890abcdef",
+    is_runtime: true,
+    is_buildtime: false,
+    is_required: false,
+  },
+  {
+    key: "NODE_ENV",
+    value: "production",
+    is_runtime: true,
+    is_buildtime: true,
+    is_required: false,
+  },
+  {
+    key: "BUILD_ARG",
+    value: "some_value",
+    is_runtime: false,
+    is_buildtime: true,
+    is_required: false,
+  },
+];
+
+const sampleChanges = {
+  added: [
+    { key: "NEW_VAR", value: "new_value" },
+    { key: "ANOTHER_NEW", value: "another" },
+  ],
+  updated: [
+    { key: "DATABASE_URL", value: "new_db_url", oldValue: "old_db_url" },
+    { key: "API_KEY", value: "new_key", oldValue: "old_key" },
+  ],
+  removed: ["DEPRECATED_VAR", "OLD_SETTING"],
+};
+
+console.log("\n" + "=".repeat(60));
+console.log("  CLI UI Demo - Syntax Highlighting");
+console.log("=".repeat(60) + "\n");
+
+// Demo 1: Syntax highlighted .env file
+console.log("1️⃣  Syntax Highlighted .env File");
+console.log("─".repeat(60));
+const envContent = await Bun.file("/tmp/test.env").text();
+console.log(highlightEnvBlock(envContent));
+console.log();
+
+// Demo 2: Table view
+console.log("2️⃣  Table View with cli-table3");
+console.log("─".repeat(60));
+console.log(createEnvTable(sampleEnvVars, { compact: true, showType: true }));
+console.log();
+
+// Demo 3: Change summary
+console.log("3️⃣  Change Summary for Sync");
+console.log("─".repeat(60));
+console.log(createChangeSummary(sampleChanges));
+console.log();
+
+console.log("=".repeat(60));
+console.log("  ✨ Demo complete!");
+console.log("=".repeat(60) + "\n");