@mks2508/coolify-mks-cli-mcp 0.4.3 → 0.6.0

package/src/coolify/index.ts

@@ -6,13 +6,15 @@
  * @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,
   type ICoolifyApplication,
+  type ICoolifyDatabase,
+  type ICoolifyDatabaseBackup,
   type ICoolifyDeleteResult,
   type ICoolifyDeployment,
   type ICoolifyDeployOptions,
@@ -21,36 +23,41 @@ import {
   type ICoolifyEnvironment,
   type ICoolifyLogs,
   type ICoolifyLogsOptions,
+  type ICoolifyPrivateKey,
   type ICoolifyProject,
   type ICoolifyServer,
+  type ICoolifyServerDomain,
+  type ICoolifyServerResource,
+  type ICoolifyService as ICoolifyServiceType,
   type ICoolifyTeam,
   type ICoolifyUpdateOptions,
+  type ICoolifyVersion,
   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 +79,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 +89,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 +100,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 +148,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 +224,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 +300,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 +331,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,44 +400,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')) {
+      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)
+        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' })
+          await this.request(`/applications/${appUuid}/envs/${existing.uuid}`, {
+            method: "DELETE",
+          });
           const repost = await this.request(`/applications/${appUuid}/envs`, {
-            method: 'POST',
+            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.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);
   }
 
   /**
@@ -407,21 +453,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 || []);
   }
 
   /**
@@ -438,46 +484,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);
   }
 
   /**
@@ -489,33 +541,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);
   }
 
   /**
@@ -524,33 +579,44 @@ 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");
   }
 
   /**
    * Lists available servers in Coolify.
    *
+   * @param page - Optional page number for pagination
+   * @param perPage - Optional number of items per page
    * @returns Result with servers or error
    */
-  async listServers(): Promise<Result<ICoolifyServer[], Error>> {
-    const result = await this.request<ICoolifyServer[]>('/servers')
+  async listServers(
+    page?: number,
+    perPage?: number,
+  ): Promise<Result<ICoolifyServer[], Error>> {
+    let endpoint = "/servers";
+    const params = new URLSearchParams();
+    if (page) params.set("page", page.toString());
+    if (perPage) params.set("per_page", perPage.toString());
+    if (params.toString()) {
+      endpoint += `?${params.toString()}`;
+    }
+
+    const result = await this.request<ICoolifyServer[]>(endpoint);
 
     if (result.error) {
-      return err(new Error(result.error))
+      return err(new Error(result.error));
     }
 
-    return ok(result.data || [])
+    return ok(result.data || []);
   }
 
   /**
@@ -559,46 +625,78 @@ 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);
   }
 
   /**
    * Lists all GitHub Apps configured in Coolify.
    *
+   * @param page - Optional page number for pagination
+   * @param perPage - Optional number of items per page
    * @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(
+    page?: number,
+    perPage?: number,
+  ): Promise<
+    Result<
+      Array<{ id: number; uuid: string; name: string; is_public: boolean }>,
+      Error
+    >
+  > {
+    let endpoint = "/github-apps";
+    const params = new URLSearchParams();
+    if (page) params.set("page", page.toString());
+    if (perPage) params.set("per_page", perPage.toString());
+    if (params.toString()) {
+      endpoint += `?${params.toString()}`;
+    }
+
+    const result =
+      await this.request<
+        Array<{ id: number; uuid: string; name: string; is_public: boolean }>
+      >(endpoint);
+    if (result.error) return err(new Error(result.error));
+    return ok(result.data || []);
   }
 
   /**
    * Lists all projects.
    *
+   * @param page - Optional page number for pagination
+   * @param perPage - Optional number of items per page
    * @returns Result with projects list or error
    */
-  async listProjects(): Promise<Result<ICoolifyProject[], Error>> {
-    const result = await this.request<ICoolifyProject[]>('/projects')
+  async listProjects(
+    page?: number,
+    perPage?: number,
+  ): Promise<Result<ICoolifyProject[], Error>> {
+    let endpoint = "/projects";
+    const params = new URLSearchParams();
+    if (page) params.set("page", page.toString());
+    if (perPage) params.set("per_page", perPage.toString());
+    if (params.toString()) {
+      endpoint += `?${params.toString()}`;
+    }
+
+    const result = await this.request<ICoolifyProject[]>(endpoint);
 
     if (result.error) {
-      return err(new Error(result.error))
+      return err(new Error(result.error));
     }
 
-    return ok(result.data || [])
+    return ok(result.data || []);
   }
 
   /**
@@ -610,22 +708,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!);
   }
 
   /**
@@ -635,36 +733,49 @@ 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 || []);
   }
 
   /**
    * Lists all teams.
    *
+   * @param page - Optional page number for pagination
+   * @param perPage - Optional number of items per page
    * @returns Result with teams list or error
    */
-  async listTeams(): Promise<Result<ICoolifyTeam[], Error>> {
-    const result = await this.request<ICoolifyTeam[]>('/teams')
+  async listTeams(
+    page?: number,
+    perPage?: number,
+  ): Promise<Result<ICoolifyTeam[], Error>> {
+    let endpoint = "/teams";
+    const params = new URLSearchParams();
+    if (page) params.set("page", page.toString());
+    if (perPage) params.set("per_page", perPage.toString());
+    if (params.toString()) {
+      endpoint += `?${params.toString()}`;
+    }
+
+    const result = await this.request<ICoolifyTeam[]>(endpoint);
 
     if (result.error) {
-      return err(new Error(result.error))
+      return err(new Error(result.error));
     }
 
-    return ok(result.data || [])
+    return ok(result.data || []);
   }
 
   /**
@@ -674,17 +785,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 || []);
   }
 
   /**
@@ -692,55 +803,79 @@ export class CoolifyService {
    *
    * @param teamId - Optional team ID to filter by
    * @param projectId - Optional project ID to filter by
+   * @param page - Optional page number for pagination
+   * @param perPage - Optional number of items per page
    * @returns Result with applications list or error
    */
   async listApplications(
     teamId?: string,
-    projectId?: string
+    projectId?: string,
+    page?: number,
+    perPage?: number,
   ): Promise<Result<ICoolifyApplication[], Error>> {
-    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)
+    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);
+    if (page) params.set("page", page.toString());
+    if (perPage) params.set("per_page", perPage.toString());
     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 || []);
   }
 
   /**
    * Deletes an application.
    *
    * @param appUuid - Application UUID
+   * @param options - Delete options for cascade deletion
    * @returns Result indicating success or error
    */
   async deleteApplication(
-    appUuid: string
+    appUuid: string,
+    options?: {
+      deleteConfigurations?: boolean;
+      deleteVolumes?: boolean;
+      dockerCleanup?: boolean;
+      deleteConnectedNetworks?: boolean;
+    },
   ): 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 params = new URLSearchParams();
