> For the complete documentation index, see [llms.txt](https://docs.akinon.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.akinon.com/technical-guides/acc/acc-cli/acc-cli.md).

# ACC CLI

`akinoncli` is an application designed to manage projects and applications on ACC through the command-line interface. This page covers non-interactive use — if you want to use interactive mode instead, see the [ACC TUI](/technical-guides/acc/acc-cli/acc-cli-tui.md).

## <mark style="color:red;">Installation</mark>

Install the AkinonCLI binary — no Node, Python, or any other runtime required on the target machine:

{% tabs %}
{% tab title="macOS/Linux" %}

```bash
curl -fsSL https://cli.akinoncloud.net/install.sh | bash
```

{% endtab %}

{% tab title="Windows (PowerShell)" %}

```powershell
irm https://cli.akinoncloud.net/install.ps1 | iex
```

{% endtab %}

{% tab title="Direct Download" %}

```
https://console.akinoncloud.com/cli/releases
```

{% endtab %}
{% endtabs %}

Both scripts detect your OS/architecture, download the matching signed release, verify its checksum, and install it onto `PATH` — replacing any existing `akinoncli` install in place if one is found.

### <mark style="color:red;">Version</mark>

To check the installed version:

```bash
akinoncli --version
```

### <mark style="color:red;">Upgrading</mark>

To upgrade to the latest released version:

```bash
akinoncli --upgrade
```

## <mark style="color:red;">Authentication</mark>

In order to use Akinon CLI, the user must authenticate first.

| Command | Description |
| ------- | ----------- |
| `login` | Log in      |

| Parameter          | Description                       | Required |
| ------------------ | --------------------------------- | -------- |
| `--account <uuid>` | Account UUID to activate on login | No       |

`login` behaves differently depending on the session:

* **Interactive terminal** → opens your default browser to log in. See [ACC TUI](broken://pages/6fc66e6a7b0d2faa2f05b05d4f1d96ac99b9328e)
* **Non-interactive** → if the CLI is running inside a CI/pipeline (Bitbucket, GitHub Actions, etc.), it automatically switches to non-interactive mode and prompts for your email/password instead. AkinonCLI detects when it's running inside a pipeline, honoring the `CI` environment variable (`true`/`1`).

After logging in, check who you're authenticated as:

```bash
akinoncli whoami
```

Switch between accounts:

```bash
akinoncli account list
akinoncli account switch <uuid>   # or `akinoncli account switch` for an interactive picker
```

Log out and clear stored credentials:

```bash
akinoncli logout
```

## <mark style="color:red;">Using with CLI</mark>

General parameters available across most commands:

| Parameter        | Purpose                                |
| ---------------- | -------------------------------------- |
| `-o`, `--output` | Output format: `json`\|`yaml`\|`table` |

Passing any of `-o json`, `-o yaml`, or `-o table` also forces non-interactive output even when run from a real terminal.

## <mark style="color:red;">Output Formats</mark>

Every command supports:

```bash
akinoncli project list -o json
akinoncli project list -o yaml
akinoncli project list -o table
```

`-o`/`--output` takes precedence over `AKINON_OUTPUT`, which takes precedence over the interactive default (TUI on a TTY, `table` otherwise).

## <mark style="color:red;">Environment Variables</mark>

| Variable        | Purpose                                                                |
| --------------- | ---------------------------------------------------------------------- |
| `AKINON_OUTPUT` | Default output format (`json`\|`yaml`\|`table`) when `-o` isn't passed |

## <mark style="color:red;">Commands</mark>

### <mark style="color:red;">AI Agent Integration</mark>

`akinoncli skills install` installs a quick command reference for this CLI into your AI coding agent(s). The agent then knows the available commands directly, instead of guessing:

```bash
akinoncli skills install [--tool claude|cursor|opencode]
akinoncli skills status [--tool claude|cursor|opencode]
```

<figure><img src="https://2911598027-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FlQinVPnOffBiOp126ldR%2Fuploads%2F5vTQrSUUnzOiazycg6Iu%2Fakinoncli_ai_integration.gif?alt=media&amp;token=e1c76261-11ef-4cf6-a6cb-b238c34bdc5b" alt=""><figcaption></figcaption></figure>

Without `--tool`, both commands act on all three supported tools at once:

| Tool        | Files Written                                                                                                                                                |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Claude Code | `~/.claude/skills/akinoncli/SKILL.md` + `references/command-reference.md`                                                                                    |
| Cursor      | `.cursor/rules/akinoncli.mdc` + `akinoncli-command-reference.md` (current project only — Cursor has no global rules mechanism; re-run inside other projects) |
| OpenCode    | `~/.config/opencode/AGENTS.md` (merged into markers, existing content outside them is left alone) + `akinoncli-command-reference.md`                         |

`install` reports, per tool, whether each file was created, updated, or left unchanged; `status` reports whether it's currently installed, without writing anything.

### <mark style="color:red;">Account</mark>

An account represents your organization's workspace in Akinon Cloud Commerce. All projects, applications, and resources are created and managed within the context of an account. A user can be a member of multiple accounts, for example when working with different organizations or environments, and can switch between them at any time.

#### <mark style="color:red;">Account List</mark>

List the accounts you have access to.

```bash
akinoncli account list
```

#### <mark style="color:red;">Account Switch</mark>

Switch the active account.

```bash
akinoncli account switch <account_uuid>
```

Parameters:

| Parameter | Description                                                        | Required |
| --------- | ------------------------------------------------------------------ | -------- |
| `<uuid>`  | Account UUID to switch to (opens an interactive picker if omitted) | No       |

### <mark style="color:red;">Public Key</mark>

A **Public Key** is an SSH public key registered to your account, used to authorize git-based access to your applications' repositories.

#### <mark style="color:red;">Public Key List</mark>

List the public keys registered to your account.

```bash
akinoncli publickey list
```

#### <mark style="color:red;">Public Key Create</mark>

Register a new public key.

```bash
akinoncli publickey create <label> <key>
```

Parameters:

| Parameter | Description             | Required |
| --------- | ----------------------- | -------- |
| `<label>` | A name for the key      | Yes      |
| `<key>`   | The public key contents | Yes      |

#### <mark style="color:red;">Public Key Remove</mark>

Remove a registered public key.

```bash
akinoncli publickey remove <id>
```

**Parameters:**

| Parameter | Description   | Required |
| --------- | ------------- | -------- |
| `<id>`    | Public key ID | Yes      |

### <mark style="color:red;">Application</mark>

In ACC, users can upload and publish their own applications or use applications published by other users in their projects.

To be able to publish an application, it should be managed with the Git version control system. Once the application is created in ACC, the user can send the code storage to the Git address provided if the user has added a Public Key.

For an application to be compiled and issued by ACC, the home directory should contain a file titled [akinon.json](https://docs.akinon.com/tutorials/acc/how-to-configure-your-acc-application-with-akinon.json-and-procfile).

#### <mark style="color:red;">Application List</mark>

List all applications.

```bash
akinoncli applications list
```

#### <mark style="color:red;">Application Get</mark>

Show the details of an application.

```bash
akinoncli applications get <app_id>
```

**Parameters:**

| Parameter  | Description    | Required |
| ---------- | -------------- | -------- |
| `<app_id>` | Application ID | Yes      |

#### <mark style="color:red;">Application Create</mark>

Create a new application.

```bash
akinoncli application create <name> <slug> <application_type_id>
```

**Parameters:**

| Parameter               | Description                                            | Required |
| ----------------------- | ------------------------------------------------------ | -------- |
| `<name>`                | Application Name                                       | Yes      |
| `<slug>`                | Application Slug (must be unique)                      | Yes      |
| `<application_type_id>` | Application Type ID (`akinoncli applicationtype list`) | Yes      |

To see the git address you should run `applications get` after creating the application — it's shown as the Clone URL field.

```bash
git remote add akinon <CLONE_URL>
git push akinon <branch_name>
```

#### <mark style="color:red;">Application Build</mark>

Build a new tagged version of an application. To deploy an application for a project, it needs to be built by Akinon Cloud Commerce first — a stable version is required for deployment. Create a tag with git and push it to the `akinon` remote, then start the build:

```bash
git tag 1.0
git push akinon --tags
```

```bash
akinoncli application build <app_id> <tag> [--note <note>]
```

**Parameters:**

| Parameter  | Description    | Required |
| ---------- | -------------- | -------- |
| `<app_id>` | Application ID | Yes      |
| `<tag>`    | Tag            | Yes      |
| `--note`   | Note           | No       |

#### <mark style="color:red;">Application Versions</mark>

List the built versions of the application. A version with status `completed` is ready for deployment.

```bash
akinoncli applications versions <app_id>
```

**Parameters:**

| Parameter  | Description    | Required |
| ---------- | -------------- | -------- |
| `<app_id>` | Application ID | Yes      |

#### <mark style="color:red;">Application Version Logs</mark>

List application version logs.

```bash
akinoncli application version-logs <app_id> <version_id>
```

**Parameters:**

| Parameter      | Description    | Required |
| -------------- | -------------- | -------- |
| `<app_id>`     | Application ID | Yes      |
| `<version_id>` | Version ID     | Yes      |

#### <mark style="color:red;">Application Stable</mark>

Mark a version as stable.

```bash
akinoncli applications stable <app_id> <version>
```

**Parameters:**

| Parameter   | Description    | Required |
| ----------- | -------------- | -------- |
| `<app_id>`  | Application ID | Yes      |
| `<version>` | Version        | Yes      |

### <mark style="color:red;">ApplicationType</mark>

Application types (used as `<application_type_id>` above) are account-specific — look them up first.

#### <mark style="color:red;">ApplicationType List</mark>

List the application types available on the active account, with their ids.

```bash
akinoncli applicationtype list
```

### <mark style="color:red;">ProjectApp</mark>

A **ProjectApp** is one Application installed into one Project — the actual running instance, with its own env vars, deployments, and logs. This is the deploy target.

#### <mark style="color:red;">ProjectApp List</mark>

List the project apps in a project.

```bash
akinoncli projectapp list <project_id>
```

**Parameters:**

| Parameter      | Description | Required |
| -------------- | ----------- | -------- |
| `<project_id>` | Project ID  | Yes      |

#### <mark style="color:red;">ProjectApp Deploy</mark>

Deploy a built tag to a project app.

```bash
akinoncli projectapp deploy <project_id> <project_app_id> <tag>
```

**Parameters:**

| Parameter          | Description    | Required |
| ------------------ | -------------- | -------- |
| `<project_id>`     | Project ID     | Yes      |
| `<project_app_id>` | Application ID | Yes      |
| `<tag>`            | Tag to deploy  | Yes      |

#### <mark style="color:red;">ProjectApp Add Env</mark>

The applications are able to run with different configurations on the various projects — the same application can run with a different default language on two different projects, for example. Environment Parameters are how this is configured; they're visible in the ENV Variables column when listing the applications.

```bash
akinoncli projectapp add-env <project_id> <project_app_id> <ENV_KEY>=<ENV_VALUE> [<ANOTHER_ENV_KEY>=<ANOTHER_ENV_VALUE>...] [--deploy]
```

**Parameters:**

| Parameter          | Description                                                           | Required |
| ------------------ | --------------------------------------------------------------------- | -------- |
| `<project_id>`     | Project ID                                                            | Yes      |
| `<project_app_id>` | Application ID                                                        | Yes      |
| `ENV_KEY`          | The key of the environment parameter                                  | Yes      |
| `ENV_VALUE`        | The value of the environment parameter                                | Yes      |
| `--deploy`         | Redeploy the current version to activate environment variable changes | No       |

The same command can also be used for updating.

```bash
akinoncli projectapp add-env 1 32 LANGUAGE_CODE=en-us
```

It's also possible to use complex (i.e. non-string) values by encoding them as JSON. The value must be quoted properly to function correctly.

```bash
akinoncli projectapp add-env 1 32 MIDDLEWARE='["my.custom.MiddlewareClass", "django.middleware.security.SecurityMiddleware", "whitenoise.middleware.WhiteNoiseMiddleware", "django.contrib.sessions.middleware.SessionMiddleware"]'
akinoncli projectapp add-env 1 32 THUMBNAIL_OPTIONS='{"product-list": {"width": 273, "height": 210}, "product-detail__slider_zoom": {"quality": 90}}'
```

For larger or dynamic payloads you can use the `EOF` operator in `sh`-based terminals. This also allows string interpolation without having to escape double quotes.

```bash
img_quality=90
opts=$(cat <<EOF
{
  "product-list": {
    "width": 273,
    "height": 210,
    "quality": $img_quality
  },
  "product-detail__slider_zoom": {
    "quality": $img_quality
  }
}
EOF
)

akinoncli projectapp add-env 1 32 THUMBNAIL_OPTIONS="$opts"
```

This environment variable can then be deserialized using the `django-environ` package, or `json.loads`:

```python
from environ import Env

env = Env()

DEFAULT_MIDDLEWARE = [
    "django.middleware.security.SecurityMiddleware",
    "whitenoise.middleware.WhiteNoiseMiddleware",
    "django.middleware.common.CommonMiddleware",
]
MIDDLEWARE = env.json('MIDDLEWARE', default=DEFAULT_MIDDLEWARE)  # omit `default` to throw an error if it's not set

THUMBNAIL_OPTIONS = env.json('THUMBNAIL_OPTIONS')  # throws error if THUMBNAIL_OPTIONS is not set

# print(MIDDLEWARE[0])  # prints "my.custom.MiddlewareClass"
# print(list(THUMBNAIL_OPTIONS))  # prints ["product-list", "product-detail__slider_zoom"]
```

Refer to `django-environ` documentation for further information.

#### <mark style="color:red;">ProjectApp Remove Env</mark>

Remove environment variables. `--deploy` re-triggers the current deployment immediately after the change; without it, the change takes effect on the next deploy.

```bash
akinoncli projectapp remove-env <project_id> <project_app_id> <ENV_KEY> [<ANOTHER_ENV_KEY>...] [--deploy]
```

**Parameters:**

| Parameter          | Description                                                           | Required |
| ------------------ | --------------------------------------------------------------------- | -------- |
| `<project_id>`     | Project ID                                                            | Yes      |
| `<project_app_id>` | Application ID                                                        | Yes      |
| `ENV_KEY`          | The key of the environment parameter to remove                        | Yes      |
| `--deploy`         | Redeploy the current version to activate environment variable changes | No       |

#### <mark style="color:red;">ProjectApp Deployments</mark>

List past deployments.

```bash
akinoncli projectapp deployments <project_id> <project_app_id>
```

**Parameters:**

| Parameter          | Description    | Required |
| ------------------ | -------------- | -------- |
| `<project_id>`     | Project ID     | Yes      |
| `<project_app_id>` | Application ID | Yes      |

#### <mark style="color:red;">ProjectApp Deployment Logs</mark>

Show the logs for a deployment.

```bash
akinoncli projectapp deployment-logs <project_id> <project_app_id> <deployment_id>
```

**Parameters:**

| Parameter          | Description    | Required |
| ------------------ | -------------- | -------- |
| `<project_id>`     | Project ID     | Yes      |
| `<project_app_id>` | Application ID | Yes      |
| `<deployment_id>`  | Deployment ID  | Yes      |

#### <mark style="color:red;">ProjectApp Attach Certificate</mark>

Attach a certificate to a project app.

```bash
akinoncli projectapp attach-certificate <project_id> <url> <fqdn>
```

**Parameters:**

| Parameter      | Description                 | Required |
| -------------- | --------------------------- | -------- |
| `<project_id>` | Project ID                  | Yes      |
| `<url>`        | Certificate URL             | Yes      |
| `<fqdn>`       | Fully qualified domain name | Yes      |

#### <mark style="color:red;">ProjectApp Logs</mark>

Show runtime logs, optionally filtered by process type.

```bash
akinoncli projectapp logs <project_id> <project_app_id> [-p/--process <type>]
```

**Parameters:**

| Parameter                | Description                 | Required |
| ------------------------ | --------------------------- | -------- |
| `<project_id>`           | Project ID                  | Yes      |
| `<project_app_id>`       | Application ID              | Yes      |
| `-p`, `--process <type>` | Filter logs by process type | No       |

### <mark style="color:red;">Project</mark>

A **Project** is a client's environment (e.g. "Acme Store"). A project has many project apps.

#### <mark style="color:red;">Project List</mark>

List projects.

```bash
akinoncli project list
```

#### <mark style="color:red;">Project Create</mark>

Create a new project.

```bash
akinoncli project create <name> <slug> [--mainapp-required]
```

**Parameters:**

| Parameter            | Description                           | Required |
| -------------------- | ------------------------------------- | -------- |
| `<name>`             | Project Name                          | Yes      |
| `<slug>`             | Project Slug (must be unique)         | Yes      |
| `--mainapp-required` | Require a main app on the new project | No       |

### <mark style="color:red;">Domain</mark>

A **Domain** is a hostname (optionally with managed DNS) that certificates and project apps attach to. When deploying an application and you want it to be reachable under a specific hostname with SSL, create a domain, then a certificate for it, and attach that certificate to the project app.

#### <mark style="color:red;">Domain List</mark>

List domains.

```bash
akinoncli domains list
```

#### <mark style="color:red;">Domain Create</mark>

Create a domain.

```bash
akinoncli domain create <hostname> <is_managed>
```

**Parameters:**

| Parameter      | Description                                                     | Required |
| -------------- | --------------------------------------------------------------- | -------- |
| `<hostname>`   | Hostname                                                        | Yes      |
| `<is_managed>` | Whether DNS for this domain is managed by Akinon Cloud Commerce | Yes      |

### <mark style="color:red;">Certificate</mark>

A **Certificate** is a TLS certificate for a given FQDN, scoped to a domain; attach it to a running project app with `projectapp attach-certificate`.

#### <mark style="color:red;">Certificate List</mark>

List certificates for a domain.

```bash
akinoncli certificate list <domain_id>
```

**Parameters:**

| Parameter     | Description | Required |
| ------------- | ----------- | -------- |
| `<domain_id>` | Domain ID   | Yes      |

#### <mark style="color:red;">Certificate Create</mark>

Create a certificate for a domain.

```bash
akinoncli certificate create <domain_id> <fqdn>
```

**Parameters:**

| Parameter     | Description                 | Required |
| ------------- | --------------------------- | -------- |
| `<domain_id>` | Domain ID                   | Yes      |
| `<fqdn>`      | Fully qualified domain name | Yes      |

### <mark style="color:red;">Users</mark>

List users on the active account.

```bash
akinoncli users list
```

### <mark style="color:red;">Roles</mark>

List roles on the active account.

```bash
akinoncli roles list
```

### <mark style="color:red;">Email Identities</mark>

List verified sending-email identities.

```bash
akinoncli emailidentities list
```

## <mark style="color:red;">AkinonCLI In Pipelines</mark>

### <mark style="color:red;">How To Log In</mark>

The example below is a Bitbucket Pipelines example.

```yaml
pipelines:
  branches:
    main:
      - step:
          name: Login via akinoncli
          image: node:20
          script:
            - curl -fsSL https://cli.akinoncloud.net/install.sh | bash
            - export PATH="$HOME/.local/bin:$PATH"
            - printf '%s\n%s\n' "$AKINON_EMAIL" "$AKINON_PASSWORD" | akinoncli login
```

{% hint style="warning" %}
`AKINON_EMAIL` and `AKINON_PASSWORD` must be added as secured variables in the repository/workspace settings — never commit them.
{% endhint %}

### <mark style="color:red;">How To Build and Deploy</mark>

This pipeline triggers when a new prod tag (e.g. `v0.0.1`) is pushed from master. It logs in, builds a new application version from that tag, then deploys it straight to a project app — no manual steps or browser interaction needed.

Example `bitbucket-pipelines.yml` step that builds a new tag and deploys it:

```yaml
pipelines:
  tags:
    'v*':
      - step:
          name: Build and deploy via akinoncli
          image: node:20
          script:
            - curl -fsSL https://cli.akinoncloud.net/install.sh | bash
            - export PATH="$HOME/.local/bin:$PATH"
            - printf '%s\n%s\n' "$AKINON_EMAIL" "$AKINON_PASSWORD" | akinoncli login
            - akinoncli application build $APPLICATION_ID $BITBUCKET_TAG --note "CI $BITBUCKET_BUILD_NUMBER"
            - |
              for i in $(seq 1 60); do
                status=$(akinoncli applications versions $APPLICATION_ID -o json | jq -r --arg tag "$BITBUCKET_TAG" '.results[] | select(.tag == $tag) | .status')
                if [ "$status" = "completed" ]; then
                  break
                fi
                if [ "$i" = "60" ]; then
                  echo "Build did not complete in time (last status: $status)"
                  exit 1
                fi
                sleep 10
              done
            - akinoncli projectapp deploy $PROJECT_ID $PROJECT_APP_ID $BITBUCKET_TAG
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.akinon.com/technical-guides/acc/acc-cli/acc-cli.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.