@mks2508/coolify-mks-cli-mcp 0.4.2 → 0.5.0

package/src/coolify/index.ts

@@ -6,9 +6,9 @@
  * @module
  */
 
-import { ok, err, isErr, type Result } from '@mks2508/no-throw'
-import { component } from '@mks2508/better-logger'
-import { loadConfig, type ICoolifyConfig } from './config.js'
+import { ok, err, isErr, type Result } from "@mks2508/no-throw";
+import { component } from "@mks2508/better-logger";
+import { loadConfig, type ICoolifyConfig } from "./config.js";
 import {
   type ICoolifyAppOptions,
   type ICoolifyAppResult,
@@ -26,31 +26,31 @@ import {
   type ICoolifyTeam,
   type ICoolifyUpdateOptions,
   type IProgressCallback,
-} from './types.js'
+} from "./types.js";
 
-const log = component('CoolifyService')
+const log = component("CoolifyService");
 
 /**
  * Coolify API response type.
  */
 interface ICoolifyApiResponse<T> {
-  data?: T
-  error?: string
-  status: number
-  durationMs?: number
+  data?: T;
+  error?: string;
+  status: number;
+  durationMs?: number;
 }
 
 /**
  * Environment variable from Coolify API.
  */
 export interface ICoolifyEnvVar {
-  uuid: string
-  key: string
-  value: string
-  real_value?: string
-  is_buildtime: boolean
-  is_runtime: boolean
-  is_required: boolean
+  uuid: string;
+  key: string;
+  value: string;
+  real_value?: string;
+  is_buildtime: boolean;
+  is_runtime: boolean;
+  is_required: boolean;
 }
 
 /**
@@ -72,9 +72,9 @@ export interface ICoolifyEnvVar {
  * ```
  */
 export class CoolifyService {
-  private baseUrl: string | undefined
-  private token: string | undefined
-  private config: ICoolifyConfig = {}
+  private baseUrl: string | undefined;
+  private token: string | undefined;
+  private config: ICoolifyConfig = {};
 
   /**
    * Checks if the service is configured with URL and token.
@@ -82,9 +82,9 @@ export class CoolifyService {
    * @returns true if both URL and token are set
    */
   isConfigured(): boolean {
-    const hasUrl = !!this.baseUrl || !!process.env.COOLIFY_URL
-    const hasToken = !!this.token || !!process.env.COOLIFY_TOKEN
-    return hasUrl && hasToken
+    const hasUrl = !!this.baseUrl || !!process.env.COOLIFY_URL;
+    const hasToken = !!this.token || !!process.env.COOLIFY_TOKEN;
+    return hasUrl && hasToken;
   }
 
   /**
@@ -93,31 +93,43 @@ export class CoolifyService {
    * @returns Result indicating success or error
    */
   async init(): Promise<Result<void, Error>> {
-    const configResult = await loadConfig()
+    const configResult = await loadConfig();
 
     if (isErr(configResult)) {
-      log.error('Failed to load config')
-      return err(configResult.error)
+      log.error("Failed to load config");
+      return err(configResult.error);
     }
 
-    this.config = configResult.value
-    this.baseUrl = this.config.url || process.env.COOLIFY_URL
-    this.token = this.config.token || process.env.COOLIFY_TOKEN
+    this.config = configResult.value;
+    this.baseUrl = this.config.url || process.env.COOLIFY_URL;
+    this.token = this.config.token || process.env.COOLIFY_TOKEN;
 
     if (!this.baseUrl) {
-      log.error('No Coolify URL configured')
-      log.info('Set COOLIFY_URL environment variable or run: coolify-mcp config set url <url>')
-      return err(new Error('No Coolify URL configured. Set COOLIFY_URL or use config command.'))
+      log.error("No Coolify URL configured");
+      log.info(
+        "Set COOLIFY_URL environment variable or run: coolify-mcp config set url <url>",
+      );
+      return err(
+        new Error(
+          "No Coolify URL configured. Set COOLIFY_URL or use config command.",
+        ),
+      );
     }
 
     if (!this.token) {
-      log.error('No Coolify token configured')
-      log.info('Set COOLIFY_TOKEN environment variable or run: coolify-mcp config set token <token>')
-      return err(new Error('No Coolify token configured. Set COOLIFY_TOKEN or use config command.'))
+      log.error("No Coolify token configured");
+      log.info(
+        "Set COOLIFY_TOKEN environment variable or run: coolify-mcp config set token <token>",
+      );
+      return err(
+        new Error(
+          "No Coolify token configured. Set COOLIFY_TOKEN or use config command.",
+        ),
+      );
     }
 
-    log.debug('Coolify connection configured')
-    return ok(undefined)
+    log.debug("Coolify connection configured");
+    return ok(undefined);
   }
 
   /**
@@ -129,57 +141,70 @@ export class CoolifyService {
    */
   private async request<T>(
     endpoint: string,
-    options: RequestInit = {}
+    options: RequestInit = {},
   ): Promise<ICoolifyApiResponse<T>> {
-    const startTime = Date.now()
+    const startTime = Date.now();
 
     if (!this.baseUrl || !this.token) {
-      return { error: 'Coolify not configured', status: 0, durationMs: Date.now() - startTime }
+      return {
+        error: "Coolify not configured",
+        status: 0,
+        durationMs: Date.now() - startTime,
+      };
     }
 
     try {
-      const baseUrl = this.baseUrl.replace(/\/+$/, '')
-      const url = `${baseUrl}/api/v1${endpoint}`
+      const baseUrl = this.baseUrl.replace(/\/+$/, "");
+      const url = `${baseUrl}/api/v1${endpoint}`;
 
       const response = await fetch(url, {
         ...options,
         headers: {
           Authorization: `Bearer ${this.token}`,
-          'Content-Type': 'application/json',
-          Accept: 'application/json',
+          "Content-Type": "application/json",
+          Accept: "application/json",
           ...options.headers,
         },
-      })
+      });
 
-      const text = await response.text()
-      const durationMs = Date.now() - startTime
-      let data: T | undefined
+      const text = await response.text();
+      const durationMs = Date.now() - startTime;
+      let data: T | undefined;
 
       try {
-        data = text ? JSON.parse(text) : undefined
+        data = text ? JSON.parse(text) : undefined;
       } catch {
         if (!response.ok) {
-          return { error: text || `HTTP ${response.status}`, status: response.status, durationMs }
+          return {
+            error: text || `HTTP ${response.status}`,
+            status: response.status,
+            durationMs,
+          };
         }
       }
 
       if (!response.ok) {
-        const parsed = data as { message?: string; errors?: Record<string, string[]> } | undefined
-        let errorMessage = parsed?.message || `HTTP ${response.status}`
+        const parsed = data as
+          | { message?: string; errors?: Record<string, string[]> }
+          | undefined;
+        let errorMessage = parsed?.message || `HTTP ${response.status}`;
         // Include validation errors if present (Coolify returns { message, errors: { field: [reasons] } })
         if (parsed?.errors) {
           const details = Object.entries(parsed.errors)
-            .map(([field, reasons]) => `${field}: ${Array.isArray(reasons) ? reasons.join(', ') : String(reasons)}`)
-            .join('; ')
-          errorMessage += ` — ${details}`
+            .map(
+              ([field, reasons]) =>
+                `${field}: ${Array.isArray(reasons) ? reasons.join(", ") : String(reasons)}`,
+            )
+            .join("; ");
+          errorMessage += ` — ${details}`;
         }
-        return { error: errorMessage, status: response.status, durationMs }
+        return { error: errorMessage, status: response.status, durationMs };
       }
 
-      return { data, status: response.status, durationMs }
+      return { data, status: response.status, durationMs };
     } catch (error) {
-      const message = error instanceof Error ? error.message : 'Unknown error'
-      return { error: message, status: 0, durationMs: Date.now() - startTime }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return { error: message, status: 0, durationMs: Date.now() - startTime };
     }
   }
 
