### Download Heex Agent Setup Script

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-1

This command downloads the `autoGetStarted.sh` script from the Heex public bucket. The script is then made executable, preparing it for the Heex Agent installation and setup process.

```bash
curl --fail -X GET "https://heex-public-bucket.s3.eu-central-1.amazonaws.com/get-started-scripts/autoGetStarted.sh" -o autoGetStarted.sh && chmod +x autoGetStarted.sh
```

--------------------------------

### Run Heex Agent Setup Script with API Key

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-1

This command executes the downloaded `autoGetStarted.sh` script, passing the user's Heex API key. The script will handle the installation of the Heex installer, set up and start the Heex Agent, and launch a speed signal controller for simulation.

```bash
./autoGetStarted.sh -k <YOUR_API_KEY>
```

--------------------------------

### Install Docker on Ubuntu

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-2

Commands to install Docker on an Ubuntu system, start and enable its service, and add the current user to the docker group for permission management. A logout/login is required after adding the user to the group.

```bash
sudo apt update
sudo apt install docker.io
sudo systemctl start docker
sudo systemctl enable docker
sudo usermod -aG docker $USER
# Log out and back in for the group changes to take effect
```

--------------------------------

### Download Heex RDA Setup Scripts

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-2

Download either the basic or advanced setup script for Heex RDA. The basic script is simpler and requires a local CLI, while the advanced script offers more configuration and can download the CLI for you. Both options also include downloading the Heex CLI if not present.

```bash
# Option 1: Basic script
curl -f "https://heex-public-bucket.s3.eu-central-1.amazonaws.com/get-started-scripts/simplifiedGetStartedRDA.sh" -o setup-heex-rda-basic.sh
chmod +x setup-heex-rda-basic.sh
# Download the CLI if you don't have it locally
curl -f "https://api.app.heex.io/v1/cli/download?operating_system=$(. /etc/os-release && echo ${ID}_${VERSION_ID}_$(uname -m))" -H "secret_key: YOUR_API_KEY" -o heex && chmod +x heex

# Option 2: Advanced script with more configuration options
curl -f "https://heex-public-bucket.s3.eu-central-1.amazonaws.com/get-started-scripts/getStartedRDA.sh" -o setup-heex-rda-advanced.sh
chmod +x setup-heex-rda-advanced.sh
```

--------------------------------

### Verify Docker Installation

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-2

Check if Docker is installed and running on your system by querying its version and listing running containers.

```bash
docker --version
docker ps
```

--------------------------------

### Execute Heex RDA Setup Script

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-2

Run the downloaded Heex RDA setup script (basic or advanced) with your API key. This script automates system creation, ROS bag transformation to a Heex datasource, and trigger configuration, returning the system UUID.

```bash
./setup-heex-rda-<basic|advanced>.sh --api-key YOUR_API_KEY [--no-clean]

# Check help for more options
./setup-heex-rda-<basic|advanced>.sh --help
```

--------------------------------

### Example `defaultAgentSourcing.sh` for Global Heex Agent Configuration

Source: https://doc.heex.io/docs/development/production-deployment/configuration

This example demonstrates how to create and use `/opt/heex/defaultAgentSourcing.sh` to source files and export environment variables that will be automatically included in the Heex Agent's environment upon installation. This method provides a system-wide way to customize the agent's setup.

```bash
source /opt/ros/custom/MyCustomMsg/setup.bash
export CUSTOM_ENV_VARIABLE="myVar"
source /some/other/file.sh
export OTHER_CUSTOM_ENV_VARIABLE=123456
```

--------------------------------

### Heex Installer Command Line Options Reference

Source: https://doc.heex.io/docs/understanding-heex/how-it-works/heex-installer

This section provides a detailed reference for all command-line options available with the `heex-installer` script. It outlines each option's purpose, whether it is mandatory or optional, and its expected input type or values.

```APIDOC
--help, -h: Show this help message and exit.
--system-id, -si: [optional] System Identification Number. If not given, you will create a new system.
--api-key, -k: [mandatory] User secret API key.
--execution-mode, -x: [optional] Execution mode: `background` or `service` (defaults to `service`).
--name, -n: [mandatory if no system_id provided] System display name (name of your system in the UI).
--system-middleware, -mid: [optional] System middleware: value should be an integer. You can use `./heex-installer --help` to list all the available middlewares.
--system-category, -cat: [mandatory if no system_id provided] System category: value should be an integer. Example for RAIL: `--system-category 5`. You can use `./heex-installer --help` to list all available categories.
```

--------------------------------

### Create and Install a New Heex System

Source: https://doc.heex.io/docs/understanding-heex/how-it-works/heex-installer

This command uses the downloaded `heex-installer` to create a new system entry on the Heex platform and install the agent. It requires your `USER_SECRET_KEY`, a display name for the new system, and a system category. Use `./heex-installer --help` to find available category values.

```bash
./heex-installer --api-key <USER_SECRET_KEY> --name <system_display_name> --system-category <category_value>
```

--------------------------------

### Display Heex SDK Replay Help Options

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-2

This command displays the comprehensive help documentation for the `heex sdk replay` tool. It provides a list of all available command-line options, their descriptions, and usage examples to assist in configuring the replay process.

```bash
./heex sdk replay --help
```

--------------------------------

### Download Heex SDK

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-3

Downloads the Heex SDK using the previously installed Heex CLI, requiring an API key. The `--unzip` flag extracts the downloaded archive into the current directory.

```bash
./heex sdk download --api-key <API_KEY> --unzip
```

--------------------------------

### Download Heex Installer Script

Source: https://doc.heex.io/docs/understanding-heex/how-it-works/heex-installer

This `curl` command downloads the latest Heex installer script from the Heex API. It automatically detects the operating system and architecture, requires a `USER_SECRET_KEY` for authentication, and makes the downloaded file executable. Replace `<USER_SECRET_KEY>` with your actual secret key.

