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.

Installation

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

macOS/Linux

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

Windows (PowerShell)

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

Direct Download

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

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.

Version

To check the installed version:

akinoncli --version

Upgrading

To upgrade to the latest released version:

akinoncli --upgrade

Authentication

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
• 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:

akinoncli whoami

Switch between accounts:

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

Log out and clear stored credentials:

akinoncli logout

Using with CLI

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.

Output Formats

Every command supports:

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).

Environment Variables

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

Commands

AI Agent Integration

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:

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

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.

Account

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.

Account List

List the accounts you have access to.

akinoncli account list

Account Switch

Switch the active account.

akinoncli account switch <account_uuid>

Parameters:

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

Public Key

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

Public Key List

List the public keys registered to your account.

akinoncli publickey list

Public Key Create

Register a new public key.

akinoncli publickey create <label> <key>

Parameters:

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

Public Key Remove

Remove a registered public key.

akinoncli publickey remove <id>

Parameters:

Parameter	Description	Required
<id>	Public key ID	Yes

Application

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.

Application List

List all applications.

akinoncli applications list

Application Get

Show the details of an application.

akinoncli applications get <app_id>

Parameters:

Parameter	Description	Required
<app_id>	Application ID	Yes

Application Create

Create a new application.

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.

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

Application Build

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:

git tag 1.0
git push akinon --tags

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

Parameters:

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

Application Versions

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

akinoncli applications versions <app_id>

Parameters:

Parameter	Description	Required
<app_id>	Application ID	Yes

Application Version Logs

List application version logs.

akinoncli application version-logs <app_id> <version_id>

Parameters:

Parameter	Description	Required
<app_id>	Application ID	Yes
<version_id>	Version ID	Yes

Application Stable

Mark a version as stable.

akinoncli applications stable <app_id> <version>

Parameters:

Parameter	Description	Required
<app_id>	Application ID	Yes
<version>	Version	Yes

ApplicationType

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

ApplicationType List

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

akinoncli applicationtype list

ProjectApp

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.

ProjectApp List

List the project apps in a project.

akinoncli projectapp list <project_id>

Parameters:

Parameter	Description	Required
<project_id>	Project ID	Yes

ProjectApp Deploy

Deploy a built tag to a project app.

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

ProjectApp Add Env

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.

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.

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.

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.

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:

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.

ProjectApp Remove Env

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

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

ProjectApp Deployments

List past deployments.

akinoncli projectapp deployments <project_id> <project_app_id>

Parameters:

Parameter	Description	Required
<project_id>	Project ID	Yes
<project_app_id>	Application ID	Yes

ProjectApp Deployment Logs

Show the logs for a deployment.

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

ProjectApp Attach Certificate

Attach a certificate to a project app.

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

ProjectApp Logs

Show runtime logs, optionally filtered by process type.

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

Project

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

Project List

List projects.

akinoncli project list

Project Create

Create a new project.

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

Domain

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.

Domain List

List domains.

akinoncli domains list

Domain Create

Create a domain.

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

Certificate

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.

Certificate List

List certificates for a domain.

akinoncli certificate list <domain_id>

Parameters:

Parameter	Description	Required
<domain_id>	Domain ID	Yes

Certificate Create

Create a certificate for a domain.

akinoncli certificate create <domain_id> <fqdn>

Parameters:

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

Users

List users on the active account.

akinoncli users list

Roles

List roles on the active account.

akinoncli roles list

Email Identities

List verified sending-email identities.

akinoncli emailidentities list

AkinonCLI In Pipelines

How To Log In

The example below is a Bitbucket Pipelines example.

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

AKINON_EMAIL and AKINON_PASSWORD must be added as secured variables in the repository/workspace settings — never commit them.

How To Build and Deploy

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:

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