# CLI for [Coolify](https://coolify.io) API

## Installation

### Install script (recommended)

#### Linux/macOS

```bash
curl -fsSL https://raw.githubusercontent.com/coollabsio/coolify-cli/main/scripts/install.sh | bash
```

It will install the CLI in `/usr/local/bin/coolify` and the configuration file in `~/.config/coolify/config.json`

### Homebrew (macOS/Linux)

```bash
brew install coollabsio/coolify-cli/coolify-cli
```

#### Windows (PowerShell)

```powershell
irm https://raw.githubusercontent.com/coollabsio/coolify-cli/main/scripts/install.ps1 | iex
```

It will install the CLI in `%ProgramFiles%\Coolify\coolify.exe` and the configuration file in `%USERPROFILE%\.config\coolify\config.json`

For user installation (no admin rights required):
```powershell
$env:COOLIFY_USER_INSTALL=1; irm https://raw.githubusercontent.com/coollabsio/coolify-cli/main/scripts/install.ps1 | iex
```

For a specific version:
```powershell
$env:COOLIFY_VERSION='v1.0.0'; irm https://raw.githubusercontent.com/coollabsio/coolify-cli/main/scripts/install.ps1 | iex
```

### Using `go install`
       
```bash
go install github.com/coollabsio/coolify-cli/coolify@latest
```

This will install the `coolify` binary in your `$GOPATH/bin` directory (usually `~/go/bin`). Make sure this directory is in your `$PATH`.

### Using the install script


## Getting Started
1. Get a `<token>` from your Coolify dashboard (Cloud or self-hosted) at `/security/api-tokens`

### Cloud

2. Add the token with `coolify context set-token cloud <token>`

### Self-hosted

2. Add the token with `coolify context add -d <context_name> <url> <token>`

> Replace `<context_name>` with the name you want to give to the context.
>
> Replace `<url>` with the fully qualified domain name of your Coolify instance.

Now you can use the CLI with the token you just added.

## For LLMs / AI agents

- Quick instructions: [`llms.txt`](./llms.txt)
- Full command catalog: [`llms-full.txt`](./llms-full.txt)
- Regenerate both files:

```bash
go run ./coolify docs llms
```

## Change default context
You can change the default context with `coolify context use <context_name>` or `coolify context set-default <context_name>`
## Currently Supported Commands

### Update
- `coolify update` - Update the CLI to the latest version

### Version
- `coolify version` - Show the current CLI version

### Configuration
- `coolify config` - Show configuration file location

### Instance Email Settings
- `coolify settings email get` - Get instance-wide SMTP and Resend settings
- `coolify settings email update --json '<settings>'` - Update instance email settings using a root-team admin/owner token with `write:sensitive`
  - Example: `coolify settings email update --json '{"smtp_ehlo_domain":"coolify.example.com"}'`
  - Set the EHLO domain to `null` to use the system default

### Shell Completion
- `coolify completion <shell>` - Generate shell completion script
  - Supported shells: `bash`, `zsh`, `fish`, `powershell`

### Context Management
- `coolify context list` - List all configured contexts
- `coolify context add <context_name> <url> <token>` - Add a new context
  - `-d, --default` - Set as default context
  - `-f, --force` - Force overwrite if context already exists
- `coolify context delete <context_name>` - Delete a context
- `coolify context get <context_name>` - Get details of a specific context
- `coolify context set-token <context_name> <token>` - Update the API token for a context
- `coolify context set-default <context_name>` - Set a context as the default
- `coolify context update <context_name>` - Update a context's properties
  - `--name <new_name>` - Change the context name
  - `--url <new_url>` - Change the context URL
  - `--token <new_token>` - Change the context token
- `coolify context use <context_name>` - Switch to a different context (set as default)
- `coolify context verify` - Verify current context connection and authentication
- `coolify context version` - Get the Coolify API version of the current context

### Servers

Commands can use `server` or `servers` interchangeably.