```bash
curl --fail -X GET "https://api.app.heex.io/v1/installer/download?operating_system=$(. /etc/os-release && echo ${ID}_${VERSION_ID}_$(uname -m))" \
     -H "secret_key: <USER_SECRET_KEY>" -o heex-installer && chmod +x heex-installer
```

--------------------------------

### Launch and Connect to ROS2 VM with Multipass

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-2

Use Multipass to quickly launch an Ubuntu VM with ROS2 Jazzy pre-installed and then connect to it. This is an alternative if you don't have Ubuntu with ROS2 installed locally.

```bash
multipass launch ros2-jazzy --name heex-demo

multipass shell heex-demo
```

--------------------------------

### Build Heex SDK C++ Samples

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-3

Provides command-line instructions to build Heex SDK C++ samples using the 'heex sdk' CLI or directly with CMake from the root SDK directory or the 'get-started/cpp' directory.

```Bash
./heex sdk build-samples
```

```Bash
cmake -DCMAKE_BUILD_TYPE=Release -S . -B build -DHEEX_SDK_DIR=/path/to/Heex_SDK_<version>
cmake --build build --config Release -j2
```

--------------------------------

### Install Heex Agent on an Existing System

Source: https://doc.heex.io/docs/understanding-heex/how-it-works/heex-installer

This command uses the `heex-installer` to install the Heex Agent on a system that has already been registered on the Heex platform. It requires your `USER_SECRET_KEY` and the unique ID of the existing system.

```bash
./heex-installer --api-key <USER_SECRET_KEY> --system-id <ID of system>
```

--------------------------------

### Verify Heex Implementation Executables Presence

Source: https://doc.heex.io/docs/development/sdk/integration

Example bash commands to check for the presence of built Heex implementation executables, specifically for `GetStartedMonitor` and `GetStartedRecorder` within the `get-started/cpp` directory.

```bash
ls /path/to/Heex_SDK_<version>/get-started/cpp/GetStartedMonitor
```

```bash
ls /path/to/Heex_SDK_<version>/get-started/cpp/GetStartedRecorder
```

--------------------------------

### Set Up Heex Agent System ID and API Key

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-3

Command to configure the Heex Agent with the system ID, SDK path, and user API key, preparing it for deployment.

```Bash
./heex sdk set-system --system-id <SYSTEM_ID> --path-to-sdk <Heex_SDK> --api-key <USER_SECRET_KEY>
```

--------------------------------

### Retrieve Details of a Heex Implementation

Source: https://doc.heex.io/docs/command-line-interface/implementation

This example demonstrates how to fetch comprehensive details about a specific Heex implementation using its unique ID. The `get` subcommand allows for optional output to a file, which is useful for further analysis or modification workflows.

```bash
./heex implementation get --implementation-id <IMPLEMENTATION_ID> --api-key <USER_SECRET_KEY> --output-file <OUTPUT-FILE>
```

--------------------------------

### Manually Install Heex Agent on Production System

Source: https://doc.heex.io/docs/development/production-deployment/installer-mode

After copying the generated installer to your production system, execute this command to perform the installation. Optional arguments can be passed to the installer by separating them with `--`.

```bash
./Agent_<version>_<OS_and_Arch>_<system_id>_installer -- <optional arguments>
```

--------------------------------

### Heex Agent Installer: General Options Usage

Source: https://doc.heex.io/docs/development/production-deployment/configuration

Demonstrates the general syntax for running the Heex Agent installer with multiple options and arguments. This command is used to configure various aspects of the agent during installation, allowing for flexible deployment based on specific requirements.

```bash
./Agent_<version>_Ubuntu_20.04_x86_64_installer -- --option1 argument --option2 argument2
```

--------------------------------

### Launch Heex Agent

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-3

Command to run the Heex Agent using the specified SDK path and user API key, initiating event generation.

```Bash
./heex sdk run --path-to-sdk <Heex_SDK> --api-key <USER_SECRET_KEY>
```

--------------------------------

### Heex CLI Get Help for Commands

Source: https://doc.heex.io/docs/command-line-interface/cli-utilities/authentification

Provides examples of how to access help documentation for various Heex CLI commands and subcommands using the `--help` flag to understand their usage and options.

```bash
./heex login --help
./heex login --help
./heex userconfig --help
./heex userconfig use --help
./heex userconfig list --help
./heex userconfig create --help
./heex userconfig delete --help
```

--------------------------------

### Heex SDK: Accessing Help Documentation for Commands

Source: https://doc.heex.io/docs/command-line-interface/sdk

These commands provide access to the help documentation for the main `heex sdk` command and its various subcommands like `download`, `build-samples`, `generate-implementations-file`, `run`, `set-system`, and `replay`. Using the `--help` flag displays usage instructions, available flags, and examples for each specific command, aiding users in understanding and utilizing the SDK's functionalities.

```bash
./heex sdk --help
./heex sdk download --help
./heex sdk build-samples --help
./heex sdk generate-implementations-file --help
./heex sdk run --help
./heex sdk set-system --help
./heex sdk replay --help
```

--------------------------------

### Download Heex CLI for Event Generation

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-2

Download the Heex CLI using your API key. This CLI is necessary to replay the ROS bag and generate events with the RDA Agent.

```bash
curl --fail -X GET "https://api.app.heex.io/v1/cli/download?operating_system=$(. /etc/os-release && echo ${ID}_${VERSION_ID}_$(uname -m))" -H "secret_key: YOUR_API_KEY" -o heex && chmod +x heex
```

--------------------------------

### Heex CLI Events Subcommand Help Options

Source: https://doc.heex.io/docs/command-line-interface/events

Provides examples for accessing the built-in help documentation for the `heex events` command and its subcommands (`get`, `list`), useful for understanding available options and usage.

```bash
./heex events --help
./heex events get --help
./heex events list --help
```

--------------------------------

### Get Heex Implementation Command Help

Source: https://doc.heex.io/docs/command-line-interface/implementation

Access detailed help documentation for the 'heex implementation' command and its various subcommands, including 'create', 'create-template-file', 'update', 'get', 'list', and 'delete'. This provides information on available flags and usage.

