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

package/src/coolify/index.ts

@@ -21,6 +21,7 @@ import {
   type ICoolifyDeployResult,
   type ICoolifyDestination,
   type ICoolifyEnvironment,
+  type ICoolifyGithubApp,
   type ICoolifyLogs,
   type ICoolifyLogsOptions,
   type ICoolifyPrivateKey,
@@ -184,7 +185,12 @@ export class CoolifyService {
 
       try {
         data = text ? JSON.parse(text) : undefined;
-      } catch {
+      } catch (parseErr) {
+        const preview = text ? text.slice(0, 200) : "(empty body)";
+        const method = options.method ?? "GET";
+        log.warn(
+          `Failed to parse JSON response from ${method} ${endpoint} (status ${response.status}): ${parseErr instanceof Error ? parseErr.message : String(parseErr)}. Body preview: ${preview}`,
+        );
         if (!response.ok) {
           return {
             error: text || `HTTP ${response.status}`,
@@ -192,6 +198,13 @@ export class CoolifyService {
             durationMs,
           };
         }
+        // OK status but body is not JSON — synthesize an error so the caller's error path triggers.
+        // Avoids silently returning undefined data which causes cryptic downstream crashes.
+        return {
+          error: `Response was not valid JSON (status ${response.status}): ${preview}`,
+          status: response.status,
+          durationMs,
+        };
       }
 
       if (!response.ok) {
@@ -320,8 +333,8 @@ export class CoolifyService {
       "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",
+      "docker-image": "/applications/dockerimage",
+      "docker-compose": "/applications/dockercompose",
       dockerimage: "/applications/dockerimage",
       dockercompose: "/applications/dockercompose",
     };
@@ -334,15 +347,14 @@ export class CoolifyService {
       description: options.description,
       project_uuid: options.projectUuid,
       environment_uuid: options.environmentUuid,
+      environment_name: options.environmentName,
       server_uuid: options.serverUuid,
     };
 
-    // Git repository — applies to all types that have a repo URL
+    // Git repository — applies to all types that have a repo URL.
+    // Coolify's API expects the full URL (https://, http://, git://, or git@).
     if (options.githubRepoUrl) {
-      // Coolify expects 'user/repo' format, not full URL
-      body.git_repository = options.githubRepoUrl
-        .replace(/^https?:\/\/github\.com\//, "")
-        .replace(/\.git$/, "");
+      body.git_repository = options.githubRepoUrl;
     }
 
     // Type-specific fields
@@ -354,25 +366,34 @@ export class CoolifyService {
       if (options.githubAppUuid) {
         body.github_app_uuid = options.githubAppUuid;
       }
+      // private_key_uuid is required for private-deploy-key type
+      if (appType === "private-deploy-key" && options.privateKeyUuid) {
+        body.private_key_uuid = options.privateKeyUuid;
+      }
       body.git_branch = options.branch || "main";
       body.build_pack = options.buildPack || "dockerfile";
       if (options.portsExposes) {
         body.ports_exposes = options.portsExposes;
       }
       // Dockerfile / Docker Compose configuration
+      // Coolify validates these paths against /^\/.*$/ regex — prepend leading slash
+      // if caller passed a relative path (CLI --help suggests "apps/x/Dockerfile" without /)
       if (options.dockerfileLocation) {
-        body.dockerfile_location = options.dockerfileLocation;
+        const p = options.dockerfileLocation;
+        body.dockerfile_location = p.startsWith("/") ? p : `/${p}`;
       }
       if (options.dockerComposeLocation) {
-        body.docker_compose_location = options.dockerComposeLocation;
+        const p = options.dockerComposeLocation;
+        body.docker_compose_location = p.startsWith("/") ? p : `/${p}`;
       }
       if (options.baseDirectory) {
-        body.base_directory = options.baseDirectory;
+        const p = options.baseDirectory;
+        body.base_directory = p.startsWith("/") ? p : `/${p}`;
       }
     } else if (appType === "docker-image" && options.dockerImage) {
-      body.docker_image = options.dockerImage;
+      body.docker_registry_image_name = options.dockerImage;
     } else if (appType === "docker-compose" && options.dockerCompose) {
-      body.docker_compose = options.dockerCompose;
+      body.docker_compose_raw = options.dockerCompose;
     }
 
     log.debug(`Create application body: ${JSON.stringify(body, null, 2)}`);
@@ -400,6 +421,15 @@ export class CoolifyService {
   /**
    * Sets environment variables for an application.
    *
+   * Delegates to {@link bulkUpdateEnvironmentVariables} so the same
+   * create-or-update logic applies. This fixes the post-delete scenario
+   * (where the variable was deleted via the API and only its base value
+   * from docker-compose/git remains visible) and prevents duplicates
+   * that the singular POST endpoint would create when called for a key
+   * that already exists. Also eliminates the N+1 API calls and the
+   * TOCTOU race between the DELETE and the re-POST that the previous
+   * per-key POST -> DELETE -> re-POST dance had.
+   *
    * @param appUuid - Application UUID
    * @param envVars - Environment variables to set
    * @returns Result indicating success or error
@@ -412,43 +442,19 @@ export class CoolifyService {
       `Setting ${Object.keys(envVars).length} environment variables for ${appUuid}`,
     );
 
-    // Coolify API: POST to create, PATCH to update existing
-    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, is_buildtime: false }),
-      });
+    const vars = Object.entries(envVars).map(([key, value]) => ({
+      key,
+      value,
+      is_buildtime: false,
+      is_runtime: true,
+    }));
 
-      if (result.error && result.error.includes("already exists")) {
-        // Var exists — DELETE + re-POST (Coolify PATCH on envs returns 404)
-        const listResult = await this.request<
-          Array<{ uuid: string; key: string }>
-        >(`/applications/${appUuid}/envs`);
-        const existing = listResult.data?.find((v) => v.key === key);
-        if (existing) {
-          await this.request(`/applications/${appUuid}/envs/${existing.uuid}`, {
-            method: "DELETE",
-          });
-          const repost = await this.request(`/applications/${appUuid}/envs`, {
-            method: "POST",
-            body: JSON.stringify({ key, value, is_preview: false, is_buildtime: false }),
-          });
-          if (repost.error) {
-            log.error(`Failed to update env var ${key}: ${repost.error}`);
-            return err(new Error(`Failed to update ${key}: ${repost.error}`));
-          }
-          log.debug(`Updated existing env var: ${key}`);
-        } else {
-          log.error(`Failed to set env var ${key}: ${result.error}`);
-          return err(new Error(`Failed to set ${key}: ${result.error}`));
-        }
-      } else if (result.error) {
-        log.error(`Failed to set env var ${key}: ${result.error}`);
-        return err(new Error(`Failed to set ${key}: ${result.error}`));
-      }
+    const result = await this.bulkUpdateEnvironmentVariables(appUuid, vars);
+    if (isErr(result)) {
+      return err(result.error);
     }
 
-    log.success(`${Object.keys(envVars).length} environment variables set`);
+    log.success(`${vars.length} environment variables set`);
     return ok(undefined);
   }
 
@@ -478,12 +484,20 @@ export class CoolifyService {
 
   /**
    * Sets a single environment variable for an application.
-   * Uses PATCH if variable exists, POST if it doesn't.
+   *
+   * Delegates to {@link bulkUpdateEnvironmentVariables} so the same
+   * create-or-update logic applies. This fixes the post-delete scenario
+   * (where the variable was deleted via the API and only its base value
+   * from docker-compose/git remains visible) and prevents duplicates
+   * that the singular PATCH endpoint would create when called without
+   * the variable's UUID.
    *
    * @param appUuid - Application UUID
    * @param key - Variable name
    * @param value - Variable value
-   * @param isBuildTime - Whether the variable is available at build time (only for new vars)
+   * @param isBuildTime - Whether the variable is available at build time
+   *   (only for new vars; existing runtime-only vars will be flipped to
+   *   build-time and vice versa).
    * @returns Result indicating success or error
    */
   async setEnvironmentVariable(
@@ -494,52 +508,17 @@ export class CoolifyService {
   ): Promise<Result<void, Error>> {
     log.info(`Setting environment variable ${key} for ${appUuid} (buildtime: ${isBuildTime})`);
 
-    // Check if variable already exists
-    const existingVars = await this.getEnvironmentVariables(appUuid);
-    if (isErr(existingVars)) {
-      return err(existingVars.error);
-    }
-
-    const exists = existingVars.value.some((ev) => ev.key === key);
-
-    if (exists) {
-      // Use PATCH to update existing variable
-      log.debug(`Variable ${key} exists, using PATCH to update`);
-      const result = await this.request<{ uuid: string }>(
-        `/applications/${appUuid}/envs`,
-        {
-          method: "PATCH",
-          body: JSON.stringify({
-            key,
-            value,
-            is_buildtime: isBuildTime,
-          }),
-        },
-      );
-
-      if (result.error) {
-        log.error(`Failed to update env var: ${result.error}`);
-        return err(new Error(result.error));
-      }
-    } else {
-      // Use POST to create new variable
-      log.debug(`Variable ${key} does not exist, using POST to create`);
-      const result = await this.request<{ uuid: string }>(
-        `/applications/${appUuid}/envs`,
-        {
-          method: "POST",
-          body: JSON.stringify({
-            key,
-            value,
-            is_buildtime: isBuildTime,
-          }),
-        },
-      );
+    const result = await this.bulkUpdateEnvironmentVariables(appUuid, [
+      {
+        key,
+        value,
+        is_buildtime: isBuildTime,
+        is_runtime: !isBuildTime,
+      },
+    ]);
 
-      if (result.error) {
-        log.error(`Failed to create env var: ${result.error}`);
-        return err(new Error(result.error));
-      }
+    if (isErr(result)) {
+      return err(result.error);
     }
 
     log.success(`Environment variable ${key} set for ${appUuid}`);
@@ -663,12 +642,7 @@ export class CoolifyService {
   async listGithubApps(
     page?: number,
     perPage?: number,
-  ): Promise<
-    Result<
-      Array<{ id: number; uuid: string; name: string; is_public: boolean }>,
-      Error
-    >
-  > {
+  ): Promise<Result<ICoolifyGithubApp[], Error>> {
     let endpoint = "/github-apps";
     const params = new URLSearchParams();
     if (page) params.set("page", page.toString());
@@ -677,14 +651,40 @@ export class CoolifyService {
       endpoint += `?${params.toString()}`;
     }
 
-    const result =
-      await this.request<
-        Array<{ id: number; uuid: string; name: string; is_public: boolean }>
-      >(endpoint);
+    const result = await this.request<ICoolifyGithubApp[]>(endpoint);
     if (result.error) return err(new Error(result.error));
     return ok(result.data || []);
   }
 
+  /**
+   * Lists all GitHub Apps configured in Coolify.
+   * Fetches all pages internally and returns a flat list.
+   *
+   * @param perPage - Items per page for each request (default: 50)
+   * @returns Result with all GitHub Apps or error
+   */
+  async listGithubAppsAll(
+    perPage = 50,
+  ): Promise<Result<ICoolifyGithubApp[], Error>> {
+    const allApps: ICoolifyGithubApp[] = [];
+    let page = 1;
+
+    while (true) {
+      const result = await this.listGithubApps(page, perPage);
+      if (isErr(result)) return err(result.error);
+      const apps = result.value;
+
+      if (apps.length === 0) break;
+      allApps.push(...apps);
+
+      // If we got fewer than perPage, we've reached the last page
+      if (apps.length < perPage) break;
+      page++;
+    }
+
+    return ok(allApps);
+  }
+
   /**
    * Lists all projects.
    *
@@ -920,10 +920,14 @@ export class CoolifyService {
     if (options.domains) body.domains = options.domains;
     if (options.dockerComposeDomains)
       body.docker_compose_domains = options.dockerComposeDomains;
+    if (options.dockerComposeRaw !== undefined)
+      body.docker_compose_raw = options.dockerComposeRaw;
     if (options.isForceHttpsEnabled !== undefined)
       body.is_force_https_enabled = options.isForceHttpsEnabled;
     if (options.isAutoDeployEnabled !== undefined)
       body.is_auto_deploy_enabled = options.isAutoDeployEnabled;
+    if (options.watchPaths !== undefined)
+      body.watch_paths = options.watchPaths;
     if (options.healthCheckEnabled !== undefined)
       body.health_check_enabled = options.healthCheckEnabled;
     if (options.healthCheckPath)
@@ -1036,8 +1040,15 @@ export class CoolifyService {
   /**
    * Bulk updates environment variables for an application.
    *
+   * Uses the bulk endpoint `PATCH /applications/{appUuid}/envs/bulk` which
+   * has create-or-update semantics: if the variable exists in the override
+   * table, its value is updated; otherwise a new override is created. This
+   * is the only reliable way to update a variable that has been deleted
+   * (i.e. its base value from docker-compose/git is still visible in
+   * `getEnvironmentVariables` but no override row exists).
+   *
    * @param appUuid - Application UUID
-   * @param envVars - Array of { key, value, is_preview? } objects
+   * @param envVars - Array of variable definitions to upsert
    * @returns Result indicating success or error
    */
   async bulkUpdateEnvironmentVariables(
@@ -1046,15 +1057,19 @@ export class CoolifyService {
       key: string;
       value: string;
       is_preview?: boolean;
+      is_buildtime?: boolean;
+      is_runtime?: boolean;
     }>,
   ): Promise<Result<{ message: string }, Error>> {
     log.info(`Bulk updating ${envVars.length} env vars for ${appUuid}`);
 
+    // Coolify bulk endpoint requires { data: [...] } envelope, not a raw array.
+    // Sending a raw array yields 400 "Bulk data is required." from the API.
     const result = await this.request<{ message: string }>(
       `/applications/${appUuid}/envs/bulk`,
       {
         method: "PATCH",
-        body: JSON.stringify(envVars),
+        body: JSON.stringify({ data: envVars }),
       },
     );
 
@@ -1067,6 +1082,50 @@ export class CoolifyService {
     return ok(result.data || { message: "Environment variables updated" });
   }
 
+  /**
+   * Bulk updates environment variables for a database.
+   *
+   * Uses the bulk endpoint `PATCH /databases/{databaseUuid}/envs/bulk` which
+   * has create-or-update semantics. Note: the database schema is narrower
+   * than applications — it accepts `key`, `value`, `is_literal`,
+   * `is_multiline`, `is_shown_once` but does NOT accept `is_preview`,
+   * `is_buildtime` or `is_runtime` (those flags are application-only).
+   *
+   * @param databaseUuid - Database UUID
+   * @param envVars - Array of variable definitions to upsert
+   * @returns Result indicating success or error
+   */
+  async bulkUpdateDatabaseEnvVars(
+    databaseUuid: string,
+    envVars: Array<{
+      key: string;
+      value: string;
+      is_literal?: boolean;
+      is_multiline?: boolean;
+      is_shown_once?: boolean;
+    }>,
+  ): Promise<Result<{ message: string }, Error>> {
+    log.info(`Bulk updating ${envVars.length} env vars for database ${databaseUuid}`);
+
+    // Coolify bulk endpoint requires { data: [...] } envelope, not a raw array.
+    // Sending a raw array yields 400 "Bulk data is required." from the API.
+    const result = await this.request<{ message: string }>(
+      `/databases/${databaseUuid}/envs/bulk`,
+      {
+        method: "PATCH",
+        body: JSON.stringify({ data: envVars }),
+      },
+    );
+
+    if (result.error) {
+      log.error(`Failed to bulk update database env vars: ${result.error}`);
+      return err(new Error(result.error));
+    }
+
+    log.success(`Bulk updated ${envVars.length} env vars for database ${databaseUuid}`);
+    return ok(result.data || { message: "Environment variables updated" });
+  }
+
   /**
    * Gets deployment history for an application.
    *
@@ -1913,9 +1972,65 @@ export class CoolifyService {
     return ok(result.data || []);
   }
 
+  /**
+   * Bulk updates environment variables for a service.
+   *
+   * Uses the bulk endpoint `PATCH /services/{uuid}/envs/bulk` which has
+   * create-or-update semantics: if the variable exists in the override
+   * table, its value is updated; otherwise a new override is created.
+   *
+   * This is the only reliable way to update a variable that has been
+   * deleted (i.e. its base value from docker-compose/git is still visible
+   * in `listServiceEnvVars` but no override row exists), and the only way
+   * to set the same key twice without the `POST /services/{uuid}/envs`
+   * returning 409 "already exists".
+   *
+   * @param serviceUuid - Service UUID
+   * @param envVars - Array of variable definitions to upsert
+   * @returns Result indicating success or error
+   */
+  async bulkUpdateServiceEnvVars(
+    serviceUuid: string,
+    envVars: Array<{
+      key: string;
+      value: string;
+      is_preview?: boolean;
+      is_buildtime?: boolean;
+      is_runtime?: boolean;
+    }>,
+  ): Promise<Result<{ message: string }, Error>> {
+    log.info(`Bulk updating ${envVars.length} env vars for service ${serviceUuid}`);
+
+    // Coolify bulk endpoint requires { data: [...] } envelope, not a raw array.
+    // Sending a raw array yields 400 "Bulk data is required." from the API.
+    const result = await this.request<{ message: string }>(
+      `/services/${serviceUuid}/envs/bulk`,
+      {
+        method: "PATCH",
+        body: JSON.stringify({ data: envVars }),
+      },
+    );
+
+    if (result.error) {
+      log.error(`Failed to bulk update service env vars: ${result.error}`);
+      return err(new Error(result.error));
+    }
+
+    log.success(`Bulk updated ${envVars.length} env vars for service ${serviceUuid}`);
+    return ok(result.data || { message: "Environment variables updated" });
+  }
+
   /**
    * Creates an environment variable for a service.
    *
+   * NOTE: Prefer `bulkUpdateServiceEnvVars` for any non-trivial use case.
+   * This endpoint uses `POST /services/{uuid}/envs` and returns 409
+   * "already exists" when the key is already present as an override,
+   * with no recovery path on the server side. Bulk has create-or-update
+   * semantics and handles both new and existing keys reliably.
+   *
+   * Kept for callers that explicitly want a strict create-only operation.
+   *
    * @param uuid - Service UUID
    * @param data - Env var data (key, value, is_preview)
    * @returns Result with created env var UUID or error
@@ -1933,6 +2048,110 @@ export class CoolifyService {
     return ok(result.data!);
   }
 
+  /**
+   * Deletes an environment variable from a service.
+   *
+   * @param serviceUuid - Service UUID
+   * @param key - Variable name to delete
+   * @returns Result indicating success or error
+   */
+  async deleteServiceEnvVar(
+    serviceUuid: string,
+    key: string,
+  ): Promise<Result<void, Error>> {
+    log.info(`Deleting environment variable ${key} from service ${serviceUuid}`);
+
+    // First get all env vars to find the UUID of the one to delete
+    const envVarsResult = await this.listServiceEnvVars(serviceUuid);
+    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 on service ${serviceUuid}`);
+      return err(new Error(`Environment variable ${key} not found`));
+    }
+
+    const result = await this.request(
+      `/services/${serviceUuid}/envs/${envVar.uuid}`,
+      {
+        method: "DELETE",
+      },
+    );
+
+    if (result.error) {
+      log.error(`Failed to delete service env var: ${result.error}`);
+      return err(new Error(result.error));
+    }
+
+    log.success(`Environment variable ${key} deleted from service ${serviceUuid}`);
+    return ok(undefined);
+  }
+
+  /**
+   * Lists environment variables for a database.
+   *
+   * @param databaseUuid - Database UUID
+   * @returns Result with env vars list or error
+   */
+  async listDatabaseEnvVars(
+    databaseUuid: string,
+  ): Promise<Result<ICoolifyEnvVar[], Error>> {
+    log.info(`Listing env vars for database ${databaseUuid}`);
+
+    const result = await this.request<ICoolifyEnvVar[]>(
+      `/databases/${databaseUuid}/envs`,
+    );
+    if (result.error) {
+      log.error(`Failed to list database env vars: ${result.error}`);
+      return err(new Error(result.error));
+    }
+
+    return ok(result.data || []);
+  }
+
+  /**
+   * Deletes an environment variable from a database.
+   *
+   * @param databaseUuid - Database UUID
+   * @param key - Variable name to delete
+   * @returns Result indicating success or error
+   */
+  async deleteDatabaseEnvVar(
+    databaseUuid: string,
+    key: string,
+  ): Promise<Result<void, Error>> {
+    log.info(`Deleting environment variable ${key} from database ${databaseUuid}`);
+
+    // First get all env vars to find the UUID of the one to delete
+    const envVarsResult = await this.listDatabaseEnvVars(databaseUuid);
+    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 on database ${databaseUuid}`);
+      return err(new Error(`Environment variable ${key} not found`));
+    }
+
+    const result = await this.request(
+      `/databases/${databaseUuid}/envs/${envVar.uuid}`,
+      {
+        method: "DELETE",
+      },
+    );
+
+    if (result.error) {
+      log.error(`Failed to delete database env var: ${result.error}`);
+      return err(new Error(result.error));
+    }
+
+    log.success(`Environment variable ${key} deleted from database ${databaseUuid}`);
+    return ok(undefined);
+  }
+
   // ===========================================================================
   // Additional Server endpoints
   // ===========================================================================