---
title: Devices
sidebar_label: devices
description: "clika-cli devices: find the machines registered with your platform, run commands on them, move files, and manage their desired state."
---

A **device** is a machine registered with your platform: a Jetson on a bench, a phone in a drawer, a workstation, a cloud instance. Each one runs the CLIKA device agent, which keeps a connection open to the orchestrator so the platform can send it work and read its state back. The `devices` group is how you inspect and drive them from a terminal.

`clika-cli devices --help` lists 59 subcommands. Most are generated one-for-one from the API, and the table at the end of this page names every one. The sections below cover the ones you will actually type.

## Registering a device from the CLI

The web dialog's registration exists as two commands here: mint an enrollment token (the body needs a `name`), then print the install script for the device's operating system and run it on the device. `install list --raw` prints the whole script, so on the device itself pipe it to `sh`.

```
clika-cli enrollment-tokens create --body '{"name":"my-laptop","max_uses":1}'
```

```
clika-cli install list --os linux --token <token> --raw | sh
```

The device is listed within a minute of the installer finishing. If the platform refuses it, the installer prints `==> ERROR: The platform refused this device` with the reason and exits 1: a used token (`TOKEN_EXHAUSTED`), a device name already registered on another identity (set `DEVICE_NAME=<another name>` in front of the command and run it again), or the plan's device limit. `enrollment-codes create` mints a short activation code instead of a token, the kind the web dialog's command carries; see [Register a device by code](../how-to/register-a-device-by-code.md).

## Finding a device

### `devices list`

```
clika-cli devices list [flags]
```

Lists the devices your project can see, newest registration first. Every filter is a flag, and filters combine with AND unless noted.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--status` | string | all | `online` or `offline`. A device is online when the orchestrator has heard from its agent recently. |
| `--platform` | string | all | `linux`, `macos`, `windows` or `android`. |
| `--search` | string | none | Free text matched against the device name, its group name, or any of its tags. |
| `--term` | string, repeatable | none | A committed free-text filter. Each term must match on its own, so terms narrow each other. |
| `--tag` | string, repeatable | none | Filter by tag. Tags that share a key (the text before the first `=`) are OR-ed together; different keys are AND-ed. A tag with no `=` narrows on its own. |
| `--search_or` | bool | `false` | Widen instead of narrow: OR the `--search` text against the tag and term filters rather than AND-ing it. Ignored when there are no tag or term filters. |
| `--group` | string | none | Filter by group name. |
| `--accelerator` | string | none | Filter by accelerator type. |
| `--gpu_model` | string | none | Filter by GPU model. |
| `--min_gpu_vram` | string | none | Minimum GPU video memory, in bytes. |
| `--min_memory` | string | none | Minimum total system memory, in bytes. |
| `--attestation_type` | string | all | The key storage the device proved it has: `tpm_attested`, `keystore_attested`, `file_backed` or `unverified`. |
| `--dirty` | string | all | `true` or `false`. A dirty device has local changes the platform did not make, and holds queued jobs until you clear the flag. |
| `--summary` | string | `false` | Pass `true` to return only `{id, name, status}` per device. Much cheaper on a large fleet, because the health snapshot, network interfaces, capabilities, resources and tags are all skipped. |
| `--sort` | string | `registered_at` | Sort column: `registered_at`, `name`, `status`, `platform` or `last_heartbeat`. |
| `--dir` | string | `desc` | Sort direction, `asc` or `desc`. |
| `--page` | string | `1` | Page number. |
| `--page_size` | string | server default | Rows per page. |
| `--raw` | bool | `false` | Print the response body byte for byte. |

```
$ clika-cli devices list --status online
NAME        STATUS   PLATFORM   LAST HEARTBEAT   TAGS
jetson-01   online   linux      12s ago          site=lab,role=bench
orin-02     online   linux      8s ago           site=lab
mac-mini-1  online   macos      31s ago          site=office
```

```
clika-cli devices list --tag site=lab --tag role=bench -o json | jq -r '.items[].name'
```

### `devices get`

```
clika-cli devices get <name-or-id>
```

Prints one device in full: its identity, platform, hardware inventory, capabilities, tags, network interfaces and the latest health snapshot. The argument accepts the device name, so you rarely need its UUID.

```
clika-cli devices get jetson-01
clika-cli devices get jetson-01 -o yaml
```

## Working on a device

These four commands are hand-written rather than generated, because each of them does something a plain API call cannot: propagate an exit code, stream a file, or hand your terminal over to `ssh`.

### `devices exec`

```
clika-cli devices exec <name-or-id> <command> [flags]
```

Runs one shell command on the device through its agent. Remote standard output goes to your standard output and remote standard error to your standard error, and the CLI exits with the remote exit code, so it composes in a script exactly like `ssh` does.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--working-dir` | string | agent default | Directory to run the command in, on the device. |
| `--shell` | string | platform default | Shell binary to run the command with. The agent picks a sensible one per platform when empty. |
| `--timeout` | int | server default | Execution timeout in seconds. The server caps it at 300. |
| `--detach` | bool | `false` | Start the command and print its id instead of waiting for it. |

```
$ clika-cli devices exec jetson-01 'nvidia-smi --query-gpu=name,memory.used --format=csv'
name, memory.used [MiB]
Orin, 1834 MiB
```