```bash
./heex implementation --help
./heex implementation create --help
./heex implementation create-template-file --help
./heex implementation update --help
./heex implementation get --help
./heex implementation list --help
./heex implementation delete --help
```

--------------------------------

### Download Heex CLI

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-3

Downloads the Heex Command Line Interface using curl, requiring an API key for authentication. The command dynamically determines the operating system and architecture to download the correct binary.

```bash
curl --fail -X GET "https://api.app.heex.io/v1/cli/download?operating_system=$(. /etc/os-release && echo ${ID}_${VERSION_ID}_$(uname -m))" \
   -H "secret_key: <API_KEY>" -o heex && chmod +x heex
```

--------------------------------

### Copy Custom Implementations to HeexSDK Folder

Source: https://doc.heex.io/docs/development/production-deployment/installer-mode

This command copies your compiled custom implementation executables (e.g., Monitors and Recorders) from your development directory into the `/implementations` folder within the HeexSDK. This step is crucial before packaging them into the Heex Agent installer.

```bash
cd ~/Heex_SDK_version/get-started/cpp
cp GetStartedMonitor ../../implementations
cp GetStartedRecorder ../../implementations
```

--------------------------------

### Get Help for Heex Agent CLI Commands

Source: https://doc.heex.io/docs/command-line-interface/agent

These commands provide detailed help documentation for the main `heex agent` command and its specific subcommands such as `package`, `upload`, `install`, and `uninstall`, outlining their usage, options, and arguments.

```bash
./heex agent --help
./heex agent package --help
./heex agent upload --help
./heex agent install --help
./heex agent uninstall --help
```

--------------------------------

### Launch and Connect to an Ubuntu VM with Multipass

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-1

This snippet provides commands to launch a virtual Ubuntu environment using Multipass, optionally with ROS2 Jazzy pre-installed, and then connect to it. This VM can be used for testing Heex features.

```bash
multipass launch ros2-jazzy --name heex-demo

multipass shell heex-demo
```

--------------------------------

### Generate Heex Agent Installer with HeexCLI

Source: https://doc.heex.io/docs/development/production-deployment/installer-mode

This command uses the HeexCLI to package your custom implementations and the Kernel into a deployable Heex Agent installer. Ensure you provide the correct path to your production system's `systemConf.json` and the HeexSDK folder.

```bash
./heex agent package --config-path <downloaded_path>/systemConf.json --path-to-sdk /path/to/sdk/folder
```

--------------------------------

### Create Heex Implementation with Name and Description

Source: https://doc.heex.io/docs/command-line-interface/implementation

This example demonstrates how to create a new implementation on the Heex Cloud by providing a unique name and an optional description directly via the command line. It uses the `create` subcommand and requires an API key for authentication.

```bash
./heex implementation create --api-key <USER_SECRET_KEY> --name "Jane's implementation" --description "Optional description"
```

--------------------------------

### Build Heex SDK Samples via CLI

Source: https://doc.heex.io/docs/development/sdk/integration

Commands to build Heex SDK samples located in `get-started` or `samples` folders using the Heex command-line interface. The `--jobs` flag can be used to specify the number of parallel build jobs for faster execution.

```bash
./heex sdk build-samples
```

```bash
./heex sdk build-samples --jobs n
```

--------------------------------

### Configure Heex Monitor in Python

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-3

Instructions for configuring a Heex monitor in Python by replacing the 'monitor_uuid' variable with the implementation ID of your monitor.

--------------------------------

### Install Heex Agent Locally

Source: https://doc.heex.io/docs/command-line-interface/agent

This command installs the Heex Agent directly onto your local computer. It requires an API key and the path to the SDK folder, and allows for optional inclusion of a system configuration file or specification of the execution mode (background or service).

```bash
./heex agent install --api-key <USER_SECRET_KEY> --path-to-sdk /path/to/sdk/folder --config-path path/to/systremConf.json
```

--------------------------------

### Instantiate Heex Monitor and Check Readiness

Source: https://doc.heex.io/docs/development/sdk/monitors

This snippet demonstrates how to instantiate the Heex `Monitor` class and ensure it successfully connects to the Heex Kernel using `awaitReady()`. Examples are provided for both C++ and Python.

```cpp
Monitor myMonitor("1a7453c0-ef64-4290-a9c3-5019e8bb43fa", "127.0.0.1", 4242);
if (myMonitor.awaitReady() == false) // awaits the connection with the kernel.
{
  return EXIT_FAILURE;
}
```

```python
import sys
sys.path.append("path/to/sdk/lib")

from libHeexSdkPython import Monitor

my_monitor = Monitor("m-1a7453c0-ef64-4290-a9c3-5019e8bb43fa", "127.0.0.1", 4242)
if not my_monitor.awaitReady():
  print("Monitor is not ready.")
  exit(1)
```

--------------------------------

### Configure Heex Recorder in C++

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-3

Steps to set up a Heex recorder in C++, including replacing the 'recorderUuid', adding labels in the 'generateRequestedLabels' function, and providing a file path in the 'generateRequestedFilePaths' function after creating a sample recording.

```C++
filepath = "/path/get-started/cpp/file.txt"
```

```Bash
echo "This is Smart Data!" > file.txt
```

--------------------------------

### Install Heex Agent in Background Process Mode

Source: https://doc.heex.io/docs/development/production-deployment/installer-mode

This command demonstrates how to install the Heex Agent with the `--execution-mode background` option. This ensures that your implementations run as background processes instead of user services, which is useful if `systemctl` is not available or if you prefer background execution. Note that background processes do not automatically restart on system reboot.

```bash
./Agent_<version>_<OS_and_Arch>_<system_id>_installer -- --execution-mode background
```

--------------------------------

### Run Heex SDK Replay with Default Bag Path

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-2

This command initiates the Heex SDK replay process, connecting to your Heex account using the provided API key and system ID. It simulates data streaming from a ROS bag, defaulting to an internal bag path and Ubuntu 24.04 as the OS version.