- `coolify server list` - List all servers
- `coolify server get <uuid>` - Get a server by UUID
  - `--resources` - Get the resources and their status of a server
- `coolify server add <name> <ip> <private_key_uuid>` - Add a new server
  - `-p, --port <port>` - SSH port (default: 22)
  - `-u, --user <user>` - SSH user (default: root)
  - `--validate` - Validate server immediately after adding
- `coolify server remove <uuid>` - Remove a server
- `coolify server validate <uuid>` - Validate a server connection
- `coolify server domains <uuid>` - Get server domains by UUID
- `coolify server destinations list <server_uuid>` - List a server's destinations
- `coolify server destinations create <server_uuid>` - Create a server destination
- `coolify server hetzner|digitalocean|vultr` - List provider options and provision a server

### Projects
- `coolify projects list` - List all projects
- `coolify projects get <uuid>` - Get project environments
- `coolify projects create` - Create a new project
  - `--name <name>` - Project name (required)
  - `--description <description>` - Project description

### Resources
- `coolify resources list` - List all resources

### Applications
- `coolify app list` - List all applications
- `coolify app get <uuid>` - Get application details
- `coolify app update <uuid>` - Update application configuration
  - `--name <name>` - Application name
  - `--description <description>` - Application description
  - `--git-branch <branch>` - Git branch
  - `--git-repository <url>` - Git repository URL
  - `--domains <domains>` - Domains (comma-separated)
  - `--compose-domain <service>=<url>[,<url>]` - Docker Compose service domains (repeatable; update replaces the existing mapping)
  - `--build-command <cmd>` - Build command
  - `--start-command <cmd>` - Start command
  - `--install-command <cmd>` - Install command
  - `--base-directory <path>` - Base directory
  - `--publish-directory <path>` - Publish directory
  - `--dockerfile <content>` - Dockerfile content
  - `--docker-image <image>` - Docker image name
  - `--docker-tag <tag>` - Docker image tag
  - `--ports-exposes <ports>` - Exposed ports
  - `--ports-mappings <mappings>` - Port mappings
  - `--health-check-enabled` - Enable health check
  - `--health-check-path <path>` - Health check path
- `coolify app delete <uuid>` - Delete an application
  - `-f, --force` - Skip confirmation prompt
- `coolify app start <uuid>` - Start an application
- `coolify app stop <uuid>` - Stop an application
- `coolify app restart <uuid>` - Restart an application
- `coolify app logs <uuid>` - Get application logs
  - `-f, --follow` - Follow log output (like tail -f)
  - `-n, --lines <n>` - Number of log lines to retrieve (default: 100)
  - `--show-timestamps` - Include timestamps in logs
  - `--service <name>` - Docker Compose service name (select one container in multi-service compose apps)
- `coolify app move <uuid> --environment-uuid <uuid>` - Move an application to another environment
- `coolify app tag list|add|remove` - Manage application tags
- Git-backed application create variants (`public`, `github`, and `deploy-key`) and `app update` support repeatable `--compose-domain <service>=<url>[,<url>]` flags for Docker Compose routing. On update, the supplied entries replace the existing mapping.
- All application create variants support `--tag` and `--tags`; create and update expose the full application settings surface.

#### Application Creation
- `coolify app create public` - Create an application from a public git repository
  - `--server-uuid <uuid>` - Server UUID (required)
  - `--project-uuid <uuid>` - Project UUID (required)
  - `--environment-name <name>` - Environment name (or use `--environment-uuid <uuid>`)
  - `--git-repository <url>` - Git repository URL (required)
  - `--git-branch <branch>` - Git branch (required)
  - `--build-pack <pack>` - Build pack: `nixpacks`, `static`, `dockerfile`, `dockercompose` (required)
  - `--ports-exposes <ports>` - Exposed ports, e.g., '3000' or '3000,8080' (required)
  - `--domains <domains>` - Domain(s) for the application
  - `--instant-deploy` - Deploy immediately after creation
  - More flags: `--name`, `--description`, `--base-directory`, `--publish-directory`, `--build-command`, `--start-command`, `--install-command`, `--health-check-enabled`, `--health-check-path`, `--limits-memory`, `--limits-cpus`, `--ports-mappings`, `--git-commit-sha`, `--destination-uuid`, `--dockerfile-target-build`