@@ -192,61 +217,63 @@ export class CoolifyService {
    */
   async deploy(
     options: ICoolifyDeployOptions,
-    onProgress?: IProgressCallback
+    onProgress?: IProgressCallback,
   ): Promise<Result<ICoolifyDeployResult, Error>> {
     if (!options.uuid && !options.tag) {
-      return err(new Error('Either uuid or tag is required'))
+      return err(new Error("Either uuid or tag is required"));
     }
 
-    const appId = options.uuid?.slice(0, 8) || options.tag || 'unknown'
-    onProgress?.(5, `Preparing deployment for ${appId}...`)
+    const appId = options.uuid?.slice(0, 8) || options.tag || "unknown";
+    onProgress?.(5, `Preparing deployment for ${appId}...`);
 
-    log.info(`Deploying application ${options.uuid || options.tag}`)
+    log.info(`Deploying application ${options.uuid || options.tag}`);
 
-    onProgress?.(25, 'Validating deployment configuration')
-    onProgress?.(50, 'Triggering build pipeline...')
+    onProgress?.(25, "Validating deployment configuration");
+    onProgress?.(50, "Triggering build pipeline...");
 
     // Build query parameters for deploy endpoint
-    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 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 endpoint = `/deploy${params.toString() ? `?${params.toString()}` : ""}`;
 
     const result = await this.request<{
       deployments: Array<{
-        message: string
-        resource_uuid: string
-        deployment_uuid: string
-      }>
+        message: string;
+        resource_uuid: string;
+        deployment_uuid: string;
+      }>;
     }>(endpoint, {
-      method: 'POST',
-    })
+      method: "GET",
+    });
 
     if (result.error) {
-      log.error(`Deployment failed: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Deployment failed: ${result.error}`);
+      return err(new Error(result.error));
     }
 
     // Response is { deployments: [{ message, resource_uuid, deployment_uuid }] }
-    const deployments = result.data?.deployments || []
+    const deployments = result.data?.deployments || [];
     if (deployments.length === 0) {
-      log.error('No deployments started')
-      return err(new Error('No deployments started - check application configuration'))
+      log.error("No deployments started");
+      return err(
+        new Error("No deployments started - check application configuration"),
+      );
     }
 
-    const deployment = deployments[0]
+    const deployment = deployments[0];
 
-    onProgress?.(90, 'Build started on Coolify server')
-    onProgress?.(100, 'Deployment triggered')
+    onProgress?.(90, "Build started on Coolify server");
+    onProgress?.(100, "Deployment triggered");
 