+    if (options?.deleteConfigurations)
+      params.set("delete_configurations", "true");
+    if (options?.deleteVolumes) params.set("delete_volumes", "true");
+    if (options?.dockerCleanup) params.set("docker_cleanup", "true");
+    if (options?.deleteConnectedNetworks)
+      params.set("delete_connected_networks", "true");
+
+    const queryString = params.toString();
+    const endpoint = `/applications/${appUuid}${queryString ? `?${queryString}` : ""}`;
+
+    const result = await this.request<ICoolifyDeleteResult>(endpoint, {
+      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" });
   }
 
   /**
@@ -752,38 +887,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);
   }
 
   /**
@@ -795,37 +937,102 @@ 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(),
-    })
+    });
+  }
+
+  /**
+   * Executes a command on an application's running container.
+   *
+   * @param appUuid - Application UUID
+   * @param command - Shell command to execute
+   * @returns Result with command output or error
+   */
+  async executeCommand(
+    appUuid: string,
+    command: string,
+  ): Promise<Result<{ message?: string; response?: string }, Error>> {
+    log.info(`Executing command on application ${appUuid}`);
+
+    const result = await this.request<{
+      message?: string;
+      response?: string;
+    }>(`/applications/${appUuid}/execute-command`, {
+      method: "POST",
+      body: JSON.stringify({ command }),
+    });
+
+    if (result.error) {
+      log.error(`Failed to execute command: ${result.error}`);
+      return err(new Error(result.error));
+    }
+
+    log.success(`Command executed on ${appUuid}`);
+    return ok(result.data || { message: "Command executed" });
+  }
+
+  /**
+   * Bulk updates environment variables for an application.
+   *
+   * @param appUuid - Application UUID
+   * @param envVars - Array of { key, value, is_preview? } objects
+   * @returns Result indicating success or error
+   */
+  async bulkUpdateEnvironmentVariables(
+    appUuid: string,
+    envVars: Array<{
+      key: string;
+      value: string;
+      is_preview?: boolean;
+    }>,
+  ): Promise<Result<{ message: string }, Error>> {
+    log.info(`Bulk updating ${envVars.length} env vars for ${appUuid}`);
+
+    const result = await this.request<{ message: string }>(
+      `/applications/${appUuid}/envs/bulk`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(envVars),
+      },
+    );
+
+    if (result.error) {
+      log.error(`Failed to bulk update env vars: ${result.error}`);
+      return err(new Error(result.error));
+    }
+
+    log.success(`Bulk updated ${envVars.length} env vars for ${appUuid}`);
+    return ok(result.data || { message: "Environment variables updated" });
   }
 
   /**
@@ -835,111 +1042,1131 @@ 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 || []);
   }
 
   /**
    * Starts a stopped application.
+   * Note: Coolify API uses GET for application start/stop/restart.
    *
    * @param appUuid - Application UUID
+   * @param options - Optional start options (force, instant_deploy)
    * @returns Result with application status or error
    */
   async startApplication(
-    appUuid: string
+    appUuid: string,
+    options?: { force?: boolean; instantDeploy?: boolean },
   ): Promise<Result<ICoolifyApplication, Error>> {
-    log.info(`Starting application ${appUuid}`)
+    log.info(`Starting application ${appUuid}`);
+
+    const params = new URLSearchParams();
+    if (options?.force) params.set("force", "true");
+    if (options?.instantDeploy) params.set("instant_deploy", "true");
+    const queryString = params.toString();
+    const endpoint = `/applications/${appUuid}/start${queryString ? `?${queryString}` : ""}`;
 
-    const result = await this.request<ICoolifyApplication>(`/applications/${appUuid}/start`, {
-      method: 'POST',
-    })
+    const result = await this.request<ICoolifyApplication>(endpoint, {
+      method: "GET",
+    });
 
     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);
   }
 
   /**
    * Stops a running application.
+   * Note: Coolify API uses GET for application start/stop/restart.
    *
    * @param appUuid - Application UUID
    * @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: "GET" },
+    );
 
     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);
   }
 
   /**
    * Restarts an application.
+   * Note: Coolify API uses GET for application start/stop/restart.
    *
    * @param appUuid - Application UUID
    * @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: "GET" },
+    );
 
     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);
+  }
+
+  // ===========================================================================
+  // Version / Health
+  // ===========================================================================
+
+  /**
+   * Gets the Coolify server version.
+   *
+   * @returns Result with version info or error
+   */
+  async getVersion(): Promise<Result<ICoolifyVersion, Error>> {
+    log.info("Getting Coolify version");
+
+    // /version returns plain text, not JSON
+    if (!this.baseUrl || !this.token) {
+      return err(new Error("Coolify not configured"));
+    }
+
+    try {
+      const baseUrl = this.baseUrl.replace(/\/+$/, "");
+      const url = `${baseUrl}/api/v1/version`;
+      const response = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+        },
+      });
+
+      if (!response.ok) {
+        return err(
+          new Error(`HTTP ${response.status}: ${response.statusText}`),
+        );
+      }
+
+      const version = (await response.text()).trim();
+      log.success(`Coolify version: ${version}`);
+      return ok({ version });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return err(new Error(message));
+    }
+  }
+
+  // ===========================================================================
+  // Database endpoints
+  // ===========================================================================
+
+  /**
+   * Lists all databases.
+   *
+   * @param page - Optional page number
+   * @param perPage - Optional items per page
+   * @returns Result with databases list or error
+   */
+  async listDatabases(
+    page?: number,
+    perPage?: number,
+  ): Promise<Result<ICoolifyDatabase[], Error>> {
+    log.info("Listing databases");
+
+    let endpoint = "/databases";
+    const params = new URLSearchParams();
+    if (page) params.set("page", page.toString());
+    if (perPage) params.set("per_page", perPage.toString());
+    if (params.toString()) endpoint += `?${params.toString()}`;
+
+    const result = await this.request<ICoolifyDatabase[]>(endpoint);
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Listed ${result.data?.length || 0} databases`);
+    return ok(result.data || []);
+  }
+
+  /**
+   * Gets details of a specific database.
+   *
+   * @param uuid - Database UUID
+   * @returns Result with database details or error
+   */
+  async getDatabase(uuid: string): Promise<Result<ICoolifyDatabase, Error>> {
+    log.info(`Getting database ${uuid}`);
+
+    const result = await this.request<ICoolifyDatabase>(`/databases/${uuid}`);
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data as ICoolifyDatabase);
+  }
+
+  /**
+   * Creates a database of the specified type.
+   *
+   * @param dbType - Database type (postgresql, mysql, mariadb, mongodb, redis, keydb, clickhouse, dragonfly)
+   * @param data - Database creation data
+   * @returns Result with created database UUID or error
+   */
+  async createDatabase(
+    dbType: string,
+    data: Record<string, unknown>,
+  ): Promise<Result<{ uuid: string }, Error>> {
+    log.info(`Creating ${dbType} database`);
+
+    const result = await this.request<{ uuid: string }>(
+      `/databases/${dbType}`,
+      {
+        method: "POST",
+        body: JSON.stringify(data),
+      },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Database created: ${result.data?.uuid}`);
+    return ok(result.data!);
+  }
+
+  /**
+   * Updates a database configuration.
+   *
+   * @param uuid - Database UUID
+   * @param data - Update data
+   * @returns Result with updated database or error
+   */
+  async updateDatabase(
+    uuid: string,
+    data: Record<string, unknown>,
+  ): Promise<Result<ICoolifyDatabase, Error>> {
+    log.info(`Updating database ${uuid}`);
+
+    const result = await this.request<ICoolifyDatabase>(`/databases/${uuid}`, {
+      method: "PATCH",
+      body: JSON.stringify(data),
+    });
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Database updated: ${uuid}`);
+    return ok(result.data as ICoolifyDatabase);
+  }
+
+  /**
+   * Deletes a database.
+   *
+   * @param uuid - Database UUID
+   * @param options - Delete options for cascade deletion
+   * @returns Result indicating success or error
+   */
+  async deleteDatabase(
+    uuid: string,
+    options?: {
+      deleteConfigurations?: boolean;
+      deleteVolumes?: boolean;
+      dockerCleanup?: boolean;
+      deleteConnectedNetworks?: boolean;
+    },
+  ): Promise<Result<ICoolifyDeleteResult, Error>> {
+    log.info(`Deleting database ${uuid}`);
+
+    const params = new URLSearchParams();
+    if (options?.deleteConfigurations)
+      params.set("delete_configurations", "true");
+    if (options?.deleteVolumes) params.set("delete_volumes", "true");
+    if (options?.dockerCleanup) params.set("docker_cleanup", "true");
+    if (options?.deleteConnectedNetworks)
+      params.set("delete_connected_networks", "true");
+
+    const queryString = params.toString();
+    const endpoint = `/databases/${uuid}${queryString ? `?${queryString}` : ""}`;
+
+    const result = await this.request<ICoolifyDeleteResult>(endpoint, {
+      method: "DELETE",
+    });
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Database deleted: ${uuid}`);
+    return ok({ success: true, message: "Database deleted" });
+  }
+
+  /**
+   * Starts a database.
+   *
+   * @param uuid - Database UUID
+   * @returns Result indicating success or error
+   */
+  async startDatabase(
+    uuid: string,
+  ): Promise<Result<{ message: string }, Error>> {
+    log.info(`Starting database ${uuid}`);
+
+    const result = await this.request<{ message: string }>(
+      `/databases/${uuid}/start`,
+      { method: "GET" },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Database started: ${uuid}`);
+    return ok(result.data || { message: "Database started" });
+  }
+
+  /**
+   * Stops a database.
+   *
+   * @param uuid - Database UUID
+   * @returns Result indicating success or error
+   */
+  async stopDatabase(
+    uuid: string,
+  ): Promise<Result<{ message: string }, Error>> {
+    log.info(`Stopping database ${uuid}`);
+
+    const result = await this.request<{ message: string }>(
+      `/databases/${uuid}/stop`,
+      { method: "GET" },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Database stopped: ${uuid}`);
+    return ok(result.data || { message: "Database stopped" });
+  }
+
+  /**
+   * Restarts a database.
+   *
+   * @param uuid - Database UUID
+   * @returns Result indicating success or error
+   */
+  async restartDatabase(
+    uuid: string,
+  ): Promise<Result<{ message: string }, Error>> {
+    log.info(`Restarting database ${uuid}`);
+
+    const result = await this.request<{ message: string }>(
+      `/databases/${uuid}/restart`,
+      { method: "GET" },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Database restarted: ${uuid}`);
+    return ok(result.data || { message: "Database restarted" });
+  }
+
+  // ===========================================================================
+  // Database Backup endpoints
+  // ===========================================================================
+
+  /**
+   * Lists backups for a database.
+   *
+   * @param databaseUuid - Database UUID
+   * @returns Result with backups list or error
+   */
+  async listDatabaseBackups(
+    databaseUuid: string,
+  ): Promise<Result<ICoolifyDatabaseBackup[], Error>> {
+    log.info(`Listing backups for database ${databaseUuid}`);
+
+    const result = await this.request<ICoolifyDatabaseBackup[]>(
+      `/databases/${databaseUuid}/backups`,
+    );
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data || []);
+  }
+
+  /**
+   * Gets a specific database backup.
+   *
+   * @param databaseUuid - Database UUID
+   * @param backupUuid - Backup UUID
+   * @returns Result with backup details or error
+   */
+  async getDatabaseBackup(
+    databaseUuid: string,
+    backupUuid: string,
+  ): Promise<Result<ICoolifyDatabaseBackup, Error>> {
+    const result = await this.request<ICoolifyDatabaseBackup>(
+      `/databases/${databaseUuid}/backups/${backupUuid}`,
+    );
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data as ICoolifyDatabaseBackup);
+  }
+
+  /**
+   * Creates a database backup.
+   *
+   * @param databaseUuid - Database UUID
+   * @param data - Backup creation data
+   * @returns Result with created backup or error
+   */
+  async createDatabaseBackup(
+    databaseUuid: string,
+    data: Record<string, unknown>,
+  ): Promise<Result<ICoolifyDatabaseBackup, Error>> {
+    log.info(`Creating backup for database ${databaseUuid}`);
+
+    const result = await this.request<ICoolifyDatabaseBackup>(
+      `/databases/${databaseUuid}/backups`,
+      { method: "POST", body: JSON.stringify(data) },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    log.success("Database backup created");
+    return ok(result.data as ICoolifyDatabaseBackup);
+  }
+
+  /**
+   * Updates a database backup.
+   *
+   * @param databaseUuid - Database UUID
+   * @param backupUuid - Backup UUID
+   * @param data - Update data
+   * @returns Result indicating success or error
+   */
+  async updateDatabaseBackup(
+    databaseUuid: string,
+    backupUuid: string,
+    data: Record<string, unknown>,
+  ): Promise<Result<{ message: string }, Error>> {
+    const result = await this.request<{ message: string }>(
+      `/databases/${databaseUuid}/backups/${backupUuid}`,
+      { method: "PATCH", body: JSON.stringify(data) },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data || { message: "Backup updated" });
+  }
+
+  /**
+   * Deletes a database backup.
+   *
+   * @param databaseUuid - Database UUID
+   * @param backupUuid - Backup UUID
+   * @returns Result indicating success or error
+   */
+  async deleteDatabaseBackup(
+    databaseUuid: string,
+    backupUuid: string,
+  ): Promise<Result<{ message: string }, Error>> {
+    const result = await this.request<{ message: string }>(
+      `/databases/${databaseUuid}/backups/${backupUuid}`,
+      { method: "DELETE" },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data || { message: "Backup deleted" });
+  }
+
+  // ===========================================================================
+  // Service endpoints
+  // ===========================================================================
+
+  /**
+   * Lists all services.
+   *
+   * @param page - Optional page number
+   * @param perPage - Optional items per page
+   * @returns Result with services list or error
+   */
+  async listServices(
+    page?: number,
+    perPage?: number,
+  ): Promise<Result<ICoolifyServiceType[], Error>> {
+    log.info("Listing services");
+
+    let endpoint = "/services";
+    const params = new URLSearchParams();
+    if (page) params.set("page", page.toString());
+    if (perPage) params.set("per_page", perPage.toString());
+    if (params.toString()) endpoint += `?${params.toString()}`;
+
+    const result = await this.request<ICoolifyServiceType[]>(endpoint);
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Listed ${result.data?.length || 0} services`);
+    return ok(result.data || []);
+  }
+
+  /**
+   * Gets details of a specific service.
+   *
+   * @param uuid - Service UUID
+   * @returns Result with service details or error
+   */
+  async getService(uuid: string): Promise<Result<ICoolifyServiceType, Error>> {
+    log.info(`Getting service ${uuid}`);
+
+    const result = await this.request<ICoolifyServiceType>(`/services/${uuid}`);
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data as ICoolifyServiceType);
+  }
+
+  /**
+   * Creates a new service.
+   *
+   * @param data - Service creation data
+   * @returns Result with created service or error
+   */
+  async createService(
+    data: Record<string, unknown>,
+  ): Promise<Result<{ uuid: string }, Error>> {
+    log.info("Creating service");
+
+    const result = await this.request<{ uuid: string }>("/services", {
+      method: "POST",
+      body: JSON.stringify(data),
+    });
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Service created: ${result.data?.uuid}`);
+    return ok(result.data!);
+  }
+
+  /**
+   * Updates a service configuration.
+   *
+   * @param uuid - Service UUID
+   * @param data - Update data
+   * @returns Result with updated service or error
+   */
+  async updateService(
+    uuid: string,
+    data: Record<string, unknown>,
+  ): Promise<Result<ICoolifyServiceType, Error>> {
+    log.info(`Updating service ${uuid}`);
+
+    const result = await this.request<ICoolifyServiceType>(
+      `/services/${uuid}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(data),
+      },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Service updated: ${uuid}`);
+    return ok(result.data as ICoolifyServiceType);
+  }
+
+  /**
+   * Deletes a service.
+   *
+   * @param uuid - Service UUID
+   * @param options - Delete options for cascade deletion
+   * @returns Result indicating success or error
+   */
+  async deleteService(
+    uuid: string,
+    options?: {
+      deleteConfigurations?: boolean;
+      deleteVolumes?: boolean;
+      dockerCleanup?: boolean;
+      deleteConnectedNetworks?: boolean;
+    },
+  ): Promise<Result<ICoolifyDeleteResult, Error>> {
+    log.info(`Deleting service ${uuid}`);
+
+    const params = new URLSearchParams();
+    if (options?.deleteConfigurations)
+      params.set("delete_configurations", "true");
+    if (options?.deleteVolumes) params.set("delete_volumes", "true");
+    if (options?.dockerCleanup) params.set("docker_cleanup", "true");
+    if (options?.deleteConnectedNetworks)
+      params.set("delete_connected_networks", "true");
+
+    const queryString = params.toString();
+    const endpoint = `/services/${uuid}${queryString ? `?${queryString}` : ""}`;
+
+    const result = await this.request<ICoolifyDeleteResult>(endpoint, {
+      method: "DELETE",
+    });
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Service deleted: ${uuid}`);
+    return ok({ success: true, message: "Service deleted" });
+  }
+
+  /**
+   * Starts a service.
+   * Note: Coolify API uses GET for service start/stop/restart.
+   *
+   * @param uuid - Service UUID
+   * @returns Result indicating success or error
+   */
+  async startService(
+    uuid: string,
+  ): Promise<Result<{ message: string }, Error>> {
+    log.info(`Starting service ${uuid}`);
+
+    const result = await this.request<{ message: string }>(
+      `/services/${uuid}/start`,
+      { method: "GET" },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Service started: ${uuid}`);
+    return ok(result.data || { message: "Service started" });
+  }
+
+  /**
+   * Stops a service.
+   * Note: Coolify API uses GET for service start/stop/restart.
+   *
+   * @param uuid - Service UUID
+   * @returns Result indicating success or error
+   */
+  async stopService(uuid: string): Promise<Result<{ message: string }, Error>> {
+    log.info(`Stopping service ${uuid}`);
+
+    const result = await this.request<{ message: string }>(
+      `/services/${uuid}/stop`,
+      { method: "GET" },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Service stopped: ${uuid}`);
+    return ok(result.data || { message: "Service stopped" });
+  }
+
+  /**
+   * Restarts a service.
+   * Note: Coolify API uses GET for service start/stop/restart.
+   *
+   * @param uuid - Service UUID
+   * @returns Result indicating success or error
+   */
+  async restartService(
+    uuid: string,
+  ): Promise<Result<{ message: string }, Error>> {
+    log.info(`Restarting service ${uuid}`);
+
+    const result = await this.request<{ message: string }>(
+      `/services/${uuid}/restart`,
+      { method: "GET" },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Service restarted: ${uuid}`);
+    return ok(result.data || { message: "Service restarted" });
+  }
+
+  /**
+   * Lists environment variables for a service.
+   *
+   * @param uuid - Service UUID
+   * @returns Result with env vars list or error
+   */
+  async listServiceEnvVars(
+    uuid: string,
+  ): Promise<Result<ICoolifyEnvVar[], Error>> {
+    const result = await this.request<ICoolifyEnvVar[]>(
+      `/services/${uuid}/envs`,
+    );
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data || []);
+  }
+
+  /**
+   * Creates an environment variable for a service.
+   *
+   * @param uuid - Service UUID
+   * @param data - Env var data (key, value, is_preview)
+   * @returns Result with created env var UUID or error
+   */
+  async createServiceEnvVar(
+    uuid: string,
+    data: { key: string; value: string; is_preview?: boolean },
+  ): Promise<Result<{ uuid: string }, Error>> {
+    const result = await this.request<{ uuid: string }>(
+      `/services/${uuid}/envs`,
+      { method: "POST", body: JSON.stringify(data) },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data!);
+  }
+
+  // ===========================================================================
+  // Additional Server endpoints
+  // ===========================================================================
+
+  /**
+   * Gets resources deployed on a server.
+   *
+   * @param serverUuid - Server UUID
+   * @returns Result with server resources or error
+   */
+  async getServerResources(
+    serverUuid: string,
+  ): Promise<Result<ICoolifyServerResource[], Error>> {
+    log.info(`Getting resources for server ${serverUuid}`);
+
+    const result = await this.request<ICoolifyServerResource[]>(
+      `/servers/${serverUuid}/resources`,
+    );
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data || []);
+  }
+
+  /**
+   * Gets domains configured on a server.
+   *
+   * @param serverUuid - Server UUID
+   * @returns Result with server domains or error
+   */
+  async getServerDomains(
+    serverUuid: string,
+  ): Promise<Result<ICoolifyServerDomain[], Error>> {
+    log.info(`Getting domains for server ${serverUuid}`);
+
+    const result = await this.request<ICoolifyServerDomain[]>(
+      `/servers/${serverUuid}/domains`,
+    );
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data || []);
+  }
+
+  /**
+   * Validates a server connection.
+   *
+   * @param serverUuid - Server UUID
+   * @returns Result with validation status or error
+   */
+  async validateServer(
+    serverUuid: string,
+  ): Promise<Result<{ message: string }, Error>> {
+    log.info(`Validating server ${serverUuid}`);
+
+    const result = await this.request<{ message: string }>(
+      `/servers/${serverUuid}/validate`,
+    );
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data || { message: "Server validated" });
+  }
+
+  /**
+   * Creates a new server.
+   *
+   * @param data - Server creation data
+   * @returns Result with created server UUID or error
+   */
+  async createServer(
+    data: Record<string, unknown>,
+  ): Promise<Result<{ uuid: string }, Error>> {
+    log.info("Creating server");
+
+    const result = await this.request<{ uuid: string }>("/servers", {
+      method: "POST",
+      body: JSON.stringify(data),
+    });
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Server created: ${result.data?.uuid}`);
+    return ok(result.data!);
+  }
+
+  /**
+   * Deletes a server.
+   *
+   * @param serverUuid - Server UUID
+   * @returns Result indicating success or error
+   */
+  async deleteServer(
+    serverUuid: string,
+  ): Promise<Result<{ message: string }, Error>> {
+    log.info(`Deleting server ${serverUuid}`);
+
+    const result = await this.request<{ message: string }>(
+      `/servers/${serverUuid}`,
+      { method: "DELETE" },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Server deleted: ${serverUuid}`);
+    return ok(result.data || { message: "Server deleted" });
+  }
+
+  // ===========================================================================
+  // Additional Project endpoints
+  // ===========================================================================
+
+  /**
+   * Updates a project.
+   *
+   * @param uuid - Project UUID
+   * @param data - Update data (name, description)
+   * @returns Result with updated project or error
+   */
+  async updateProject(
+    uuid: string,
+    data: { name?: string; description?: string },
+  ): Promise<Result<ICoolifyProject, Error>> {
+    log.info(`Updating project ${uuid}`);
+
+    const result = await this.request<ICoolifyProject>(`/projects/${uuid}`, {
+      method: "PATCH",
+      body: JSON.stringify(data),
+    });
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Project updated: ${uuid}`);
+    return ok(result.data as ICoolifyProject);
+  }
+
+  /**
+   * Deletes a project.
+   *
+   * @param uuid - Project UUID
+   * @returns Result indicating success or error
+   */
+  async deleteProject(
+    uuid: string,
+  ): Promise<Result<{ message: string }, Error>> {
+    log.info(`Deleting project ${uuid}`);
+
+    const result = await this.request<{ message: string }>(
+      `/projects/${uuid}`,
+      { method: "DELETE" },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Project deleted: ${uuid}`);
+    return ok(result.data || { message: "Project deleted" });
+  }
+
+  /**
+   * Creates a new environment within a project.
+   *
+   * @param projectUuid - Project UUID
+   * @param data - Environment creation data (name, description)
+   * @returns Result with created environment UUID or error
+   */
+  async createProjectEnvironment(
+    projectUuid: string,
+    data: { name: string; description?: string },
+  ): Promise<Result<{ uuid: string }, Error>> {
+    log.info(`Creating environment in project ${projectUuid}`);
+
+    const result = await this.request<{ uuid: string }>(
+      `/projects/${projectUuid}/environments`,
+      { method: "POST", body: JSON.stringify(data) },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    log.success("Environment created");
+    return ok(result.data!);
+  }
+
+  // ===========================================================================
+  // Additional Team endpoints
+  // ===========================================================================
+
+  /**
+   * Gets the current team.
+   *
+   * @returns Result with current team or error
+   */
+  async getCurrentTeam(): Promise<Result<ICoolifyTeam, Error>> {
+    log.info("Getting current team");
+
+    const result = await this.request<ICoolifyTeam>("/teams/current");
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data as ICoolifyTeam);
+  }
+
+  /**
+   * Gets a specific team by ID.
+   *
+   * @param id - Team ID
+   * @returns Result with team details or error
+   */
+  async getTeam(id: number): Promise<Result<ICoolifyTeam, Error>> {
+    log.info(`Getting team ${id}`);
+
+    const result = await this.request<ICoolifyTeam>(`/teams/${id}`);
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data as ICoolifyTeam);
+  }
+
+  /**
+   * Gets members of a specific team.
+   *
+   * @param id - Team ID
+   * @returns Result with team members or error
+   */
+  async getTeamMembers(
+    id: number,
+  ): Promise<
+    Result<Array<{ id: number; name: string; email: string }>, Error>
+  > {
+    log.info(`Getting members for team ${id}`);
+
+    const result = await this.request<
+      Array<{ id: number; name: string; email: string }>
+    >(`/teams/${id}/members`);
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data || []);
+  }
+
+  // ===========================================================================
+  // Deployment Control
+  // ===========================================================================
+
+  /**
+   * Cancels a deployment.
+   *
+   * @param deploymentUuid - Deployment UUID
+   * @returns Result indicating success or error
+   */
+  async cancelDeployment(
+    deploymentUuid: string,
+  ): Promise<Result<{ message: string }, Error>> {
+    log.info(`Cancelling deployment ${deploymentUuid}`);
+
+    const result = await this.request<{ message: string }>(
+      `/deployments/${deploymentUuid}/cancel`,
+      { method: "POST" },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Deployment cancelled: ${deploymentUuid}`);
+    return ok(result.data || { message: "Deployment cancelled" });
+  }
+
+  // ===========================================================================
+  // SSH / Private Key endpoints
+  // ===========================================================================
+
+  /**
+   * Lists all private keys.
+   *
+   * @returns Result with private keys list or error
+   */
+  async listPrivateKeys(): Promise<Result<ICoolifyPrivateKey[], Error>> {
+    log.info("Listing private keys");
+
+    const result = await this.request<ICoolifyPrivateKey[]>("/security/keys");
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data || []);
+  }
+
+  /**
+   * Gets a specific private key.
+   *
+   * @param uuid - Private key UUID
+   * @returns Result with private key details or error
+   */
+  async getPrivateKey(
+    uuid: string,
+  ): Promise<Result<ICoolifyPrivateKey, Error>> {
+    const result = await this.request<ICoolifyPrivateKey>(
+      `/security/keys/${uuid}`,
+    );
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data as ICoolifyPrivateKey);
+  }
+
+  /**
+   * Creates a new private key.
+   *
+   * @param data - Key creation data (name, private_key, description)
+   * @returns Result with created key UUID or error
+   */
+  async createPrivateKey(data: {
+    name: string;
+    private_key: string;
+    description?: string;
+  }): Promise<Result<{ uuid: string }, Error>> {
+    log.info("Creating private key");
+
+    const result = await this.request<{ uuid: string }>("/security/keys", {
+      method: "POST",
+      body: JSON.stringify(data),
+    });
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Private key created: ${result.data?.uuid}`);
+    return ok(result.data!);
+  }
+
+  /**
+   * Updates a private key.
+   *
+   * @param uuid - Private key UUID
+   * @param data - Update data
+   * @returns Result with updated key or error
+   */
+  async updatePrivateKey(
+    uuid: string,
+    data: { name?: string; private_key?: string; description?: string },
+  ): Promise<Result<ICoolifyPrivateKey, Error>> {
+    const result = await this.request<ICoolifyPrivateKey>(
+      `/security/keys/${uuid}`,
+      { method: "PATCH", body: JSON.stringify(data) },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data as ICoolifyPrivateKey);
+  }
+
+  /**
+   * Deletes a private key.
+   *
+   * @param uuid - Private key UUID
+   * @returns Result indicating success or error
+   */
+  async deletePrivateKey(
+    uuid: string,
+  ): Promise<Result<{ message: string }, Error>> {
+    log.info(`Deleting private key ${uuid}`);
+
+    const result = await this.request<{ message: string }>(
+      `/security/keys/${uuid}`,
+      { method: "DELETE" },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    log.success(`Private key deleted: ${uuid}`);
+    return ok(result.data || { message: "Private key deleted" });
+  }
+
+  // ===========================================================================
+  // GitHub App endpoints (additional)
+  // ===========================================================================
+
+  /**
+   * Creates a GitHub App configuration.
+   *
+   * @param data - GitHub App creation data
+   * @returns Result with created app or error
+   */
+  async createGitHubApp(
+    data: Record<string, unknown>,
+  ): Promise<Result<{ id: number; uuid: string }, Error>> {
+    log.info("Creating GitHub App");
+
+    const result = await this.request<{ id: number; uuid: string }>(
+      "/github-apps",
+      { method: "POST", body: JSON.stringify(data) },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data!);
+  }
+
+  /**
+   * Updates a GitHub App configuration.
+   *
+   * @param id - GitHub App ID
+   * @param data - Update data
+   * @returns Result with updated app or error
+   */
+  async updateGitHubApp(
+    id: number,
+    data: Record<string, unknown>,
+  ): Promise<Result<{ message: string }, Error>> {
+    const result = await this.request<{ message: string }>(
+      `/github-apps/${id}`,
+      { method: "PATCH", body: JSON.stringify(data) },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data || { message: "GitHub App updated" });
+  }
+
+  /**
+   * Deletes a GitHub App configuration.
+   *
+   * @param id - GitHub App ID
+   * @returns Result indicating success or error
+   */
+  async deleteGitHubApp(
+    id: number,
+  ): Promise<Result<{ message: string }, Error>> {
+    log.info(`Deleting GitHub App ${id}`);
+
+    const result = await this.request<{ message: string }>(
+      `/github-apps/${id}`,
+      { method: "DELETE" },
+    );
+    if (result.error) return err(new Error(result.error));
+
+    return ok(result.data || { message: "GitHub App deleted" });
   }
 
   /**
    * Lists all active and queued deployments.
    *
+   * @param page - Optional page number for pagination
+   * @param perPage - Optional number of items per page
    * @returns Result with deployments list or error
    */
-  async listDeployments(): Promise<Result<ICoolifyDeployment[], Error>> {
-    log.info('Listing active deployments')
+  async listDeployments(
+    page?: number,
+    perPage?: number,
+  ): Promise<Result<ICoolifyDeployment[], Error>> {
+    log.info("Listing active deployments");
+
+    let endpoint = "/deployments";
+    const params = new URLSearchParams();
+    if (page) params.set("page", page.toString());
+    if (perPage) params.set("per_page", perPage.toString());
+    if (params.toString()) {
+      endpoint += `?${params.toString()}`;
+    }
 
-    const result = await this.request<ICoolifyDeployment[]>('/deployments')
+    const result = await this.request<ICoolifyDeployment[]>(endpoint);
 
     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 || []);
   }
 
   /**
@@ -949,19 +2176,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,
+    });
   }
 
   /**
@@ -975,29 +2236,611 @@ 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 deployments = result.data?.deployments || [];
+    log.success(`Retrieved ${deployments.length} deployments for ${appUuid}`);
+    return ok(deployments);
+  }
 
-    const params = new URLSearchParams()
-    if (skip > 0) params.set('skip', skip.toString())
-    if (take !== 10) params.set('take', take.toString())
+  /**
+   * 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}`);
 