- `coolify app create github` - Create an application from a private repository using a GitHub App
  - Same flags as `public`, plus `--github-app-uuid <uuid>` (required)
  - `--git-repository` takes the `owner/repo` format
- `coolify app create deploy-key` - Create an application from a private repository using an SSH deploy key
  - Same flags as `public`, plus `--private-key-uuid <uuid>` (required)
  - `--git-repository` takes an SSH URL, e.g., `git@github.com:owner/repo.git`
- `coolify app create dockerfile` - Create an application from a custom Dockerfile
  - `--dockerfile <content>` - Dockerfile content (required)
  - `--server-uuid <uuid>` - Server UUID (required)
  - `--project-uuid <uuid>` - Project UUID (required)
  - `--environment-name <name>` - Environment name (or use `--environment-uuid <uuid>`)
- `coolify app create dockerimage` - Create an application from a pre-built Docker image
  - `--docker-registry-image-name <image>` - Docker image name from registry (required)
  - `--docker-registry-image-tag <tag>` - Docker image tag (defaults to `latest`)
  - `--ports-exposes <ports>` - Exposed ports (required)
  - `--server-uuid <uuid>` - Server UUID (required)
  - `--project-uuid <uuid>` - Project UUID (required)
  - `--environment-name <name>` - Environment name (or use `--environment-uuid <uuid>`)

#### Application Previews
- `coolify app previews delete <app_uuid> <pr_id>` - Delete a preview deployment
  - `--force` - Skip confirmation prompt

#### Application Storage
- `coolify app storage list <app_uuid>` - List all storages for an application
- `coolify app storage create <app_uuid>` - Create a storage for an application
  - `--type <type>` - Storage type: `persistent` or `file` (required)
  - `--mount-path <path>` - Mount path inside the container (required)
  - `--name <name>` - Volume name (persistent only)
  - `--host-path <path>` - Host path (persistent only)
  - `--content <content>` - File content (file only)
  - `--is-directory` - Whether this is a directory mount (file only)
  - `--fs-path <path>` - Host directory path (file only, required when `--is-directory` is set)
- `coolify app storage update <app_uuid>` - Update a storage for an application
  - `--uuid <uuid>` - Storage UUID (required, use `storage list` to find)
  - `--type <type>` - Storage type: `persistent` or `file` (required)
  - `--is-preview-suffix-enabled` - Enable preview suffix for this storage
  - Other flags same as `create`
- `coolify app storage delete <app_uuid> <storage_uuid>` - Delete a storage from an application