```bash
./heex sdk replay --api-key YOUR_API_KEY --os-version Ubuntu_24.04 --system-id YOUR_SYSTEM_ID
```

--------------------------------

### Configure Heex Monitor in C++

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-3

Instructions for configuring a Heex monitor in C++ by replacing the 'monitorUuid' variable with the implementation ID of your monitor.

--------------------------------

### Get Help for Heex CLI Commands

Source: https://doc.heex.io/docs/command-line-interface/recordings

Commands to display help information for the main Heex CLI command and its 'recordings' subcommands, including 'get', 'list', 'download', and 'delete'. This is useful for understanding command-line options and usage.

```bash
./heex --help
./heex recordings get --help
./heex recordings list --help
./heex recordings download --help
./heex recordings delete --help
```

--------------------------------

### Run Heex SDK Replay with Custom Bag Path

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-2

This command executes the Heex SDK replay, allowing you to specify a custom ROS bag file for data processing using the `--bag-path` option. It requires your API key and system ID to connect to the Heex platform and simulate real-time data streaming.

```bash
./heex sdk replay --api-key YOUR_API_KEY --os-version Ubuntu_24.04 --bag-path PATH_TO_YOUR_BAG --system-id YOUR_SYSTEM_ID
```

--------------------------------

### Configure Heex Recorder in Python

Source: https://doc.heex.io/docs/getting-started/quick-starts/quick-start-3

Steps to set up a Heex recorder in Python, including replacing the 'recorder_uuid', adding labels in the 'generateRequestedLabels' function, and providing a file path in the 'generateRequestedFilePaths' function after creating a sample recording.

```Python
filepath = "/path/get-started/python/file.txt"
```

```Bash
echo "This is Smart Data!" > file.txt
```

--------------------------------

### Accessing Help for Heex Workspace CLI Commands

Source: https://doc.heex.io/docs/command-line-interface/workspace

Provides examples for accessing the built-in help documentation for various Heex workspace commands. This includes general help for the workspace command and specific help for the `get-storage` and `set-storage` subcommands, useful for understanding available options and usage.

```bash
./heex workspace --help
./heex workspace get-storage --help
./heex workspace set-storage --help
```

--------------------------------

### Heex Agent Installer: Setting Execution Mode to Background

Source: https://doc.heex.io/docs/development/production-deployment/configuration

Illustrates how to set the Heex Agent's execution mode to 'background' using the `--execution` or `-x` option during installation. This is particularly useful in environments like Docker where launching services might not be feasible, though it implies the agent will not automatically restart after a system reboot.

```bash
./Agent_<version>_Ubuntu_20.04_x86_64_ES-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX_installer -- -x background
```

--------------------------------

### Heex Agent `agentSetupHeader.sh` Template for Customization

Source: https://doc.heex.io/docs/development/production-deployment/configuration

This template for `additionalAgentContent/agentSetupHeader.sh` allows users to define files to be sourced (`FILES_TO_SOURCE_IN_HEEX_AGENT_ENV`) and environment variables to be exported (`VARIABLES_TO_EXPORT_IN_HEEX_AGENT_ENV`) within the Heex Agent's bash environment. It also includes options to disable automatic ROS installation search and local environment sourcing.

```bash
#!/bin/bash
##################################################################
## specific files to source in the Heex Agent bash environments ##
##################################################################

## Replace the commented lines in the following FILES_TO_SOURCE_IN_HEEX_AGENT_ENV variable to source
## specific files inside the Heex Agent environment before they are launched. Please ensure that
## the paths are full paths without any '~' in them.
## NOTE: THE SOURCING OF THE FILES IS DONE IN THE ORDER OF DECLARATION!

FILES_TO_SOURCE_IN_HEEX_AGENT_ENV=(
#    "path/to/file1.sh"
#    "path/to/file2.bash"
#    ...
) # it needs to be kept as a list

##################################################################
########### specific Heex Agent installer variables ##############
##################################################################

## Following variable is for ROS environment only. If you set this to 1, the Heex Agent
## Installer shall not look for any installed ROS distribution inside the /opt/ros folder and
## will not source them in the Heex Agent environment. By doing so, you will need to explicitly
## add the path to your ROS distribution's installation inside the FILES_TO_SOURCE_IN_HEEX_AGENT_ENV
## variable mentionned above.

DISABLE_AUTOMATIC_ROS_INSTALL_SEARCH=0

## By default, when you install our Heex Agent, we include all user's environment variables available. 
## If you set the following variable to 1, we will not include them and leave it to the system env only.
## NOTE: if you run in background process, the env is not contained so the user's env is automatically sourced

DISABLE_SOURCING_OF_LOCAL_ENVIRONMENT=0

## Whether you disable the local environment sourcing or not, you may want to add environment variables
## into the Heex Agent's environement. You may add any variable in the following list. Please make sure
## you follow the 'env="value"' format as shown below.

VARIABLES_TO_EXPORT_IN_HEEX_AGENT_ENV=(
    'HEEX_AGENT_ENV_VAR="VALUE1"'
    'ANOTHER_ENV_VAR=123456'
) # it needs to be kept as a list

##################################################################
##################################################################
```

--------------------------------

### Get Help for Heex Data Source Commands

Source: https://doc.heex.io/docs/command-line-interface/datasource

These commands provide detailed help and usage information for the `heex datasource` command and its various subcommands. Use `--help` after any command to see available flags and options.

```bash
./heex datasource --help
./heex datasource add --help
./heex datasource create --help
./heex datasource create-template-file --help
./heex datasource get --help
./heex datasource list --help
./heex datasource update --help
./heex datasource delete --help
```

--------------------------------

### Get help for Heex CLI signal commands

Source: https://doc.heex.io/docs/command-line-interface/signal

These commands provide detailed help information for various `heex signal` subcommands, including general signal commands, and specific commands for create, update, get, list, create-template-file, and delete operations.

```bash
./heex signal --help
./heex signal create --help
./heex signal update --help
./heex signal get --help
./heex signal list --help
./heex signal create-template-file --help
./heex signal delete --help
```