```
clika-cli devices exec jetson-01 'ls -la' --working-dir /opt/clika
clika-cli devices exec jetson-01 'sleep 5; echo done' --timeout 30
```

For anything longer than a couple of minutes, detach and pick the result up later. The command keeps running on the device whether or not the CLI is still attached, so a dropped connection no longer loses the transcript:

```
$ clika-cli devices exec jetson-01 'make -j all' --detach
5f0c1a2b-3c4d-5e6f-7081-92a3b4c5d6e7
```

### `devices command`

```
clika-cli devices command <name-or-id> <command-id> [flags]
```

Reads one command back out of the device's history: its status (`pending`, `running`, `exited` or `lost`), its exit code, and the stored transcript. Once the command has exited, this exits with the remote exit code too.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--wait` | string | not set | Block until the command reaches a terminal state. Bare `--wait` waits indefinitely; `--wait=5m` or `--wait=300` bounds it. |
| `--tail` | int | `0` | Print only the last N lines of each stream. |
| `--stdout-offset` | int | `0` | Byte offset to resume reading standard output from. The offsets reached are printed to standard error, so a poller can pass them back. |
| `--stderr-offset` | int | `0` | The same, for standard error. |

```
clika-cli devices command jetson-01 5f0c1a2b-3c4d-5e6f-7081-92a3b4c5d6e7 --wait
clika-cli devices command jetson-01 5f0c1a2b-3c4d-5e6f-7081-92a3b4c5d6e7 --tail 50
```

`devices commands <name-or-id>` lists the history rather than one entry.

### `devices push`

```
clika-cli devices push <name-or-id> <local-path> <dest-path> [flags]
```

Uploads one local file to an absolute path on the device. A `<dest-path>` ending in `/` keeps the local file name. The upload streams, so a multi-gigabyte file never has to fit in memory.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--permissions` | string | agent default | Octal file mode to set on the device, for example `0755`. |
| `--mkdir-parents` | bool | `false` | Create missing parent directories on the device. |

```
clika-cli devices push jetson-01 ./run.sh /opt/clika/run.sh --permissions 0755
clika-cli devices push jetson-01 ./config.yaml /etc/clika/ --mkdir-parents
```

Pushing a file the platform already stores is a different command. `devices files-push-from-library` sends an existing [artifact](artifacts.md) to the device without it passing through your machine at all.

### `devices files-fetch`

```
clika-cli devices files-fetch <name-or-id> <remote-path> [dest] [flags]
```

Downloads a file or a directory from the device. With no `[dest]` the file lands in the current directory under its remote name.

The download is verified end to end. A single file is checked against the SHA-256 the device computed while reading its own disk, echoed on success so you can keep it; a `--recursive` directory is checked against the checksum of the archive the server assembled. An older agent that declares no checksum completes the fetch unverified rather than failing it.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--recursive` | bool | `false` | Fetch a directory, packed as a `tar.gz`. |
| `--tail-bytes` | int | `0` | Print only the last N bytes to standard output, instead of writing a file. Useful for peeking at a log. |

```
clika-cli devices files-fetch jetson-01 /var/log/agent.log ./agent.log
clika-cli devices files-fetch jetson-01 /data/results/run-42 --recursive
clika-cli devices files-fetch jetson-01 /var/log/agent.log --tail-bytes 4096
```

`devices files <name-or-id> --path /some/dir` lists a directory without downloading anything.

### `devices connect`

```
clika-cli devices connect <name-or-id> [flags]
```

Fetches the device's SSH details from the orchestrator and then replaces the CLI process with the `ssh` command it suggests, so your terminal behaves exactly as if you had typed that `ssh` yourself. On Windows, which has no process-replacing exec, the `ssh` client is launched as a child process instead.

