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

package/src/coolify/index.ts

@@ -13,6 +13,8 @@ import {
   type ICoolifyAppOptions,
   type ICoolifyAppResult,
   type ICoolifyApplication,
+  type ICoolifyDatabase,
+  type ICoolifyDatabaseBackup,
   type ICoolifyDeleteResult,
   type ICoolifyDeployment,
   type ICoolifyDeployOptions,
@@ -21,10 +23,15 @@ 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";
 
@@ -477,7 +484,7 @@ 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}`);
 
@@ -587,10 +594,23 @@ export class CoolifyService {
   /**
    * 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));
@@ -622,18 +642,31 @@ export class CoolifyService {
   /**
    * 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<
+  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 }>
-      >("/github-apps");
+      >(endpoint);
     if (result.error) return err(new Error(result.error));
     return ok(result.data || []);
   }
@@ -641,10 +674,23 @@ export class CoolifyService {
   /**
    * 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));
@@ -707,10 +753,23 @@ export class CoolifyService {
   /**
    * 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));
@@ -744,11 +803,15 @@ 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,
+    page?: number,
+    perPage?: number,
   ): Promise<Result<ICoolifyApplication[], Error>> {
     log.info("Listing applications");
 
@@ -756,6 +819,8 @@ export class CoolifyService {
     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()}`;
     }
@@ -775,19 +840,34 @@ export class CoolifyService {
    * Deletes an application.
    *
    * @param appUuid - Application UUID
+   * @param options - Delete options for cascade deletion
    * @returns Result indicating success or error
    */
   async deleteApplication(
     appUuid: string,
+    options?: {
+      deleteConfigurations?: boolean;
+      deleteVolumes?: boolean;
+      dockerCleanup?: boolean;
+      deleteConnectedNetworks?: boolean;
+    },
   ): Promise<Result<ICoolifyDeleteResult, Error>> {
     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}`);
@@ -891,6 +971,70 @@ export class CoolifyService {
     });
   }
 
+  /**
+   * 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" });
+  }
+
   /**
    * Gets deployment history for an application.
    *
@@ -920,21 +1064,27 @@ export class CoolifyService {
 
   /**
    * 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,
+    options?: { force?: boolean; instantDeploy?: boolean },
   ): Promise<Result<ICoolifyApplication, Error>> {
     log.info(`Starting application ${appUuid}`);
 
-    const result = await this.request<ICoolifyApplication>(
-      `/applications/${appUuid}/start`,
-      {
-        method: "POST",
-      },
-    );
+    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>(endpoint, {
+      method: "GET",
+    });
 
     if (result.error) {
       log.error(`Failed to start application: ${result.error}`);
@@ -947,6 +1097,7 @@ export class CoolifyService {
 
   /**
    * 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
@@ -958,9 +1109,7 @@ export class CoolifyService {
 
     const result = await this.request<ICoolifyApplication>(
       `/applications/${appUuid}/stop`,
-      {
-        method: "POST",
-      },
+      { method: "GET" },
     );
 
     if (result.error) {
@@ -974,6 +1123,7 @@ export class CoolifyService {
 
   /**
    * Restarts an application.
+   * Note: Coolify API uses GET for application start/stop/restart.
    *
    * @param appUuid - Application UUID
    * @returns Result with application status or error
@@ -985,9 +1135,7 @@ export class CoolifyService {
 
     const result = await this.request<ICoolifyApplication>(
       `/applications/${appUuid}/restart`,
-      {
-        method: "POST",
-      },
+      { method: "GET" },
     );
 
     if (result.error) {
@@ -999,145 +1147,1696 @@ export class CoolifyService {
     return ok(result.data as ICoolifyApplication);
   }
 
+  // ===========================================================================
+  // Version / Health
+  // ===========================================================================
+
   /**
-   * Lists all active and queued deployments.
+   * Gets the Coolify server version.
    *
-   * @returns Result with deployments list or error
+   * @returns Result with version info or error
    */
-  async listDeployments(): Promise<Result<ICoolifyDeployment[], Error>> {
-    log.info("Listing active deployments");
+  async getVersion(): Promise<Result<ICoolifyVersion, Error>> {
+    log.info("Getting Coolify version");
 
-    const result = await this.request<ICoolifyDeployment[]>("/deployments");
+    // /version returns plain text, not JSON
+    if (!this.baseUrl || !this.token) {
+      return err(new Error("Coolify not configured"));
+    }
 
-    if (result.error) {
-      log.error(`Failed to list deployments: ${result.error}`);
-      return err(new Error(result.error));
+    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));
     }
+  }
 
-    log.success(`Listed ${result.data?.length || 0} active deployments`);
+  // ===========================================================================
+  // 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 detailed information about a specific deployment.
+   * Gets details of a specific database.
    *
-   * @param deploymentUuid - Deployment UUID
-   * @returns Result with deployment details or error
+   * @param uuid - Database UUID
+   * @returns Result with database details or error
    */
-  async getDeployment(
-    deploymentUuid: string,
-  ): Promise<Result<ICoolifyDeployment, Error>> {
-    log.info(`Getting deployment details for ${deploymentUuid}`);
+  async getDatabase(uuid: string): Promise<Result<ICoolifyDatabase, Error>> {
+    log.info(`Getting database ${uuid}`);
 
-    const result = await this.request<ICoolifyDeployment>(
-      `/deployments/${deploymentUuid}`,
-    );
+    const result = await this.request<ICoolifyDatabase>(`/databases/${uuid}`);
+    if (result.error) return err(new Error(result.error));
 
-    if (result.error) {
-      log.error(`Failed to get deployment: ${result.error}`);
-      return err(new Error(result.error));
-    }
+    return ok(result.data as ICoolifyDatabase);
+  }
 
-    log.success(`Deployment details retrieved: ${deploymentUuid}`);
-    return ok(result.data as ICoolifyDeployment);
+  /**
+   * 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!);
   }
 
   /**
-   * Gets logs for a specific deployment.
+   * Updates a database configuration.
    *
-   * @param deploymentUuid - Deployment UUID
-   * @returns Result with deployment status and logs or error
+   * @param uuid - Database UUID
+   * @param data - Update data
+   * @returns Result with updated database or error
    */
-  async getDeploymentLogs(
-    deploymentUuid: string,
-  ): Promise<
-    Result<{ status: string; logs: string; deployment_uuid: string }, Error>
-  > {
-    log.info(`Getting deployment logs for ${deploymentUuid}`);
+  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));
 
-    const result = await this.request<{
-      status: string;
-      logs: string;
-      deployment_uuid: string;
-    }>(`/deployments/${deploymentUuid}`);
+    log.success(`Database updated: ${uuid}`);
+    return ok(result.data as ICoolifyDatabase);
+  }
 
-    if (result.error) {
-      log.error(`Failed to get deployment logs: ${result.error}`);
-      return err(new Error(result.error));
-    }
+  /**
+   * 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}`);
 