--------------------------------

### Upload Heex Agent Installer for OTA Update

Source: https://doc.heex.io/docs/development/production-deployment/agent-remote-update

This command uploads a new Heex Agent installer from your Dev Station to connected systems, enabling Over The Air (OTA) updates. It requires an API key, a path to the system configuration file, and the SDK folder path. The uploaded installer will be automatically downloaded and installed on systems configured for OTA updates during their next data upload.

```bash
./heex agent upload --api-key <USER_SECRET_KEY> --config-path path/to/your/systemConf.json --path-to-sdk /path/to/sdk/folder
```

--------------------------------

### Uninstall Heex Agent Using Installer

Source: https://doc.heex.io/docs/development/production-deployment/installer-mode

To uninstall the Heex Agent from your production system, run the installer with the `--uninstall` option. This will remove the Kernel executable and any installed implementations.

```bash
./Agent_<version>_<OS_and_Arch>_<system_id>_installer -- --uninstall
```

--------------------------------

### Example Heex Trigger Configuration JSON

Source: https://doc.heex.io/docs/command-line-interface/trigger

This JSON structure provides an example of a trigger configuration file. It includes fields for labels, monitoring signal conditions, recording signal conditions, name, priority, and description. Only the 'name' field is mandatory; other fields can be removed if not needed.

```json
{
  "labels": [
    {
      "key": "TestKey",
      "value": "TestValue"
    }
  ],
  "monitoring_signal_conditions": [
    {
      "value": {
        "string": "test"
      },
      "signal_id": "si-xxxxxxxxxxxx",
      "operator": "CONTAIN",
      "unit": "METER"
    }
  ],
  "recording_signal_conditions": [
    {
      "signal_id": "si-xxxxxxxxxxxx"
    }
  ],
  "name": "TriggerTestWithFile",
  "priority": 1,
  "description": "TriggerTestWithFile"
}
```

--------------------------------

### Get Help for Specific Heex CLI Commands

Source: https://doc.heex.io/docs/command-line-interface/cli-overview

Displays detailed help information, including usage, options, and subcommands, for individual Heex CLI commands. This allows users to understand the specific functionality and parameters of each command.

```bash
./heex agent --help
./heex completion --help
./heex datasource --help
./heex events --help
./heex implementation --help
./heex quotas --help
./heex recordings --help
./heex sdk --help
./heex signal --help
./heex system --help
./heex trigger --help
./heex update --help
./heex workspace --help
```

--------------------------------

### Heex SDK: Replay Bag and Watch Real-time Events

Source: https://doc.heex.io/docs/command-line-interface/sdk

This command executes the `heex sdk replay` functionality, which pulls a Docker image, installs the latest Agent, and plays a specified bag file. It requires an API key and a system ID to connect and watch events in real time. The command is essential for debugging and monitoring system behavior.

```bash
/heex sdk replay --api-key <USER_SECRET_KEY> --system-id <SYSTEM_ID>
```

--------------------------------

### Update Heex CLI Installation

Source: https://doc.heex.io/docs/command-line-interface/cli-overview

Updates an existing Heex CLI installation to its latest version or a specified version. This operation requires an API key for successful authentication with the Heex platform.

```bash
./heex update --api-key <USER_SECRET_KEY>
```

--------------------------------

### Generate and Install Heex CLI Autocompletion Script

Source: https://doc.heex.io/docs/command-line-interface/cli-utilities/completion

Executes the `heex completion` command to generate and install an autocompletion script for the `heex` CLI. This command supports `bash`, `sh`, `zsh`, and `fish` shells. After execution, users must restart their shell or source the generated script (e.g., `source /home/<yourUser>/.bash_completion.d/heex_autocomplete.bash`) for the autocompletion to take effect. The command output provides specific instructions.

```bash
./heex completion
```

--------------------------------

### Build Heex Agent Executable with CMake

Source: https://doc.heex.io/docs/development/sdk/integration

Bash commands for building an agent using a CMakeLists.txt file. This involves configuring the CMake project with a release build type and specifying the SDK directory, followed by building the project with multiple parallel jobs.

```bash
cmake -DCMAKE_BUILD_TYPE=Release -S . -B build -DHEEX_SDK_DIR=/path/to/Heex_SDK_<version>
```

```bash
cmake --build build --config Release -j2
```

--------------------------------

### Retrieve Data Source Details by ID using Heex CLI

Source: https://doc.heex.io/docs/command-line-interface/datasource

To get detailed information about a specific data source, use the `heex datasource get` command. This requires the data source ID and your API key. Optionally, you can specify an output file to save the results in JSON format.

```bash
./heex datasource get --datasource-id <datasource_ID> --api-key <USER_SECRET_KEY> --output-file <OUTPUT-FILE>
```

--------------------------------

### Manually Add Heex SDK to Python System Path

Source: https://doc.heex.io/docs/development/sdk/integration

This Python snippet demonstrates how to manually add the Heex SDK library directory to the system path. This step is crucial for launching Python implementations independently, outside of the automated Heex environment.

```Python
import sys
sys.path.append("path/to/sdk/lib")
```

--------------------------------

### Get Help for Heex Trigger CLI Commands

Source: https://doc.heex.io/docs/command-line-interface/trigger

These commands demonstrate how to access help documentation for various Heex trigger subcommands, providing detailed information on their usage, flags, and options.

```bash
./heex trigger --help
./heex trigger get --help
./heex trigger list --help
./heex trigger update --help
./heex trigger create --help
./heex trigger create-template-file --help
./heex trigger delete --help
./heex trigger deploy --help
./heex trigger linked --help
./heex trigger candidates --help
```

--------------------------------

### Integrate Heex SDK in CMake C++ Project

Source: https://doc.heex.io/docs/development/sdk/integration

Instructions to import the Heex SDK library and link it to an executable in a CMake C++ project. The `HEEX_SDK_DIR` variable allows specifying a custom path for the SDK.