-    log.success(`Deployment started: ${deployment.deployment_uuid}`)
+    log.success(`Deployment started: ${deployment.deployment_uuid}`);
     return ok({
       success: true,
       deploymentUuid: deployment.deployment_uuid,
       resourceUuid: deployment.resource_uuid,
-    })
+    });
   }
 
   /**
@@ -266,27 +293,29 @@ export class CoolifyService {
    */
   async createApplication(
     options: ICoolifyAppOptions,
-    onProgress?: IProgressCallback
+    onProgress?: IProgressCallback,
   ): Promise<Result<ICoolifyAppResult, Error>> {
-    onProgress?.(5, `Preparing app "${options.name}"`)
+    onProgress?.(5, `Preparing app "${options.name}"`);
 
-    const appType = options.type || 'public'
-    log.info(`Creating application ${options.name} (type: ${appType})`)
+    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...')
+    onProgress?.(25, `Validating server ${options.serverUuid.slice(0, 8)}...`);
+    onProgress?.(50, "Sending creation request to Coolify API...");
 
     // Determine endpoint based on application type
     const endpointMap: Record<string, string> = {
-      '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'
+      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",
+      dockerimage: "/applications/dockerimage",
+      dockercompose: "/applications/dockercompose",
+    };
+
+    const endpoint = endpointMap[appType] || "/applications/public";
 
     // Build request body based on application type
     const body: Record<string, unknown> = {
@@ -295,60 +324,64 @@ export class CoolifyService {
       project_uuid: options.projectUuid,
       environment_uuid: options.environmentUuid,
       server_uuid: options.serverUuid,
-    }
+    };
 
     // Type-specific fields
-    if (appType === 'public' || appType === 'private-github-app' || appType === 'private-deploy-key') {
+    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$/, '')
+          .replace(/^https?:\/\/github\.com\//, "")
+          .replace(/\.git$/, "");
       }
       if (options.githubAppUuid) {
-        body.github_app_uuid = options.githubAppUuid
+        body.github_app_uuid = options.githubAppUuid;
       }
-      body.git_branch = options.branch || 'main'
-      body.build_pack = options.buildPack || 'dockerfile'
+      body.git_branch = options.branch || "main";
+      body.build_pack = options.buildPack || "dockerfile";
       if (options.portsExposes) {
-        body.ports_exposes = options.portsExposes
+        body.ports_exposes = options.portsExposes;
       }
       // Dockerfile / Docker Compose configuration
       if (options.dockerfileLocation) {
-        body.dockerfile_location = options.dockerfileLocation
+        body.dockerfile_location = options.dockerfileLocation;
       }
       if (options.dockerComposeLocation) {
-        body.docker_compose_location = options.dockerComposeLocation
+        body.docker_compose_location = options.dockerComposeLocation;
       }
       if (options.baseDirectory) {
-        body.base_directory = 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
+    } else if (appType === "docker-image" && options.dockerImage) {
+      body.docker_image = options.dockerImage;
+    } else if (appType === "docker-compose" && options.dockerCompose) {
+      body.docker_compose = options.dockerCompose;
     }
 
-    log.debug(`Create application body: ${JSON.stringify(body, null, 2)}`)
-    log.debug(`Endpoint: POST ${endpoint}`)
+    log.debug(`Create application body: ${JSON.stringify(body, null, 2)}`);
+    log.debug(`Endpoint: POST ${endpoint}`);
 
     const result = await this.request<{ uuid: string }>(endpoint, {
-      method: 'POST',
+      method: "POST",
       body: JSON.stringify(body),
-    })
+    });
 
     if (result.error) {
-      log.error(`Failed to create application: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to create application: ${result.error}`);
+      return err(new Error(result.error));
     }
 
-    onProgress?.(100, `Application "${options.name}" created`)
+    onProgress?.(100, `Application "${options.name}" created`);
 
-    log.success(`Application created: ${result.data?.uuid}`)
+    log.success(`Application created: ${result.data?.uuid}`);
     return ok({
       success: true,
       uuid: result.data?.uuid,
-    })
+    });
   }
 
   /**
@@ -360,43 +393,50 @@ export class CoolifyService {
    */
   async setEnvironmentVariables(
     appUuid: string,
-    envVars: Record<string, string>
+    envVars: Record<string, string>,
   ): Promise<Result<void, Error>> {
-    log.info(`Setting ${Object.keys(envVars).length} environment variables for ${appUuid}`)
+    log.info(
+      `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',
+        method: "POST",
         body: JSON.stringify({ key, value, is_preview: false }),
-      })
-
-      if (result.error && result.error.includes('already exists')) {
-        // Var exists — find its UUID and PATCH
-        const listResult = await this.request<Array<{ uuid: string; key: string }>>(`/applications/${appUuid}/envs`)
-        const existing = listResult.data?.find((v) => v.key === key)
+      });
+
+      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) {
-          const patchResult = await this.request(`/applications/${appUuid}/envs/${existing.uuid}`, {
-            method: 'PATCH',
+          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 (patchResult.error) {
-            log.error(`Failed to update env var ${key}: ${patchResult.error}`)
-            return err(new Error(`Failed to update ${key}: ${patchResult.error}`))
+          });
+          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}`)
+          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}`))
+          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}`))
+        log.error(`Failed to set env var ${key}: ${result.error}`);
+        return err(new Error(`Failed to set ${key}: ${result.error}`));
       }
     }
 
-    log.success(`${Object.keys(envVars).length} environment variables set`)
-    return ok(undefined)
+    log.success(`${Object.keys(envVars).length} environment variables set`);
+    return ok(undefined);
   }
 
   /**
@@ -406,21 +446,21 @@ export class CoolifyService {
    * @returns Result with environment variables or error
    */
   async getEnvironmentVariables(
-    appUuid: string
+    appUuid: string,
   ): Promise<Result<ICoolifyEnvVar[], Error>> {
-    log.info(`Getting environment variables for ${appUuid}`)
+    log.info(`Getting environment variables for ${appUuid}`);
 
     const result = await this.request<ICoolifyEnvVar[]>(
-      `/applications/${appUuid}/envs`
-    )
+      `/applications/${appUuid}/envs`,
+    );
 
     if (result.error) {
-      log.error(`Failed to get env vars: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to get env vars: ${result.error}`);
+      return err(new Error(result.error));
     }
 