-    log.success(`Deployment logs retrieved: ${deploymentUuid}`);
-    return ok({
-      status: result.data?.status || "unknown",
-      logs: result.data?.logs || "",
-      deployment_uuid: result.data?.deployment_uuid || deploymentUuid,
+    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" });
   }
 
   /**
-   * Gets deployment history for a specific application.
+   * Starts a database.
    *
-   * @param appUuid - Application UUID
-   * @param skip - Number of deployments to skip
-   * @param take - Number of deployments to return
-   * @returns Result with deployments list or error
+   * @param uuid - Database UUID
+   * @returns Result indicating success or error
    */
-  async getApplicationDeployments(
-    appUuid: string,
-    skip: number = 0,
-    take: number = 10,
-  ): Promise<Result<ICoolifyDeployment[], Error>> {
-    log.info(`Getting deployments for application ${appUuid}`);
+  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));
 
-    const params = new URLSearchParams();
-    if (skip > 0) params.set("skip", skip.toString());
-    if (take !== 10) params.set("take", take.toString());
+    log.success(`Database started: ${uuid}`);
+    return ok(result.data || { message: "Database started" });
+  }
 
-    const endpoint = `/applications/${appUuid}/deployments${params.toString() ? `?${params.toString()}` : ""}`;
-    const result = await this.request<{
-      count: number;
-      deployments: ICoolifyDeployment[];
-    }>(endpoint);
+  /**
+   * 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));
 
-    if (result.error) {
-      log.error(`Failed to get application deployments: ${result.error}`);
-      return err(new Error(result.error));
-    }
+    log.success(`Database stopped: ${uuid}`);
+    return ok(result.data || { message: "Database stopped" });
+  }
 
-    const deployments = result.data?.deployments || [];
-    log.success(`Retrieved ${deployments.length} deployments for ${appUuid}`);
-    return ok(deployments);
+  /**
+   * 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 deployments for a specific application.
+   * Lists backups for a database.
    *
-   * 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 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 appUuid - Application UUID
-   * @returns Result with deployments list or error
+   * @param databaseUuid - Database UUID
+   * @param backupUuid - Backup UUID
+   * @returns Result with backup details or error
    */
