CLI Reference¶

All resource commands follow the pattern:

appliku <resource> <action> --team <team-path> [--app <app-id>] [options]

Most list commands support JSON output:

appliku apps list --team my-team --output json

Use --help on any command for full option details:

appliku apps --help
appliku apps logs --help

Authentication commands¶

These root-level commands manage your local session.

appliku login                        # Start browser-based login
appliku login --token YOUR_TOKEN     # Log in with an API token directly
appliku whoami                       # Show the authenticated user
appliku logout                       # Remove the saved token

teams¶

List and inspect your Appliku teams.

# List all teams you belong to
appliku teams list

# Get details for a specific team
appliku teams get my-team

Note

teams get returns the same set of fields whatever your membership level, but values you are not entitled to read come back as null:

Admins see null for the billing fields (paddle_*), can_invite_members and name_picked.
Developers additionally see null for the deploy keys (public_key, public_key_ed25519) and the notification webhook URLs (slack_webhook_url, discord_webhook_url).

A null therefore means either "not set" or "not visible to you" — for billing-related values, check as an owner before concluding a team has no subscription.

apps¶

Manage applications and fetch their logs.

# List applications in a team
appliku apps list --team my-team

Create an application¶

Create an application from GitHub, GitLab, or a custom Git repository:

# GitHub repository
appliku apps create github acme/example \
  --team my-team --name example --branch main --server 12

# GitLab project path or numeric project ID
appliku apps create gitlab group/subgroup/example \
  --team my-team --name example --branch main --cluster 7

# Custom Git repository
appliku apps create custom git@example.com:team/example.git \
  --team my-team --name example --branch main --server 12 \
  --private-key-file ~/.ssh/example_deploy_key

All three commands require exactly one positive --server or --cluster ID. Use --static-site to create a static site. Use --output json to return one JSON object with the application ID, name, provider, repository, branch, target, and static-site state.

For a custom HTTPS URL that contains credentials, do not put the URL in the command. Read it from a file or standard input:

appliku apps create custom \
  --team my-team --name example --branch main --server 12 \
  --git-url-file repository-url.txt

printf '%s\n' "$CUSTOM_GIT_URL" | appliku apps create custom \
  --team my-team --name example --branch main --server 12 \
  --git-url-file -

The command reads an SSH private key only from --private-key-file. It does not print the private key or the credential-bearing URL. Table and JSON output use only safe application fields.

Note

Create makes the application and starts the initial appliku.yml inspection. It does not deploy the application. Complete its setup, then deploy it with appliku apps deploy --team my-team --app <id>.

Deploy or restart¶

# Full deployment: clone, build, release command, then restart the processes
appliku apps deploy --team my-team --app 42

# Restart without a build
appliku apps restart --team my-team --app 42

# Only check whether a restart is possible now (exit 1 and the reason if not)
appliku apps restart --team my-team --app 42 --check

apps restart starts the images of the running deployment again with the current environment variables and process settings. It pulls no new code, builds nothing, and does not run the release command. Variables used during the build (for example NEXT_PUBLIC_*, or anything your build command reads) keep the values baked into the image; use apps deploy to change them. See Restarting Without a Build.

Both commands print the deployment ID; add --output json for JSON.

Note

apps restart needs the Appliku backend with the restart feature. The first restart of an application needs one full deployment made after that release. Static sites have nothing to restart.

Application logs¶

There are two distinct log commands:

apps logs — fetches application-level logs using an async two-step flow. Use this to get logs across one or more processes:

# Fetch logs for the web process
appliku apps logs --team my-team --app 42 --process web

# Fetch logs for multiple processes
appliku apps logs --team my-team --app 42 --process web --process celery

# Limit output to the last N lines
appliku apps logs --team my-team --app 42 --process web --tail 200

apps service-logs — fetches service logs directly in a single request. Faster, but limited to one process at a time:

appliku apps service-logs --team my-team --app 42 --service web --tail 100

Nginx and load balancer logs¶

# Fetch nginx access logs for a domain
appliku apps nginx-logs --team my-team --app 42 --domain example.com --tail 100

# Fetch load balancer logs for a domain
appliku apps load-balancer-logs --team my-team --app 42 --domain example.com --tail 100

Note

apps load-balancer-logs is only available for applications deployed to a cluster, since the load balancer is a cluster node. For an application running on a single server, use apps nginx-logs for the same per-domain access and error logs, or apps logs for the application's own output.

config¶

Manage an application's environment variables. The commands follow the Heroku CLI (heroku config, config:get, config:set, config:unset):

Heroku	Appliku
`heroku config`	`appliku config list -t TEAM -a APP`
`heroku config --json`	`appliku config list -t TEAM -a APP -o json`
`heroku config --shell`	`appliku config list -t TEAM -a APP -o shell`
`heroku config:get KEY`	`appliku config get KEY -t TEAM -a APP`
`heroku config:set A=1 B=2`	`appliku config set A=1 B=2 -t TEAM -a APP`
`heroku config:unset A B`	`appliku config unset A B -t TEAM -a APP`

# List all variables: name, value, source (Manual / Config File), mode
appliku config list --team my-team --app 42

# As one JSON object: {"NAME": "value", ...}
appliku config list --team my-team --app 42 --output json

# As POSIX shell assignments, one per line: NAME='value'
appliku config list --team my-team --app 42 --output shell