```CMake
set(HEEX_SDK_DIR ~/heex/)
find_package(HeexSdk REQUIRED PATHS ${HEEX_SDK_DIR})
```

```CMake
add_executable(myProgram main.cpp)
target_link_libraries(myProgram PRIVATE HeexSdk::HeexSdk)
```

--------------------------------

### Generate Data Source Template File (heex CLI)

Source: https://doc.heex.io/docs/command-line-interface/datasource

This command generates a basic `create_datasource_template.json` file, which serves as a starting point for defining data sources and signals. The file can be saved to a specified directory or the current working directory, and then edited to customize data source properties before being used with the `--from-file` option.

```bash
./heex datasource create-template-file --folder-path /path/to/directory
```

--------------------------------

### Example JSON structure for multiple Heex signals

Source: https://doc.heex.io/docs/command-line-interface/signal

This JSON object demonstrates the structure required for creating multiple signals from a file. Each signal includes required fields like 'name', 'type', and 'datasource_id', with optional fields like 'ros_topic_type' and 'unit'.

```json
{
  "signals": [
    {
      "name": "CreateSignalWithFile1",
      "type": "BOOLEAN",
      "datasource_id": "d-xxxxxxxx"
    },
    {
      "name": "CreateSignalWithFile2",
      "type": "STRING",
      "ros_topic_type": "",
      "datasource_id": "d-xxxxxx",
      "unit": "METER"
    }
  ]
}
```

--------------------------------

### List Heex Signals with Multiple Filters

Source: https://doc.heex.io/docs/command-line-interface/signal

Shows how to retrieve a filtered list of available signals within a workspace. This example demonstrates applying multiple filters simultaneously, such as system IDs and datasource IDs, to narrow down the results. The output can be saved to a specified JSON file.

```bash
./heex signal list --system-id <SYSTEM_ID1>  --system-id <SYSTEM_ID2>  --datasource-id <DATASOURCE_ID1>  --datasource-id <DATASOURCE_ID2> --api-key <USER_SECRET_KEY> --output-file <OUTPUT-FILE>
```

--------------------------------

### Get Candidate Systems for Heex Trigger Deployment

Source: https://doc.heex.io/docs/command-line-interface/trigger

This command lists systems compatible with a given trigger, allowing verification before deployment. It requires an API key and the trigger ID, and can optionally save the output to a file in JSON format.

```bash
./heex trigger candidates --api-key <USER_SECRET_KEY> --trigger-id <TRIGGER_ID> --output-file <OUTPUT-FILE>
```

--------------------------------

### Heex Kernel: Most Commonly Used Configuration Parameters

Source: https://doc.heex.io/docs/development/agent/configuration

This section outlines the most frequently used configuration parameters for the Heex Kernel, including settings for logging, connectivity behavior, over-the-air updates, and default ROS bag recording formats. These parameters are crucial for initial setup and common operational adjustments.

```APIDOC
log_level:
  description: Defines the log level.
  possible_values: "default", "info", "warning", "error", "critical"
connectivity_mode:
  description: See section 'Runtime Configuration'.
enable_agent_ota_update:
  description: Used to disable the Agent OTA update.
enable_system_configuration_ota_update:
  description: Used to disable the system configuration OTA update.
ros_recording_default_format:
  description: Default format used for ROS bag recording.
  possible_values:
    - ROS2_BAG_STORAGE_TYPE_AUTOMATIC (for ROS2 Galactic & Humble it will be SQLITE3, and MCAP for the versions above)
    - ROS2_BAG_STORAGE_TYPE_SQLITE3
    - ROS2_BAG_STORAGE_TYPE_MCAP
```

--------------------------------

### List Heex Triggers with Advanced Filtering

Source: https://doc.heex.io/docs/command-line-interface/trigger

This example illustrates how to retrieve a filtered list of triggers from your workspace. It shows the usage of multiple `--system-id` and `--trigger-id` flags simultaneously, along with the API key and an output file path for saving the JSON results.

```bash
./heex trigger list --system-id <SYSTEM_ID1> --system-id <SYSTEM_ID2> --trigger-id <TRIGGER_ID1> --trigger-id <TRIGGER_ID2> --api-key <USER_SECRET_KEY> --output-file <OUTPUT-FILE>
```

--------------------------------

### Run Heex SDK with Implementations

Source: https://doc.heex.io/docs/command-line-interface/sdk

Command to launch the Heex SDK. This command also automatically generates the 'implementations.json' file if it doesn't exist. It requires specifying the path to the Heex SDK and an API key for authentication.

```bash
/heex sdk run --path-to-sdk <Heex_SDK> --api-key <USER_SECRET_KEY>
```

--------------------------------

### Build Heex SDK C++ Samples

Source: https://doc.heex.io/docs/command-line-interface/sdk

Shows the command to build the C++ samples included with the Heex SDK. By default, it uses a single job, but the --jobs flag can be used for faster parallel builds. MCAP samples are disabled by default and require manual activation in CMakeLists.txt.

```bash
./heex sdk build-samples
```

--------------------------------

### Download Heex SDK Package

Source: https://doc.heex.io/docs/command-line-interface/sdk

Illustrates how to download the Heex SDK package using the CLI. This command requires a USER_SECRET_KEY and automatically detects the platform. Optional flags allow specifying the SDK version, output directory, and automatic unzipping.

```bash
./heex sdk download --api-key <USER_SECRET_KEY>
```

--------------------------------

### Heex CLI Implementation Subcommand Overview

Source: https://doc.heex.io/docs/command-line-interface/implementation

This snippet illustrates the general syntax for interacting with the `heex implementation` subcommand. It shows how to invoke the main command followed by a specific subcommand and optional help flag, providing a foundational understanding of the CLI structure.

```bash
./heex implementation SUBCOMMAND [--help]
```

--------------------------------

### Recorder: Get All Recording Signals

Source: https://doc.heex.io/docs/development/sdk/utilities

This method returns a collection of `RecordingSignals` associated with the current recorder. It can be filtered by an optional `triggerId` to retrieve signals related to a specific trigger.

