@elo/elo-cli 1.0.2

package/README.md

@@ -0,0 +1,765 @@
+# elo-cli
+
+This Command Line Interface supports the development of single-page web applications with Node.js and offers the following features:
+
+- **[setup](#setup)**: Configures the ELO-CLI for further use.
+- **[init](#init)**: Connects the application to an ELOwf during development to enable login and ELO session.
+- **[build](#build)**: Prepares a built app for use as an ELO app.
+- **[deploy](#deploy)**: Deploys a built app as an ELO app on the ELOwf.
+- **[localize](#localize)**: Converts language files (.properties) into a JavaScript file so that the entries can be used directly in the application.
+- **[import](#import)**: Imports workflows, entries, or packages into the system.
+- **[export](#export)**: Exports ELO packages or archive areas from the system.
+- **[TestHelpers](#test_helpers)**: Helper class for easy access to ELO-CLI configuration data within tests or development servers.
+
+Without ELO relevance, the CLI additionally offers the following features (used internally in some cases):
+- **[publish](#publish)**: Publishes built projects to an npm repository manager.
+- **[license](#license_cmd)**: Creates a 3rdPartyLicense.txt that clearly summarizes all project licenses used.
+- **[link](#link)**: Allows linking and building of ELO libraries to always develop with the current master state.
+
+
+## Installation & Usage
+<a id="installation"></a>
+
+The CLI can be installed globally as a npm package:
+
+    npm install -g @elo/elo-cli
+
+Afterwards, the elo command is available globally and can be used directly.
+
+    elo <command> --<flag>
+
+When you need to import the TestHelpers into your project, we recommend installing the package as a development dependency:
+
+    npm install --save-dev @elo/elo-cli
+
+You can then use it like this:
+
+    npx elo <command> --<flag>
+
+
+## Getting Started
+<a id="getting_started"></a>
+
+### Creating an App
+
+Create an app with a framework of your choice. We recommend the current technology stack of
+[Vue.js](https://vuejs.org/).
+
+Follow the instructions there to create a new Vue.js app:
+[Quick Start](https://vuejs.org/guide/quick-start.html#creating-a-vue-application).
+
+**Please note**: Since we have no influence on this stack, changes may occur at any time that
+affect the use of elo-cli.
+
+**Please note**: When using other technology stacks (React, Angular, etc.), there may be deviations in the
+use of elo-cli that are not described here. Usage with other frameworks is not tested.
+
+Summary of recommended steps:
+
+- Create an app with the default tools:
+
+
+    npm create vue@latest
+
+Recommended options:
+- Typescript
+- Vitest
+- End-to-End Testing (Playwright)
+- ESLint
+- Prettier
+
+
+    cd my-project
+    npm install
+    npm run format
+    npm run dev
+
+### Installing and Setting Up the ELO-CLI
+
+Install elo-cli as a development dependency in the project:
+
+    npm install -D @elo/elo-cli
+
+(ELO internal)
+
+    npm install -D @elo/elo-cli@main
+
+This installs elo-cli as a devDependency so it can be used in the project context. The cli command
+**elo** is not directly available, but can only be used via npx elo or an npm script.
+
+For the initial setup, a global settings file must be created. This is done with the [setup](setup.md) command.
+
+    npx elo setup
+
+Inputs see [Setup](setup.md).
+
+This creates a file `.elo-cli-settings.json` in the user directory. It stores a default developer archive access
+and general (typically unchanging) development data (default language, namespace, etc.).
+
+For our project, we directly create a specific archive access for development. This is done with the
+flag `--repository` and the name of the access (in this case 'dev').
+
+    npx elo setup --repository dev
+
+Inputs see [Setup](setup.md).
+
+Specific archives for the project are stored in the `.elo-repository` directory. This makes it possible to store separate
+connection data for CI/CD or shared ELO servers and to check them into source control together with the app code.
+
+If a developer works alone against their local test ELO installation, the global access can be used.
+
+For the following steps, an ELO archive with ixUrl http://elo:9090/repository/ix is assumed.
+
+### Initialization
+
+To establish a connection with the archive and use helper functions in the app, the app should use the
+library @elo/elo-base-lib.
+
+    npm install @elo/elo-base-lib
+
+Connect the app to the ELOwf; the app will be marked as 'In Development'.
+This instructs the ELOwf to allow the app during a login attempt and redirect to the local
+development server. Use the [init](init.md) command with the flag --repository and the name of the
+archive access (in this case 'dev').
+
+    npx elo init --repository dev
+
+Inputs:
+- **use_sordType_icons**: n Are Sord type icons needed in the app (injects a CSS file from ELOwf).
+- **use_archive_icons**: n Are archive icons needed in the app (injects a CSS file from ELOwf).
+- **indexHtmlPath**: public/
+- **id**: my-project
+- **build_number**: 0
+- **useELOSession**: y
+- **dev_redirect**: http://localhost:5173
+
+After initialization, the following files are present in the project:
+- manifest.json - contains the metadata of the ELO app
+- devData.js - development code for the app (needed to load icons, for example, as long as the app is not running inside ELOwf).
+- modified index.html - contains references to devData.js and styles.
+- .elo-current-repository - contains the name of the currently used repository (in this case 'dev').
+
+The following files still need to be adjusted; this is also indicated in the console:
+- main.ts - contains the code for loading the ELO libraries.
+
+
+    import { createApp } from 'vue'
+    import { initEloBaseServices, ixService, logger } from '@elo/elo-base-lib';
+    import { LockC, EditInfoC } from '@elo/ix-client-typescript';
+    ...
+    import App from './App.vue'
+
+    // Initialize the elo base services
+    try {
+        await initEloBaseServices() // perform redirect to ELO login if not authenticated.
+        
+        // --- example call to ix: checkout root repository folder.
+        const sord = await ixService.callIxEndpoint('checkoutSord', {
+            objId: "1",
+            editInfoZ: EditInfoC.mbSord,
+            lockZ: LockC.NO
+        })
+        logger.info("Checked out sord:", sord.sord!.name);
+        // ---
+        
+        createApp(App).mount('#app') // <- mount the app after initialization is complete
+    } catch (error) {
+        logger.error('Failed to initialize ELO Base Lib:', error);
+    }
+
+
+
+**vite.config.ts** - contains proxy settings for accessing the ELOwf during development; additionally, the
+base path is set to ''. This links scripts relatively and ensures that the app works both in
+ELOwf and on the local development server. The TestHelpers allow access to the
+archive configuration of the setup command.
+
+
+    import { defineConfig, ProxyOptions } from 'vite'
+    import TestHelpers from '@elo/elo-cli'; // load global config from elo-cli
+    ...
+
+    TestHelpers.init(); //repository is optional
+     
+    const config = {
+      ...,
+      base: '',
+      server: {
+        ...,
+        port: 5173, // port from dev Redirect in manifest.json
+        proxy: {} as Record<string, string | ProxyOptions>
+      }
+    };
+    config.server.proxy[TestHelpers.getIxContext()] = {
+      target: TestHelpers.getIxServer(),
+      changeOrigin: true
+    };
+    export default defineConfig(config);
+
+### Localization
+
+To equip the app with language files, we use .properties files. These are known from the Java environment
+and widely used.
+
+Create a *locales* folder in the app directory and place the language files there:
+
+    locales/
+      messages.properties
+
+The entries in this file should be written in the default language (see manifest.json):
+
+    APP.GREETINGS=Hello World!
+    APP.FAREWELL=Goodbye!
+
+To use the language files in the app, they must be converted into a JavaScript file. This
+is done with the [localize](localize.md) command:
+
+    npx elo localize --src locales/ --dist src/jsLocales/
+
+The target directory is completely overwritten. The generated file *all_locales.js* can then be imported and used in
+the app (main.ts):
+
+    import './jsLocales/all_locales'
+
+The entries can then be accessed via the singleton instance ``text.getText(key)``:
+
+    import { text } from '@elo/elo-base-lib';
+    ...
+    logger.info(text.getText("APP.NAME");
+
+### Starting the App
+
+To start the app on a local development server, use the command:
+
+    npm run dev
+
+The server starts on the port specified in vite.config.ts (here 5173) and sets up a proxy to the ELO archive
+as specified in dev.json.
+
+A request to http://localhost:5173 starts the app, a request to http://localhost:5173/repository/* is
+forwarded to the ELO archive http://elo:9090/repository/*.
+
+### Build and Deployment
+
+Build the app with the command:
+
+    npm run build
+
+The built app is located in the *dist/* directory.
+
+To prepare the app for deployment, use the [build](build.md) command:
+
+    npx elo build
+
+This adjusts the index.html so that devData.js is no longer loaded and the data is loaded via relative ELOwf URLs.
+
+The app can now be packaged as a ZIP file and deployed in ELOwf. This is done via the [deploy](deploy.md)
+command:
+
+    npx elo deploy --repository dev
+
+The app is now available in ELOwf and can be used there. To test this, the app can be opened in the AppManager.
+There, the app is listed under 'In Development'.
+
+Using the 'Archive' button, it can be transferred to the repository and is in the 'Installed' state.
+In the archive, the app can be found under Administration/ELOapps/Apps/<namespace>.<id>. In this directory, the
+**access** folder was also created, which regulates the app's access rights.
+
+### Further Development of the App
+
+To further develop the app, the steps Initialization, Localization, Build, and Deployment
+can be repeated as often as desired.
+
+With the [init](init.md) command, the installed app is removed and the manifest with the devRedirect is re-imported.
+The app remains in the archive and is again in the 'In Development' state. It can then either be overwritten with a new
+version via elo-cli (deploy) or reset to the archived version (install) via AppManager.
+
+
+## Command: help
+<a id="help"></a>
+
+The help command displays all available commands and their short descriptions in the console.
+
+**Example:**
+
+    elo help
+
+To display the available options and flags for a specific command, the --help flag can be used after the respective command.
+
+**Example:**
+
+    elo <command> --help
+
+
+## Command: setup
+<a id="setup"></a>
+
+The `setup` command configures the ELO CLI for further use. This step is required to be able to use all other functions.
+
+**Optional flags:**
+- `--repository <repoName>`: Creates a local repository for projects. Without this flag, the setup data is stored globally.
+- `--config <path>`: Executes the setup automatically based on a configuration file.
+
+**Multiple archives:**
+
+It is possible to create additional local configuration archives within a project, in addition to the user-dependent
+global archive. All relevant commands can then be executed with the parameter --repository <name> to use the
+corresponding configuration.
+
+The last used configuration is stored in the file .elo-current-repository. This file should be added to .gitignore.
+If the global configuration is used, the value ELO_GLOBAL is stored in this file.
+
+Project-specific configurations are stored in the .elo-repository/ folder of the respective project.
+
+**Example:**
+
+    elo setup --repository <string>
+
+**Interactive inputs on first run**
+
+If the setup is run without a configuration file, the CLI will prompt for the following parameters:
+
+- **wf_url**: URL to the ELOwf, e.g. `http://server:9090/ix-Archiv/plugin/de.elo.ix.plugin.proxy/wf/`. Required for login and deployment.
+- **index_html**: Name of the HTML file into which the CLI injects code (e.g. for redirects). Default is `index.html`, but can be changed.
+- **src**: Relative path to the app's source folder (contains the HTML file).
+- **dist**: Relative path to the app's build folder (final application).
+- **namespace**: Default namespace for apps. Can be adjusted per app in the manifest.
+- **default_lang**: Default language for the initial language file and as fallback.
+- **server_url**: URL to the index server, the current development system. E.g. `http://server:9090/repository/`.
+- **admin_name**: Administrator username for development logins.
+- **admin_pw**: Administrator password (stored encrypted).
+
+The configuration is saved in the file `.elo-cli-settings.json` in the user's home directory (e.g.
+`C:/Users/<username>/.elo-cli-settings.json`). The setup can be run again at any time or the file can be edited manually.
+
+All parameters can alternatively be passed directly as flags, e.g.:
+
+    elo setup --server_url http://server:9090/ix-Archiv/
+
+
+## Command: initialization
+<a id="init"></a>
+
+To connect a project with an archive, it must be initialized using the `init` command. This creates the `manifest.json`
+file, which stores important data for processing with the CLI.
+
+**Optional flags:**
+- `--repository <repoName>`
+
+Using the `--repository` flag, initialization can be performed against a different archive. From this point on, the app
+will use the specified archive when starting.
+
+**Example:**
+
+    elo init --repository <string>
+
+
+**Interactive inputs on first run**
+
+On the first run, the data for the manifest file (`manifest.json`) is requested:
+
+- **use_sordType_icons**: `y|n` Indicates whether the app needs icons for entry types. If yes, these are loaded via
+  `devData.js` and a corresponding tag is added to `dist/index.html` during deployment. The icons are then available 
+  as CSS classes.
+- **use_archive_icons**: `y|n` Indicates whether the app needs archive icons. If yes, these are loaded via `devData.js`
+  and a corresponding tag is added to `dist/index.html` during deployment. The icons are then available as CSS classes.
+- **indexHtmlPath**: Relative path to the `index.html` file.
+- **id**: The ID of the ELO app, required for registration in ELOwf.
+- **build_number**: The build number of the app, required for ELOwf.
+- **use_elo_session**: `y|n` Indicates whether an ELO session is required. If yes, a redirect to the ELOwf login occurs
+  if the session is missing.
+- **dev_redirect**: Redirect URL that is called after successful login in ELOwf. Typically, this is the address where
+  the app is accessible during development (e.g. `http://localhost:8082`).
+
+After initialization, or if the `manifest.json` already exists, the following actions are performed:
+
+- The `index.html` is adjusted to allow access to the manifest data in JavaScript. Additionally, the script `devData.js`
+  is included, which executes additional code during development.
+- The file `devData.js` is created. It contains development code that, for example, dynamically injects entry icons and
+  makes requests to the ELOwf to obtain data as with normal ELO apps.
+- For Vue.js applications, an attempt is made to find `main.js` / `main.ts` and inject code there to load the ELO libraries.
+- The app is registered with the ELOwf so that the ELOwf login page knows the app and can redirect to the specified
+  redirect URL after successful login.
+
+After successful initialization, the app can be started and a connection to the ELOwf can be established. If necessary, 
+proxy settings or further configurations may need to be made.
+
+The `elo init` command should be executed again during development if changes are made to the archive or the `manifest.json`.
+
+All parameters can also be passed directly as flags, e.g.:
+
+    elo init --use_sordType_icons y --use_elo_session y ...
+
+
+## Command: build
+<a id="build"></a>
+
+Once development has reached a stage where the application should be used as an ELO app, the application can be prepared
+for deployment using the `build` command. During this process, the `index.html` in the `/dist` folder is modified: the
+development file `devData.js` is removed and the data is instead loaded via relative ELOwf URLs.
+
+With the parameters `--key <key>` and `--value <value>`, any key/value pairs can be set or overwritten in the
+`manifest.json` that are relevant for the build:
+
+**Optional flags:**
+- `--key <string>`: Sets or overwrites the specified key in the `manifest.json`.
+- `--value <string>`: Sets or overwrites the value of the key/value pair in the `manifest.json` defined with `--key`.
+
+Any number of key/value pairs can be added by executing the command multiple times, each with a `--key` and `--value`.
+
+**Examples:**
+
+Manifest.json before the build:
+
+    {
+        "version": "0.1.8",
+        // ...
+    }
+
+Add a key/value pair:
+
+    elo build --key noBuild --value true
+
+Manifest.json after execution:
+
+    {
+        "version": "0.1.8",
+        "noBuild": true
+        // ...
+    }
+
+Overwrite an existing key/value pair:
+
+    elo build --key version --value 0.1.0
+
+Manifest.json after execution:
+
+    {
+        "version": "0.1.0",
+        "noBuild": true
+        // ...
+    }
+
+Remove a key/value pair:
+
+    elo build --key noBuild --value undefined
+
+Manifest.json after execution:
+
+    {
+        "version": "0.1.0"
+        // ...
+    }
+
+To use the original `manifest.json` for the build, all set key/value pairs can be discarded by simply running `elo build`:
+
+    elo build
+
+Manifest.json:
+
+    {
+        "version": "0.1.8"
+        // ...
+    }
+
+
+## Command: deploy
+<a id="deploy"></a>
+
+To transfer the app directly to the ELOwf, use the `deploy` command. This first performs all steps of the `build`
+command and then sends the built application to the ELOwf. After successful deployment, the app can be accessed via
+the App Manager.
+
+**Optional flags:**
+- `--repository <string>` Allows deployment to a specific archive.
+- `--neon` Required to deploy Neon extensions on the ELOwf. INTERNAL USE ONLY.
+- `--key <string>` Sets or overwrites a key in the `manifest.json`.
+- `--value <string>` Sets or overwrites the value of the key/value pair in the `manifest.json` specified with `--key`.
+
+Any number of key/value pairs can be added by executing the command multiple times, each with a `--key` and `--value`.
+
+**Examples:**
+
+Manifest.json before deployment:
+
+    {
+        "version": "0.1.8"
+        // ...
+    }
+
+Add a key/value pair:
+
+    elo deploy --key noBuild --value true
+
+Manifest.json after execution:
+
+    {
+        "version": "0.1.8",
+        "noBuild": true
+        // ...
+    }
+
+Overwrite an existing key/value pair:
+
+    elo deploy --key version --value 0.1.0
+
+Manifest.json after execution:
+
+    {
+        "version": "0.1.0",
+        "noBuild": true
+        // ...
+    }
+
+Remove a key/value pair:
+
+    elo deploy --key noBuild --value undefined
+
+Manifest.json after execution:
+
+    {
+        "version": "0.1.0"
+        // ...
+    }
+
+To use the original `manifest.json` for deployment, all set key/value pairs can be discarded by simply running `elo deploy`:
+
+    elo deploy
+
+Manifest.json:
+
+    {
+        "version": "0.1.8"
+        // ...
+    }
+
+
+## Command: localize
+<a id="localize"></a>
+
+With the `localize` command, all `.properties` language files in a folder can be converted into a central JavaScript
+file (`all_locales.js`). This file can be directly included and used in the application.
+
+At runtime, the CLI checks the completeness of the used keys and creates a report about missing, redundant, or
+duplicate entries.
+
+**Required flags:**
+- `--src <path>`: Path to the folder containing the properties files.
+- `--dist <path>`: Output path for the generated `all_locales.js` file.
+
+**Optional flags:**
+- `--report`: Creates a report about missing, redundant, and duplicate keys. The report is saved in the root directory.
+
+**Example:**
+
+    elo localize --src <path-to-folder> --dist <path-to-target-file> --report
+
+
+## Command: import
+<a id="import"></a>
+
+The `import` command allows you to import workflows, entries, or packages into the system. The command is flexible and
+supports various import modes:
+
+**General options:**
+- `--src <string>`: Path to the file to be imported.
+
+**Examples:**
+
+### Importing an ELO package
+
+Imports an ELO package from a file:
+
+    elo import --src <path-to-file>
+
+### Importing an export record
+
+Imports an export record into a specific archive:
+
+- `--guid <string>`: Target parent ID for the import (format: `"(54F8BE3A-B860-31B4-3224-077FFDE546A9)"`)
+- `--guidMode <number>`: Optional, sets the GUID mode (default: 1)
+
+
+    elo import --mode archive --src <path-to-file> --guid <guid>
+
+### Importing a workflow
+
+Imports a workflow from a `.ewf` file. Optionally, a template name and a user GUID can be specified:
+
+- `--flowName <string>`: Optional, name of the workflow template
+- `--guid <string>`: Optional, user GUID for unknown user nodes
+
+
+    elo import --mode workflow --src <path-to-file> [--flowName <name>] [--guid <userid>]
+
+### Importing an entry
+
+Imports an entry into a specific archive:
+
+- `--guid <string>`: Target parent ID (format: `"(54F8BE3A-B860-31B4-3224-077FFDE546A9)"`)
+
+  elo import --mode entry --src <path-to-file> --guid <guid>
+
+
+## Command: export
+<a id="export"></a>
+
+With the `export` command, you can export an ELO package or an archive area.
+
+**Required flags:**
+- `--guid <string>`: Name or GUID of the package or GUID of the archive area to be exported.
+- `--dist <string>`: Path and name of the export file.
+
+**Example:**
+
+    elo export --guid <string> --dist <string>
+
+
+## TestHelpers
+<a id="test_helpers"></a>
+
+The `TestHelpers` class provides access to the ELO-CLI repository data within tests or development configurations.
+
+
+
+## Internal use
+<a id="internal_use"></a>
+
+The following commands are intended for internal use and may not be of use.
+
+### Command: publish
+<a id="publish"></a>
+
+With the `publish` command, built projects can be published to a repository manager such as `Nexus`. The command
+supports single projects as well as mono- and multirepos using a configuration file.
+
+After publishing, the CLI checks whether the latest version is available under the specified tag on the repository manager.
+
+**Required flags:**
+- `--tag <string>`: Tag under which the project is published (e.g. `master`, `main` or following the scheme
+  `release-<majorVersion>-<minorVersion?>`). The `minorVersion` is optional.
+- `--server <string>`: URL of the repository manager including the path to the repository, e.g.
+  `https://nexus.example.de/repository/your-repo/`
+
+**Optional flags:**
+- `--delay <number>`: Delay in seconds between publishing the projects and checking, if the projects are available on
+  the repository manager (default is 0).
+- `--latest`: If set the publish command will also set the latest flag for the published version.
+- `--multirepoconfig <string>`: Path to the configuration file containing the names and paths of the projects in the
+  mono-/multirepo.
+
+In multirepo mode, the dependencies in the respective `package.json` files are automatically adjusted so that the
+currently published version is always set as a dependency.
+
+**Example for the configuration file (`elo-cli-multirepo.json`):**
+
+    [
+        {
+            "name": "example-project",
+            "path": "./packages/example-project"
+        }
+        // more projects
+    ]
+
+
+**Note:**
+The `publish` command is intended for automated publishing in CI/CD pipelines. A `.npmrc` file with a valid auth token
+must be present in the root directory of the project to be published.
+
+**Example for the publish command:**
+
+    elo publish --tag release-1-2 --server https://nexus.example.de/repository/my-repo/ --multirepoconfig ./elo-cli-multirepo.json
+
+
+### Command: license
+<a id="license_cmd"></a>
+
+The `license` command creates a `3rdPartyLicenses.txt` file that clearly summarizes all productive dependency licenses
+of the project.
+
+**Optional flags:**
+- `--path <string>`: Specifies an additional directory to search for further licenses.
+
+**Example:**
+
+    elo license --path ./3rdpartylicenses
+
+The structure of the directory specified with the `--path` flag should be as follows:
+
+    path/
+        dependency-name/
+            version(/)
+                License[.txt]
+                [Notice[.txt]]
+        dependency-name/
+            version/
+                License[.txt]
+                [Notice[.txt]]
+        [...]
+
+The CLI automatically detects the package manager used and takes the respective dependencies into account. Currently
+supported: `npm`, `pnpm`, and `yarn`.
+
+
+### Command: link
+<a id="link"></a>
+
+With the `link` command, the ELO components listed under `eloDependencies` in the `package.json` can be automatically
+linked. The script reads the entries and links the corresponding NPM modules in the `node_modules/@elo` folder.
+Optionally, a build command (`npm run <command>`) can be executed for each component.
+
+**Conditionally required flags:**
+- `--source_path <path>`: Must be specified if the folder with the components (e.g., `elo-vue-libs`) is not in the
+  default path. The path must contain the folder where the components are located (e.g., `elo-cli`, `elo-core`, etc.).
+
+**Optional flags:**
+- `--no_build`: Skips the build command specified in the entry.
+- `--no_source_link`: Skips executing `npm link` in the respective component folder.
+
+**Example:**
+
+    elo link
+
+**Example for `eloDependencies` in the `package.json`:**
+
+    "eloDependencies": [
+        {
+            "name": "elo-cli",
+            "folder": "elo-cli",
+            "buildCommand": "NONE"
+        },
+        {
+            "name": "core",
+            "folder": "elo-core",
+            "buildCommand": "build"
+        },
+        {
+            "name": "ui",
+            "folder": "elo-ui-components",
+            "buildCommand": "build:lib"
+        }
+    ]
+
+Note: The order of the entries is relevant for correct linking.
+
+- `name`: NPM package name of the component (from its `package.json`)
+- `folder`: Name of the folder within the project (not a path)
+- `buildCommand`: Optional; if specified, `npm run <buildCommand>` is executed for the component
+
+**Process of the link command:**
+
+For each entry in `eloDependencies`:
+1. Change to `<source_path>/<folder>`, execute `npm run <buildCommand>` if applicable, and then `npm link`.
+2. Link the component in the main project with `npm link @elo/<name>`.
+
+
+## License
+<a id="license"></a>
+
+This project is licensed under the MIT License.
+See [LICENSE.txt](./LICENSE.txt) of this package.
+
+## Version history
+<a id="version history"></a>
+
+See the full change history in versionhistory.txt in the package or [npm](https://www.npmjs.com/package/@elo/elo-cli?activeTab=code).