# Print one value (nothing else), for use in scripts
appliku config get DATABASE_URL --team my-team --app 42

# Set one or more variables. Variables you do not name are left alone.
appliku config set DEBUG=false LOG_LEVEL=info --team my-team --app 42

# Set and start a deployment in one step
appliku config set DEBUG=false --team my-team --app 42 --deploy

# Set and restart without a build in one step
appliku config set DEBUG=false --team my-team --app 42 --restart

# Remove variables
appliku config unset OLD_VAR OTHER_VAR --team my-team --app 42

Note

Changes take effect on the next deployment or restart. Saving does not restart the application. Pass --deploy to set or unset to start a deployment (a full build) after the change is saved, or --restart to restart without a build. Or run appliku apps deploy or appliku apps restart later. A restart applies runtime values only: variables read during the build (for example NEXT_PUBLIC_*) keep their old values until the next deployment (see Restarting Without a Build). --deploy and --restart cannot be combined, and neither runs when nothing was written. If the config is saved but the deployment or restart cannot start, the command says so and exits 1.

list

Values are shown as they resolve now. A database-linked variable shows the selected database property; a domain-linked variable shows the current domain list. The running deployment can still have older values.
Volume variables (<NAME>_ROOT, <NAME>_URL) are added at deployment time and are not shown.
--output shell is POSIX shell syntax, for eval. It is not a .env file format. The command refuses to print shell output if a variable name is not a valid shell name, or a linked value cannot be resolved; use --output json.

get

Prints the value followed by a newline. $(...) removes trailing newlines.
Exits with status 1 if the variable is not set. (Heroku prints an empty line and exits 0.) --shell prints KEY=value.

set

Each argument is KEY=VALUE, split on the first =, so values can contain =.
An empty value (KEY=) is refused: on Appliku an empty value deletes the variable. Use config unset KEY.
The same name twice in one command is refused.
Values with leading or trailing whitespace are refused for now.
Variables defined in appliku.yml cannot be changed here; change them in the file.
A variable linked to a database or to the domain list is only replaced with a static value when you pass --replace-links.
The command checks the API's answer. If a variable was not applied, it exits with status 1 and names it.
The checks before writing (appliku.yml, linked variables) are advisory. They use the state at the time of the check. If someone changes a variable between the check and the write (for example, links it to a database), the write can still replace it, and the answer check does not detect that.
--output json prints only the variables you set.

unset

Names that are not set are skipped with a warning.
Variables defined in appliku.yml cannot be removed; the command removes nothing if any name is one of them.
All names are removed in one request.

API tokens: set and unset read the variables before they write, so a token needs both env_vars read and update permissions. --deploy and --restart also need deployments create.

appliku apps delete-config-var --key KEY still works but is deprecated; use appliku config unset KEY.

deployments¶

Inspect deployments and their build logs.

# List all deployments for an app
appliku deployments list --team my-team --app 42

# Show only the latest deployment
appliku deployments latest --team my-team --app 42

# Fetch logs for a specific deployment
appliku deployments logs --team my-team --id 1234

domains¶

Manage custom domains attached to an application.

# List domains
appliku domains list --team my-team --app 42

# Add a domain
appliku domains create --team my-team --app 42 --domain example.com

# Remove a domain
appliku domains delete --team my-team --app 42 --id 7

# Verify DNS configuration for a domain
appliku domains check-dns --team my-team --app 42 --domain example.com

datastores¶

Manage attached datastores (PostgreSQL, MySQL, Redis, etc.).

appliku datastores list    --team my-team --app 42
appliku datastores start   --team my-team --app 42 --id 5
appliku datastores stop    --team my-team --app 42 --id 5
appliku datastores restart --team my-team --app 42 --id 5
appliku datastores delete  --team my-team --app 42 --id 5

volumes¶

Manage persistent volumes attached to an application.

appliku volumes list   --team my-team --app 42
appliku volumes delete --team my-team --app 42 --id 3

crons¶

Manage cron jobs for an application.

appliku crons list   --team my-team --app 42
appliku crons delete --team my-team --app 42 --id 8

clusters¶

Manage Docker Swarm clusters.

appliku clusters list   --team my-team
appliku clusters delete --team my-team --id 2

servers¶

Inspect servers attached to your team.

appliku servers list --team my-team
appliku servers get  --team my-team --id 10

invites¶

Manage pending team invitations.

appliku invites list   --team my-team
appliku invites delete --team my-team --id 4

migrations¶

Manage and inspect database migrations.

appliku migrations list --team my-team
appliku migrations logs --team my-team --id 99

ssh-keys¶

Manage the SSH public keys associated with your account. These keys are used for server access.

# List your SSH public keys
appliku ssh-keys list

# Add a new SSH public key
appliku ssh-keys add --key "ssh-rsa AAAA... user@host"

# Add your existing public key from a file
appliku ssh-keys add --key "$(cat ~/.ssh/id_ed25519.pub)"

# Remove an SSH public key by ID
appliku ssh-keys delete --id 12

Generating an SSH key pair¶

If you don't have a key yet, generate one with:

ssh-keygen -t ed25519 -C "your_email@example.com"

This creates two files: ~/.ssh/id_ed25519 (private key — keep this safe) and ~/.ssh/id_ed25519.pub (public key). Then add the public key to Appliku:

appliku ssh-keys add --key "$(cat ~/.ssh/id_ed25519.pub)"