@mks2508/coolify-mks-cli-mcp 0.6.3 → 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,
@@ -32,6 +33,10 @@ import {
   type ICoolifyTeam,
   type ICoolifyUpdateOptions,
   type ICoolifyVersion,
+  type ICoolifyInfrastructureTree,
+  type ICoolifyProjectNode,
+  type ICoolifyEnvironmentNode,
+  type ICoolifyResource,
   type IProgressCallback,
 } from "./types.js";
 
@@ -180,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}`,
@@ -188,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) {
@@ -316,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",
     };
@@ -330,43 +347,53 @@ 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.
+    // Coolify's API expects the full URL (https://, http://, git://, or git@).
+    if (options.githubRepoUrl) {
+      body.git_repository = options.githubRepoUrl;
+    }
+
     // 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;
       }
+      // 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)}`);
@@ -394,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
@@ -406,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 }),
-      });
+    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 }),
-          });
-          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);
   }
 
@@ -472,60 +484,41 @@ 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(
     appUuid: string,
     key: string,
     value: string,
-    _isBuildTime: boolean = false,
+    isBuildTime: boolean = false,
   ): Promise<Result<void, Error>> {
-    log.info(`Setting environment variable ${key} for ${appUuid}`);
-
-    // 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);
+    log.info(`Setting environment variable ${key} for ${appUuid} (buildtime: ${isBuildTime})`);
 
-    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 }),
-        },
-      );
-
-      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 }),
-        },
-      );
+    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}`);
@@ -649,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());
@@ -663,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.
    *
@@ -906,10 +920,32 @@ 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)
+      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}`,
@@ -1004,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(
@@ -1014,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 }),
       },
     );
 
@@ -1035,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.
    *
@@ -1620,6 +1711,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.
@@ -1701,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
@@ -1721,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
   // ===========================================================================
@@ -2295,6 +2726,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 +3338,8 @@ export type {
   ICoolifyLogsOptions,
   ICoolifyLogs,
   IProgressCallback,
+  ICoolifyInfrastructureTree,
+  ICoolifyProjectNode,
+  ICoolifyEnvironmentNode,
+  ICoolifyResource,
 } from "./types.js";