This needs an `ssh` client on your `PATH` and direct network reachability to the device. The orchestrator reports whether it believes you are on the same network, but it cannot route for you.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--dry-run` | bool | `false` | Print the `ssh` command instead of running it. |

```
$ clika-cli devices connect jetson-01 --dry-run
ssh -p 22 clika@192.168.10.24
```

## Desired state

The platform keeps a **desired state** per device: the configuration, the jobs and the services it should be running. The agent reconciles the device towards it and reports what actually happened. That is why a change here is a request, not an instruction that takes effect the moment the command returns.

| Command | What it does |
| --- | --- |
| `devices desired-state <name-or-id>` | The whole desired state in one document. |
| `devices desired-state-config <name-or-id>` | The desired agent configuration on its own. |
| `devices desired-state-config-update <name-or-id> --body '<json>'` | Set the desired agent configuration. |
| `devices desired-state-jobs <name-or-id>` | The jobs the device should be running. |
| `devices desired-state-jobs-update-job_name <name-or-id> <job_name> --body '<json>'` | Add or change one desired job. |
| `devices desired-state-jobs-delete-job_name <name-or-id> <job_name>` | Remove one desired job. |
| `devices desired-state-services <name-or-id>` | The services the device should be running. |
| `devices desired-state-services-update-svc_id <name-or-id> <svc_id> --body '<json>'` | Set one desired service state. |
| `devices desired-state-services-delete-svc_id <name-or-id> <svc_id>` | Remove one desired service state. |
| `devices reconcile <name-or-id>` | Ask the agent to reconcile now instead of at its next cycle. |
| `devices reconciliation-log <name-or-id>` | What the agent did on its recent reconciliation passes, and why. |

When a device has been changed outside the platform, the orchestrator marks it **dirty** and holds its queued jobs rather than running them against an unknown state. Inspect it, then release the queue:

```
clika-cli devices list --dirty true
clika-cli devices clear-dirty jetson-01
```

## Health, power and hardware

| Command | What it does |
| --- | --- |
| `devices health <name-or-id>` | The latest health snapshot: reachability, load, temperature, disk and memory as the agent last reported them. |
| `devices health-history <name-or-id>` | The same, over time. |
| `devices health-probe <name-or-id>` | Ask for a fresh probe now rather than waiting for the next report. |
| `devices resources <name-or-id>` | Refresh the stored hardware inventory (CPU, memory, accelerators). |
| `devices power <name-or-id> --body '{"policy":"prevent_sleep"}'` | Set the power policy. `prevent_sleep` keeps a laptop or phone awake for long runs; an empty policy restores the default. |
| `devices job-queue <name-or-id>` | The jobs queued for this device. |
| `devices job-queue-delete <name-or-id>` | Clear the queue. |
| `devices benchmarks <name-or-id>` | The benchmarks that have run on this device. |

## Services on a device

A **service** is a long-running process the platform keeps alive on a device, as opposed to a job, which runs and finishes. See [job definitions](job-definitions.md) for how one is described.

| Command | What it does |
| --- | --- |
| `devices services <name-or-id>` | List the services on the device. |
| `devices services-create <name-or-id> --body '<json>'` | Start a service. |
| `devices services-svc_id <name-or-id> <svc_id>` | Get one service. |
| `devices services-restart <name-or-id> <svc_id>` | Restart it. |
| `devices services-stop <name-or-id> <svc_id>` | Stop it. |
| `devices services-delete-svc_id <name-or-id> <svc_id>` | Remove it. |
| `devices services-update <name-or-id> <svc_id> --body '<json>'` | Update the artifacts it runs. |
| `devices services-artifacts <name-or-id> <svc_id>` | Whether its artifacts have arrived on the device. |
| `devices services-events <name-or-id> <svc_id>` | Its lifecycle events. |

## Agent updates and certificates

Each device agent can be updated from the platform, and each one holds a client certificate that identifies it.

| Command | What it does |
| --- | --- |
| `devices update-create <name-or-id>` | Trigger an agent update on one device. |
| `devices batch-update` | Trigger an agent update on many devices at once. |
| `devices update-history <name-or-id>` | Past agent updates and their outcome. |
| `devices update-policy <name-or-id>` | The device's update policy. |
| `devices update-policy-update <name-or-id> --body '<json>'` | Set that policy. |
| `devices cert-status <name-or-id>` | The device certificate's validity and expiry. |
| `devices revoke-cert <name-or-id>` | Revoke it. The device cannot reconnect until it re-enrolls. |
| `devices ssh-info <name-or-id>` | The SSH connection details `devices connect` uses. |
| `devices ssh-keys <name-or-id> --body '<json>'` | Replace the authorized keys the agent installs. |
| `devices engine-package <name-or-id>` | Provision the inference engine package onto the device. |

## Tags and tag scripts

Tags are `key=value` labels you attach to devices and then filter on. A **tag script** is a script the platform runs automatically on every device carrying a given tag, which is how a fleet stays consistent without anyone logging in.

| Command | What it does |
| --- | --- |
| `devices tags` | Every tag in use across the fleet. |
| `devices tags-starred` | The tags pinned to the top of the web app's filters. |
| `devices tags-starred-update --body '<json>'` | Replace the starred set. |
| `devices run-tag-scripts <name-or-id>` | Run this device's tag scripts now. |
| `devices tag-script-runs <name-or-id>` | The device's tag-script run history. |
| `tag-scripts list` | All tag scripts. |
| `tag-scripts get <id>` | One tag script. |
| `tag-scripts create --body '<json>'` | Create one. |
| `tag-scripts update <id> --body '<json>'` | Change one. |
| `tag-scripts toggle <id>` | Enable or disable one without deleting it. |
| `tag-scripts delete <id>` | Delete one. |

## Enrolling a new device

A device joins the platform by presenting an **enrollment token**: a single credential that authorizes it to register and receive its own certificate. You mint the token, the device uses it once, and the certificate takes over from there.

| Command | What it does |
| --- | --- |
| `enrollment-tokens create --body '<json>'` | Mint a token. |
| `enrollment-tokens list` | Every token, used and unused. |
| `enrollment-tokens get <id>` | One token. |
| `enrollment-tokens qr <id>` | The QR code form, which is how a phone enrolls. |
| `enrollment-tokens revoke <id>` | Revoke it. The row is kept with a `revoked_at` timestamp rather than deleted, so the audit trail survives. |

## Hosted devices

Not every target has to be a machine you own. **Hosted devices** are phones and boards rented from a cloud device farm for the length of a run.

| Command | What it does |
| --- | --- |
| `hosted-devices backends` | Which hosted-device backends this deployment has enabled. |
| `hosted-devices list` | The hosted fleet available to you. |
| `hosted-devices runs` | Hosted-device runs, past and present. |
| `hosted-devices runs-create --body '<json>'` | Start a benchmark run on hosted devices. |
| `hosted-devices runs-id <id>` | One run. |
| `hosted-devices runs-stop <id>` | Stop a run early. |
| `hosted-devices runs-delete-id <id>` | Delete a run record. |
| `hosted-devices runnable-types` | The benchmark types hosted devices can run. |
| `hosted-devices legs-telemetry` | A hosted leg's self-reported telemetry. |

A benchmark group can mix both kinds of target, and `benchmarks watch` follows registered-device legs and hosted-device legs alike. See [benchmarks](benchmarks.md).

## Deleting devices

```
clika-cli devices delete <name-or-id>
clika-cli devices batch-delete --body '<json>'
```

Deleting a device also deletes its job history, so both commands prompt for confirmation. Pass `-y` to skip the prompt; in a script the CLI refuses to proceed without it.

## Subcommand index

Every subcommand, as a quick index. The full detail for each one, with its flags and the API operation it dispatches, is in the [full command reference](#full-command-reference) below.

| Subcommand | Purpose |
| --- | --- |
| `batch-delete` | Delete several devices at once. |
| `batch-update` | Update the agent on several devices at once. |
| `benchmarks` | Benchmarks that ran on this device. |
| `cert-status` | Device certificate validity. |
| `clear-dirty` | Clear the dirty flag and release queued jobs. |
| `command` | Read one recorded command: status, exit code, transcript. |
| `commands` | List the device's command history. |
| `commands-cid` | Get one command by id, generated form of `command`. |
| `connect` | Open an SSH session to the device. |
| `delete` | Delete the device and its job history. |
| `desired-state` | Full desired state. |
| `desired-state-config` | Desired agent configuration. |
| `desired-state-config-update` | Set desired agent configuration. |
| `desired-state-jobs` | Desired jobs. |
| `desired-state-jobs-delete-job_name` | Remove one desired job. |
| `desired-state-jobs-update-job_name` | Set one desired job. |
| `desired-state-services` | Desired services. |
| `desired-state-services-delete-svc_id` | Remove one desired service. |
| `desired-state-services-update-svc_id` | Set one desired service. |
| `engine-package` | Provision the engine package. |
| `exec` | Run a shell command on the device. |
| `files` | List a directory on the device. |
| `files-fetch` | Download a file or directory from the device. |
| `files-push` | Generated file upload, form fields as flags. |
| `files-push-from-library` | Push a stored artifact to the device. |
| `get` | Get one device. |
| `health` | Latest health snapshot. |
| `health-history` | Health over time. |
| `health-probe` | Probe health now. |
| `job-queue` | Jobs queued for the device. |
| `job-queue-delete` | Clear that queue. |
| `list` | List devices. |
| `power` | Set the power policy. |
| `push` | Upload a local file to the device. |
| `reconcile` | Force a reconciliation pass. |
| `reconciliation-log` | Reconciliation history. |
| `resources` | Refresh the hardware inventory. |
| `revoke-cert` | Revoke the device certificate. |
| `run-tag-scripts` | Run the device's tag scripts. |
| `services` | Services on the device. |
| `services-artifacts` | Artifact status for one service. |
| `services-create` | Start a service. |
| `services-delete-svc_id` | Delete a service. |
| `services-events` | Service lifecycle events. |
| `services-restart` | Restart a service. |
| `services-stop` | Stop a service. |
| `services-svc_id` | Get one service. |
| `services-update` | Update a service's artifacts. |
| `ssh-info` | SSH connection details. |
| `ssh-keys` | Replace authorized keys. |
| `tag-script-runs` | Tag-script runs for this device. |
| `tags` | All device tags. |
| `tags-starred` | Starred tags. |
| `tags-starred-update` | Replace starred tags. |
| `update-create` | Trigger an agent update. |
| `update-history` | Agent update history. |
| `update-policy` | Get the update policy. |
| `update-policy-update` | Set the update policy. |
| `update-put` | Update device metadata such as its name. |

<!-- BEGIN GENERATED COMMAND REFERENCE (NOTES/gen-cli-reference.py) -->

## Full command reference

Every command below is generated from the deployment's own API description, so
one subcommand is exactly one platform operation. Each entry names the method,
the endpoint and the [MCP](mcp.md) tool name, so the same operation is
identifiable whichever surface you drive it from. Path parameters are positional
arguments, query parameters are flags, and a request body is `--body` or
`--body-file`. The hand-written commands, the ones that stream, propagate an
exit code, or hand your terminal to `ssh`, carry no operation line.

The prose above covers the commands most people reach for. This section is the
complete surface, for when you need the flag you have not used before.

### `clika-cli devices`

`devices` has 67 subcommands.

#### `clika-cli devices batch-delete`

Batch delete devices

```
clika-cli devices batch-delete [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices batch-update`

Batch update agent on multiple devices

```
clika-cli devices batch-update [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices benchmark-groups`

List benchmark groups that ran on a device

```
clika-cli devices benchmark-groups <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--page` | string | none | Page number (default: 1) |
| `--page_size` | string | `25, max 200` | Items per page |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices benchmarks`

List benchmarks run on a device

```
clika-cli devices benchmarks <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices cert-status`

Get device cert status

```
clika-cli devices cert-status <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices clear-dirty`

Clear device dirty state

```
clika-cli devices clear-dirty <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices command`

Reads one command from the device's history: status (pending|running|exited|lost), exit code, and the stored transcript. Remote stdout goes to stdout and stderr to stderr, and once the command has exited this exits with the remote exit code.

```
clika-cli devices command <name-or-id> <command-id> [flags]
```

Positional arguments: required `<name-or-id>`, `<command-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--stderr-offset` | int | none | byte offset to read stderr from (from a previous read) |
| `--stdout-offset` | int | none | byte offset to read stdout from (from a previous read) |
| `--tail` | int | none | print only the last N lines of each stream |

#### `clika-cli devices commands`

List device command history

```
clika-cli devices commands <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--page` | string | none | Page number (default: 1) |
| `--page_size` | string | none | Items per page (default: 20, max: 500) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices commands-cid`

Get one device command

```
clika-cli devices commands-cid <name-or-id> <cid> [flags]
```

Positional arguments: required `<name-or-id>`, `<cid>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |
| `--seen` | string | none | Last observed status; the wait also ends as soon as the current status differs |
| `--stderr_offset` | string | `0` | Byte offset to read stderr from |
| `--stdout_offset` | string | `0` | Byte offset to read stdout from |
| `--tail_lines` | string | none | Return only the last N lines of each stream (mutually exclusive with offsets) |
| `--wait_s` | string | none | Long-poll up to this many seconds for the command to reach a terminal state (clamped to the deployment ceiling) |

#### `clika-cli devices connect`

Fetches the device's SSH info from the orchestrator and executes the suggested ssh command, replacing this process. Requires an ssh client on PATH and network reachability to the device, the orchestrator reports whether it believes you are on the same network.

```
clika-cli devices connect <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--dry-run` | bool | `false` | print the ssh command instead of running it |

#### `clika-cli devices delete`

Delete device

```
clika-cli devices delete <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices desired-state`

Get device desired state

```
clika-cli devices desired-state <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices desired-state-config`

Get desired config for device

```
clika-cli devices desired-state-config <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices desired-state-config-update`

Set desired config for device

```
clika-cli devices desired-state-config-update <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices desired-state-jobs`

Get desired jobs for device

```
clika-cli devices desired-state-jobs <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices desired-state-jobs-delete-job_name`

Remove desired job for device

```
clika-cli devices desired-state-jobs-delete-job_name <name-or-id> <job_name> [flags]
```

Positional arguments: required `<name-or-id>`, `<job_name>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices desired-state-jobs-update-job_name`

Set desired job for device

```
clika-cli devices desired-state-jobs-update-job_name <name-or-id> <job_name> [flags]
```

Positional arguments: required `<name-or-id>`, `<job_name>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices desired-state-services`

List desired services for device

```
clika-cli devices desired-state-services <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices desired-state-services-delete-svc_id`

Remove desired service state

```
clika-cli devices desired-state-services-delete-svc_id <name-or-id> <svc_id> [flags]
```

Positional arguments: required `<name-or-id>`, `<svc_id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices desired-state-services-update-svc_id`

Set desired service state

```
clika-cli devices desired-state-services-update-svc_id <name-or-id> <svc_id> [flags]
```

Positional arguments: required `<name-or-id>`, `<svc_id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices engine-package`

Provision the engine package onto a device

```
clika-cli devices engine-package <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices exec`

Runs a command on the device via its agent and prints the result. Remote stdout goes to stdout and stderr to stderr, and this command exits with the remote exit code, so it composes in scripts.

```
clika-cli devices exec <name-or-id> <command> [flags]
```

Positional arguments: required `<name-or-id>`, `<command>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--detach` | bool | `false` | start the command and print its id instead of waiting |
| `--shell` | string | none | shell binary (agent picks a platform default when empty) |
| `--timeout` | int | none | execution timeout in seconds (server max 300) |
| `--working-dir` | string | none | working directory on the device |

#### `clika-cli devices files`

List directory on device

```
clika-cli devices files <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--path` | string | none | Absolute path to list on device |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices files-fetch`

Downloads a file from the device to `<dest>` (default: the current directory, keeping the remote file name). The download is verified end-to-end from the response trailer: a single file against the SHA-256 the device computed while reading its disk (echoed on success for your own records), a --recursive directory against the server-assembled tar.gz checksum. Old agents declare no checksum, the fetch then completes unverified rather than failing. With --tail-bytes N only the last N bytes are printed to stdout.

```
clika-cli devices files-fetch <name-or-id> <remote-path> [dest] [flags]
```

Positional arguments: required `<name-or-id>`, `<remote-path>`; optional `[dest]`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--recursive` | bool | `false` | fetch a directory as a tar.gz archive |
| `--tail-bytes` | int | none | print only the last N bytes (text) to stdout |

#### `clika-cli devices files-push`

Push file to device

```
clika-cli devices files-push <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices files-push-from-library`

Push artifact from library to device

```
clika-cli devices files-push-from-library <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--async` | string | none | When true, return 202 with a transfer_id immediately and run the transfer in the background; poll GET /api/transfers/{transfer_id}. When absent, the call blocks until completion (the pre-existing behaviour). |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices get`

Get device

```
clika-cli devices get <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices health`

Get device health

```
clika-cli devices health <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices health-history`

Get device health history

```
clika-cli devices health-history <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--duration` | string | none | Relative window: 1h, 6h, 24h, 7d, 30d |
| `--from` | string | none | Range start (RFC3339, used when duration absent) |
| `--interval` | string | none | Downsampling bucket size in seconds. Floored at the range divided by 2000, so one read answers at most 2000 points; a smaller value is widened, not refused. |
| `--raw` | bool | `false` | print raw response without pretty-printing |
| `--to` | string | none | Range end (RFC3339, used when duration absent) |

#### `clika-cli devices health-probe`

Probe device health on demand

```
clika-cli devices health-probe <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |
| `--wait_s` | string | `5, clamped to 1-10` | Seconds to wait for the agent's reply |

#### `clika-cli devices job-queue`

Get device job queue

```
clika-cli devices job-queue <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices job-queue-delete`

Clear device job queue

```
clika-cli devices job-queue-delete <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices list`

List devices

```
clika-cli devices list [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--accelerator` | string | none | Filter by accelerator type |
| `--attestation_type` | string | none | Filter by the device's verified key-storage medium: tpm_attested, keystore_attested, file_backed, unverified |
| `--dir` | string | none | Sort direction: desc (default), asc |
| `--dirty` | string | none | Filter by dirty state (true/false) |
| `--gpu_model` | string | none | Filter by GPU model |
| `--group` | string | none | Filter by group name |
| `--min_gpu_vram` | string | none | Minimum GPU VRAM bytes |
| `--min_memory` | string | none | Minimum total memory bytes |
| `--page` | string | none | Page number (default: 1) |
| `--page_size` | string | none | Items per page |
| `--platform` | string | none | Filter by platform: linux, macos, windows, android |
| `--raw` | bool | `false` | print raw response without pretty-printing |
| `--search` | string | none | Search by name, group name or tag |
| `--search_or` | search | none | When true, search is OR-ed against the combined tag+term filters instead of AND-ed, so in-flight text widens the committed filter set. Ignored when there are no tag or term filters. |
| `--sort` | string | none | Sort column: registered_at (default), name, status, platform, last_heartbeat |
| `--status` | string | none | Filter by status: online, offline, provisioning, error (the last two are cloud devices whose VM is still launching or failed to launch) |
| `--summary` | string | none | Pass 'true' to return only {id, name, status} per device instead of the full row. Filtering, sorting and pagination are unchanged; the health snapshot, network interfaces, capabilities, resources and tags are omitted, and the health lookup they require is skipped. Any other value returns the full row. |
| `--tag` | string | none | Filter by tag (repeatable). Tags sharing a key (the text before the first '=') are OR-ed; different keys are AND-ed. Tags without '=' each narrow the result on their own. |
| `--term` | string | none | Committed free-text filter (repeatable). Each term must match the device's name, group name or a tag, so terms AND with each other and with the tag filters. |

#### `clika-cli devices power`

Set device power policy

```
clika-cli devices power <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices push`

Uploads a local file to an absolute path on the device. A `<dest-path>` ending in '/' keeps the local file name.

```
clika-cli devices push <name-or-id> <local-path> <dest-path> [flags]
```

Positional arguments: required `<name-or-id>`, `<local-path>`, `<dest-path>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--mkdir-parents` | bool | `false` | create missing parent directories on the device |
| `--permissions` | string | none | octal file mode on the device (e.g. 0755) |

#### `clika-cli devices reconcile`

Force reconciliation

```
clika-cli devices reconcile <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices reconciliation-log`

Get reconciliation log

```
clika-cli devices reconciliation-log <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--limit` | string | none | Max records to return (default: 100) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices resources`

Update device resource inventory

```
clika-cli devices resources <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices revoke-cert`

Revoke device certificate

```
clika-cli devices revoke-cert <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices run-tag-scripts`

Run tag scripts on device

```
clika-cli devices run-tag-scripts <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices services`

List services on device

```
clika-cli devices services <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices services-artifacts`

Get service artifact status

```
clika-cli devices services-artifacts <name-or-id> <svc_id> [flags]
```

Positional arguments: required `<name-or-id>`, `<svc_id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices services-create`

Start service on device

```
clika-cli devices services-create <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices services-delete-svc_id`

Delete service on device

```
clika-cli devices services-delete-svc_id <name-or-id> <svc_id> [flags]
```

Positional arguments: required `<name-or-id>`, `<svc_id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices services-events`

List service events

```
clika-cli devices services-events <name-or-id> <svc_id> [flags]
```

Positional arguments: required `<name-or-id>`, `<svc_id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--limit` | string | none | Max events to return (default: 100, max: 1000) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices services-restart`

Restart service on device

```
clika-cli devices services-restart <name-or-id> <svc_id> [flags]
```

Positional arguments: required `<name-or-id>`, `<svc_id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices services-stop`

Stop service on device

```
clika-cli devices services-stop <name-or-id> <svc_id> [flags]
```

Positional arguments: required `<name-or-id>`, `<svc_id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices services-svc_id`

Get service on device

```
clika-cli devices services-svc_id <name-or-id> <svc_id> [flags]
```

Positional arguments: required `<name-or-id>`, `<svc_id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices services-update`

Update service artifacts on device

```
clika-cli devices services-update <name-or-id> <svc_id> [flags]
```

Positional arguments: required `<name-or-id>`, `<svc_id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices session`

An exec session keeps one shell alive on the device: cd and exports persist between commands, background processes stay anchored to the live shell (and visible to the next command), and commands may run unbounded. The session survives this CLI exiting, reconnect and keep using the same session id.

#### `clika-cli devices sessions`

List exec sessions

```
clika-cli devices sessions <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--all` | string | none | Include closed sessions |
| `--page` | string | none | Page number (default: 1) |
| `--page_size` | string | none | Items per page |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices sessions-create`

Open an exec session

```
clika-cli devices sessions-create <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices sessions-delete-sid`

Close an exec session

```
clika-cli devices sessions-delete-sid <name-or-id> <sid> [flags]
```

Positional arguments: required `<name-or-id>`, `<sid>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices sessions-exec`

Run a command in an exec session

```
clika-cli devices sessions-exec <name-or-id> <sid> [flags]
```

Positional arguments: required `<name-or-id>`, `<sid>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices sessions-sid`

Get one exec session

```
clika-cli devices sessions-sid <name-or-id> <sid> [flags]
```

Positional arguments: required `<name-or-id>`, `<sid>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices sessions-signal`

Signal an exec session's running command

```
clika-cli devices sessions-signal <name-or-id> <sid> [flags]
```

Positional arguments: required `<name-or-id>`, `<sid>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices ssh-info`

Get SSH connection info

```
clika-cli devices ssh-info <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices ssh-keys`

Update SSH authorized keys

```
clika-cli devices ssh-keys <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices tag-script-runs`

List tag script runs for device

```
clika-cli devices tag-script-runs <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--limit` | string | none | Max records to return (default: 100, max: 1000) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices tags`

List device tags

```
clika-cli devices tags [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices tags-starred`

List starred device tags

```
clika-cli devices tags-starred [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices tags-starred-update`

Replace starred device tags

```
clika-cli devices tags-starred-update [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices update`

Update device

```
clika-cli devices update <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices update-agent`

Trigger agent update on device

```
clika-cli devices update-agent <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices update-history`

Get device agent update history

```
clika-cli devices update-history <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--limit` | string | none | Max records to return (default: 50) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices update-policy`

Get device update policy

```
clika-cli devices update-policy <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

#### `clika-cli devices update-policy-update`

Set device update policy

```
clika-cli devices update-policy-update <name-or-id> [flags]
```

Positional arguments: required `<name-or-id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

### `clika-cli enrollment-tokens`

`enrollment-tokens` has 5 subcommands.

#### `clika-cli enrollment-tokens create`

Create enrollment token

```
clika-cli enrollment-tokens create [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `POST /api/enrollment-tokens`. MCP tool name: `post_enrollment_tokens`.

#### `clika-cli enrollment-tokens get`

Get enrollment token

```
clika-cli enrollment-tokens get <id> [flags]
```

Positional arguments: required `<id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `GET /api/enrollment-tokens/{id}`. MCP tool name: `get_enrollment_tokens_id`.

#### `clika-cli enrollment-tokens list`

List enrollment tokens

```
clika-cli enrollment-tokens list [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `GET /api/enrollment-tokens`. MCP tool name: `get_enrollment_tokens`.

#### `clika-cli enrollment-tokens qr`

Get enrollment QR code

```
clika-cli enrollment-tokens qr <id> [flags]
```

Positional arguments: required `<id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `GET /api/enrollment-tokens/{id}/qr`. MCP tool name: `get_enrollment_tokens_id_qr`.

#### `clika-cli enrollment-tokens revoke`

Revoke enrollment token

```
clika-cli enrollment-tokens revoke <id> [flags]
```

Positional arguments: required `<id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `DELETE /api/enrollment-tokens/{id}`. MCP tool name: `delete_enrollment_tokens_id`.

### `clika-cli enrollment-codes`

`enrollment-codes` has 2 subcommands.

#### `clika-cli enrollment-codes create`

Create enrollment code

```
clika-cli enrollment-codes create [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `POST /api/enrollment-codes`. MCP tool name: `post_enrollment_codes`.

#### `clika-cli enrollment-codes delete`

Revoke enrollment code

```
clika-cli enrollment-codes delete <id> [flags]
```

Positional arguments: required `<id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `DELETE /api/enrollment-codes/{id}`. MCP tool name: `delete_enrollment_codes_id`.

### `clika-cli hosted-devices`

`hosted-devices` has 9 subcommands.

#### `clika-cli hosted-devices backends`

List the enabled hosted-device backends

```
clika-cli hosted-devices backends [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `GET /api/hosted-devices/backends`. MCP tool name: `get_hosted_devices_backends`.

#### `clika-cli hosted-devices legs-telemetry`

Get a hosted leg's self-reported telemetry

```
clika-cli hosted-devices legs-telemetry <id> [flags]
```

Positional arguments: required `<id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `GET /api/hosted-devices/legs/{id}/telemetry`. MCP tool name: `get_hosted_devices_legs_id_telemetry`.

#### `clika-cli hosted-devices list`

List the hosted device fleet

```
clika-cli hosted-devices list [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--backend` | string | none | Which hosted-device backend to list (device_farm \| test_lab); omit when only one is enabled, required when more than one is |
| `--raw` | bool | `false` | print raw response without pretty-printing |
| `--refresh` | string | none | Set to 1 to bypass the server-side cache and re-fetch the fleet |

Endpoint: `GET /api/hosted-devices`. MCP tool name: `get_hosted_devices`.

#### `clika-cli hosted-devices runnable-types`

List the benchmark types hosted devices can run

```
clika-cli hosted-devices runnable-types [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `GET /api/hosted-devices/runnable-types`. MCP tool name: `get_hosted_devices_runnable_types`.

#### `clika-cli hosted-devices runs`

List hosted-device runs

```
clika-cli hosted-devices runs [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--benchmark_group_id` | string | none | Filter to the runs created by one benchmark group (UUID) |
| `--page` | string | none | Page number (default: 1) |
| `--per_page` | string | none | Items per page (default: 20) |
| `--raw` | bool | `false` | print raw response without pretty-printing |
| `--status` | string | none | Filter by status (pending\|uploading\|scheduling\|queued\|running\|collecting\|completed\|failed\|stopped) |

Endpoint: `GET /api/hosted-devices/runs`. MCP tool name: `get_hosted_devices_runs`.

#### `clika-cli hosted-devices runs-create`

Start a benchmark run on hosted devices

```
clika-cli hosted-devices runs-create [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `POST /api/hosted-devices/runs`. MCP tool name: `post_hosted_devices_runs`.

#### `clika-cli hosted-devices runs-delete-id`

Delete a hosted-device run

```
clika-cli hosted-devices runs-delete-id <id> [flags]
```

Positional arguments: required `<id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `DELETE /api/hosted-devices/runs/{id}`. MCP tool name: `delete_hosted_devices_runs_id`.

#### `clika-cli hosted-devices runs-id`

Get a hosted-device run

```
clika-cli hosted-devices runs-id <id> [flags]
```

Positional arguments: required `<id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `GET /api/hosted-devices/runs/{id}`. MCP tool name: `get_hosted_devices_runs_id`.

#### `clika-cli hosted-devices runs-stop`

Stop a hosted-device run

```
clika-cli hosted-devices runs-stop <id> [flags]
```

Positional arguments: required `<id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `POST /api/hosted-devices/runs/{id}/stop`. MCP tool name: `post_hosted_devices_runs_id_stop`.

### `clika-cli tag-scripts`

`tag-scripts` has 6 subcommands.

#### `clika-cli tag-scripts create`

Create tag script

```
clika-cli tag-scripts create [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `POST /api/tag-scripts`. MCP tool name: `post_tag_scripts`.

#### `clika-cli tag-scripts delete`

Delete tag script

```
clika-cli tag-scripts delete <id> [flags]
```

Positional arguments: required `<id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `DELETE /api/tag-scripts/{id}`. MCP tool name: `delete_tag_scripts_id`.

#### `clika-cli tag-scripts get`

Get tag script

```
clika-cli tag-scripts get <id> [flags]
```

Positional arguments: required `<id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `GET /api/tag-scripts/{id}`. MCP tool name: `get_tag_scripts_id`.

#### `clika-cli tag-scripts list`

List tag scripts

```
clika-cli tag-scripts list [flags]
```

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `GET /api/tag-scripts`. MCP tool name: `get_tag_scripts`.

#### `clika-cli tag-scripts toggle`

Toggle tag script enabled state

```
clika-cli tag-scripts toggle <id> [flags]
```

Positional arguments: required `<id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `POST /api/tag-scripts/{id}/toggle`. MCP tool name: `post_tag_scripts_id_toggle`.

#### `clika-cli tag-scripts update`

Update tag script

```
clika-cli tag-scripts update <id> [flags]
```

Positional arguments: required `<id>`.

| Flag | Type | Default | Meaning |
| --- | --- | --- | --- |
| `--body` | string | none | request body (inline JSON) |
| `--body-file` | string | none | request body (path to a JSON file) |
| `--raw` | bool | `false` | print raw response without pretty-printing |

Endpoint: `PUT /api/tag-scripts/{id}`. MCP tool name: `put_tag_scripts_id`.

<!-- END GENERATED COMMAND REFERENCE -->

## Related

- [Benchmarks](benchmarks.md): running work across a set of devices and reading the results.
- [Jobs](jobs.md): one unit of work on one device.
- [Artifacts](artifacts.md): the files you push to devices and the files they produce.
- [job definitions](job-definitions.md): what the platform runs on a device.
- [Device concept](../concepts/device.mdx): what a device is and what you can do with one, in prose.
- [CLI overview](index.md): global flags, output formats and exit codes.