-  async listApplicationDeployments(
-    appUuid: string,
-  ): Promise<Result<ICoolifyDeployment[], Error>> {
-    log.info(`Listing deployments for application ${appUuid}`);
+  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));
 
-    // API returns { count: number, deployments: ICoolifyDeployment[] }
-    const result = await this.request<{
-      count: number;
-      deployments: ICoolifyDeployment[];
-    }>(`/deployments/applications/${appUuid}`);
+    return ok(result.data as ICoolifyDatabaseBackup);
+  }
 
-    if (result.error) {
-      log.error(`Failed to list application deployments: ${result.error}`);
-      return err(new Error(result.error));
-    }
+  /**
+   * 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));
 
-    const deployments = result.data?.deployments || [];
-    log.success(`Listed ${deployments.length} deployments for ${appUuid}`);
-    return ok(deployments);
+    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(
+    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[]>(endpoint);
+
+    if (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 || []);
+  }
+
+  /**
+   * Gets detailed information about a specific deployment.
+   *
+   * @param deploymentUuid - Deployment UUID
+   * @returns Result with deployment details or error
+   */
+  async getDeployment(
+    deploymentUuid: string,
+  ): Promise<Result<ICoolifyDeployment, Error>> {
+    log.info(`Getting deployment details for ${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.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,
+    });
+  }
+
+  /**
+   * Gets deployment history for a specific application.
+   *
+   * @param appUuid - Application UUID
+   * @param skip - Number of deployments to skip
+   * @param take - Number of deployments to return
+   * @returns Result with deployments list or error
+   */
+  async getApplicationDeployments(
+    appUuid: string,
+    skip: number = 0,
+    take: number = 10,
+  ): Promise<Result<ICoolifyDeployment[], Error>> {
+    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);
+  }
+
+  /**
+   * Lists deployments for a specific application.
+   *
+   * Uses the /deployments/applications/{appUuid} endpoint which returns
+   * all deployments (active, queued, and completed) for a single application.
+   * This differs from listDeployments() which returns ALL deployments globally.
+   *
+   * @param appUuid - Application UUID
+   * @returns Result with deployments list or error
+   */
+  async listApplicationDeployments(
+    appUuid: string,
+  ): Promise<Result<ICoolifyDeployment[], Error>> {
+    log.info(`Listing deployments for application ${appUuid}`);
+
+    // API returns { count: number, deployments: ICoolifyDeployment[] }
+    const result = await this.request<{
+      count: number;
+      deployments: ICoolifyDeployment[];
+    }>(`/deployments/applications/${appUuid}`);
+
+    if (result.error) {
+      log.error(`Failed to 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++;
+      }
+    }
+
+    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,
+      })),
+    );
   }
 }
 
@@ -1158,11 +2857,18 @@ export function getCoolifyService(): CoolifyService {
 // Re-export types
 export type {
   ICoolifyServer,
+  ICoolifyServerResource,
+  ICoolifyServerDomain,
   ICoolifyDestination,
   ICoolifyProject,
   ICoolifyTeam,
   ICoolifyApplication,
+  ICoolifyDatabase,
+  ICoolifyDatabaseBackup,
+  ICoolifyService as ICoolifyServiceType,
+  ICoolifyPrivateKey,
   ICoolifyDeployment,
+  ICoolifyVersion,
   ICoolifyAppOptions,
   ICoolifyAppResult,
   ICoolifyDeployOptions,