-    const endpoint = `/applications/${appUuid}/deployments${params.toString() ? `?${params.toString()}` : ''}`
-    const result = await this.request<{ count: number; deployments: ICoolifyDeployment[] }>(endpoint)
+    // 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(`Listed ${deployments.length} deployments for ${appUuid}`);
+    return ok(deployments);
+  }
+
+  // ===========================================================================
+  // Smart Resolution Helpers
+  // ===========================================================================
+
+  /**
+   * Resolves an application by UUID, name, or domain (FQDN).
+   *
+   * @param query - UUID, name, or domain to search for
+   * @returns Result with application or error
+   */
+  async resolveApplication(
+    query: string,
+  ): Promise<Result<ICoolifyApplication, Error>> {
+    log.info(`Resolving application: ${query}`);
+
+    // If it looks like a UUID, try direct lookup first
+    if (this.isLikelyUuid(query)) {
+      const apps = await this.listApplications();
+      if (isErr(apps)) return err(apps.error);
+      const match = apps.value.find((a) => a.uuid === query);
+      if (match) return ok(match);
+    }
+
+    // Search by name or domain
+    const apps = await this.listApplications();
+    if (isErr(apps)) return err(apps.error);
+
+    const lowerQuery = query.toLowerCase();
+    const matches = apps.value.filter(
+      (a) =>
+        a.name?.toLowerCase() === lowerQuery ||
+        a.fqdn?.toLowerCase().includes(lowerQuery) ||
+        a.uuid.startsWith(query),
+    );
+
+    if (matches.length === 1) return ok(matches[0]);
+    if (matches.length === 0) {
+      return err(
+        new Error(
+          `No application found matching "${query}". Use 'list' to see available applications.`,
+        ),
+      );
+    }
+
+    const names = matches.map((a) => `  - ${a.name} (${a.uuid})`).join("\n");
+    return err(
+      new Error(
+        `Multiple applications match "${query}":\n${names}\nPlease use the full UUID.`,
+      ),
+    );
+  }
+
+  /**
+   * Resolves a server by UUID, name, or IP address.
+   *
+   * @param query - UUID, name, or IP to search for
+   * @returns Result with server or error
+   */
+  async resolveServer(query: string): Promise<Result<ICoolifyServer, Error>> {
+    log.info(`Resolving server: ${query}`);
+
+    const servers = await this.listServers();
+    if (isErr(servers)) return err(servers.error);
+
+    const lowerQuery = query.toLowerCase();
+    const match = servers.value.find(
+      (s) =>
+        s.uuid === query ||
+        s.name?.toLowerCase() === lowerQuery ||
+        s.ip === query ||
+        s.uuid.startsWith(query),
+    );
+
+    if (match) return ok(match);
+    return err(
+      new Error(
+        `No server found matching "${query}". Use 'servers' to see available servers.`,
+      ),
+    );
+  }
+
+  /**
+   * Checks if a string looks like a UUID (Coolify or standard format).
+   *
+   * @param query - String to check
+   * @returns true if it looks like a UUID
+   */
+  private isLikelyUuid(query: string): boolean {
+    if (/^[a-z0-9]{20,}$/i.test(query)) return true;
+    if (
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+        query,
+      )
+    )
+      return true;
+    return false;
+  }
+
+  // ===========================================================================
+  // Diagnostics
+  // ===========================================================================
+
+  /**
+   * Diagnoses an application by aggregating health, logs, deployments, and env vars.
+   *
+   * @param query - Application UUID, name, or domain
+   * @returns Result with diagnostic report or error
+   */
+  async diagnoseApplication(query: string): Promise<
+    Result<
+      {
+        application: ICoolifyApplication;
+        recentDeployments: ICoolifyDeployment[];
+        envVarCount: number;
+        recentLogs: string[];
+        issues: string[];
+      },
+      Error
+    >
+  > {
+    log.info(`Diagnosing application: ${query}`);
+
+    const appResult = await this.resolveApplication(query);
+    if (isErr(appResult)) return err(appResult.error);
+
+    const app = appResult.value;
+    const issues: string[] = [];
+
+    // Gather data in parallel
+    const [deploymentsResult, envResult, logsResult] = await Promise.all([
+      this.getApplicationDeploymentHistory(app.uuid),
+      this.getEnvironmentVariables(app.uuid),
+      this.getApplicationLogs(app.uuid, { tail: 20 }),
+    ]);
+
+    const deployments = isErr(deploymentsResult) ? [] : deploymentsResult.value;
+    const envVarCount = isErr(envResult) ? 0 : envResult.value.length;
+    const recentLogs = isErr(logsResult) ? [] : logsResult.value.logs;
+
+    // Check for issues
+    if (app.status?.includes("stopped")) {
+      issues.push("Application is stopped");
+    }
+    if (!app.fqdn) {
+      issues.push("No domain configured");
+    }
+    if (envVarCount === 0) {
+      issues.push("No environment variables set");
+    }
+
+    const recentDeploys = deployments.slice(-5);
+    const failedDeploys = recentDeploys.filter((d) =>
+      d.status?.includes("failed"),
+    );
+    if (failedDeploys.length > 0) {
+      issues.push(
+        `${failedDeploys.length} of last ${recentDeploys.length} deployments failed`,
+      );
+    }
+
+    log.success(`Diagnosis complete for ${app.name}`);
+    return ok({
+      application: app,
+      recentDeployments: recentDeploys,
+      envVarCount,
+      recentLogs,
+      issues,
+    });
+  }
+
+  /**
+   * Diagnoses a server by aggregating health, resources, and domains.
+   *
+   * @param query - Server UUID, name, or IP
+   * @returns Result with diagnostic report or error
+   */
+  async diagnoseServer(query: string): Promise<
+    Result<
+      {
+        server: ICoolifyServer;
+        resources: ICoolifyServerResource[];
+        domains: ICoolifyServerDomain[];
+        issues: string[];
+      },
+      Error
+    >
+  > {
+    log.info(`Diagnosing server: ${query}`);
+
+    const serverResult = await this.resolveServer(query);
+    if (isErr(serverResult)) return err(serverResult.error);
+
+    const server = serverResult.value;
+    const issues: string[] = [];
+
+    const [resourcesResult, domainsResult] = await Promise.all([
+      this.getServerResources(server.uuid),
+      this.getServerDomains(server.uuid),
+    ]);
+
+    const resources = isErr(resourcesResult) ? [] : resourcesResult.value;
+    const domains = isErr(domainsResult) ? [] : domainsResult.value;
+
+    if (!server.is_reachable) {
+      issues.push("Server is not reachable");
+    }
+    if (!server.is_usable) {
+      issues.push("Server is not usable");
+    }
+    if (resources.length === 0) {
+      issues.push("No resources deployed on this server");
+    }
+
+    log.success(`Server diagnosis complete for ${server.name}`);
+    return ok({ server, resources, domains, issues });
+  }
+
+  /**
+   * Scans all infrastructure for potential issues.
+   *
+   * @returns Result with issues report or error
+   */
+  async findInfrastructureIssues(): Promise<
+    Result<
+      {
+        totalServers: number;
+        totalApps: number;
+        totalDatabases: number;
+        totalServices: number;
+        issues: Array<{
+          type: string;
+          resource: string;
+          uuid: string;
+          message: string;
+        }>;
+      },
+      Error
+    >
+  > {
+    log.info("Scanning infrastructure for issues");
+
+    const [serversR, appsR, dbsR, svcsR] = await Promise.all([
+      this.listServers(),
+      this.listApplications(),
+      this.listDatabases(),
+      this.listServices(),
+    ]);
+
+    const servers = isErr(serversR) ? [] : serversR.value;
+    const apps = isErr(appsR) ? [] : appsR.value;
+    const dbs = isErr(dbsR) ? [] : dbsR.value;
+    const svcs = isErr(svcsR) ? [] : svcsR.value;
+
+    const issues: Array<{
+      type: string;
+      resource: string;
+      uuid: string;
+      message: string;
+    }> = [];
+
+    for (const server of servers) {
+      if (!server.is_reachable) {
+        issues.push({
+          type: "server",
+          resource: server.name,
+          uuid: server.uuid,
+          message: "Server unreachable",
+        });
+      }
+    }
+
+    for (const app of apps) {
+      if (app.status?.includes("stopped")) {
+        issues.push({
+          type: "application",
+          resource: app.name,
+          uuid: app.uuid,
+          message: "Application stopped",
+        });
+      }
+      if (app.status?.includes("failed") || app.status?.includes("error")) {
+        issues.push({
+          type: "application",
+          resource: app.name,
+          uuid: app.uuid,
+          message: `Status: ${app.status}`,
+        });
+      }
+    }
+
+    for (const db of dbs) {
+      if (db.status?.includes("stopped") || db.status?.includes("exited")) {
+        issues.push({
+          type: "database",
+          resource: db.name,
+          uuid: db.uuid,
+          message: `Database stopped: ${db.status}`,
+        });
+      }
+    }
+
+    for (const svc of svcs) {
+      if (svc.status?.includes("stopped") || svc.status?.includes("exited")) {
+        issues.push({
+          type: "service",
+          resource: svc.name,
+          uuid: svc.uuid,
+          message: `Service stopped: ${svc.status}`,
+        });
+      }
+    }
+
+    log.success(
+      `Infrastructure scan complete: ${issues.length} issue(s) found`,
+    );
+    return ok({
+      totalServers: servers.length,
+      totalApps: apps.length,
+      totalDatabases: dbs.length,
+      totalServices: svcs.length,
+      issues,
+    });
+  }
+
+  // ===========================================================================
+  // Batch Operations
+  // ===========================================================================
+
+  /**
+   * Restarts all applications in a project.
+   *
+   * @param projectUuid - Project UUID
+   * @returns Result with batch operation results
+   */
+  async restartProjectApps(
+    projectUuid: string,
+  ): Promise<
+    Result<{ total: number; succeeded: number; failed: string[] }, Error>
+  > {
+    log.info(`Restarting all apps in project ${projectUuid}`);
+
+    const appsResult = await this.listApplications(undefined, projectUuid);
+    if (isErr(appsResult)) return err(appsResult.error);
+
+    const apps = appsResult.value;
+    const failed: string[] = [];
+    let succeeded = 0;
+
+    for (const app of apps) {
+      const result = await this.restartApplication(app.uuid);
+      if (isErr(result)) {
+        failed.push(`${app.name} (${app.uuid}): ${result.error.message}`);
+      } else {
+        succeeded++;
+      }
+    }
+
+    log.success(`Restarted ${succeeded}/${apps.length} apps in project`);
+    return ok({ total: apps.length, succeeded, failed });
+  }
+
+  /**
+   * Redeploys all applications in a project.
+   *
+   * @param projectUuid - Project UUID
+   * @param force - Force rebuild
+   * @returns Result with batch operation results
+   */
+  async redeployProjectApps(
+    projectUuid: string,
+    force: boolean = false,
+  ): Promise<
+    Result<{ total: number; succeeded: number; failed: string[] }, Error>
+  > {
+    log.info(`Redeploying all apps in project ${projectUuid}`);
+
+    const appsResult = await this.listApplications(undefined, projectUuid);
+    if (isErr(appsResult)) return err(appsResult.error);
+
+    const apps = appsResult.value;
+    const failed: string[] = [];
+    let succeeded = 0;
+
+    for (const app of apps) {
+      const result = await this.deploy({ uuid: app.uuid, force });
+      if (isErr(result)) {
+        failed.push(`${app.name} (${app.uuid}): ${result.error.message}`);
+      } else {
+        succeeded++;
+      }
+    }
+
+    log.success(`Redeployed ${succeeded}/${apps.length} apps in project`);
+    return ok({ total: apps.length, succeeded, failed });
+  }
+
+  /**
+   * Stops all running applications.
+   *
+   * @returns Result with batch operation results
+   */
+  async stopAllApps(): Promise<
+    Result<{ total: number; succeeded: number; failed: string[] }, Error>
+  > {
+    log.info("Stopping all applications");
+
+    const appsResult = await this.listApplications();
+    if (isErr(appsResult)) return err(appsResult.error);
+
+    const running = appsResult.value.filter(
+      (a) => !a.status?.includes("stopped"),
+    );
+    const failed: string[] = [];
+    let succeeded = 0;
+
+    for (const app of running) {
+      const result = await this.stopApplication(app.uuid);
+      if (isErr(result)) {
+        failed.push(`${app.name} (${app.uuid}): ${result.error.message}`);
+      } else {
+        succeeded++;
+      }
     }
 
-    const deployments = result.data?.deployments || []
-    log.success(`Retrieved ${deployments.length} deployments for ${appUuid}`)
-    return ok(deployments)
+    log.success(`Stopped ${succeeded}/${running.length} apps`);
+    return ok({ total: running.length, succeeded, failed });
+  }
+
+  // ===========================================================================
+  // Summary Types (Token Optimization for MCP)
+  // ===========================================================================
+
+  /**
+   * Lists applications with minimal fields for token efficiency.
+   *
+   * @returns Result with application summaries or error
+   */
+  async listApplicationSummaries(): Promise<
+    Result<
+      Array<{
+        uuid: string;
+        name: string;
+        status: string;
+        fqdn: string | null;
+      }>,
+      Error
+    >
+  > {
+    const result = await this.listApplications();
+    if (isErr(result)) return err(result.error);
+
+    return ok(
+      result.value.map((a) => ({
+        uuid: a.uuid,
+        name: a.name,
+        status: a.status,
+        fqdn: a.fqdn || null,
+      })),
+    );
+  }
+
+  /**
+   * Lists servers with minimal fields for token efficiency.
+   *
+   * @returns Result with server summaries or error
+   */
+  async listServerSummaries(): Promise<
+    Result<
+      Array<{
+        uuid: string;
+        name: string;
+        ip: string;
+        is_reachable: boolean;
+      }>,
+      Error
+    >
+  > {
+    const result = await this.listServers();
+    if (isErr(result)) return err(result.error);
+
+    return ok(
+      result.value.map((s) => ({
+        uuid: s.uuid,
+        name: s.name,
+        ip: s.ip || "",
+        is_reachable: s.is_reachable || false,
+      })),
+    );
+  }
+
+  /**
+   * Lists databases with minimal fields for token efficiency.
+   *
+   * @returns Result with database summaries or error
+   */
+  async listDatabaseSummaries(): Promise<
+    Result<
+      Array<{
+        uuid: string;
+        name: string;
+        type: string;
+        status: string;
+      }>,
+      Error
+    >
+  > {
+    const result = await this.listDatabases();
+    if (isErr(result)) return err(result.error);
+
+    return ok(
+      result.value.map((d) => ({
+        uuid: d.uuid,
+        name: d.name,
+        type: d.type,
+        status: d.status,
+      })),
+    );
+  }
+
+  /**
+   * Lists services with minimal fields for token efficiency.
+   *
+   * @returns Result with service summaries or error
+   */
+  async listServiceSummaries(): Promise<
+    Result<
+      Array<{
+        uuid: string;
+        name: string;
+        type: string;
+        status: string;
+      }>,
+      Error
+    >
+  > {
+    const result = await this.listServices();
+    if (isErr(result)) return err(result.error);
+
+    return ok(
+      result.value.map((s) => ({
+        uuid: s.uuid,
+        name: s.name,
+        type: s.type,
+        status: s.status,
+      })),
+    );
   }
 }
 
-let instance: CoolifyService | null = null
+let instance: CoolifyService | null = null;
 
 /**
  * Gets the singleton CoolifyService instance.
@@ -1006,19 +2849,26 @@ let instance: CoolifyService | null = null
  */
 export function getCoolifyService(): CoolifyService {
   if (!instance) {
-    instance = new CoolifyService()
+    instance = new CoolifyService();
   }
-  return instance
+  return instance;
 }
 
 // Re-export types
 export type {
   ICoolifyServer,
+  ICoolifyServerResource,
+  ICoolifyServerDomain,
   ICoolifyDestination,
   ICoolifyProject,
   ICoolifyTeam,
   ICoolifyApplication,
+  ICoolifyDatabase,
+  ICoolifyDatabaseBackup,
+  ICoolifyService as ICoolifyServiceType,
+  ICoolifyPrivateKey,
   ICoolifyDeployment,
+  ICoolifyVersion,
   ICoolifyAppOptions,
   ICoolifyAppResult,
   ICoolifyDeployOptions,
@@ -1028,4 +2878,4 @@ export type {
   ICoolifyLogsOptions,
   ICoolifyLogs,
   IProgressCallback,
-} from './types.js'
+} from "./types.js";