@mks2508/coolify-mks-cli-mcp 0.1.0

package/src/coolify/index.ts

@@ -0,0 +1,688 @@
+/**
+ * Coolify service for MCP server and CLI.
+ *
+ * Provides all Coolify API operations for deployment management.
+ *
+ * @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 {
+  type ICoolifyAppOptions,
+  type ICoolifyAppResult,
+  type ICoolifyApplication,
+  type ICoolifyDeleteResult,
+  type ICoolifyDeployment,
+  type ICoolifyDeployOptions,
+  type ICoolifyDeployResult,
+  type ICoolifyDestination,
+  type ICoolifyLogs,
+  type ICoolifyLogsOptions,
+  type ICoolifyProject,
+  type ICoolifyServer,
+  type ICoolifyTeam,
+  type ICoolifyUpdateOptions,
+  type IProgressCallback,
+} from './types.js'
+
+const log = component('CoolifyService')
+
+/**
+ * Coolify API response type.
+ */
+interface ICoolifyApiResponse<T> {
+  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
+}
+
+/**
+ * Coolify service for deployment operations.
+ *
+ * @example
+ * ```typescript
+ * const coolify = new CoolifyService()
+ * const initResult = await coolify.init()
+ * if (initResult.isErr()) {
+ *   console.error(initResult.error.message)
+ *   return
+ * }
+ *
+ * const deployResult = await coolify.deploy({ uuid: 'app-uuid' })
+ * if (deployResult.isOk()) {
+ *   console.log('Deployment UUID:', deployResult.value.deploymentUuid)
+ * }
+ * ```
+ */
+export class CoolifyService {
+  private baseUrl: string | undefined
+  private token: string | undefined
+  private config: ICoolifyConfig = {}
+
+  /**
+   * Checks if the service is configured with URL and token.
+   *
+   * @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
+  }
+
+  /**
+   * Initializes the Coolify service by loading configuration.
+   *
+   * @returns Result indicating success or error
+   */
+  async init(): Promise<Result<void, Error>> {
+    const configResult = await loadConfig()
+
+    if (isErr(configResult)) {
+      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
+
+    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.'))
+    }
+
+    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.debug('Coolify connection configured')
+    return ok(undefined)
+  }
+
+  /**
+   * Makes a request to the Coolify API.
+   *
+   * @param endpoint - API endpoint
+   * @param options - Fetch options
+   * @returns API response with data or error
+   */
+  private async request<T>(
+    endpoint: string,
+    options: RequestInit = {}
+  ): Promise<ICoolifyApiResponse<T>> {
+    const startTime = Date.now()
+
+    if (!this.baseUrl || !this.token) {
+      return { error: 'Coolify not configured', status: 0, durationMs: Date.now() - startTime }
+    }
+
+    try {
+      const url = `${this.baseUrl}/api/v1${endpoint}`
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+          ...options.headers,
+        },
+      })
+
+      const text = await response.text()
+      const durationMs = Date.now() - startTime
+      let data: T | undefined
+
+      try {
+        data = text ? JSON.parse(text) : undefined
+      } catch {
+        if (!response.ok) {
+          return { error: text || `HTTP ${response.status}`, status: response.status, durationMs }
+        }
+      }
+
+      if (!response.ok) {
+        const errorMessage =
+          (data as { message?: string } | undefined)?.message ||
+          `HTTP ${response.status}`
+        return { error: errorMessage, 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 }
+    }
+  }
+
+  /**
+   * Deploys an application.
+   *
+   * @param options - Deployment options
+   * @param onProgress - Optional progress callback (0-100, message, step)
+   * @returns Result with deployment info or error
+   */
+  async deploy(
+    options: ICoolifyDeployOptions,
+    onProgress?: IProgressCallback
+  ): Promise<Result<ICoolifyDeployResult, Error>> {
+    if (!options.uuid && !options.tag) {
+      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}...`)
+
+    log.info(`Deploying application ${options.uuid || options.tag}`)
+
+    onProgress?.(25, 'Validating deployment configuration')
+    onProgress?.(50, 'Triggering build pipeline...')
+
+    const result = await this.request<{
+      resource_uuid: string
+      deployment_uuid: string
+    }>('/deploy', {
+      method: 'POST',
+      body: JSON.stringify({
+        uuid: options.uuid,
+        tag: options.tag,
+        force: options.force ?? false,
+      }),
+    })
+
+    if (result.error) {
+      log.error(`Deployment failed: ${result.error}`)
+      return err(new Error(result.error))
+    }
+
+    onProgress?.(90, 'Build started on Coolify server')
+    onProgress?.(100, 'Deployment triggered')
+
+    log.success(`Deployment started: ${result.data?.deployment_uuid}`)
+    return ok({
+      success: true,
+      deploymentUuid: result.data?.deployment_uuid,
+      resourceUuid: result.data?.resource_uuid,
+    })
+  }
+
+  /**
+   * Creates a new application in Coolify.
+   *
+   * @param options - Application options
+   * @param onProgress - Optional progress callback (0-100, message, step)
+   * @returns Result with application UUID or error
+   */
+  async createApplication(
+    options: ICoolifyAppOptions,
+    onProgress?: IProgressCallback
+  ): Promise<Result<ICoolifyAppResult, Error>> {
+    onProgress?.(5, `Preparing app "${options.name}"`)
+
+    log.info(`Creating application ${options.name}`)
+
+    onProgress?.(25, `Validating server ${options.serverUuid.slice(0, 8)}...`)
+    onProgress?.(50, 'Sending creation request to Coolify API...')
+
+    const result = await this.request<{ uuid: string }>('/applications', {
+      method: 'POST',
+      body: JSON.stringify({
+        name: options.name,
+        description: options.description,
+        server_uuid: options.serverUuid,
+        destination_uuid: options.destinationUuid,
+        project_uuid: options.serverUuid,
+        environment_name: 'production',
+        git_repository: options.githubRepoUrl,
+        git_branch: options.branch || 'main',
+        build_pack: options.buildPack || 'nixpacks',
+        ports_exposes: '3000',
+        instant_deploy: false,
+      }),
+    })
+
+    if (result.error) {
+      log.error(`Failed to create application: ${result.error}`)
+      return err(new Error(result.error))
+    }
+
+    onProgress?.(100, `Application "${options.name}" created`)
+
+    log.success(`Application created: ${result.data?.uuid}`)
+    return ok({
+      success: true,
+      uuid: result.data?.uuid,
+    })
+  }
+
+  /**
+   * Sets environment variables for an application.
+   *
+   * @param appUuid - Application UUID
+   * @param envVars - Environment variables to set
+   * @returns Result indicating success or error
+   */
+  async setEnvironmentVariables(
+    appUuid: string,
+    envVars: Record<string, string>
+  ): Promise<Result<void, Error>> {
+    log.info(`Setting environment variables for ${appUuid}`)
+
+    const envArray = Object.entries(envVars).map(([key, value]) => ({
+      key,
+      value,
+      is_build_time: false,
+    }))
+
+    const result = await this.request(`/applications/${appUuid}/envs`, {
+      method: 'POST',
+      body: JSON.stringify({ data: envArray }),
+    })
+
+    if (result.error) {
+      log.error(`Failed to set env vars: ${result.error}`)
+      return err(new Error(result.error))
+    }
+
+    log.success('Environment variables set')
+    return ok(undefined)
+  }
+
+  /**
+   * Gets environment variables for an application.
+   *
+   * @param appUuid - Application UUID
+   * @returns Result with environment variables or error
+   */
+  async getEnvironmentVariables(
+    appUuid: string
+  ): Promise<Result<ICoolifyEnvVar[], Error>> {
+    log.info(`Getting environment variables for ${appUuid}`)
+
+    const result = await this.request<ICoolifyEnvVar[]>(
+      `/applications/${appUuid}/envs`
+    )
+
+    if (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 || [])
+  }
+
+  /**
+   * Gets the status of an application.
+   *
+   * @param appUuid - Application UUID
+   * @returns Result with status or error
+   */
+  async getApplicationStatus(
+    appUuid: string
+  ): Promise<Result<string, Error>> {
+    const result = await this.request<{ status: string }>(
+      `/applications/${appUuid}`
+    )
+
+    if (result.error) {
+      return err(new Error(result.error))
+    }
+
+    return ok(result.data?.status || 'unknown')
+  }
+
+  /**
+   * Lists available servers in Coolify.
+   *
+   * @returns Result with servers or error
+   */
+  async listServers(): Promise<Result<ICoolifyServer[], Error>> {
+    const result = await this.request<ICoolifyServer[]>('/servers')
+
+    if (result.error) {
+      return err(new Error(result.error))
+    }
+
+    return ok(result.data || [])
+  }
+
+  /**
+   * Gets details of a specific server.
+   *
+   * @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}`)
+
+    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.success(`Server details retrieved: ${serverUuid}`)
+    return ok(result.data as ICoolifyServer)
+  }
+
+  /**
+   * Lists all projects.
+   *
+   * @returns Result with projects list or error
+   */
+  async listProjects(): Promise<Result<ICoolifyProject[], Error>> {
+    const result = await this.request<ICoolifyProject[]>('/projects')
+
+    if (result.error) {
+      return err(new Error(result.error))
+    }
+
+    return ok(result.data || [])
+  }
+
+  /**
+   * Lists all teams.
+   *
+   * @returns Result with teams list or error
+   */
+  async listTeams(): Promise<Result<ICoolifyTeam[], Error>> {
+    const result = await this.request<ICoolifyTeam[]>('/teams')
+
+    if (result.error) {
+      return err(new Error(result.error))
+    }
+
+    return ok(result.data || [])
+  }
+
+  /**
+   * Gets available destinations for a server.
+   *
+   * @param serverUuid - Server UUID
+   * @returns Result with destinations or error
+   */
+  async getServerDestinations(
+    serverUuid: string
+  ): Promise<Result<ICoolifyDestination[], Error>> {
+    const result = await this.request<{
+      destinations: ICoolifyDestination[]
+    }>(`/servers/${serverUuid}`)
+
+    if (result.error) {
+      return err(new Error(result.error))
+    }
+
+    return ok(result.data?.destinations || [])
+  }
+
+  /**
+   * Lists all applications.
+   *
+   * @param teamId - Optional team ID to filter by
+   * @param projectId - Optional project ID to filter by
+   * @returns Result with applications list or error
+   */
+  async listApplications(
+    teamId?: string,
+    projectId?: string
+  ): 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)
+    if (params.toString()) {
+      endpoint += `?${params.toString()}`
+    }
+
+    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.success(`Listed ${result.data?.length || 0} applications`)
+    return ok(result.data || [])
+  }
+
+  /**
+   * Deletes an application.
+   *
+   * @param appUuid - Application UUID
+   * @returns Result indicating success or error
+   */
+  async deleteApplication(
+    appUuid: string
+  ): Promise<Result<ICoolifyDeleteResult, Error>> {
+    log.info(`Deleting application ${appUuid}`)
+
+    const result = await this.request<ICoolifyDeleteResult>(`/applications/${appUuid}`, {
+      method: 'DELETE',
+    })
+
+    if (result.error) {
+      log.error(`Failed to delete application: ${result.error}`)
+      return err(new Error(result.error))
+    }
+
+    log.success(`Application deleted: ${appUuid}`)
+    return ok({ success: true, message: 'Application deleted' })
+  }
+
+  /**
+   * Updates an application configuration.
+   *
+   * @param appUuid - Application UUID
+   * @param options - Update options
+   * @returns Result with updated application or error
+   */
+  async updateApplication(
+    appUuid: string,
+    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
+
+    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.success(`Application updated: ${appUuid}`)
+    return ok(result.data as ICoolifyApplication)
+  }
+
+  /**
+   * Gets application logs.
+   *
+   * @param appUuid - Application UUID
+   * @param options - Log retrieval options
+   * @returns Result with logs or error
+   */
+  async getApplicationLogs(
+    appUuid: string,
+    options: ICoolifyLogsOptions = {}
+  ): Promise<Result<ICoolifyLogs, Error>> {
+    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 endpoint = `/applications/${appUuid}/logs${params.toString() ? `?${params.toString()}` : ''}`
+
+    const result = await this.request<{ logs: string[] }>(endpoint)
+
+    if (result.error) {
+      log.error(`Failed to get logs: ${result.error}`)
+      return err(new Error(result.error))
+    }
+
+    log.success(`Logs retrieved for application: ${appUuid}`)
+    return ok({
+      logs: result.data?.logs || [],
+      timestamp: new Date().toISOString(),
+    })
+  }
+
+  /**
+   * Gets deployment history for an application.
+   *
+   * @param appUuid - Application UUID
+   * @returns Result with deployment history or error
+   */
+  async getApplicationDeploymentHistory(
+    appUuid: string
+  ): Promise<Result<ICoolifyDeployment[], Error>> {
+    log.info(`Getting deployment history for ${appUuid}`)
+
+    const result = await this.request<ICoolifyDeployment[]>(`/applications/${appUuid}/deployments`)
+
+    if (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 || [])
+  }
+
+  /**
+   * Starts a stopped application.
+   *
+   * @param appUuid - Application UUID
+   * @returns Result with application status or error
+   */
+  async startApplication(
+    appUuid: string
+  ): Promise<Result<ICoolifyApplication, Error>> {
+    log.info(`Starting application ${appUuid}`)
+
+    const result = await this.request<ICoolifyApplication>(`/applications/${appUuid}/start`, {
+      method: 'POST',
+    })
+
+    if (result.error) {
+      log.error(`Failed to start application: ${result.error}`)
+      return err(new Error(result.error))
+    }
+
+    log.success(`Application started: ${appUuid}`)
+    return ok(result.data as ICoolifyApplication)
+  }
+
+  /**
+   * Stops a running application.
+   *
+   * @param appUuid - Application UUID
+   * @returns Result with application status or error
+   */
+  async stopApplication(
+    appUuid: string
+  ): Promise<Result<ICoolifyApplication, Error>> {
+    log.info(`Stopping application ${appUuid}`)
+
+    const result = await this.request<ICoolifyApplication>(`/applications/${appUuid}/stop`, {
+      method: 'POST',
+    })
+
+    if (result.error) {
+      log.error(`Failed to stop application: ${result.error}`)
+      return err(new Error(result.error))
+    }
+
+    log.success(`Application stopped: ${appUuid}`)
+    return ok(result.data as ICoolifyApplication)
+  }
+
+  /**
+   * Restarts an application.
+   *
+   * @param appUuid - Application UUID
+   * @returns Result with application status or error
+   */
+  async restartApplication(
+    appUuid: string
+  ): Promise<Result<ICoolifyApplication, Error>> {
+    log.info(`Restarting application ${appUuid}`)
+
+    const result = await this.request<ICoolifyApplication>(`/applications/${appUuid}/restart`, {
+      method: 'POST',
+    })
+
+    if (result.error) {
+      log.error(`Failed to restart application: ${result.error}`)
+      return err(new Error(result.error))
+    }
+
+    log.success(`Application restarted: ${appUuid}`)
+    return ok(result.data as ICoolifyApplication)
+  }
+}
+
+let instance: CoolifyService | null = null
+
+/**
+ * Gets the singleton CoolifyService instance.
+ *
+ * @returns The CoolifyService instance
+ */
+export function getCoolifyService(): CoolifyService {
+  if (!instance) {
+    instance = new CoolifyService()
+  }
+  return instance
+}
+
+// Re-export types
+export type {
+  ICoolifyServer,
+  ICoolifyDestination,
+  ICoolifyProject,
+  ICoolifyTeam,
+  ICoolifyApplication,
+  ICoolifyDeployment,
+  ICoolifyAppOptions,
+  ICoolifyDeployOptions,
+  ICoolifyUpdateOptions,
+  ICoolifyLogsOptions,
+}