```C++
std::unordered_set<RecordingSignal> getRecorderSignals(const std::string& triggerId = "") const;
```

```Python
def getRecorderSignals(triggerId: str = "") -> list
```

--------------------------------

### Display Heex CLI Global Help

Source: https://doc.heex.io/docs/command-line-interface/cli-overview

Shows a comprehensive list of all available top-level commands and general usage information for the Heex CLI. This is useful for discovering the main functionalities of the tool.

```bash
./heex --help
```

--------------------------------

### Recorder: Get Signal Recording Range

Source: https://doc.heex.io/docs/development/sdk/utilities

This function retrieves the minimum and maximum recording ranges for a specific signal. It supports optional filtering by `triggerId` and `signalName` to narrow down the results.

```C++
std::pair<int, int> getSignalRecordingRange(const std::string triggerId = "", const std::string signalName = "") const;
```

```Python
def getSignalRecordingRange(triggerId: str = "", signalName: str = "") -> tuple
```

--------------------------------

### Create Heex Implementation from JSON Configuration File

Source: https://doc.heex.io/docs/command-line-interface/implementation

This snippet shows an advanced method for creating an implementation using a pre-configured JSON file. The `create` subcommand is used with the `--input-file` option, pointing to a file containing all necessary implementation data, streamlining bulk or complex creations.

```bash
./heex implementation create --api-key <USER_SECRET_KEY> --input-file path/to/your/filledConfigFile.json
```

--------------------------------

### Heex CLI Get Specific Event by ID

Source: https://doc.heex.io/docs/command-line-interface/events

Shows how to fetch detailed information for a single event using its unique ID. The command requires an event ID and can optionally save the retrieved data to a JSON file.

```bash
./heex events get --api-key <USER_SECRET_KEY> --event-id <EVENT_ID> --output-file EventDetailsID.json
```

--------------------------------

### Accessing Heex CLI Command Help

Source: https://doc.heex.io/docs/command-line-interface/system

This snippet demonstrates how to use the `--help` flag with various `heex` CLI commands to retrieve their usage documentation. It covers commands for system management, adding credentials, checking connectivity, and creating resources.

```bash
./heex system --help
./heex add-credentials --help
./heex connectivity --help
./heex create --help
./heex create-template-file  --help
./heex system get --help
./heex system get-sys-conf --help
./heex system list --help
./heex system status --help
./heex system todo-list --help
./heex system update --help
./heex system delete --help
```

--------------------------------

### List Heex Systems with Details (Bash)

Source: https://doc.heex.io/docs/command-line-interface/system

This command retrieves a comprehensive list of systems within a workspace, including detailed information for each. It supports filtering by `--system-id` and `--system-status`. Authentication is handled by `--api-key`, and the output can be directed to a file using `--output-file`. This command is similar to `todo-list` but provides full system details by default.

```bash
./heex system list --api-key <USER_SECRET_KEY> --system-id <SYSTEM_ID>  --system-status <SYSTEM_STATUS> --output-file path/to/your/systemsList.json
```

--------------------------------

### General Heex SDK CLI Usage

Source: https://doc.heex.io/docs/command-line-interface/sdk

Provides the basic command line syntax for interacting with the Heex SDK via the CLI, specifying a subcommand and an optional help flag to display usage information.

```bash
./heex sdk SUBCOMMAND [--help]
```

--------------------------------

### Set Heex SDK System Credentials and Configuration

Source: https://doc.heex.io/docs/command-line-interface/sdk

Defines the command to set system credentials and download the 'systemConf.json' file to the default SDK kernel path. This operation requires a system ID, the path to the Heex SDK, and an API key.

```bash
./heex sdk set-system --system-id <SYSTEM_ID> --path-to-sdk <Heex_SDK> --api-key <USER_SECRET_KEY>
```

--------------------------------

### Create Data Source by Name and Description (heex CLI)

Source: https://doc.heex.io/docs/command-line-interface/datasource

This command demonstrates how to create a new Data Source by directly specifying its name and an optional description. It requires an API key for authentication. This method is suitable for creating a data source without pre-defined signals.

```bash
./heex datasource create --api-key <USER_SECRET_KEY> --datasource-name "My Data Source" --description "This is my data source"
```

--------------------------------

### Heex CLI System Create Command with Configuration File

Source: https://doc.heex.io/docs/command-line-interface/system

This command creates a new system on the Heex Cloud by providing a path to a pre-filled JSON configuration file. This method allows for more detailed system generation, where 'name' and 'type' fields are mandatory in the input file.

```bash
./heex system create --api-key <USER_SECRET_KEY> --input-file /path/to/your/createSystemFilled.json
```

--------------------------------

### Python SDK Documentation URL Constant

Source: https://doc.heex.io/docs/development/sdk/samples

Defines a constant for the URL of the Heex Python SDK documentation, hosted on an S3 bucket. This URL provides access to all available Python methods and structures.

```JavaScript
export const URL_PYTHON_SDK_DOC = 'https://heex-public-bucket.s3.eu-central-1.amazonaws.com/heex-documentation/sdk-python-docs/sdk-python-doc-2025.5.1.html';
```

--------------------------------

### Heex CLI Completion Command Basic Usage

Source: https://doc.heex.io/docs/command-line-interface/cli-utilities/completion

Illustrates the general syntax for the `heex completion` command, indicating that it can be run with or without the `--help` flag.

```bash
./heex completion [--help]
```

--------------------------------

### Heex CLI Quotas Command Help

Source: https://doc.heex.io/docs/command-line-interface/quotas

Provides the command to display the help documentation for the `heex quotas` command, detailing all available options, arguments, and their descriptions.

```bash
./heex quotas --help
```

--------------------------------

### Heex CLI System Create Command by Name

Source: https://doc.heex.io/docs/command-line-interface/system

This command creates a new system on the Heex Cloud using a unique name and optional parameters like description, system middleware, and category. The created system can be further modified via the cloud platform.

```bash
./heex system create --api-key <USER_SECRET_KEY> --name "Jane's system" --description "Optional description" --system-middleware 1 --system-category 1
```