#### Application Environment Variables
- `coolify app env list <app_uuid>` - List all environment variables
- `coolify app env get <app_uuid> <env_uuid_or_key>` - Get a specific environment variable
- `coolify app env create <app_uuid>` - Create a new environment variable
  - `--key <key>` - Variable key (required)
  - `--value <value>` - Variable value (required)
  - `--preview` - Available in preview deployments
  - `--build-time` - Available at build time (default: true)
  - `--runtime` - Available at runtime (default: true)
  - `--comment <comment>` - Comment for the environment variable
  - `--is-literal` - Treat value as literal (don't interpolate variables)
  - `--is-multiline` - Value is multiline
- `coolify app env update <app_uuid> <env_uuid_or_key>` - Update an environment variable
  - `--value <value>` - Variable value (required)
  - `--key <key>` - New variable key (optional, for renaming)
  - `--preview` - Available in preview deployments
  - `--build-time` - Available at build time (default: true)
  - `--runtime` - Available at runtime (default: true)
  - `--comment <comment>` - Comment for the environment variable
  - `--is-literal` - Treat value as literal (don't interpolate variables)
  - `--is-multiline` - Value is multiline
- `coolify app env delete <app_uuid> <env_uuid>` - Delete an environment variable
  - `--force` - Skip confirmation prompt
- `coolify app env sync <app_uuid>` - Sync environment variables from a .env file
  - `-f, --file <path>` - Path to .env file (required)
  - `--build-time` - Make all variables available at build time (default: true)
  - `--runtime` - Make all variables available at runtime (default: true)
  - `--preview` - Make all variables available in preview deployments
  - `--is-literal` - Treat all values as literal (don't interpolate variables)
  - **Behavior**: Updates existing variables, creates missing ones. Does NOT delete variables not in the file.

#### Application Deployments
- `coolify app deployments list <app-uuid>` - List all deployments for an application
- `coolify app deployments logs <app-uuid> [deployment-uuid]` - Get deployment logs (formatted as human-readable text)
  - If only `app-uuid` is provided: retrieves logs from the **latest/most recent deployment only**
  - If `deployment-uuid` is also provided: retrieves logs for that **specific deployment**
  - `-n, --lines <n>` - Number of log lines to display (default: 0 = all lines)
  - `-f, --follow` - Follow log output in real-time (like tail -f)
  - `--debuglogs` - Show debug logs (includes hidden commands and internal operations)

### Databases
- `coolify database list` - List all databases
- `coolify database get <uuid>` - Get database details
- `coolify database create <type>` - Create a new database
  - Supported types: `postgresql`, `mysql`, `mariadb`, `mongodb`, `redis`, `keydb`, `clickhouse`, `dragonfly`
  - `--server-uuid <uuid>` - Server UUID (required)
  - `--project-uuid <uuid>` - Project UUID (required)
  - `--environment-name <name>` - Environment name (required unless using --environment-uuid)
  - `--environment-uuid <uuid>` - Environment UUID (required unless using --environment-name)
  - `--destination-uuid <uuid>` - Destination UUID if server has multiple destinations
  - `--name <name>` - Database name
  - `--description <description>` - Database description
  - `--image <image>` - Docker image
  - `--instant-deploy` - Deploy immediately after creation
  - `--is-public` - Make database publicly accessible
  - `--public-port <port>` - Public port number
  - `--limits-memory <size>` - Memory limit (e.g., '512m', '2g')
  - `--limits-cpus <cpus>` - CPU limit (e.g., '0.5', '2')
  - Database-specific flags (postgres-user, mysql-root-password, etc.)
- `coolify database update <uuid>` - Update database configuration
- `coolify database delete <uuid>` - Delete a database
  - `--delete-configurations` - Delete configurations (default: true)
  - `--delete-volumes` - Delete volumes (default: true)
  - `--docker-cleanup` - Run docker cleanup (default: true)
  - `--delete-connected-networks` - Delete connected networks (default: true)
- `coolify database start <uuid>` - Start a database
- `coolify database stop <uuid>` - Stop a database
- `coolify database restart <uuid>` - Restart a database
- `coolify database logs <uuid>` - Get database logs
- `coolify database move <uuid> --environment-uuid <uuid>` - Move a database to another environment
- `coolify database tag list|add|remove` - Manage database tags
- Database creation supports repeatable `--tag` and comma-separated `--tags`.

#### Database Backups
- `coolify database backup list <database_uuid>` - List all backup configurations
- `coolify database backup create <database_uuid>` - Create a new backup configuration
  - `--frequency <cron>` - Backup frequency (cron expression)
  - `--enabled` - Enable backup schedule
  - `--save-s3` - Save backups to S3
  - `--s3-storage-uuid <uuid>` - S3 storage UUID
  - `--databases-to-backup <list>` - Comma-separated list of databases to backup
  - `--dump-all` - Dump all databases
  - `--retention-amount-locally <n>` - Number of backups to retain locally
  - `--retention-days-locally <n>` - Days to retain backups locally
  - `--retention-max-storage-locally <size>` - Max storage for local backups (e.g., '1GB', '500MB')
  - `--retention-amount-s3 <n>` - Number of backups to retain in S3
  - `--retention-days-s3 <n>` - Days to retain backups in S3
  - `--retention-max-storage-s3 <size>` - Max storage for S3 backups (e.g., '1GB', '500MB')
  - `--timeout <seconds>` - Backup timeout in seconds
  - `--disable-local-backup` - Disable local backup storage
- `coolify database backup update <database_uuid> <backup_uuid>` - Update a backup configuration
- `coolify database backup delete <database_uuid> <backup_uuid>` - Delete a backup configuration
- `coolify database backup trigger <database_uuid> <backup_uuid>` - Trigger an immediate backup
- `coolify database backup executions <database_uuid> <backup_uuid>` - List backup executions
- `coolify database backup delete-execution <database_uuid> <backup_uuid> <execution_uuid>` - Delete a backup execution

#### Database Environment Variables
- `coolify database env list <database_uuid>` - List all environment variables
- `coolify database env get <database_uuid> <env_uuid_or_key>` - Get a specific environment variable
- `coolify database env create <database_uuid>` - Create a new environment variable
  - `--key <key>` - Variable key (required)
  - `--value <value>` - Variable value (required)
  - `--comment <comment>` - Comment for the environment variable
  - `--is-literal` - Treat value as literal (don't interpolate variables)
  - `--is-multiline` - Value is multiline
  - `--is-shown-once` - Only show value once
- `coolify database env update <database_uuid> <env_uuid_or_key>` - Update an environment variable
  - `--value <value>` - New variable value (required)
  - `--key <key>` - New variable key (optional, for renaming)
  - Other flags same as `create`
- `coolify database env delete <database_uuid> <env_uuid>` - Delete an environment variable
  - `--force` - Skip confirmation prompt
- `coolify database env sync <database_uuid>` - Sync environment variables from a .env file
  - `-f, --file <path>` - Path to .env file (required)
  - `--is-literal` - Treat all values as literal (don't interpolate variables)
  - **Behavior**: Updates existing variables, creates missing ones. Does NOT delete variables not in the file.

#### Database Storage
- `coolify database storage list <db_uuid>` - List all storages for a database
- `coolify database storage create <db_uuid>` - Create a storage for a database
  - Same flags as `coolify app storage create`
- `coolify database storage update <db_uuid>` - Update a storage for a database
  - Same flags as `coolify app storage update`
- `coolify database storage delete <db_uuid> <storage_uuid>` - Delete a storage from a database

### Services
- `coolify service list` - List all services
- `coolify service get <uuid>` - Get service details
- `coolify service create <type>` - Create a new one-click service (e.g., `wordpress-with-mysql`, `ghost`, `n8n`)
  - `--list-types` - List all available service types
  - `--server-uuid <uuid>` - Server UUID (required)
  - `--project-uuid <uuid>` - Project UUID (required)
  - `--environment-name <name>` - Environment name (or use `--environment-uuid <uuid>`)
  - `--name <name>` - Service name
  - `--description <description>` - Service description
  - `--docker-compose <content>` - Custom Docker Compose content (for advanced customization)
  - `--destination-uuid <uuid>` - Destination UUID if server has multiple destinations
  - `--instant-deploy` - Deploy immediately after creation
- `coolify service start <uuid>` - Start a service
- `coolify service stop <uuid>` - Stop a service
- `coolify service restart <uuid>` - Restart a service
- `coolify service delete <uuid>` - Delete a service
- `coolify service logs <uuid> --sub-service-name <name>` - Get logs for a service application or database
- `coolify service move <uuid> --environment-uuid <uuid>` - Move a service to another environment
- `coolify service tag list|add|remove` - Manage service tags
- Service creation supports repeatable `--tag` and comma-separated `--tags`.

#### Service Applications
- `coolify service application list <service_uuid>` - List applications in a service
- `coolify service application get <service_uuid> <application_uuid>` - Get a service application
- `coolify service application update <service_uuid> <application_uuid>` - Update a service application
- `coolify service application logs <service_uuid> <application_uuid>` - Get application logs
- `coolify service application start|restart|stop <service_uuid> <application_uuid>` - Manage its lifecycle

#### Service Databases
- `coolify service database list <service_uuid>` - List databases in a service
- `coolify service database get <service_uuid> <database_uuid>` - Get a service database
- `coolify service database update <service_uuid> <database_uuid>` - Update metadata, image, log drain, or public access
- `coolify service database logs <service_uuid> <database_uuid>` - Get database logs
- `coolify service database start|restart|stop <service_uuid> <database_uuid>` - Manage its lifecycle

#### Service Environment Variables
- `coolify service env list <service_uuid>` - List all environment variables
- `coolify service env get <service_uuid> <env_uuid_or_key>` - Get a specific environment variable
- `coolify service env create <service_uuid>` - Create a new environment variable
  - Same flags as application environment variables, except `--preview` (not available for services)
- `coolify service env update <service_uuid> <env_uuid_or_key>` - Update an environment variable
  - `--value <value>` - Variable value (required)
  - `--key <key>` - New variable key (optional, for renaming)
  - `--build-time` - Available at build time (default: true)
  - `--runtime` - Available at runtime (default: true)
  - `--comment <comment>` - Comment for the environment variable
  - `--is-literal` - Treat value as literal (don't interpolate variables)
  - `--is-multiline` - Value is multiline
- `coolify service env delete <service_uuid> <env_uuid>` - Delete an environment variable
  - `--force` - Skip confirmation prompt
- `coolify service env sync <service_uuid>` - Sync environment variables from a .env file
  - `-f, --file <path>` - Path to .env file (required)
  - `--build-time` - Make all variables available at build time (default: true)
  - `--runtime` - Make all variables available at runtime (default: true)
  - `--is-literal` - Treat all values as literal (don't interpolate variables)
  - **Behavior**: Updates existing variables, creates missing ones. Does NOT delete variables not in the file.

#### Service Storage
- `coolify service storage list <service_uuid>` - List all storages for a service
- `coolify service storage create <service_uuid>` - Create a storage for a service
  - `--resource-uuid <uuid>` - UUID of the service application or database that owns the storage (required)
  - Other flags are the same as `coolify app storage create`
- `coolify service storage update <service_uuid>` - Update a storage for a service
  - Same flags as `coolify app storage update`
- `coolify service storage delete <service_uuid> <storage_uuid>` - Delete a storage from a service

### Deployments
- `coolify deploy uuid <uuid>` - Deploy a resource by UUID
  - `--force` - Force deployment
  - `--pull-request-id <id>` - Pull request ID for preview deployments
  - `--docker-tag <tag>` - Docker image tag override for the deployment (requires Coolify `4.0.0-beta.471+`)
- `coolify deploy name <name>` - Deploy a resource by name
  - `--force` - Force deployment
  - `--pull-request-id <id>` - Pull request ID for preview deployments
  - `--docker-tag <tag>` - Docker image tag override for the deployment (requires Coolify `4.0.0-beta.471+`)
- `coolify deploy batch <name1,name2,...>` - Deploy multiple resources at once
  - `--force` - Force all deployments
  - `--pull-request-id <id>` - Pull request ID for preview deployments
  - `--docker-tag <tag>` - Docker image tag override for the deployment (requires Coolify `4.0.0-beta.471+`)
- `coolify deploy list` - List all deployments
- `coolify deploy get <uuid>` - Get deployment details
- `coolify deploy cancel <uuid>` - Cancel a deployment
  - `-f, --force` - Skip confirmation prompt

### GitHub Apps
- `coolify github list` - List all GitHub App integrations
- `coolify github get <app_uuid>` - Get GitHub App details
- `coolify github create` - Create a new GitHub App integration
  - `--name <name>` - GitHub App name (required)
  - `--api-url <url>` - GitHub API URL (optional; defaults to GitHub's public API)
  - `--html-url <url>` - GitHub HTML URL (required, e.g., https://github.com)
  - `--app-id <id>` - GitHub App ID (required)
  - `--installation-id <id>` - GitHub Installation ID (required)
  - `--client-id <id>` - GitHub OAuth Client ID (required)
  - `--client-secret <secret>` - GitHub OAuth Client Secret (required)
  - `--private-key-uuid <uuid>` - UUID of existing private key (required)
  - `--organization <org>` - GitHub organization
  - `--custom-user <user>` - Custom user for SSH (default: git)
  - `--custom-port <port>` - Custom port for SSH (default: 22)
  - `--webhook-secret <secret>` - GitHub Webhook Secret
  - `--system-wide` - Is this app system-wide (cloud only)
- `coolify github update <app_uuid>` - Update a GitHub App
- `coolify github delete <app_uuid>` - Delete a GitHub App
  - `-f, --force` - Skip confirmation prompt
- `coolify github repos <app_uuid>` - List repositories accessible by a GitHub App
- `coolify github branches <app_uuid> <owner/repo>` - List branches for a repository

### Tags
- `coolify tag list` - List all tags for the current team

### Destinations
- `coolify destination list [--server <server_uuid>]` - List Docker network destinations
- `coolify destination get <uuid>` - Get a destination
- `coolify destination create --server <uuid> --network <name> [--type standalone|swarm]` - Create a destination
- `coolify destination delete <uuid>` - Delete an unused destination

### Cloud Provider Tokens
- `coolify cloud-token list|get|create|update|delete|validate` - Manage Hetzner, DigitalOcean, and Vultr API tokens
- Token values are redacted by default. `--show-sensitive` can reveal them only when the Coolify API token has sensitive-data permission.

### Teams
- `coolify team list` - List all teams
- `coolify team get <team_id>` - Get team details
- `coolify team current` - Get current team
- `coolify team members list [team_id]` - List team members

### Private Keys

Commands can use `private-key`, `private-keys`, `key`, or `keys` interchangeably.

- `coolify private-key list` - List all private keys
- `coolify private-key add <key_name> <private_key_or_file>` - Add a new private key
  - Pass the key content directly or a path to a key file: `coolify private-key add mykey ~/.ssh/id_rsa`
- `coolify private-key remove <uuid>` - Remove a private key

## Global Flags

All commands support these global flags:

- `--context <name>` - Use a specific context instead of default
- `--token <token>` - Override the authentication token
- `--format <format>` - Output format: `table` (default), `json`, or `pretty`
- `-s, --show-sensitive` - Show sensitive information (tokens, IPs, etc.)
- `--debug` - Enable debug mode

## Examples

### Multi-Environment Workflows

```bash
# Add multiple contexts
coolify context add prod https://prod.coolify.io <prod-token>
coolify context add staging https://staging.coolify.io <staging-token>
coolify context add dev https://dev.coolify.io <dev-token>

# Set default
coolify context use prod

# Use different contexts
coolify --context=staging servers list
coolify --context=prod deploy name api
coolify --context=dev resources list

# Default context (prod in this case)
coolify servers list
```

### Application Management

```bash
# List all applications
coolify app list

# Get application details
coolify app get <uuid>

# Create an application from a public git repository
coolify app create public --server-uuid <uuid> --project-uuid <uuid> --environment-name production \
  --git-repository "https://github.com/user/repo" --git-branch main --build-pack nixpacks --ports-exposes 3000

# Create an application from a pre-built Docker image
coolify app create dockerimage --server-uuid <uuid> --project-uuid <uuid> --environment-name production \
  --docker-registry-image-name "nginx:latest" --ports-exposes 80

# Manage application lifecycle
coolify app start <uuid>
coolify app stop <uuid>
coolify app restart <uuid>

# View application logs
coolify app logs <uuid>

# View logs for one service in a Docker Compose application
coolify app logs <uuid> --service web

# Environment variables
coolify app env list <uuid>
coolify app env create <uuid> --key API_KEY --value secret123

# Sync from .env file (updates existing, creates new, keeps others unchanged)
coolify app env sync <uuid> --file .env
coolify app env sync <uuid> --file .env.production --build-time --preview
```

### Database Management

```bash
# List databases
coolify database list

# Create a PostgreSQL database
coolify database create postgresql \
  --server-uuid <server-uuid> \
  --project-uuid <project-uuid> \
  --name mydb \
  --instant-deploy

# Manage database lifecycle
coolify database start <uuid>
coolify database stop <uuid>
coolify database restart <uuid>

# Backup management
coolify database backup list <database-uuid>
coolify database backup create <database-uuid> \
  --frequency "0 2 * * *" \
  --enabled \
  --save-s3 \
  --retention-days-locally 7
coolify database backup trigger <database-uuid> <backup-uuid>
```

### Service Management

```bash
# List services
coolify service list

# Get service details
coolify service get <uuid>

# See all available one-click service types
coolify service create --list-types

# Create a one-click service
coolify service create wordpress-with-mysql --server-uuid=<uuid> --project-uuid=<uuid> --environment-name=production

# Manage services
coolify service start <uuid>
coolify service restart <uuid>

# Environment variables (same as applications)
coolify service env sync <uuid> --file .env
```

### Deploy Workflows

```bash
# Deploy single app by name (easier than UUID)
coolify deploy name my-application

# Deploy multiple apps at once
coolify deploy batch api,worker,frontend

# Force deploy with specific context
coolify --context=prod deploy batch api,worker --force

# Deploy a preview with an explicit docker tag
coolify deploy uuid u5ualfp30j27qtfpgcen8p03 --pull-request-id 2345 --docker-tag 1.28.3

# Traditional UUID deployment still works
coolify deploy uuid abc123-def456-...

# Monitor deployments
coolify deploy list
coolify deploy get <deployment-uuid>

# Cancel a deployment
coolify deploy cancel <deployment-uuid>
```

### GitHub Apps Integration

```bash
# List GitHub Apps
coolify github list

# Create a GitHub App integration
coolify github create \
  --name "My GitHub App" \
  --api-url "https://api.github.com" \
  --html-url "https://github.com" \
  --app-id 123456 \
  --installation-id 789012 \
  --client-id "Iv1.abc123" \
  --client-secret "secret" \
  --private-key-uuid <key-uuid>

# List repositories accessible by the app
coolify github repos <app-uuid>

# List branches for a repository
coolify github branches <app-uuid> owner/repo

# Delete a GitHub App
coolify github delete <app-uuid>
```

### Team Management

```bash
# List teams
coolify team list

# Get current team
coolify team current

# List team members
coolify team members list
```

### Server Management

```bash
# List servers in production
coolify --context=prod server list

# Add a server with validation
coolify server add myserver 192.168.1.100 <key-uuid> --validate

# Get server details with resources
coolify server get <uuid> --resources
```

## Output Formats

The CLI supports three output formats:

```bash
# Table format (default, human-readable)
coolify server list

# JSON format (for scripts)
coolify server list --format=json

# Pretty JSON (for debugging)
coolify server list --format=pretty
```

## Architecture

This CLI follows a clean architecture with:
- **Service Layer**: Business logic and API interactions
- **Output Layer**: Consistent formatting across all commands
- **Config Layer**: Multi-context configuration management
- **Models Layer**: Type-safe data structures

## Development

```bash
# Build
go build -o coolify ./coolify

# Run tests
go test ./...

# Run with coverage
go test -cover ./...

# Install locally
go install ./coolify
```

## Contributing

Contributions are welcome!

## License

MIT