-    log.success(`Environment variables retrieved for ${appUuid}`)
-    return ok(result.data || [])
+    log.success(`Environment variables retrieved for ${appUuid}`);
+    return ok(result.data || []);
   }
 
   /**
@@ -437,46 +477,52 @@ 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}`);
 
     // Check if variable already exists
-    const existingVars = await this.getEnvironmentVariables(appUuid)
+    const existingVars = await this.getEnvironmentVariables(appUuid);
     if (isErr(existingVars)) {
-      return err(existingVars.error)
+      return err(existingVars.error);
     }
 
-    const exists = existingVars.value.some(ev => ev.key === key)
+    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 }),
-      })
+      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))
+        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 }),
-      })
+      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 }),
+        },
+      );
 
       if (result.error) {
-        log.error(`Failed to create env var: ${result.error}`)
-        return err(new Error(result.error))
+        log.error(`Failed to create env var: ${result.error}`);
+        return err(new Error(result.error));
       }
     }
 
-    log.success(`Environment variable ${key} set for ${appUuid}`)
-    return ok(undefined)
+    log.success(`Environment variable ${key} set for ${appUuid}`);
+    return ok(undefined);
   }
 
   /**
@@ -488,33 +534,36 @@ export class CoolifyService {
    */
   async deleteEnvironmentVariable(
     appUuid: string,
-    key: string
+    key: string,
   ): Promise<Result<void, Error>> {
-    log.info(`Deleting environment variable ${key} from ${appUuid}`)
+    log.info(`Deleting environment variable ${key} from ${appUuid}`);
 
     // First get all env vars to find the UUID of the one to delete
-    const envVarsResult = await this.getEnvironmentVariables(appUuid)
+    const envVarsResult = await this.getEnvironmentVariables(appUuid);
     if (isErr(envVarsResult)) {
-      return err(envVarsResult.error)
+      return err(envVarsResult.error);
     }
 
-    const envVar = envVarsResult.value.find(ev => ev.key === key)
+    const envVar = envVarsResult.value.find((ev) => ev.key === key);
     if (!envVar) {
-      log.error(`Environment variable ${key} not found`)
-      return err(new Error(`Environment variable ${key} not found`))
+      log.error(`Environment variable ${key} not found`);
+      return err(new Error(`Environment variable ${key} not found`));
     }
 
-    const result = await this.request(`/applications/${appUuid}/envs/${envVar.uuid}`, {
-      method: 'DELETE',
-    })
+    const result = await this.request(
+      `/applications/${appUuid}/envs/${envVar.uuid}`,
+      {
+        method: "DELETE",
+      },
+    );
 
     if (result.error) {
-      log.error(`Failed to delete env var: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to delete env var: ${result.error}`);
+      return err(new Error(result.error));
     }
 
-    log.success(`Environment variable ${key} deleted from ${appUuid}`)
-    return ok(undefined)
+    log.success(`Environment variable ${key} deleted from ${appUuid}`);
+    return ok(undefined);
   }
 
   /**
@@ -523,18 +572,16 @@ export class CoolifyService {
    * @param appUuid - Application UUID
    * @returns Result with status or error
    */
-  async getApplicationStatus(
-    appUuid: string
-  ): Promise<Result<string, Error>> {
+  async getApplicationStatus(appUuid: string): Promise<Result<string, Error>> {
     const result = await this.request<{ status: string }>(
-      `/applications/${appUuid}`
-    )
+      `/applications/${appUuid}`,
+    );
 
     if (result.error) {
-      return err(new Error(result.error))
+      return err(new Error(result.error));
     }
 
-    return ok(result.data?.status || 'unknown')
+    return ok(result.data?.status || "unknown");
   }
 
   /**
@@ -543,13 +590,13 @@ export class CoolifyService {
    * @returns Result with servers or error
    */
   async listServers(): Promise<Result<ICoolifyServer[], Error>> {
-    const result = await this.request<ICoolifyServer[]>('/servers')
+    const result = await this.request<ICoolifyServer[]>("/servers");
 
     if (result.error) {
-      return err(new Error(result.error))
+      return err(new Error(result.error));
     }
 
-    return ok(result.data || [])
+    return ok(result.data || []);
   }
 
   /**
@@ -558,20 +605,18 @@ export class CoolifyService {
    * @param serverUuid - Server UUID
    * @returns Result with server details or error
    */