--------------------------------

### Heex Monitor Class API Reference

Source: https://doc.heex.io/docs/development/sdk/monitors

Comprehensive API documentation for the Heex `Monitor` class, detailing its constructor and key methods for managing dataflow monitoring. Includes parameter descriptions, return types, and usage notes.

```APIDOC
Monitor(id, serverIp, serverPort)
  id: Monitor implementation ID, retrieved from Heex Cloud
  serverIp: IP address to contact Heex Kernel
  serverPort: Port to contact Heex Kernel

awaitReady()
  Description: To wait until the monitor is ready to receive data. Please ensure this function returns True before continuing.
  Returns: bool

updateValue(inputValue)
  Description: To update the in-memory value of your signal, and communicate with the Heex Kernel when the conditions set on the Heex Cloud are met.
  Parameters:
    inputValue: The value of the signal to update.

updateValue(inputValue, timestamp)
  Description: Call updateValue with the timestamp in the form of a string.
  Parameters:
    inputValue: The value of the signal to update.
    timestamp: The timestamp of the signal value, formatted as a string.

updateValueBySignalName(inputValue, timestamp, signalName)
  Description: Call updateValue but only for the signal with the specified name.
  Parameters:
    inputValue: The value of the signal to update.
    timestamp: The timestamp of the signal value, formatted as a string.
    signalName: The name of the signal.
```

--------------------------------

### Retrieve Heex System To-Do List (Bash)

Source: https://doc.heex.io/docs/command-line-interface/system

This command retrieves a list of systems with their corresponding to-do statuses for a given workspace. Results can be filtered by `--system-id` and/or `--system-status` (e.g., `TO_CODE`). The `--details` flag provides more granular information, including signal implementation statuses, otherwise, it shows basic system ID, status, and agent version. An `--output-file` can be specified to save the results.

```bash
./heex system todo-list --api-key <USER_SECRET_KEY> --system-id <SYSTEM_ID>  --system-status <SYSTEM_STATUS> --output-file path/to/your/systemsToDoList.json
```

--------------------------------

### Retrieve Heex System Configuration (Bash)

Source: https://doc.heex.io/docs/command-line-interface/system

This command fetches the configuration details for a given system. Similar to retrieving system details, it requires an `--api-key` and `--system-id`. The `--output-file` flag allows saving the configuration to a specified path. This is useful for reviewing or backing up system settings.

```bash
./heex system get-sys-conf --api-key <USER_SECRET_KEY> --system-id <SYSTEM_ID> --output-file path/to/your/sysConf.json
```

--------------------------------

### Heex CLI List Userconfigs

Source: https://doc.heex.io/docs/command-line-interface/cli-utilities/authentification

Shows how to list existing userconfigs. The `--output-file` option allows saving the list to a JSON file, which includes API keys, so caution is advised regarding exposure.

```bash
./heex userconfig list --output-file <OUTPUT_FILE_PATH>
```

--------------------------------

### Heex CLI Quotas Basic Command Syntax

Source: https://doc.heex.io/docs/command-line-interface/quotas

Illustrates the fundamental command structure for invoking the `heex quotas` utility, indicating that the `--help` flag is an optional argument for displaying usage information.

```bash
./heex quotas [--help]
```

--------------------------------

### Heex CLI General Authentication Commands Overview

Source: https://doc.heex.io/docs/command-line-interface/cli-utilities/authentification

Provides an overview of the main Heex CLI commands for authentication and user configuration management, including login, userconfig, and logout, along with their help options.

```bash
./heex login SUBCOMMAND [--help]
./heex userconfig SUBCOMMAND [--help]
./heex logout [--help]
```

--------------------------------

### Generate Heex SDK implementations.json File

Source: https://doc.heex.io/docs/command-line-interface/sdk

Command to automatically generate the 'implementations.json' file, which is essential for the SDK to handle implementations located within the 'implementations' folder. This command requires specifying the path to the SDK folder.

```bash
./heex sdk generate-implementations-file --path-to-sdk /path/to/sdk/folder
```

--------------------------------

### Create Data Source from ROS Bag File (heex CLI)

Source: https://doc.heex.io/docs/command-line-interface/datasource

This command facilitates the creation of a Data Source by extracting topics from a ROS bag file. It automatically creates the data source, binds it to a specified system, generates individual signals, and updates the system's implementation. An API key and system ID are mandatory.

```bash
./heex datasource create --from-bag <BAG_PATH> --api-key <USER_SECRET_KEY> --system-id <SYSTEM_ID>
```

--------------------------------

### Display Help for Heex CLI Completion Command

Source: https://doc.heex.io/docs/command-line-interface/cli-utilities/completion

Invokes the `heex completion` command with the `--help` flag to display detailed usage information, available options, and arguments for the completion feature.

```bash
./heex completion --help
```

--------------------------------

### Heex CLI Trigger Creation Syntax

Source: https://doc.heex.io/docs/getting-started/faq

This snippet shows the general syntax for creating a new trigger using the Heex command-line interface. Incorrect syntax or insufficient permissions are common reasons for command failure.

```bash
heex trigger create [options]
```

--------------------------------

### Call Recorder Base Constructor

Source: https://doc.heex.io/docs/development/sdk/recorders

This snippet illustrates how to call the base `Recorder` class's constructor, which requires an ID, server IP, and server port for initialization, shown for both C++ and Python.

```cpp
Recorder(const std::string& id, const std::string& serverIp, const unsigned int& serverPort)
```

```python
super().__init__(self, id, server_ip, server_port, "1.0.0") // Where "1.0.0" is the version
```

--------------------------------

### Create Data Source from JSON File (heex CLI)

Source: https://doc.heex.io/docs/command-line-interface/datasource

This command allows creating Data Sources and their signals using a pre-configured JSON file. The JSON file must adhere to the specified schema for data source and signal definitions. An API key is required for authentication.

```bash
./heex datasource create --from-file create_datasource_template.json --api-key <USER_SECRET_KEY>
```