-  async getServer(
-    serverUuid: string
-  ): Promise<Result<ICoolifyServer, Error>> {
-    log.info(`Getting server details for ${serverUuid}`)
+  async getServer(serverUuid: string): Promise<Result<ICoolifyServer, Error>> {
+    log.info(`Getting server details for ${serverUuid}`);
 
-    const result = await this.request<ICoolifyServer>(`/servers/${serverUuid}`)
+    const result = await this.request<ICoolifyServer>(`/servers/${serverUuid}`);
 
     if (result.error) {
-      log.error(`Failed to get server: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to get server: ${result.error}`);
+      return err(new Error(result.error));
     }
 
-    log.success(`Server details retrieved: ${serverUuid}`)
-    return ok(result.data as ICoolifyServer)
+    log.success(`Server details retrieved: ${serverUuid}`);
+    return ok(result.data as ICoolifyServer);
   }
 
   /**
@@ -579,10 +624,18 @@ export class CoolifyService {
    *
    * @returns Result with GitHub Apps list or error
    */
-  async listGithubApps(): Promise<Result<Array<{ id: number; uuid: string; name: string; is_public: boolean }>, Error>> {
-    const result = await this.request<Array<{ id: number; uuid: string; name: string; is_public: boolean }>>('/github-apps')
-    if (result.error) return err(new Error(result.error))
-    return ok(result.data || [])
+  async listGithubApps(): Promise<
+    Result<
+      Array<{ id: number; uuid: string; name: string; is_public: boolean }>,
+      Error
+    >
+  > {
+    const result =
+      await this.request<
+        Array<{ id: number; uuid: string; name: string; is_public: boolean }>
+      >("/github-apps");
+    if (result.error) return err(new Error(result.error));
+    return ok(result.data || []);
   }
 
   /**
@@ -591,13 +644,13 @@ export class CoolifyService {
    * @returns Result with projects list or error
    */
   async listProjects(): Promise<Result<ICoolifyProject[], Error>> {
-    const result = await this.request<ICoolifyProject[]>('/projects')
+    const result = await this.request<ICoolifyProject[]>("/projects");
 
     if (result.error) {
-      return err(new Error(result.error))
+      return err(new Error(result.error));
     }
 
-    return ok(result.data || [])
+    return ok(result.data || []);
   }
 
   /**
@@ -609,22 +662,22 @@ export class CoolifyService {
    */
   async createProject(
     name: string,
-    description?: string
+    description?: string,
   ): Promise<Result<ICoolifyProject, Error>> {
-    log.info(`Creating project: ${name}`)
+    log.info(`Creating project: ${name}`);
 
-    const result = await this.request<ICoolifyProject>('/projects', {
-      method: 'POST',
-      body: JSON.stringify({ name, description: description || '' }),
-    })
+    const result = await this.request<ICoolifyProject>("/projects", {
+      method: "POST",
+      body: JSON.stringify({ name, description: description || "" }),
+    });
 
     if (result.error) {
-      log.error(`Failed to create project: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to create project: ${result.error}`);
+      return err(new Error(result.error));
     }
 
-    log.success(`Project created: ${result.data?.uuid}`)
-    return ok(result.data!)
+    log.success(`Project created: ${result.data?.uuid}`);
+    return ok(result.data!);
   }
 
   /**
@@ -634,21 +687,21 @@ export class CoolifyService {
    * @returns Result with environments list or error
    */
   async getProjectEnvironments(
-    projectUuid: string
+    projectUuid: string,
   ): Promise<Result<ICoolifyEnvironment[], Error>> {
-    log.info(`Getting environments for project ${projectUuid}`)
+    log.info(`Getting environments for project ${projectUuid}`);
 
     const result = await this.request<{ environments: ICoolifyEnvironment[] }>(
-      `/projects/${projectUuid}`
-    )
+      `/projects/${projectUuid}`,
+    );
 
     if (result.error) {
-      log.error(`Failed to get environments: ${result.error}`)
-      return err(new Error(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 || [])
+    log.success(`Environments retrieved for project ${projectUuid}`);
+    return ok(result.data?.environments || []);
   }
 
   /**
@@ -657,13 +710,13 @@ export class CoolifyService {
    * @returns Result with teams list or error
    */
   async listTeams(): Promise<Result<ICoolifyTeam[], Error>> {
-    const result = await this.request<ICoolifyTeam[]>('/teams')
+    const result = await this.request<ICoolifyTeam[]>("/teams");
 
     if (result.error) {
-      return err(new Error(result.error))
+      return err(new Error(result.error));
     }
 
-    return ok(result.data || [])
+    return ok(result.data || []);
   }
 
   /**
@@ -673,17 +726,17 @@ export class CoolifyService {
    * @returns Result with destinations or error
    */
   async getServerDestinations(
-    serverUuid: string
+    serverUuid: string,
   ): Promise<Result<ICoolifyDestination[], Error>> {
     const result = await this.request<{
-      destinations: ICoolifyDestination[]
-    }>(`/servers/${serverUuid}`)
+      destinations: ICoolifyDestination[];
+    }>(`/servers/${serverUuid}`);
 
     if (result.error) {
-      return err(new Error(result.error))
+      return err(new Error(result.error));
     }
 
-    return ok(result.data?.destinations || [])
+    return ok(result.data?.destinations || []);
   }
 
   /**
@@ -695,27 +748,27 @@ export class CoolifyService {
    */
   async listApplications(
     teamId?: string,
-    projectId?: string
+    projectId?: string,
   ): Promise<Result<ICoolifyApplication[], Error>> {
-    log.info('Listing applications')
+    log.info("Listing applications");
 
-    let endpoint = '/applications'
-    const params = new URLSearchParams()
-    if (teamId) params.set('team_id', teamId)
-    if (projectId) params.set('project_id', projectId)
+    let endpoint = "/applications";
+    const params = new URLSearchParams();
+    if (teamId) params.set("team_id", teamId);
+    if (projectId) params.set("project_id", projectId);
     if (params.toString()) {
-      endpoint += `?${params.toString()}`
+      endpoint += `?${params.toString()}`;
     }
 
-    const result = await this.request<ICoolifyApplication[]>(endpoint)
+    const result = await this.request<ICoolifyApplication[]>(endpoint);
 
     if (result.error) {
-      log.error(`Failed to list applications: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to list applications: ${result.error}`);
+      return err(new Error(result.error));
     }
 
-    log.success(`Listed ${result.data?.length || 0} applications`)
-    return ok(result.data || [])
+    log.success(`Listed ${result.data?.length || 0} applications`);
+    return ok(result.data || []);
   }
 
   /**
@@ -725,21 +778,24 @@ export class CoolifyService {
    * @returns Result indicating success or error
    */
   async deleteApplication(
-    appUuid: string
+    appUuid: string,
   ): Promise<Result<ICoolifyDeleteResult, Error>> {
-    log.info(`Deleting application ${appUuid}`)
+    log.info(`Deleting application ${appUuid}`);
 
-    const result = await this.request<ICoolifyDeleteResult>(`/applications/${appUuid}`, {
-      method: 'DELETE',
-    })
+    const result = await this.request<ICoolifyDeleteResult>(
+      `/applications/${appUuid}`,
+      {
+        method: "DELETE",
+      },
+    );
 
     if (result.error) {
-      log.error(`Failed to delete application: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to delete application: ${result.error}`);
+      return err(new Error(result.error));
     }
 
-    log.success(`Application deleted: ${appUuid}`)
-    return ok({ success: true, message: 'Application deleted' })
+    log.success(`Application deleted: ${appUuid}`);
+    return ok({ success: true, message: "Application deleted" });
   }
 
   /**
@@ -751,38 +807,45 @@ export class CoolifyService {
    */
   async updateApplication(
     appUuid: string,
-    options: ICoolifyUpdateOptions
+    options: ICoolifyUpdateOptions,
   ): Promise<Result<ICoolifyApplication, Error>> {
-    log.info(`Updating application ${appUuid}`)
-
-    const body: Record<string, unknown> = {}
-    if (options.name) body.name = options.name
-    if (options.description) body.description = options.description
-    if (options.buildPack) body.build_pack = options.buildPack
-    if (options.gitBranch) body.git_branch = options.gitBranch
-    if (options.portsExposes) body.ports_exposes = options.portsExposes
-    if (options.installCommand) body.install_command = options.installCommand
-    if (options.buildCommand) 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
-    if (options.domains) body.domains = options.domains
-    if (options.dockerComposeDomains) body.docker_compose_domains = options.dockerComposeDomains
-    if (options.isForceHttpsEnabled !== undefined) body.is_force_https_enabled = options.isForceHttpsEnabled
-    if (options.isAutoDeployEnabled !== undefined) body.is_auto_deploy_enabled = options.isAutoDeployEnabled
-
-    const result = await this.request<ICoolifyApplication>(`/applications/${appUuid}`, {
-      method: 'PATCH',
-      body: JSON.stringify(body),
-    })
+    log.info(`Updating application ${appUuid}`);
+
+    const body: Record<string, unknown> = {};
+    if (options.name) body.name = options.name;
+    if (options.description) body.description = options.description;
+    if (options.buildPack) body.build_pack = options.buildPack;
+    if (options.gitBranch) body.git_branch = options.gitBranch;
+    if (options.portsExposes) body.ports_exposes = options.portsExposes;
+    if (options.installCommand) body.install_command = options.installCommand;
+    if (options.buildCommand) 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;
+    if (options.domains) body.domains = options.domains;
+    if (options.dockerComposeDomains)
+      body.docker_compose_domains = options.dockerComposeDomains;
+    if (options.isForceHttpsEnabled !== undefined)
+      body.is_force_https_enabled = options.isForceHttpsEnabled;
+    if (options.isAutoDeployEnabled !== undefined)
+      body.is_auto_deploy_enabled = options.isAutoDeployEnabled;
+
+    const result = await this.request<ICoolifyApplication>(
+      `/applications/${appUuid}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(body),
+      },
+    );
 
     if (result.error) {
-      log.error(`Failed to update application: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to update application: ${result.error}`);
+      return err(new Error(result.error));
     }
 
-    log.success(`Application updated: ${appUuid}`)
-    return ok(result.data as ICoolifyApplication)
+    log.success(`Application updated: ${appUuid}`);
+    return ok(result.data as ICoolifyApplication);
   }
 
   /**
@@ -794,37 +857,38 @@ export class CoolifyService {
    */
   async getApplicationLogs(
     appUuid: string,
-    options: ICoolifyLogsOptions = {}
+    options: ICoolifyLogsOptions = {},
   ): Promise<Result<ICoolifyLogs, Error>> {
-    log.info(`Getting logs for application ${appUuid}`)
+    log.info(`Getting logs for application ${appUuid}`);
 
-    const params = new URLSearchParams()
-    if (options.follow) params.set('follow', 'true')
-    if (options.tail) params.set('tail', options.tail.toString())
+    const params = new URLSearchParams();
+    if (options.follow) params.set("follow", "true");
+    if (options.tail) params.set("lines", options.tail.toString());
+    if (options.serviceName) params.set("service_name", options.serviceName);
 
-    const endpoint = `/applications/${appUuid}/logs${params.toString() ? `?${params.toString()}` : ''}`
+    const endpoint = `/applications/${appUuid}/logs${params.toString() ? `?${params.toString()}` : ""}`;
 
-    const result = await this.request<{ logs: string | string[] }>(endpoint)
+    const result = await this.request<{ logs: string | string[] }>(endpoint);
 
     if (result.error) {
-      log.error(`Failed to get logs: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to get logs: ${result.error}`);
+      return err(new Error(result.error));
     }
 
     // Coolify API returns logs as a single newline-delimited string for
     // docker-compose apps, but as string[] for single-container apps.
-    const rawLogs = result.data?.logs
+    const rawLogs = result.data?.logs;
     const logsArray: string[] = Array.isArray(rawLogs)
       ? rawLogs
-      : typeof rawLogs === 'string'
-        ? rawLogs.split('\n').filter((l: string) => l.length > 0)
-        : []
+      : typeof rawLogs === "string"
+        ? rawLogs.split("\n").filter((l: string) => l.length > 0)
+        : [];
 
-    log.success(`Logs retrieved for application: ${appUuid}`)
+    log.success(`Logs retrieved for application: ${appUuid}`);
     return ok({
       logs: logsArray,
       timestamp: new Date().toISOString(),
-    })
+    });
   }
 
   /**
@@ -834,20 +898,24 @@ export class CoolifyService {
    * @returns Result with deployment history or error
    */
   async getApplicationDeploymentHistory(
-    appUuid: string
+    appUuid: string,
   ): Promise<Result<ICoolifyDeployment[], Error>> {
-    log.info(`Getting deployment history for ${appUuid}`)
+    log.info(`Getting deployment history for ${appUuid}`);
 
-    // According to Coolify API docs, endpoint is /applications/{app_uuid}/deployments
-    const result = await this.request<{ deployments: ICoolifyDeployment[] }>(`/applications/${appUuid}/deployments`)
+    // Coolify API: /deployments/applications/{appUuid}
+    // Response: { count: number, deployments: ICoolifyDeployment[] }
+    const result = await this.request<{
+      count: number;
+      deployments: ICoolifyDeployment[];
+    }>(`/deployments/applications/${appUuid}`);
 
     if (result.error) {
-      log.error(`Failed to get deployment history: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to get deployment history: ${result.error}`);
+      return err(new Error(result.error));
     }
 
-    log.success(`Deployment history retrieved for ${appUuid}`)
-    return ok(result.data?.deployments || [])
+    log.success(`Deployment history retrieved for ${appUuid}`);
+    return ok(result.data?.deployments || []);
   }
 
   /**
@@ -857,21 +925,24 @@ export class CoolifyService {
    * @returns Result with application status or error
    */
   async startApplication(
-    appUuid: string
+    appUuid: string,
   ): Promise<Result<ICoolifyApplication, Error>> {
-    log.info(`Starting application ${appUuid}`)
+    log.info(`Starting application ${appUuid}`);
 
-    const result = await this.request<ICoolifyApplication>(`/applications/${appUuid}/start`, {
-      method: 'POST',
-    })
+    const result = await this.request<ICoolifyApplication>(
+      `/applications/${appUuid}/start`,
+      {
+        method: "POST",
+      },
+    );
 
     if (result.error) {
-      log.error(`Failed to start application: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to start application: ${result.error}`);
+      return err(new Error(result.error));
     }
 
-    log.success(`Application started: ${appUuid}`)
-    return ok(result.data as ICoolifyApplication)
+    log.success(`Application started: ${appUuid}`);
+    return ok(result.data as ICoolifyApplication);
   }
 
   /**
@@ -881,21 +952,24 @@ export class CoolifyService {
    * @returns Result with application status or error
    */
   async stopApplication(
-    appUuid: string
+    appUuid: string,
   ): Promise<Result<ICoolifyApplication, Error>> {
-    log.info(`Stopping application ${appUuid}`)
+    log.info(`Stopping application ${appUuid}`);
 
-    const result = await this.request<ICoolifyApplication>(`/applications/${appUuid}/stop`, {
-      method: 'POST',
-    })
+    const result = await this.request<ICoolifyApplication>(
+      `/applications/${appUuid}/stop`,
+      {
+        method: "POST",
+      },
+    );
 
     if (result.error) {
-      log.error(`Failed to stop application: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to stop application: ${result.error}`);
+      return err(new Error(result.error));
     }
 
-    log.success(`Application stopped: ${appUuid}`)
-    return ok(result.data as ICoolifyApplication)
+    log.success(`Application stopped: ${appUuid}`);
+    return ok(result.data as ICoolifyApplication);
   }
 
   /**
@@ -905,21 +979,24 @@ export class CoolifyService {
    * @returns Result with application status or error
    */
   async restartApplication(
-    appUuid: string
+    appUuid: string,
   ): Promise<Result<ICoolifyApplication, Error>> {
-    log.info(`Restarting application ${appUuid}`)
+    log.info(`Restarting application ${appUuid}`);
 
-    const result = await this.request<ICoolifyApplication>(`/applications/${appUuid}/restart`, {
-      method: 'POST',
-    })
+    const result = await this.request<ICoolifyApplication>(
+      `/applications/${appUuid}/restart`,
+      {
+        method: "POST",
+      },
+    );
 
     if (result.error) {
-      log.error(`Failed to restart application: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to restart application: ${result.error}`);
+      return err(new Error(result.error));
     }
 
-    log.success(`Application restarted: ${appUuid}`)
-    return ok(result.data as ICoolifyApplication)
+    log.success(`Application restarted: ${appUuid}`);
+    return ok(result.data as ICoolifyApplication);
   }
 
   /**
@@ -928,17 +1005,17 @@ export class CoolifyService {
    * @returns Result with deployments list or error
    */
   async listDeployments(): Promise<Result<ICoolifyDeployment[], Error>> {
-    log.info('Listing active deployments')
+    log.info("Listing active deployments");
 
-    const result = await this.request<ICoolifyDeployment[]>('/deployments')
+    const result = await this.request<ICoolifyDeployment[]>("/deployments");
 
     if (result.error) {
-      log.error(`Failed to list deployments: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to list deployments: ${result.error}`);
+      return err(new Error(result.error));
     }
 
-    log.success(`Listed ${result.data?.length || 0} active deployments`)
-    return ok(result.data || [])
+    log.success(`Listed ${result.data?.length || 0} active deployments`);
+    return ok(result.data || []);
   }
 
   /**
@@ -948,19 +1025,53 @@ export class CoolifyService {
    * @returns Result with deployment details or error
    */
   async getDeployment(
-    deploymentUuid: string
+    deploymentUuid: string,
   ): Promise<Result<ICoolifyDeployment, Error>> {
-    log.info(`Getting deployment details for ${deploymentUuid}`)
+    log.info(`Getting deployment details for ${deploymentUuid}`);
 
-    const result = await this.request<ICoolifyDeployment>(`/deployments/${deploymentUuid}`)
+    const result = await this.request<ICoolifyDeployment>(
+      `/deployments/${deploymentUuid}`,
+    );
 
     if (result.error) {
-      log.error(`Failed to get deployment: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to get deployment: ${result.error}`);
+      return err(new Error(result.error));
     }
 
-    log.success(`Deployment details retrieved: ${deploymentUuid}`)
-    return ok(result.data as ICoolifyDeployment)
+    log.success(`Deployment details retrieved: ${deploymentUuid}`);
+    return ok(result.data as ICoolifyDeployment);
+  }
+
+  /**
+   * Gets logs for a specific deployment.
+   *
+   * @param deploymentUuid - Deployment UUID
+   * @returns Result with deployment status and logs or error
+   */
+  async getDeploymentLogs(
+    deploymentUuid: string,
+  ): Promise<
+    Result<{ status: string; logs: string; deployment_uuid: string }, Error>
+  > {
+    log.info(`Getting deployment logs for ${deploymentUuid}`);
+
+    const result = await this.request<{
+      status: string;
+      logs: string;
+      deployment_uuid: string;
+    }>(`/deployments/${deploymentUuid}`);
+
+    if (result.error) {
+      log.error(`Failed to get deployment logs: ${result.error}`);
+      return err(new Error(result.error));
+    }
+
+    log.success(`Deployment logs retrieved: ${deploymentUuid}`);
+    return ok({
+      status: result.data?.status || "unknown",
+      logs: result.data?.logs || "",
+      deployment_uuid: result.data?.deployment_uuid || deploymentUuid,
+    });
   }
 
   /**
@@ -974,29 +1085,63 @@ export class CoolifyService {
   async getApplicationDeployments(
     appUuid: string,
     skip: number = 0,
-    take: number = 10
+    take: number = 10,
   ): Promise<Result<ICoolifyDeployment[], Error>> {
-    log.info(`Getting deployments for application ${appUuid}`)
+    log.info(`Getting deployments for application ${appUuid}`);
+
+    const params = new URLSearchParams();
+    if (skip > 0) params.set("skip", skip.toString());
+    if (take !== 10) params.set("take", take.toString());
+
+    const endpoint = `/applications/${appUuid}/deployments${params.toString() ? `?${params.toString()}` : ""}`;
+    const result = await this.request<{
+      count: number;
+      deployments: ICoolifyDeployment[];
+    }>(endpoint);
+
+    if (result.error) {
+      log.error(`Failed to get application deployments: ${result.error}`);
+      return err(new Error(result.error));
+    }
 
-    const params = new URLSearchParams()
-    if (skip > 0) params.set('skip', skip.toString())
-    if (take !== 10) params.set('take', take.toString())
+    const deployments = result.data?.deployments || [];
+    log.success(`Retrieved ${deployments.length} deployments for ${appUuid}`);
+    return ok(deployments);
+  }
 
-    const endpoint = `/applications/${appUuid}/deployments${params.toString() ? `?${params.toString()}` : ''}`
-    const result = await this.request<{ count: number; deployments: ICoolifyDeployment[] }>(endpoint)
+  /**
+   * Lists deployments for a specific application.
+   *
+   * Uses the /deployments/applications/{appUuid} endpoint which returns
+   * all deployments (active, queued, and completed) for a single application.
+   * This differs from listDeployments() which returns ALL deployments globally.
+   *
+   * @param appUuid - Application UUID
+   * @returns Result with deployments list or error
+   */
+  async listApplicationDeployments(
+    appUuid: string,
+  ): Promise<Result<ICoolifyDeployment[], Error>> {
+    log.info(`Listing deployments for application ${appUuid}`);
+
+    // API returns { count: number, deployments: ICoolifyDeployment[] }
+    const result = await this.request<{
+      count: number;
+      deployments: ICoolifyDeployment[];
+    }>(`/deployments/applications/${appUuid}`);
 
     if (result.error) {
-      log.error(`Failed to get application deployments: ${result.error}`)
-      return err(new Error(result.error))
+      log.error(`Failed to list application deployments: ${result.error}`);
+      return err(new Error(result.error));
     }
 
-    const deployments = result.data?.deployments || []
-    log.success(`Retrieved ${deployments.length} deployments for ${appUuid}`)
-    return ok(deployments)
+    const deployments = result.data?.deployments || [];
+    log.success(`Listed ${deployments.length} deployments for ${appUuid}`);
+    return ok(deployments);
   }
 }
 
-let instance: CoolifyService | null = null
+let instance: CoolifyService | null = null;
 
 /**
  * Gets the singleton CoolifyService instance.
@@ -1005,9 +1150,9 @@ let instance: CoolifyService | null = null
  */
 export function getCoolifyService(): CoolifyService {
   if (!instance) {
-    instance = new CoolifyService()
+    instance = new CoolifyService();
   }
-  return instance
+  return instance;
 }
 
 // Re-export types
@@ -1027,4 +1172,4 @@ export type {
   ICoolifyLogsOptions,
   ICoolifyLogs,
   IProgressCallback,
-} from './types.js'
+} from "./types.js";