feat(flow): EmbeddedFlow task

Adds an EmbeddedFlow that allow to embed subflow tasks into a parent tasks.

Fixes #6518

.devcontainer/Dockerfile

@@ -0,0 +1,82 @@
+FROM ubuntu:24.04
+
+ARG BUILDPLATFORM
+ARG DEBIAN_FRONTEND=noninteractive
+
+USER root
+WORKDIR /root
+
+RUN apt update && apt install -y \
+  apt-transport-https ca-certificates gnupg curl wget git zip unzip less zsh net-tools iputils-ping jq lsof
+
+ENV HOME="/root"
+
+# --------------------------------------
+# Git
+# --------------------------------------
+# Need to add the devcontainer workspace folder as a safe directory to enable git 
+# version control system to be enabled in the containers file system.
+RUN git config --global --add safe.directory "/workspaces/kestra"
+# --------------------------------------
+
+# --------------------------------------
+# Oh my zsh
+# --------------------------------------
+RUN sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)" -- \
+  -t robbyrussell \
+  -p git -p node -p npm
+
+ENV SHELL=/bin/zsh
+# --------------------------------------
+
+# --------------------------------------
+# Java
+# --------------------------------------
+ARG OS_ARCHITECTURE
+
+RUN mkdir -p /usr/java
+RUN echo "Building on platform: $BUILDPLATFORM"
+RUN case "$BUILDPLATFORM" in \
+  "linux/amd64") OS_ARCHITECTURE="linux-x64" ;; \
+  "linux/arm64") OS_ARCHITECTURE="linux-aarch64" ;; \
+  "darwin/amd64") OS_ARCHITECTURE="macos-x64" ;; \
+  "darwin/arm64") OS_ARCHITECTURE="macos-aarch64" ;; \
+  *) echo "Unsupported BUILDPLATFORM: $BUILDPLATFORM" && exit 1 ;; \
+  esac && \
+  wget "https://aka.ms/download-jdk/microsoft-jdk-21.0.6-$OS_ARCHITECTURE.tar.gz" && \
+  mv "microsoft-jdk-21.0.6-$OS_ARCHITECTURE.tar.gz" microsoft-jdk-21.0.6.tar.gz
+RUN tar -xzvf microsoft-jdk-21.0.6.tar.gz && \
+  mv jdk-21.0.6+7 jdk-21 && \
+  mv jdk-21 /usr/java/
+ENV JAVA_HOME=/usr/java/jdk-21
+ENV PATH="$PATH:$JAVA_HOME/bin"
+# Will load a custom configuration file for Micronaut
+ENV MICRONAUT_ENVIRONMENTS=local,override
+# Sets the path where you save plugins as Jar and is loaded during the startup process
+ENV KESTRA_PLUGINS_PATH="/workspaces/kestra/local/plugins"
+# --------------------------------------
+
+# --------------------------------------
+# Node.js
+# --------------------------------------
+RUN curl -fsSL https://deb.nodesource.com/setup_22.x -o nodesource_setup.sh \
+  && bash nodesource_setup.sh && apt install -y nodejs
+# Increases JavaScript heap memory to 4GB to prevent heap out of error during startup
+ENV NODE_OPTIONS=--max-old-space-size=4096
+# --------------------------------------
+
+# --------------------------------------
+# Python
+# --------------------------------------
+RUN apt install -y python3 pip python3-venv
+# --------------------------------------
+
+# --------------------------------------
+# SSH 
+# --------------------------------------
+RUN mkdir -p ~/.ssh
+RUN touch ~/.ssh/config
+RUN echo "Host github.com" >> ~/.ssh/config \
+  && echo "    IdentityFile ~/.ssh/id_ed25519" >> ~/.ssh/config
+RUN touch ~/.ssh/id_ed25519
+# --------------------------------------

.devcontainer/README.md

@@ -0,0 +1,149 @@
+# Kestra Devcontainer
+
+This devcontainer provides a quick and easy setup for anyone using VSCode to get up and running quickly with this project to start development on either the frontend or backend. It bootstraps a docker container for you to develop inside of without the need to manually setup the environment.
+
+---
+
+## INSTRUCTIONS
+
+### Setup:
+
+Take a look at this guide to get an idea of what the setup is like as this devcontainer setup follows this approach: https://kestra.io/docs/getting-started/contributing
+
+Once you have this repo cloned to your local system, you will need to install the VSCode extension [Remote Development](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.vscode-remote-extensionpack).
+
+Then run the following command from the command palette:
+`Dev Containers: Open Folder in Container...` and select your Kestra root folder.
+
+This will then put you inside a docker container ready for development.
+
+NOTE: you'll need to wait for the gradle build to finish and compile Java files but this process should happen automatically within VSCode.
+
+In the meantime, you can move onto the next step...
+
+---
+
+### Development:
+
+- Create a `.env.development.local` file in the `ui` folder and paste the following:
+
+```bash
+# This lets the frontend know what the backend URL is but you are free to change this to your actual server URL e.g. hosted version of Kestra.
+VITE_APP_API_URL=http://localhost:8080
+```
+
+- Navigate into the `ui` folder and run `npm install` to install the dependencies for the frontend project.
+
+- Now go to the `cli/src/main/resources` folder and create a `application-override.yml` file.
+
+Now you have two choices:
+
+`Local mode`:
+
+Runs the Kestra server in local mode which uses a H2 database, so this is the only config you'd need:
+
+```yaml
+micronaut:
+  server:
+    cors:
+      enabled: true
+      configurations:
+        all:
+          allowedOrigins:
+            - http://localhost:5173
+```
+
+You can then open a new terminal and run the following command to start the backend server: `./gradlew runLocal`
+
+`Standalone mode`:
+
+Runs in standalone mode which uses Postgres. Make sure to have a local Postgres instance already running on localhost:
+
+```yaml
+kestra:
+  repository:
+    type: postgres
+  storage:
+    type: local
+    local:
+      base-path: "/app/storage"
+  queue:
+    type: postgres
+  tasks:
+    tmp-dir:
+      path: /tmp/kestra-wd/tmp
+  anonymous-usage-report:
+    enabled: false
+  server:
+    basic-auth:
+      enabled: false
+
+datasources:
+  postgres:
+    # It is important to note that you must use the "host.docker.internal" host when connecting to a docker container outside of your devcontainer as attempting to use localhost will only point back to this devcontainer.
+    url: jdbc:postgresql://host.docker.internal:5432/kestra
+    driverClassName: org.postgresql.Driver
+    username: kestra
+    password: k3str4
+
+flyway:
+  datasources:
+    postgres:
+      enabled: true
+      locations:
+        - classpath:migrations/postgres
+      # We must ignore missing migrations as we may delete the wrong ones or delete those that are not used anymore.
+      ignore-migration-patterns: "*:missing,*:future"
+      out-of-order: true
+
+micronaut:
+  server:
+    cors:
+      enabled: true
+      configurations:
+        all:
+          allowedOrigins:
+            - http://localhost:5173
+```
+
+Then add the following settings to the `.vscode/launch.json` file:
+
+```json
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "java",
+      "name": "Kestra Standalone",
+      "request": "launch",
+      "mainClass": "io.kestra.cli.App",
+      "projectName": "cli",
+      "args": "server standalone"
+    }
+  ]
+}
+```
+
+You can then use the VSCode `Run and Debug` extension to start the Kestra server.
+
+Additionally, if you're doing frontend development, you can run `npm run dev` from the `ui` folder after having the above running (which will provide a backend) to access your application from `localhost:5173`. This has the benefit to watch your changes and hot-reload upon doing frontend changes.
+
+#### Plugins
+If you want your plugins to be loaded inside your devcontainer, point the `source` field to a folder containing jars of the plugins you want to embed in the following snippet in `devcontainer.json`:
+```
+"mounts": [
+  {
+    "source": "/absolute/path/to/your/local/jar/plugins/folder",
+    "target": "/workspaces/kestra/local/plugins",
+    "type": "bind"
+  }
+],
+```
+
+---
+
+### GIT
+
+If you want to commit to GitHub, make sure to navigate to the `~/.ssh` folder and either create a new SSH key or override the existing `id_ed25519` file and paste an existing SSH key from your local machine into this file. You will then need to change the permissions of the file by running: `chmod 600 id_ed25519`. This will allow you to then push to GitHub.
+
+---

.devcontainer/devcontainer.json

@@ -0,0 +1,46 @@
+{
+  "name": "kestra",
+  "build": {
+    "context": ".",
+    "dockerfile": "Dockerfile"
+  },
+  "workspaceFolder": "/workspaces/kestra",
+  "forwardPorts": [5173, 8080],
+  "customizations": {
+    "vscode": {
+      "settings": {
+        "terminal.integrated.profiles.linux": {
+          "zsh": {
+            "path": "/bin/zsh"
+          }
+        },
+        "workbench.iconTheme": "vscode-icons",
+        "editor.tabSize": 4,
+        "editor.formatOnSave": true,
+        "files.insertFinalNewline": true,
+        "editor.defaultFormatter": "esbenp.prettier-vscode",
+        "telemetry.telemetryLevel": "off",
+        "editor.bracketPairColorization.enabled": true,
+        "editor.guides.bracketPairs": "active"
+      },
+      "extensions": [
+        "redhat.vscode-yaml",
+        "dbaeumer.vscode-eslint",
+        "vscode-icons-team.vscode-icons",
+        "eamodio.gitlens",
+        "esbenp.prettier-vscode",
+        "aaron-bond.better-comments",
+        "codeandstuff.package-json-upgrade",
+        "andys8.jest-snippets",
+        "oderwat.indent-rainbow",
+        "evondev.indent-rainbow-palettes",
+        "formulahendry.auto-rename-tag",
+        "IronGeek.vscode-env",
+        "yoavbls.pretty-ts-errors",
+        "github.vscode-github-actions",
+        "vscjava.vscode-java-pack",
+        "ms-azuretools.vscode-docker"
+      ]
+    }
+  }
+}

.dockerignore

@@ -1,5 +0,0 @@
-# Ignore everything
-**
-
-# Allow docker directories
-!docker/

.gitattributes

@@ -0,0 +1,9 @@
+# Match the .editorconfig
+*           text=auto eol=lf
+
+# Scripts
+*.bat       text eol=crlf
+*.sh        text eol=lf
+
+# Gradle wrapper
+/gradlew    text eol=lf

.github/CODE_OF_CONDUCT.md

@@ -0,0 +1,114 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+hello@kestra.io.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+

.github/CONTRIBUTING.md

@@ -0,0 +1,143 @@
+## Code of Conduct
+
+This project and everyone participating in it is governed by the
+[Kestra Code of Conduct](https://github.com/kestra-io/kestra/blob/develop/.github/CODE_OF_CONDUCT.md).
+By participating, you are expected to uphold this code. Please report unacceptable behavior
+to <hello@kestra.io>.
+
+## I Want To Contribute
+
+> ### Legal Notice
+> When contributing to this project, you must agree that you have authored 100% of the content, that you have the necessary rights to the content and that the content you contribute may be provided under the project license.
+
+
+### Submit issues
+
+### Reporting bugs
+Bug reports help us make Kestra better for everyone. We provide a preconfigured template for bugs to make it very clear what information we need.
+Please search within our [already reported bugs](https://github.com/kestra-io/kestra/issues?q=is%3Aissue+is%3Aopen+label%3Abug) before raising a new one to make sure you're not raising a duplicate.
+
+### Reporting security issues
+Please do not create a public GitHub issue. If you've found a security issue, please email us directly at hello@kestra.io instead of raising an issue.
+
+
+### Requesting new features
+To request new features, please create an issue on this project.
+If you would like to suggest a new feature, we ask that you please use our issue template. It contains a few essential questions that help us understand the problem you are looking to solve and how you think your recommendation will address it.
+To see what has already been proposed by the community, you can look [here](https://github.com/kestra-io/kestra/issues?q=is%3Aissue+is%3Aopen+label%3Aenhancement).
+Watch out for duplicates! If you are creating a new issue, please check existing open, or recently closed. Having a single voted for issue is far easier for us to prioritize.
+
+### Your First Code Contribution
+
+#### Requirements
+The following dependencies are required to build Kestra locally:
+- Java 21+
+- Node 18+ and npm
+- Python 3, pip and python venv
+- Docker & Docker Compose
+- an IDE (Intellij IDEA, Eclipse or VS Code)
+
+Thanks to the Kestra community, if using VSCode, you can also start development on either the frontend or backend with a bootstrapped docker container without the need to manually set up the environment.
+
+Check out the [README](../.devcontainer/README.md) for set-up instructions and the associated [Dockerfile](../.devcontainer/Dockerfile) in the respository to get started.
+
+To start contributing:
+- [Fork](https://docs.github.com/en/github/getting-started-with-github/fork-a-repo) the repository
+- Clone the fork on your workstation:
+
+```shell
+git clone git@github.com:{YOUR_USERNAME}/kestra.git
+cd kestra
+```
+
+#### Develop on the backend
+The backend is made with [Micronaut](https://micronaut.io).
+
+Open the cloned repository in your favorite IDE. In most of decent IDEs, Gradle build will be detected and all dependencies will be downloaded.
+You can also build it from a terminal using `./gradlew build`, the Gradle wrapper will download the right Gradle version to use.
+
+- You may need to enable java annotation processors since we are using them.
+- On IntelliJ IDEA, click on **Run -> Edit Configurations -> + Add new Configuration** to create a run configuration to start Kestra.
+  - The main class is `io.kestra.cli.App` from module `kestra.cli.main`.
+  - Pass as program arguments the server you want to work with, for example `server local` will start the [standalone local](https://kestra.io/docs/administrator-guide/server-cli#kestra-local-development-server-with-no-dependencies). You can also use `server standalone` and use the provided `docker-compose-ci.yml` Docker compose file to start a standalone server with a real database as a backend that would need to be configured properly.
+  - Configure the following environment variables:
+    - `MICRONAUT_ENVIRONMENTS`: can be set to any string and will load a custom configuration file in `cli/src/main/resources/application-{env}.yml`.
+    - `KESTRA_PLUGINS_PATH`: is the path where you will save plugins as Jar and will be load on startup.
+  - See the screenshot below for an example: ![Intellij IDEA Configuration ](run-app.png)
+  - If you encounter **JavaScript memory heap out** error during startup, configure `NODE_OPTIONS` environment variable with some large value.
+      - Example `NODE_OPTIONS: --max-old-space-size=4096` or `NODE_OPTIONS: --max-old-space-size=8192` ![Intellij IDEA Configuration ](node_option_env_var.png)
+- The server starts by default on port 8080 and is reachable on `http://localhost:8080`
+
+If you want to launch all tests, you need Python and some packages installed on your machine, on Ubuntu you can install them with:
+
+```shell
+sudo apt install python3 pip python3-venv
+python3 -m pip install virtualenv
+```
+
+
+#### Develop on the frontend
+The frontend is made with [Vue.js](https://vuejs.org/) and located on the `/ui` folder.
+
+- `npm install`
+- create a file `ui/.env.development.local` with content `VITE_APP_API_URL=http://localhost:8080` (or your actual server url)
+- `npm run dev` will start the development server with hot reload.
+- The server start by default on port 5173 and is reachable on `http://localhost:5173`
+- You can run `npm run build` in order to build the front-end that will be delivered from the backend (without running the `npm run dev`) above.
+
+Now, you need to start a backend server, you could:
+- start a [local server](https://kestra.io/docs/administrator-guide/server-cli#kestra-local-development-server-with-no-dependencies) without a database using this docker-compose file already configured with CORS enabled:
+```yaml
+services:
+  kestra:
+    image: kestra/kestra:latest
+    user: "root"
+    command: server local
+    environment:
+      KESTRA_CONFIGURATION: |
+        micronaut:
+          server:
+            cors:
+              enabled: true
+              configurations:
+                all:
+                  allowedOrigins:
+                    - http://localhost:5173
+    ports:
+      - "8080:8080"
+```
+- start the [Develop backend](#develop-backend) from your IDE, you need to configure CORS restrictions when using the local development npm server, changing the backend configuration allowing the http://localhost:5173 origin in `cli/src/main/resources/application-override.yml`
+
+```yaml
+micronaut:
+  server:
+    cors:
+      enabled: true
+      configurations:
+        all:
+          allowedOrigins:
+            - http://localhost:5173
+```
+
+#### Build and deploy Kestra locally
+
+For testing purposes, you can use the `Makefile` provided at the project's root to build and deploy Kestra locally.
+By default, Kestra will be installed under: `$HOME/.kestra/current`. Set the `KESTRA_HOME` environment variable to override default.
+
+```bash
+# build and install Kestra
+make install
+# install plugins (plugins installation is based on the `.plugins` or `.plugins.override` files located at the root of the project.
+make install-plugins
+# start Kestra in standalone mode with Postgres as backend
+make start-standalone-postgres
+```
+
+Note: the local installation writes logs into the ` ~/.kestra/current/logs/` directory.
+
+#### Develop plugins
+A complete documentation for developing plugin can be found [here](https://kestra.io/docs/plugin-developer-guide/).
+
+### Improving The Documentation
+The main documentation is located in a separate [repository](https://github.com/kestra-io/kestra.io).
+For tasks documentation, they are located directly in the Java source, using [Swagger annotations](https://github.com/swagger-api/swagger-core/wiki/Swagger-2.X---Annotations) (Example: [for Bash tasks](https://github.com/kestra-io/kestra/blob/develop/core/src/main/java/io/kestra/core/tasks/scripts/AbstractBash.java))

.github/ISSUE_TEMPLATE/bug.yml

@@ -0,0 +1,26 @@
+name: Bug report
+description: File a bug report
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for reporting an issue! Please provide a [Minimal Reproducible Example](https://stackoverflow.com/help/minimal-reproducible-example) and share any additional information that may help reproduce, troubleshoot, and hopefully fix the issue, including screenshots, error traceback, and your Kestra server logs. For quick questions, you can contact us directly on [Slack](https://kestra.io/slack).
+  - type: textarea
+    attributes:
+      label: Describe the issue
+      description: A concise description of the issue and how we can reproduce it.
+      placeholder: Describe the issue step by step
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Environment
+      description: Environment information where the problem occurs.
+      value: |
+        - Kestra Version: develop
+    validations:
+      required: false
+labels:
+  - bug
+  - area/backend
+  - area/frontend

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,4 @@
+contact_links:
+  - name: Chat
+    url: https://kestra.io/slack
+    about: Chat with us on Slack.

.github/ISSUE_TEMPLATE/feature.yml

@@ -0,0 +1,13 @@
+name: Feature request
+description: Create a new feature request
+body:
+  - type: textarea
+    attributes:
+      label: Feature description
+      placeholder: Tell us more about your feature request
+    validations:
+      required: true
+labels:
+  - enhancement
+  - area/backend
+  - area/frontend

.github/actions/plugins-list/action.yml

@@ -0,0 +1,29 @@
+name: 'Load Kestra Plugin List'
+description: 'Composite action to load list of plugins'
+inputs:
+  plugin-version:
+    description: "Kestra version"
+    default: 'LATEST'
+    required: true
+  plugin-file:
+    description: "File of the plugins"
+    default: './.plugins'
+    required: true
+outputs:
+  plugins:
+    description: "List of all Kestra plugins"
+    value: ${{ steps.plugins.outputs.plugins }}
+  repositories:
+    description: "List of all Kestra repositories of plugins"
+    value: ${{ steps.plugins.outputs.repositories }}
+runs:
+  using: composite
+  steps:
+    - name: Get Plugins List
+      id: plugins
+      shell: bash
+      run: |
+        PLUGINS=$([ -f ${{ inputs.plugin-file }} ] && cat ${{ inputs.plugin-file }} | grep "io\\.kestra\\." | sed -e '/#/s/^.//' | sed -e "s/LATEST/${{ inputs.plugin-version }}/g" | cut -d':' -f2- | xargs || echo '');
+        REPOSITORIES=$([ -f ${{ inputs.plugin-file }} ] && cat ${{ inputs.plugin-file }} | grep "io\\.kestra\\." | sed -e '/#/s/^.//' | cut -d':' -f1 | uniq | sort | xargs || echo '')
+        echo "plugins=$PLUGINS" >> $GITHUB_OUTPUT
+        echo "repositories=$REPOSITORIES" >> $GITHUB_OUTPUT

.github/actions/setup-vars/action.yml

@@ -0,0 +1,20 @@
+name: 'Setup vars'
+description: 'Composite action to setup common vars'
+outputs:
+  tag:
+    description: "Git tag"
+    value: ${{ steps.vars.outputs.tag }}
+  commit:
+    description: "Git commit"
+    value: ${{ steps.vars.outputs.commit }}
+runs:
+  using: composite
+  steps:
+    # Setup vars
+    - name: Set variables
+      id: vars
+      shell: bash
+      run: |
+        TAG=${GITHUB_REF#refs/*/}
+        echo "tag=${TAG}" >> $GITHUB_OUTPUT
+        echo "commit=$(git rev-parse --short "$GITHUB_SHA")" >> $GITHUB_OUTPUT

.github/dependabot.yml

@@ -0,0 +1,38 @@
+# See GitHub's docs for more information on this file:
+# https://docs.github.com/en/free-pro-team@latest/github/administering-a-repository/configuration-options-for-dependency-updates
+version: 2
+updates:
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      # Check for updates to GitHub Actions every week
+      interval: "weekly"
+    labels:
+      - "dependency-upgrade"
+    open-pull-requests-limit: 50
+
+  # Maintain dependencies for Gradle modules
+  - package-ecosystem: "gradle"
+    directory: "/"
+    schedule:
+      # Check for updates to Gradle modules every week
+      interval: "weekly"
+    labels:
+      - "dependency-upgrade"
+    open-pull-requests-limit: 50
+
+  # Maintain dependencies for NPM modules
+  - package-ecosystem: "npm"
+    directory: "/ui"
+    schedule:
+      interval: "weekly"
+      day: "wednesday"
+      time: "08:00"
+      timezone: "Europe/Paris"
+    open-pull-requests-limit: 50
+    labels: ["dependency-upgrade"]
+    ignore:
+      # Ignore updates of version 1.x, as we're using beta of 2.x
+      - dependency-name: "vue-virtual-scroller"
+        versions: ["1.x"]

.github/pull_request_template.md

@@ -0,0 +1,38 @@
+<!-- Thanks for submitting a Pull Request to Kestra. To help us review your contribution, please follow the guidelines below:
+
+- Make sure that your commits follow the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) specification e.g. `feat(ui): add a new navigation menu item` or `fix(core): fix a bug in the core model` or `docs: update the README.md`. This will help us automatically generate the changelog.
+- The title should briefly summarize the proposed changes.
+- Provide a short overview of the change and the value it adds.
+- Share a flow example to help the reviewer understand and QA the change.
+- Use "closes" to automatically close an issue. For example, `closes #1234` will close issue #1234. -->
+
+### What changes are being made and why?
+
+<!-- Please include a brief summary of the changes included in this PR e.g. closes #1234. -->
+
+---
+
+### How the changes have been QAed?
+
+<!-- Include example code that shows how this PR has been QAed. The code should present a complete yet easily reproducible flow.
+
+```yaml
+# Your example flow code here
+```
+
+Note that this is not a replacement for unit tests but rather a way to demonstrate how the changes work in a real-life scenario, as the end-user would experience them.
+
+Remove this section if this change applies to all flows or to the documentation only. -->
+
+---
+
+### Setup Instructions
+
+<!--If there are any setup requirements like API keys or trial accounts, kindly include brief bullet-points-description outlining the setup process below.
+
+- [External System Documentation](URL)
+- Steps to set up the necessary resources
+
+If there are no setup requirements, you can remove this section.
+
+Thank you for your contribution. ❤️  -->

.github/workflows/codeql-analysis.yml

@@ -6,11 +6,11 @@
 name: "CodeQL"
 
 on:
-  push:
-    branches: [develop]
   schedule:
     - cron: '0 5 * * 1'
 
+  workflow_dispatch: {}
+
 jobs:
   analyze:
     name: Analyze
@@ -27,7 +27,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
       with:
         # We must fetch at least the immediate parents so that if this is
         # a pull request then we can checkout the head.
@@ -40,24 +40,35 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v3
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file. 
+        # By default, queries listed here will override any specified in a config file.
         # Prefix the list here with "+" to use these queries and those in the config file.
         # queries: ./path/to/local/query, your-org/your-repo/queries@main
 
     # Set up JDK
     - name: Set up JDK
-      uses: actions/setup-java@v1
+      uses: actions/setup-java@v4
+      if: ${{ matrix.language == 'java' }}
       with:
-        java-version: 11
+        distribution: 'temurin'
+        java-version: 21
+
+    - name: Setup gradle
+      if: ${{ matrix.language == 'java' }}
+      uses: gradle/actions/setup-gradle@v4
+
+    - name: Build with Gradle
+      if: ${{ matrix.language == 'java' }}
+      run: ./gradlew testClasses -x :ui:installFrontend -x :ui:assembleFrontend
 
     # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
     # If this step fails, then you should remove it and run the build manually (see below)
     - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
+      if: ${{ matrix.language != 'java' }}
+      uses: github/codeql-action/autobuild@v3
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -71,4 +82,4 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      uses: github/codeql-action/analyze@v3

.github/workflows/docker.yml

@@ -0,0 +1,147 @@
+name: Create Docker images on Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      retag-latest:
+        description: 'Retag latest Docker images'
+        required: true
+        type: string
+        default: "true"
+        options:
+          - "true"
+          - "false"
+      release-tag:
+        description: 'Kestra Release Tag'
+        required: false
+        type: string
+      plugin-version:
+        description: 'Plugin version'
+        required: false
+        type: string
+        default: "LATEST"
+env:
+  PLUGIN_VERSION: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
+jobs:
+  plugins:
+    name: List Plugins
+    runs-on: ubuntu-latest
+    outputs:
+      plugins: ${{ steps.plugins.outputs.plugins }}
+    steps:
+      # Checkout
+      - uses: actions/checkout@v4
+
+      # Get Plugins List
+      - name: Get Plugins List
+        uses: ./.github/actions/plugins-list
+        id: plugins
+        with:
+          plugin-version: ${{ env.PLUGIN_VERSION }}
+  docker:
+    name: Publish Docker
+    needs: [ plugins ]
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        image:
+          - name: "-no-plugins"
+            plugins: ""
+            packages: jattach
+            python-libs: ""
+          - name: ""
+            plugins: ${{needs.plugins.outputs.plugins}}
+            packages: python3 python3-venv python-is-python3 python3-pip nodejs npm curl zip unzip jattach
+            python-libs: kestra
+    steps:
+      - uses: actions/checkout@v4
+
+      # Vars
+      - name: Set image name
+        id: vars
+        run: |
+          if [[ "${{ inputs.release-tag }}" == "" ]]; then
+            TAG=${GITHUB_REF#refs/*/}
+            echo "tag=${TAG}" >> $GITHUB_OUTPUT
+          else
+            TAG="${{ inputs.release-tag }}"
+            echo "tag=${TAG}" >> $GITHUB_OUTPUT
+          fi
+
+          if [[ "${{ env.PLUGIN_VERSION }}" == *"-SNAPSHOT" ]]; then
+            echo "plugins=--repositories=https://s01.oss.sonatype.org/content/repositories/snapshots ${{ matrix.image.plugins }}" >> $GITHUB_OUTPUT;
+          else
+            echo "plugins=${{ matrix.image.plugins }}" >> $GITHUB_OUTPUT
+          fi
+      # Download release
+      - name: Download release
+        uses: robinraju/release-downloader@v1.12
+        with:
+          tag: ${{steps.vars.outputs.tag}}
+          fileName: 'kestra-*'
+          out-file-path: build/executable
+
+      - name: Copy exe to image
+        run: |
+          cp build/executable/* docker/app/kestra && chmod +x docker/app/kestra
+
+      # Docker setup
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Docker - Fix Qemu
+        shell: bash
+        run: |
+          docker run --rm --privileged multiarch/qemu-user-static --reset -p yes -c yes
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      # Docker Login
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_PASSWORD }}
+
+      # Docker Build and push
+      - name: Push to Docker Hub
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          tags: ${{ format('kestra/kestra:{0}{1}', steps.vars.outputs.tag, matrix.image.name) }}
+          platforms: linux/amd64,linux/arm64
+          build-args: |
+            KESTRA_PLUGINS=${{ steps.vars.outputs.plugins }}
+            APT_PACKAGES=${{ matrix.image.packages }}
+            PYTHON_LIBRARIES=${{ matrix.image.python-libs }}
+
+      - name: Install regctl
+        if: github.event.inputs.retag-latest == 'true'
+        uses: regclient/actions/regctl-installer@main
+
+      - name: Retag to latest
+        if: github.event.inputs.retag-latest == 'true'
+        run: |
+          regctl image copy ${{ format('kestra/kestra:{0}{1}', steps.vars.outputs.tag, matrix.image.name) }} ${{ format('kestra/kestra:latest{0}', matrix.image.name) }}
+
+  end:
+    runs-on: ubuntu-latest
+    needs:
+      - docker
+    if: always()
+    env:
+      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+    steps:
+
+      # Slack
+      - name: Slack notification
+        uses: Gamesight/slack-workflow-status@master
+        if: ${{ always() && env.SLACK_WEBHOOK_URL != 0 }}
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          slack_webhook_url: ${{ secrets.SLACK_WEBHOOK_URL }}
+          name: GitHub Actions
+          icon_emoji: ':github-actions:'
+          channel: 'C02DQ1A7JLR' # _int_git channel

.github/workflows/e2e.yml

@@ -0,0 +1,158 @@
+name: 'Reusable Workflow for Running End-to-End Tests'
+on:
+  workflow_call:
+    inputs:
+      tags:
+        description: "Tags used for filtering tests to include for QA."
+        type: string
+        required: true
+      docker-artifact-name:
+        description: "The GitHub artifact containing the Kestra docker image."
+        type: string
+        required: false
+      docker-image-tag:
+        description: "The Docker image Tag for Kestra"
+        default: 'kestra/kestra:develop'
+        type: string
+        required: true
+      backend:
+        description: "The Kestra backend type to be used for E2E tests."
+        type: string
+        required: true
+        default: "postgres"
+    secrets:
+      GITHUB_AUTH_TOKEN:
+        description: "The GitHub Token."
+        required: true
+      GOOGLE_SERVICE_ACCOUNT:
+        description: "The Google Service Account."
+        required: false
+jobs:
+  check:
+    timeout-minutes: 60
+    runs-on: ubuntu-latest
+    env:
+      GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
+      E2E_TEST_DOCKER_DIR: ./kestra/e2e-tests/docker
+      KESTRA_BASE_URL: http://127.27.27.27:8080/ui/
+    steps:
+      # Checkout kestra
+      - name: Checkout kestra
+        uses: actions/checkout@v4
+        with:
+          path: kestra
+
+      # Setup build
+      - uses: kestra-io/actions/.github/actions/setup-build@main
+        id: build
+        with:
+          java-enabled: true
+          node-enabled: true
+          python-enabled: true
+
+      # Get Docker Image
+      - name: Download Kestra Image
+        if: inputs.docker-artifact-name != ''
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ inputs.docker-artifact-name }}
+          path: /tmp
+
+      - name: Load Kestra Image
+        if: inputs.docker-artifact-name != ''
+        run: |
+          docker load --input /tmp/${{ inputs.docker-artifact-name }}.tar
+
+      # Docker Compose
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        if: inputs.docker-artifact-name == ''
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ github.token }}
+
+      # Build configuration
+      - name: Create additional application configuration
+        run: |
+          touch ${{ env.E2E_TEST_DOCKER_DIR }}/data/application-secrets.yml
+
+      - name: Setup additional application configuration
+        if: env.APPLICATION_SECRETS != null
+        env:
+          APPLICATION_SECRETS: ${{ secrets.APPLICATION_SECRETS }}
+        run: |
+          echo $APPLICATION_SECRETS | base64 -d > ${{ env.E2E_TEST_DOCKER_DIR }}/data/application-secrets.yml
+
+      # Deploy Docker Compose Stack
+      - name: Run Kestra (${{ inputs.backend }})
+        env:
+          KESTRA_DOCKER_IMAGE: ${{ inputs.docker-image-tag }}
+        run: |
+          cd ${{ env.E2E_TEST_DOCKER_DIR }}
+          echo "KESTRA_DOCKER_IMAGE=$KESTRA_DOCKER_IMAGE" >> .env
+          docker compose -f docker-compose-${{ inputs.backend }}.yml up -d
+
+      - name: Install Playwright Deps
+        run: |
+          cd kestra
+          ./gradlew playwright --args="install-deps"
+
+      # Run E2E Tests
+      - name: Wait For Kestra UI
+        run: |
+          # Start time
+          START_TIME=$(date +%s)
+          # Timeout duration in seconds (5 minutes)
+          TIMEOUT_DURATION=$((5 * 60))
+          while [ $(curl -s -L -o /dev/null -w %{http_code} $KESTRA_BASE_URL) != 200 ]; do
+            echo -e $(date) "\tKestra server HTTP state: " $(curl -k -L -s -o /dev/null -w %{http_code} $KESTRA_BASE_URL) " (waiting for 200)";
+            # Check the elapsed time
+            CURRENT_TIME=$(date +%s)
+            ELAPSED_TIME=$((CURRENT_TIME - START_TIME))
+            # Break the loop if the elapsed time exceeds the timeout duration
+            if [ $ELAPSED_TIME -ge $TIMEOUT_DURATION ]; then
+              echo "Timeout reached: Exiting after 5 minutes."
+              exit 1;
+            fi
+            sleep 2;
+          done;
+          echo "Kestra is running: $KESTRA_BASE_URL 🚀";
+        continue-on-error: true
+
+      - name: Run E2E Tests (${{ inputs.tags }})
+        if: inputs.tags != ''
+        run: |
+          cd kestra
+          ./gradlew e2eTestsCheck -P tags=${{ inputs.tags }}
+
+      - name: Run E2E Tests
+        if: inputs.tags == ''
+        run: |
+          cd kestra
+          ./gradlew e2eTestsCheck
+
+      # Allure check
+      - name: Auth to Google Cloud
+        id: auth
+        if: ${{ !cancelled() && env.GOOGLE_SERVICE_ACCOUNT != 0 }}
+        uses: 'google-github-actions/auth@v2'
+        with:
+          credentials_json: '${{ secrets.GOOGLE_SERVICE_ACCOUNT }}'
+
+      - uses: rlespinasse/github-slug-action@v5
+
+      - name: Publish allure report
+        uses: andrcuns/allure-publish-action@v2.9.0
+        if: ${{ !cancelled() && env.GOOGLE_SERVICE_ACCOUNT != 0 }}
+        env:
+          GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_AUTH_TOKEN }}
+          JAVA_HOME: /usr/lib/jvm/default-jvm/
+        with:
+          storageType: gcs
+          resultsGlob: build/allure-results
+          bucket: internal-kestra-host
+          baseUrl: "https://internal.dev.kestra.io"
+          prefix: ${{ format('{0}/{1}/{2}', github.repository, env.GITHUB_HEAD_REF_SLUG != '' && env.GITHUB_HEAD_REF_SLUG || github.ref_name, 'allure/playwright') }}
+          copyLatest: true
+          ignoreMissingResults: true

.github/workflows/generate-translations.yml

@@ -0,0 +1,67 @@
+name: Auto-Translate UI keys and create PR
+
+on:
+  schedule:
+    - cron: "0 9-21 * * *"  # Every hour from 9 AM to 9 PM
+  workflow_dispatch:
+    inputs:
+      retranslate_modified_keys:
+        description: "Whether to re-translate modified keys even if they already have translations."
+        type: choice
+        options:
+          - "false"
+          - "true"
+        default: "false"
+        required: false
+
+jobs:
+  translations:
+    name: Translations
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+        - uses: actions/checkout@v4
+          name: Checkout
+          with:
+            fetch-depth: 0
+
+        - name: Set up Python
+          uses: actions/setup-python@v5
+          with:
+            python-version: "3.x"
+
+        - name: Install Python dependencies
+          run: pip install gitpython openai
+
+        - name: Generate translations
+          run: python ui/src/translations/generate_translations.py ${{ github.event.inputs.retranslate_modified_keys }}
+          env:
+            OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+
+        - name: Set up Node
+          uses: actions/setup-node@v4
+          with:
+            node-version: "20.x"
+
+        - name: Check keys matching
+          run: node ui/src/translations/check.js
+
+        - name: Set up Git
+          run: |
+            git config --global user.name "GitHub Action"
+            git config --global user.email "actions@github.com"
+
+        - name: Commit and create PR
+          env:
+            GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          run: |
+            BRANCH_NAME="chore/update-translations-$(date +%s)"
+            git checkout -b $BRANCH_NAME
+            git add ui/src/translations/*.json
+            if git diff --cached --quiet; then
+              echo "No changes to commit. Exiting with success."
+              exit 0
+            fi
+            git commit -m "chore(core): localize to languages other than english" -m "Extended localization support by adding translations for multiple languages using English as the base. This enhances accessibility and usability for non-English-speaking users while keeping English as the source reference."
+            git push -u origin $BRANCH_NAME || (git push origin --delete $BRANCH_NAME && git push -u origin $BRANCH_NAME)
+            gh pr create --title "Translations from en.json" --body "This PR was created automatically by a GitHub Action." --base develop --head $BRANCH_NAME --assignee anna-geller --reviewer anna-geller

.github/workflows/gradle-release-plugins.yml

@@ -0,0 +1,82 @@
+name: Run Gradle Release for Kestra Plugins
+
+on:
+  workflow_dispatch:
+    inputs:
+      releaseVersion:
+        description: 'The release version (e.g., 0.21.0-rc1)'
+        required: true
+        type: string
+      nextVersion:
+        description: 'The next version (e.g., 0.22.0-SNAPSHOT)'
+        required: true
+        type: string
+      dryRun:
+        description: 'Use DRY_RUN mode'
+        required: false
+        default: 'false'
+jobs:
+  release:
+    name: Release plugins
+    runs-on: ubuntu-latest
+    steps:
+      # Checkout
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # Checkout GitHub Actions
+      - uses: actions/checkout@v4
+        with:
+          repository: kestra-io/actions
+          path: actions
+          ref: main
+
+      # Setup build
+      - uses: ./actions/.github/actions/setup-build
+        id: build
+        with:
+          java-enabled: true
+          node-enabled: true
+          python-enabled: true
+          caches-enabled: true
+
+      # Get Plugins List
+      - name: Get Plugins List
+        uses: ./.github/actions/plugins-list
+        id: plugins-list
+        with:
+          plugin-version: 'LATEST'
+
+      - name: 'Configure Git'
+        run: |
+          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+
+      # Execute
+      - name: Run Gradle Release
+        if: ${{ github.event.inputs.dryRun == 'false' }}
+        env:
+          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
+        run: |
+          chmod +x ./dev-tools/release-plugins.sh;
+          
+          ./dev-tools/release-plugins.sh \
+          --release-version=${{github.event.inputs.releaseVersion}} \
+          --next-version=${{github.event.inputs.nextVersion}} \
+          --yes \
+           ${{ steps.plugins-list.outputs.repositories }}
+
+      - name: Run Gradle Release (DRY_RUN)
+        if: ${{ github.event.inputs.dryRun == 'true' }}
+        env:
+          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
+        run: |
+          chmod +x ./dev-tools/release-plugins.sh;
+          
+          ./dev-tools/release-plugins.sh \
+          --release-version=${{github.event.inputs.releaseVersion}} \
+          --next-version=${{github.event.inputs.nextVersion}} \
+          --dry-run \
+          --yes \
+          ${{ steps.plugins-list.outputs.repositories }}

.github/workflows/gradle-release.yml

@@ -0,0 +1,89 @@
+name: Run Gradle Release
+run-name: "Releasing Kestra ${{ github.event.inputs.releaseVersion }} 🚀"
+on:
+  workflow_dispatch:
+    inputs:
+      releaseVersion:
+        description: 'The release version (e.g., 0.21.0-rc1)'
+        required: true
+        type: string
+      nextVersion:
+        description: 'The next version (e.g., 0.22.0-SNAPSHOT)'
+        required: true
+        type: string
+env:
+  RELEASE_VERSION: "${{ github.event.inputs.releaseVersion }}"
+  NEXT_VERSION: "${{ github.event.inputs.nextVersion }}"
+jobs:
+  release:
+    name: Release Kestra
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/develop'
+    steps:
+      # Checks
+      - name: Check Inputs
+        run: |
+          if ! [[ "$RELEASE_VERSION" =~ ^[0-9]+(\.[0-9]+)\.0-rc[01](-SNAPSHOT)?$ ]]; then
+            echo "Invalid release version. Must match regex: ^[0-9]+(\.[0-9]+)\.0-rc[01](-SNAPSHOT)?$"
+            exit 1
+          fi
+            
+          if ! [[ "$NEXT_VERSION" =~ ^[0-9]+(\.[0-9]+)\.0-SNAPSHOT$ ]]; then
+            echo "Invalid next version. Must match regex: ^[0-9]+(\.[0-9]+)\.0-SNAPSHOT$"
+            exit 1;
+          fi
+      # Checkout
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # Checkout GitHub Actions
+      - uses: actions/checkout@v4
+        with:
+          repository: kestra-io/actions
+          path: actions
+          ref: main
+
+      # Setup build
+      - uses: ./actions/.github/actions/setup-build
+        id: build
+        with:
+          java-enabled: true
+          node-enabled: true
+          python-enabled: true
+          caches-enabled: true
+
+      - name: Configure Git
+        run: |
+          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+
+      # Execute
+      - name: Run Gradle Release
+        env:
+          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
+        run: |          
+          # Extract the major and minor versions
+          BASE_VERSION=$(echo "$RELEASE_VERSION" | sed -E 's/^([0-9]+\.[0-9]+)\..*/\1/')
+          PUSH_RELEASE_BRANCH="releases/v${BASE_VERSION}.x"
+  
+          # Create and push release branch
+          git checkout -b "$PUSH_RELEASE_BRANCH";
+          git push -u origin "$PUSH_RELEASE_BRANCH";
+      
+          # Run gradle release
+          git checkout develop;
+      
+          if [[ "$RELEASE_VERSION" == *"-SNAPSHOT" ]]; then
+            # -SNAPSHOT qualifier maybe used to test release-candidates
+            ./gradlew release -Prelease.useAutomaticVersion=true \
+            -Prelease.releaseVersion="${RELEASE_VERSION}" \
+            -Prelease.newVersion="${NEXT_VERSION}" \
+            -Prelease.pushReleaseVersionBranch="${PUSH_RELEASE_BRANCH}" \
+            -Prelease.failOnSnapshotDependencies=false
+          else
+            ./gradlew release -Prelease.useAutomaticVersion=true \
+            -Prelease.releaseVersion="${RELEASE_VERSION}" \
+            -Prelease.newVersion="${NEXT_VERSION}" \
+            -Prelease.pushReleaseVersionBranch="${PUSH_RELEASE_BRANCH}"
+          fi

.github/workflows/main.yml

@@ -1,240 +1,74 @@
-name: Main
+name: Main Workflow
 
 on:
+  workflow_dispatch:
+    inputs:
+      plugin-version:
+          description: "Kestra version"
+          default: 'LATEST'
+          required: true
+          type: string
   push:
     branches:
       - master
+      - main
+      - releases/*
       - develop
-      - release
     tags:
       - v*
 
-  pull_request:
-    branches:
-      - master
-      - develop
-      - release
-  repository_dispatch:
-    types: [rebuild]
-  workflow_dispatch:
-
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-main
+  cancel-in-progress: true
 
 jobs:
-  check:
-    name: Check
+  tests:
+    name: Execute tests
+    uses: ./.github/workflows/workflow-test.yml
+    with:
+      report-status: false
+
+  release:
+    name: Release
+    needs: [tests]
+    if: "!startsWith(github.ref, 'refs/heads/releases')"
+    uses: ./.github/workflows/workflow-release.yml
+    with:
+        plugin-version: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
+    secrets:
+      DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+      DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
+      SONATYPE_USER: ${{ secrets.SONATYPE_USER }}
+      SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
+      SONATYPE_GPG_KEYID: ${{ secrets.SONATYPE_GPG_KEYID }}
+      SONATYPE_GPG_PASSWORD: ${{ secrets.SONATYPE_GPG_PASSWORD }}
+      SONATYPE_GPG_FILE: ${{ secrets.SONATYPE_GPG_FILE }}
+
+  end:
     runs-on: ubuntu-latest
-    timeout-minutes: 25
-
-    strategy:
-      matrix:
-        java: ['11']
-
+    needs:
+      - release
+    if: always()
+    env:
+      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2
+      # Update
+      - name: Github - Update internal
+        uses: benc-uk/workflow-dispatch@v1
+        if: github.ref == 'refs/heads/develop' && needs.docker.result == 'success'
         with:
-          python-version: '3.x'
-          architecture: 'x64'
-      - uses: actions/setup-node@v1
-        with:
-          node-version: '12'
-          check-latest: true
-
-      # Services
-      - name: Build the docker-compose stack
-        run: docker-compose -f docker-compose-ci.yml up -d
-
-      # Caches
-      - name: Gradle cache
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.gradle/caches
-            ~/.gradle/wrapper
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle*.properties') }}
-          restore-keys: |
-            ${{ runner.os }}-gradle-
-
-      - name: Npm cache
-        uses: actions/cache@v1
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-node-
-      - name: Node cache
-        uses: actions/cache@v1
-        with:
-          path: node
-          key: ${{ runner.os }}-node-${{ hashFiles('ui/*.gradle') }}
-          restore-keys: |
-            ${{ runner.os }}-node-
-
-      # JDK
-      - name: Set up JDK
-        uses: actions/setup-java@v1
-        with:
-          java-version: ${{ matrix.java }}
-
-      # Gradle check
-      - name: Build with Gradle
-        env:
-          GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
-        run: |
-          python3 -m pip install virtualenv
-          echo $GOOGLE_SERVICE_ACCOUNT | base64 -d > ~/.gcp-service-account.json
-          export GOOGLE_APPLICATION_CREDENTIALS=$HOME/.gcp-service-account.json
-          ./gradlew classes testClasses --parallel --no-daemon
-          ./gradlew check jacoco --no-daemon
-        # --parallel
-
-      # Codecov
-      - uses: codecov/codecov-action@v1
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-#          directory: ./build/reports/jacoco/jacoco/html/index.html
-
-      # Shadow Jar
-      - name: Build jars
-        if: success() && matrix.java == '11'
-        run: ./gradlew executableJar --no-daemon
-
-      # Publish
-      - name: Publish package to Sonatype
-        if: github.ref == 'refs/heads/develop'
-        env:
-          ORG_GRADLE_PROJECT_sonatypeUsername: ${{ secrets.SONATYPE_USER }}
-          ORG_GRADLE_PROJECT_sonatypePassword: ${{ secrets.SONATYPE_PASSWORD }}
-          SONATYPE_GPG_KEYID: ${{ secrets.SONATYPE_GPG_KEYID }}
-          SONATYPE_GPG_PASSWORD: ${{ secrets.SONATYPE_GPG_PASSWORD }}
-          SONATYPE_GPG_FILE: ${{ secrets.SONATYPE_GPG_FILE }}
-        run: |
-          echo "signing.keyId=${SONATYPE_GPG_KEYID}" > ~/.gradle/gradle.properties
-          echo "signing.password=${SONATYPE_GPG_PASSWORD}" >> ~/.gradle/gradle.properties
-          echo "signing.secretKeyRingFile=${HOME}/.gradle/secring.gpg" >> ~/.gradle/gradle.properties
-          echo ${SONATYPE_GPG_FILE} | base64 -d > ~/.gradle/secring.gpg
-          ./gradlew publishToSonatype --parallel --no-daemon
-
-      # Release
-      - name: Release package to Maven Central
-        if: startsWith(github.ref, 'refs/tags/v')
-        env:
-          ORG_GRADLE_PROJECT_sonatypeUsername: ${{ secrets.SONATYPE_USER }}
-          ORG_GRADLE_PROJECT_sonatypePassword: ${{ secrets.SONATYPE_PASSWORD }}
-          SONATYPE_GPG_KEYID: ${{ secrets.SONATYPE_GPG_KEYID }}
-          SONATYPE_GPG_PASSWORD: ${{ secrets.SONATYPE_GPG_PASSWORD }}
-          SONATYPE_GPG_FILE: ${{ secrets.SONATYPE_GPG_FILE }}
-        run: |
-          echo "signing.keyId=${SONATYPE_GPG_KEYID}" > ~/.gradle/gradle.properties
-          echo "signing.password=${SONATYPE_GPG_PASSWORD}" >> ~/.gradle/gradle.properties
-          echo "signing.secretKeyRingFile=${HOME}/.gradle/secring.gpg" >> ~/.gradle/gradle.properties
-          echo ${SONATYPE_GPG_FILE} | base64 -d > ~/.gradle/secring.gpg
-          ./gradlew publishToSonatype closeAndReleaseSonatypeStagingRepository --no-daemon
-
-      # Upload artifacts
-      - name: Upload jar
-        uses: actions/upload-artifact@v1
-        if: success() && matrix.java == '11'
-        with:
-          name: jar
-          path: build/libs/
-
-      - name: Upload Executable
-        uses: actions/upload-artifact@v1
-        if: success() && matrix.java == '11'
-        with:
-          name: exe
-          path: build/executable/
+          workflow: oss-build.yml
+          repo: kestra-io/infra
+          ref: master
+          token: ${{ secrets.GH_PERSONAL_TOKEN }}
 
       # Slack
-      - name: Slack notification
-        uses: 8398a7/action-slack@v3
-        if: always()
+      - name: Slack - Notification
+        uses: Gamesight/slack-workflow-status@master
+        if: ${{ always() && env.SLACK_WEBHOOK_URL != 0 }}
         with:
-          status: ${{ job.status }}
-          job_name: Check
-          fields: repo,message,author,action,ref,job,took
-          username: Github Actions
-          icon_emoji: ':octocat:'
-          channel: '#kestra'
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
-          MATRIX_CONTEXT: ${{ toJson(matrix) }}
-
-  docker:
-    name: Publish docker
-    runs-on: ubuntu-latest
-    needs: check
-    if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/develop' || github.ref == 'refs/heads/release' || startsWith(github.ref, 'refs/tags/v')
-    steps:
-      - uses: actions/checkout@v2
-
-      # Artifact
-      - name: Download executable
-        uses: actions/download-artifact@v1
-        with:
-          name: exe
-
-      - name: Copy exe to image
-        run: |
-          cp exe/* docker/app/kestra && chmod +x docker/app/kestra
-
-      # Vars
-      - name: Set image name
-        id: vars
-        run: |
-          TAG=${GITHUB_REF#refs/*/}
-          if [[ $TAG = "master" ]]
-          then
-            echo ::set-output name=tag::latest
-            echo ::set-output name=plugins::
-          else
-            echo ::set-output name=tag::${TAG}
-            echo ::set-output name=plugins::--repositories=https://s01.oss.sonatype.org/content/repositories/snapshots
-          fi
-
-      # Docker
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-
-      - name: Login to DockerHub
-        uses: docker/login-action@v1
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_PASSWORD }}
-
-      - name: Push to Docker Hub
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          push: true
-          tags: ${{ format('kestra/kestra:{0}', steps.vars.outputs.tag) }}
-
-      - name: Push to Docker Hub Full
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          push: true
-          tags: ${{ format('kestra/kestra:{0}-full', steps.vars.outputs.tag) }}
-          build-args: |
-            KESTRA_PLUGINS=${{ steps.vars.outputs.plugins }} io.kestra.storage:storage-gcs:LATEST io.kestra.storage:storage-minio:LATEST io.kestra.plugin:plugin-aws:LATEST io.kestra.plugin:plugin-fs:LATEST io.kestra.plugin:plugin-gcp:LATEST io.kestra.plugin:plugin-kubernetes:LATEST io.kestra.plugin:plugin-serdes:LATEST io.kestra.plugin:plugin-notifications:LATEST io.kestra.plugin:plugin-crypto:LATEST io.kestra.plugin:plugin-jdbc-mysql:LATEST io.kestra.plugin:plugin-jdbc-postgres:LATEST io.kestra.plugin:plugin-jdbc-vertica:LATEST io.kestra.plugin:plugin-jdbc-clickhouse:LATEST io.kestra.plugin:plugin-script-groovy:LATEST io.kestra.plugin:plugin-script-jython:LATEST io.kestra.plugin:plugin-script-nashorn:LATEST
-            APT_PACKAGES=python3-pip python3-wheel python3-setuptools python3-virtualenv nodejs
-
-      # Slack
-      - name: Slack notification
-        uses: 8398a7/action-slack@v3
-        if: always()
-        with:
-          status: ${{ job.status }}
-          job_name: Publish docker
-          fields: repo,commit,action,ref,job,took
-          username: Github Actions
-          icon_emoji: ':octocat:'
-          channel: '#kestra'
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          slack_webhook_url: ${{ secrets.SLACK_WEBHOOK_URL }}
+          name: GitHub Actions
+          icon_emoji: ":github-actions:"
+          channel: "C02DQ1A7JLR" # _int_git channel

.github/workflows/pull-request.yml

@@ -0,0 +1,74 @@
+name: Pull Request Workflow
+
+on:
+  pull_request:
+    branches:
+      - develop
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref_name }}-pr
+  cancel-in-progress: true
+
+jobs:
+  # ********************************************************************************************************************
+  # File changes detection
+  # ********************************************************************************************************************
+  file-changes:
+    if: ${{ github.event.pull_request.draft == false }}
+    name: File changes detection
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    outputs:
+      ui: ${{ steps.changes.outputs.ui }}
+      translations: ${{ steps.changes.outputs.translations }}
+      backend: ${{ steps.changes.outputs.backend }}
+    steps:
+      - uses: dorny/paths-filter@v3
+        id: changes
+        with:
+          filters: |
+            ui:
+              - 'ui/**'
+            backend:
+              - '!{ui,.github}/**'
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+  # ********************************************************************************************************************
+  # Tests
+  # ********************************************************************************************************************
+  frontend:
+    name: Frontend - Tests
+    needs: [file-changes]
+    if: "needs.file-changes.outputs.ui == 'true'"
+    uses: ./.github/workflows/workflow-frontend-test.yml
+    secrets:
+      GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  backend:
+    name: Backend - Tests
+    needs: file-changes
+    if: "needs.file-changes.outputs.backend == 'true'"
+    uses: ./.github/workflows/workflow-backend-test.yml
+    secrets:
+      GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+      GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
+
+  end:
+    name: End
+    runs-on: ubuntu-latest
+    if: always()
+    needs: [frontend, backend]
+    steps:
+      # Slack
+      - name: Slack notification
+        uses: Gamesight/slack-workflow-status@master
+        if: ${{ always() && env.SLACK_WEBHOOK_URL != 0 }}
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          slack_webhook_url: ${{ secrets.SLACK_WEBHOOK_URL }}
+          name: GitHub Actions
+          icon_emoji: ":github-actions:"
+          channel: "C02DQ1A7JLR"

.github/workflows/setversion-tag-plugins.yml

@@ -0,0 +1,60 @@
+name: Set Version and Tag Plugins
+
+on:
+  workflow_dispatch:
+    inputs:
+      releaseVersion:
+        description: 'The release version (e.g., 0.21.0)'
+        required: true
+        type: string
+      dryRun:
+        description: 'Use DRY_RUN mode'
+        required: false
+        default: 'false'
+jobs:
+  tag:
+    name: Release plugins
+    runs-on: ubuntu-latest
+    steps:
+      # Checkout
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # Get Plugins List
+      - name: Get Plugins List
+        uses: ./.github/actions/plugins-list
+        id: plugins-list
+        with:
+          plugin-version: 'LATEST'
+
+      - name: 'Configure Git'
+        run: |
+          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+
+      # Execute
+      - name: Set Version and Tag Plugins
+        if: ${{ github.event.inputs.dryRun == 'false' }}
+        env:
+          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
+        run: |
+          chmod +x ./dev-tools/setversion-tag-plugins.sh;
+          
+          ./dev-tools/setversion-tag-plugins.sh \
+          --release-version=${{github.event.inputs.releaseVersion}} \
+          --yes \
+           ${{ steps.plugins-list.outputs.repositories }}
+
+      - name: Set Version and Tag Plugins (DRY_RUN)
+        if: ${{ github.event.inputs.dryRun == 'true' }}
+        env:
+          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
+        run: |
+          chmod +x ./dev-tools/setversion-tag-plugins.sh;
+          
+          ./dev-tools/setversion-tag-plugins.sh \
+          --release-version=${{github.event.inputs.releaseVersion}} \
+          --dry-run \
+          --yes \
+          ${{ steps.plugins-list.outputs.repositories }}

.github/workflows/setversion-tag.yml

@@ -0,0 +1,57 @@
+name: Set Version and Tag
+run-name: "Set version and Tag Kestra to ${{ github.event.inputs.releaseVersion }} 🚀"
+on:
+  workflow_dispatch:
+    inputs:
+      releaseVersion:
+        description: 'The release version (e.g., 0.21.1)'
+        required: true
+        type: string
+env:
+  RELEASE_VERSION: "${{ github.event.inputs.releaseVersion }}"
+jobs:
+  release:
+    name: Release Kestra
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/heads/releases/v')
+    steps:
+      # Checks
+      - name: Check Inputs
+        run: |
+          if ! [[ "$RELEASE_VERSION" =~ ^[0-9]+(\.[0-9]+)(\.[0-9]+)(-rc[0-9])?(-SNAPSHOT)?$ ]]; then
+            echo "Invalid release version. Must match regex: ^[0-9]+(\.[0-9]+)(\.[0-9]+)-(rc[0-9])?(-SNAPSHOT)?$"
+            exit 1
+          fi
+          
+          # Extract the major and minor versions
+          BASE_VERSION=$(echo "$RELEASE_VERSION" | sed -E 's/^([0-9]+\.[0-9]+)\..*/\1/')
+          RELEASE_BRANCH="refs/heads/releases/v${BASE_VERSION}.x"
+          
+          CURRENT_BRANCH="$GITHUB_REF"
+          if ! [[ "$CURRENT_BRANCH" == "$RELEASE_BRANCH" ]]; then
+            echo "Invalid release branch. Expected $RELEASE_BRANCH, was $CURRENT_BRANCH"
+            exit 1
+          fi
+
+      # Checkout
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Configure Git
+        run: |
+          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+
+      # Execute
+      - name: Run Gradle Release
+        env:
+          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
+        run: |
+          # Update version
+          sed -i "s/^version=.*/version=$RELEASE_VERSION/" ./gradle.properties
+          git add ./gradle.properties
+          git commit -m"chore(version): update to version '$RELEASE_VERSION'"
+          git push
+          git tag -a "v$RELEASE_VERSION" -m"v$RELEASE_VERSION"
+          git push origin "v$RELEASE_VERSION"

.github/workflows/vulnerabilities-check.yml

@@ -0,0 +1,121 @@
+name: Vulnerabilities Checks
+
+on:
+  schedule:
+    - cron: "0 0 * * *"  # Every day
+  workflow_dispatch: {}
+
+env:
+  JAVA_VERSION: '21'
+
+jobs:
+  dependency-check:
+    name: Dependency Check
+    runs-on: ubuntu-latest
+    steps:
+      # Checkout
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # Checkout GitHub Actions
+      - uses: actions/checkout@v4
+        with:
+          repository: kestra-io/actions
+          path: actions
+          ref: main
+
+      # Setup build
+      - uses: ./actions/.github/actions/setup-build
+        id: build
+        with:
+          java-enabled: true
+          node-enabled: true
+          caches-enabled: true
+
+      # Npm
+      - name: Npm - Install
+        shell: bash
+        working-directory: ui
+        run: npm ci
+
+      # Run OWASP dependency check plugin
+      - name: Gradle Dependency Check
+        env:
+          NVD_API_KEY: ${{ secrets.NIST_APIKEY }}
+        run: |
+          ./gradlew dependencyCheckAggregate
+
+        # Upload dependency check report
+      - name: Upload dependency check report
+        uses: actions/upload-artifact@v4
+        if: ${{ always() }}
+        with:
+          name: dependency-check-report
+          path: build/reports/dependency-check-report.html
+
+  develop-image-check:
+    name: Image Check (develop)
+    runs-on: ubuntu-latest
+    steps:
+      # Checkout
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # Checkout GitHub Actions
+      - uses: actions/checkout@v4
+        with:
+          repository: kestra-io/actions
+          path: actions
+          ref: main
+
+      # Setup build
+      - uses: ./actions/.github/actions/setup-build
+        id: build
+        with:
+          java-enabled: false
+          node-enabled: false
+          caches-enabled: true
+
+      # Run Trivy image scan for Docker vulnerabilities, see https://github.com/aquasecurity/trivy-action
+      - name: Docker Vulnerabilities Check
+        uses: aquasecurity/trivy-action@0.30.0
+        with:
+          image-ref: kestra/kestra:develop
+          format: table
+          skip-dirs: /app/plugins
+          scanners: vuln
+
+  latest-image-check:
+    name: Image Check (latest)
+    runs-on: ubuntu-latest
+    steps:
+      # Checkout
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # Checkout GitHub Actions
+      - uses: actions/checkout@v4
+        with:
+          repository: kestra-io/actions
+          path: actions
+          ref: main
+
+      # Setup build
+      - uses: ./actions/.github/actions/setup-build
+        id: build
+        with:
+          java-enabled: false
+          node-enabled: false
+          caches-enabled: true
+
+      # Run Trivy image scan for Docker vulnerabilities, see https://github.com/aquasecurity/trivy-action
+      - name: Docker Vulnerabilities Check
+        uses: aquasecurity/trivy-action@0.30.0
+        with:
+          image-ref: kestra/kestra:latest
+          format: table
+          skip-dirs: /app/plugins
+          scanners: vuln

.github/workflows/workflow-backend-test.yml

@@ -0,0 +1,140 @@
+name: Backend - Tests
+
+on:
+  workflow_call:
+    secrets:
+      GITHUB_AUTH_TOKEN:
+        description: "The GitHub Token."
+        required: true
+      CODECOV_TOKEN:
+        description: 'Codecov Token'
+        required: true
+      SONAR_TOKEN:
+        description: 'Sonar Token'
+        required: true
+      GOOGLE_SERVICE_ACCOUNT:
+        description: 'Google Service Account'
+        required: true
+
+permissions:
+  contents: write
+  checks: write
+  actions: read
+
+jobs:
+  test:
+    name: Backend - Tests
+    runs-on: ubuntu-latest
+    env:
+      GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
+      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        name: Checkout - Current ref
+
+      # Setup build
+      - uses: kestra-io/actions/.github/actions/setup-build@main
+        name: Setup - Build
+        id: build
+        with:
+          java-enabled: true
+          node-enabled: true
+          python-enabled: true
+
+      # Services
+      - name: Setup - Start docker compose
+        shell: bash
+        run: docker compose -f docker-compose-ci.yml up -d
+
+      # Gradle check
+      - name: Gradle - Build
+        if: ${{ github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '' }}
+        env:
+          GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
+        shell: bash
+        run: |
+          echo $GOOGLE_SERVICE_ACCOUNT | base64 -d > ~/.gcp-service-account.json
+          export GOOGLE_APPLICATION_CREDENTIALS=$HOME/.gcp-service-account.json
+          ./gradlew check javadoc --parallel
+
+      # report test
+      - name: Test - Publish Test Results
+        uses: dorny/test-reporter@v2
+        if: always()
+        with:
+          name: Java Tests Report
+          reporter: java-junit
+          path: '**/build/test-results/test/TEST-*.xml'
+          list-suites: 'failed'
+          list-tests: 'failed'
+          fail-on-error: 'false'
+          token: ${{ secrets.GITHUB_AUTH_TOKEN }}
+
+      # Sonar
+      - name: Test - Analyze with Sonar
+        if: env.SONAR_TOKEN != ''
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_AUTH_TOKEN }}
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+        shell: bash
+        run: ./gradlew sonar --info
+
+      # GCP
+      - name: GCP - Auth with unit test account
+        id: auth
+        if: always() && env.GOOGLE_SERVICE_ACCOUNT != ''
+        continue-on-error: true
+        uses: "google-github-actions/auth@v2"
+        with:
+          credentials_json: "${{ secrets.GOOGLE_SERVICE_ACCOUNT }}"
+
+      - name: GCP - Setup Cloud SDK
+        if: env.GOOGLE_SERVICE_ACCOUNT != ''
+        uses: "google-github-actions/setup-gcloud@v2"
+
+        # Allure check
+      - uses: rlespinasse/github-slug-action@v5
+        name: Allure - Generate slug variables
+
+      - name: Allure - Publish report
+        uses: andrcuns/allure-publish-action@v2.9.0
+        if: always() && env.GOOGLE_SERVICE_ACCOUNT != ''
+        continue-on-error: true
+        env:
+          GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_AUTH_TOKEN }}
+          JAVA_HOME: /usr/lib/jvm/default-jvm/
+        with:
+          storageType: gcs
+          resultsGlob: "**/build/allure-results"
+          bucket: internal-kestra-host
+          baseUrl: "https://internal.dev.kestra.io"
+          prefix: ${{ format('{0}/{1}', github.repository, 'allure/java') }}
+          copyLatest: true
+          ignoreMissingResults: true
+
+      # Jacoco
+      - name: Jacoco - Copy reports
+        if: env.GOOGLE_SERVICE_ACCOUNT != ''
+        continue-on-error: true
+        shell: bash
+        run: |
+          mv build/reports/jacoco/testCodeCoverageReport build/reports/jacoco/test/
+          mv build/reports/jacoco/test/testCodeCoverageReport.xml build/reports/jacoco/test/jacocoTestReport.xml
+          gsutil -m rsync -d -r  build/reports/jacoco/test/ gs://internal-kestra-host/${{ format('{0}/{1}', github.repository, 'jacoco') }}
+
+      # Codecov
+      - name: Codecov - Upload coverage reports
+        uses: codecov/codecov-action@v5
+        if: ${{ !cancelled() }}
+        continue-on-error: true
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          flags: backend
+
+      - name: Codecov - Upload test results
+        uses: codecov/test-results-action@v1
+        if: ${{ !cancelled() }}
+        continue-on-error: true
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          flags: backend

.github/workflows/workflow-build-artifacts.yml

@@ -0,0 +1,152 @@
+name: Build Artifacts
+
+on:
+  workflow_call:
+    inputs:
+      plugin-version:
+        description: "Kestra version"
+        default: 'LATEST'
+        required: true
+        type: string
+    outputs:
+      docker-tag:
+        value: ${{ jobs.build.outputs.docker-tag }}
+        description: "The Docker image Tag for Kestra"
+      docker-artifact-name:
+        value: ${{ jobs.build.outputs.docker-artifact-name }}
+        description: "The GitHub artifact containing the Kestra docker image name."
+      plugins:
+        value: ${{ jobs.build.outputs.plugins }}
+        description: "The Kestra plugins list used for the build."
+
+jobs:
+  build:
+    name: Build - Artifacts
+    runs-on: ubuntu-latest
+    outputs:
+        docker-tag: ${{ steps.vars.outputs.tag }}
+        docker-artifact-name: ${{ steps.vars.outputs.artifact }}
+        plugins: ${{ steps.plugins.outputs.plugins }}
+    env:
+      PLUGIN_VERSION: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
+    steps:
+      - name: Checkout - Current ref
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # Npm
+      - name: Setup - Npm install
+        shell: bash
+        working-directory: ui
+        run: npm ci
+
+      # Setup build
+      - uses: kestra-io/actions/.github/actions/setup-build@main
+        name: Setup - Build
+        id: build
+        with:
+          java-enabled: true
+          node-enabled: true
+
+      # Get Plugins List
+      - name: Plugins - Get List
+        uses: ./.github/actions/plugins-list
+        if: "!startsWith(github.ref, 'refs/tags/v')"
+        id: plugins-list
+        with:
+          plugin-version: ${{ env.PLUGIN_VERSION }}
+
+      # Set Plugins List
+      - name: Plugins - Set List
+        id: plugins
+        if: "!startsWith(github.ref, 'refs/tags/v')"
+        shell: bash
+        run: |
+          PLUGINS="${{ steps.plugins-list.outputs.plugins }}"
+          TAG=${GITHUB_REF#refs/*/}
+          if [[ $TAG = "master" || $TAG == v* ]]; then
+            echo "plugins=$PLUGINS" >> $GITHUB_OUTPUT
+          else
+            echo "plugins=--repositories=https://s01.oss.sonatype.org/content/repositories/snapshots $PLUGINS" >> $GITHUB_OUTPUT
+          fi
+
+      # Build
+      - name: Gradle - Build
+        shell: bash
+        run: |
+          ./gradlew executableJar
+
+      - name: Artifacts - Copy exe to image
+        shell: bash
+        run: |
+          cp build/executable/* docker/app/kestra && chmod +x docker/app/kestra
+
+      # Docker Tag
+      - name: Setup - Docker vars
+        id: vars
+        shell: bash
+        run: |
+          TAG=${GITHUB_REF#refs/*/}
+          if [[ $TAG = "master" ]]
+          then
+            TAG="latest";
+          elif [[ $TAG = "develop" ]]
+          then
+            TAG="develop";
+          elif [[ $TAG = v* ]]
+          then
+            TAG="${TAG}";
+          else
+            TAG="build-${{ github.run_id }}";
+          fi
+          echo "tag=${TAG}" >> $GITHUB_OUTPUT
+          echo "artifact=docker-kestra-${TAG}" >> $GITHUB_OUTPUT
+
+      # Docker setup
+      - name: Docker - Setup QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Docker - Fix Qemu
+        shell: bash
+        run: |
+          docker run --rm --privileged multiarch/qemu-user-static --reset -p yes -c yes
+
+      - name: Docker - Setup Buildx
+        uses: docker/setup-buildx-action@v3
+
+      # Docker Build
+      - name: Docker - Build & export image
+        uses: docker/build-push-action@v6
+        if: "!startsWith(github.ref, 'refs/tags/v')"
+        with:
+          context: .
+          push: false
+          file: Dockerfile
+          tags: |
+            kestra/kestra:${{ steps.vars.outputs.tag }}
+          build-args: |
+            KESTRA_PLUGINS=${{ steps.plugins.outputs.plugins }}
+            APT_PACKAGES=${{ env.DOCKER_APT_PACKAGES }}
+            PYTHON_LIBRARIES=${{ env.DOCKER_PYTHON_LIBRARIES }}
+          outputs: type=docker,dest=/tmp/${{ steps.vars.outputs.artifact }}.tar
+
+      # Upload artifacts
+      - name: Artifacts - Upload JAR
+        uses: actions/upload-artifact@v4
+        with:
+          name: jar
+          path: build/libs/
+
+      - name: Artifacts - Upload Executable
+        uses: actions/upload-artifact@v4
+        with:
+          name: exe
+          path: build/executable/
+
+      - name: Artifacts - Upload Docker
+        uses: actions/upload-artifact@v4
+        if: "!startsWith(github.ref, 'refs/tags/v')"
+        with:
+          name: ${{ steps.vars.outputs.artifact }}
+          path: /tmp/${{ steps.vars.outputs.artifact }}.tar

.github/workflows/workflow-frontend-test.yml

@@ -0,0 +1,68 @@
+name: Frontend - Tests
+
+on:
+  workflow_call:
+    secrets:
+      GITHUB_AUTH_TOKEN:
+        description: "The GitHub Token."
+        required: true
+      CODECOV_TOKEN:
+        description: 'Codecov Token'
+        required: true
+
+env:
+  # to save corepack from itself
+  COREPACK_INTEGRITY_KEYS: 0
+
+jobs:
+  test:
+    name: Frontend - Tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Npm - install
+        shell: bash
+        working-directory: ui
+        run: npm ci
+
+      - name: Npm - lint
+        uses: reviewdog/action-eslint@v1
+        with:
+          github_token: ${{ secrets.GITHUB_AUTH_TOKEN }}
+          reporter: github-pr-review
+          workdir: ui
+
+      - name: Npm - Run build
+        shell: bash
+        working-directory: ui
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+        run: npm run build
+
+      - name: Storybook - Install Playwright
+        shell: bash
+        working-directory: ui
+        run: npx playwright install --with-deps
+
+      - name: Run front-end unit tests
+        shell: bash
+        working-directory: ui
+        run: npm run test:cicd
+
+      - name: Codecov - Upload coverage reports
+        uses: codecov/codecov-action@v5
+        if: ${{ !cancelled() && github.event.pull_request.head.repo.full_name == github.repository }}
+        continue-on-error: true
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          flags: frontend
+
+      - name: Codecov - Upload test results
+        uses: codecov/test-results-action@v1
+        if: ${{ !cancelled() }}
+        continue-on-error: true
+        with:
+          token: ${{ secrets.CODECOV_TOKEN && github.event.pull_request.head.repo.full_name == github.repository }}
+          flags: frontend

.github/workflows/workflow-github-release.yml

@@ -0,0 +1,54 @@
+name: Github - Release
+
+on:
+  workflow_call:
+    secrets:
+      GH_PERSONAL_TOKEN:
+        description: "The Github personal token."
+        required: true
+
+jobs:
+  publish:
+    name: Github - Release
+    runs-on: ubuntu-latest
+    steps:
+      # Download Exec
+      - name: Artifacts - Download executable
+        uses: actions/download-artifact@v4
+        if: startsWith(github.ref, 'refs/tags/v')
+        with:
+          name: exe
+          path: build/executable
+
+      # Checkout GitHub Actions
+      - name: Checkout - Actions
+        uses: actions/checkout@v4
+        with:
+          repository: kestra-io/actions
+          sparse-checkout-cone-mode: true
+          path: actions
+          sparse-checkout: |
+            .github/actions
+
+      # GitHub Release
+      - name: Create GitHub release
+        uses: ./actions/.github/actions/github-release
+        if: ${{ startsWith(github.ref, 'refs/tags/v') }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          SLACK_RELEASES_WEBHOOK_URL: ${{ secrets.SLACK_RELEASES_WEBHOOK_URL }}
+
+      # Trigger gha workflow to bump helm chart version
+      - name: GitHub - Trigger the Helm chart version bump
+        uses: peter-evans/repository-dispatch@v3
+        if: steps.create_github_release.conclusion == 'success'
+        with:
+          token: ${{ secrets.GH_PERSONAL_TOKEN }}
+          repository: kestra-io/helm-charts
+          event-type: update-helm-chart-version
+          client-payload: |-
+            {
+              "new_version": "${{ github.ref_name }}",
+              "github_repository": "${{ github.repository }}",
+              "github_actor": "${{ github.actor }}"
+            }

.github/workflows/workflow-publish-docker.yml

@@ -0,0 +1,146 @@
+name: Publish - Docker
+
+on:
+  workflow_dispatch:
+    inputs:
+      plugin-version:
+        description: "Kestra version"
+        default: 'LATEST'
+        required: false
+        type: string
+      force-download-artifact:
+        description: 'Force download artifact'
+        required: false
+        type: string
+        default: "true"
+  workflow_call:
+    inputs:
+      plugin-version:
+        description: "Kestra version"
+        default: 'LATEST'
+        required: false
+        type: string
+      force-download-artifact:
+        description: 'Force download artifact'
+        required: false
+        type: string
+        default: "true"
+    secrets:
+      DOCKERHUB_USERNAME:
+        description: "The Dockerhub username."
+        required: true
+      DOCKERHUB_PASSWORD:
+        description: "The Dockerhub password."
+        required: true
+
+jobs:
+  # ********************************************************************************************************************
+  # Build
+  # ********************************************************************************************************************
+  build-artifacts:
+    name: Build Artifacts
+    if: ${{ github.event.inputs.force-download-artifact == 'true' }}
+    uses: ./.github/workflows/workflow-build-artifacts.yml
+    with:
+      plugin-version: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
+  # ********************************************************************************************************************
+  # Docker
+  # ********************************************************************************************************************
+  publish:
+    name: Publish - Docker
+    runs-on: ubuntu-latest
+    needs: build-artifacts
+    if: |
+      always() &&
+      (needs.build-artifacts.result == 'success' ||
+        github.event.inputs.force-download-artifact != 'true')
+    env:
+      PLUGIN_VERSION: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
+    strategy:
+      matrix:
+        image:
+          - tag: -no-plugins
+            packages: jattach
+            plugins: false
+            python-libraries: ""
+
+          - tag: ""
+            plugins: true
+            packages: python3 python3-venv python-is-python3 python3-pip nodejs npm curl zip unzip jattach
+            python-libraries: kestra
+    steps:
+      - name: Checkout - Current ref
+        uses: actions/checkout@v4
+
+      # Docker setup
+      - name: Docker - Setup QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Docker - Fix Qemu
+        shell: bash
+        run: |
+          docker run --rm --privileged multiarch/qemu-user-static --reset -p yes -c yes
+
+      - name: Docker - Setup Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      # Docker Login
+      - name: Docker - Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_PASSWORD }}
+
+
+#     # Get Plugins List
+      - name: Plugins - Get List
+        uses: ./.github/actions/plugins-list
+        id: plugins-list
+        if: ${{ matrix.image.plugins}}
+        with:
+          plugin-version: ${{ env.PLUGIN_VERSION }}
+
+      # Vars
+      - name: Docker - Set variables
+        shell: bash
+        id: vars
+        run: |
+          TAG=${GITHUB_REF#refs/*/}
+          PLUGINS="${{ matrix.image.plugins == true && steps.plugins-list.outputs.plugins || '' }}"
+          if [[ $TAG == v* ]]; then
+            TAG="${TAG}";
+            echo "plugins=${{ matrix.image.plugins }}" >> $GITHUB_OUTPUT
+          elif [[ $TAG = "develop" ]]; then
+            TAG="develop";
+            echo "plugins=--repositories=https://s01.oss.sonatype.org/content/repositories/snapshots $PLUGINS" >> $GITHUB_OUTPUT
+          else
+            TAG="build-${{ github.run_id }}";
+            echo "plugins=--repositories=https://s01.oss.sonatype.org/content/repositories/snapshots $PLUGINS" >> $GITHUB_OUTPUT
+          fi
+          
+          echo "tag=${TAG}${{ matrix.image.tag }}" >> $GITHUB_OUTPUT
+
+      # Build Docker Image
+      - name: Artifacts - Download executable
+        uses: actions/download-artifact@v4
+        with:
+          name: exe
+          path: build/executable
+
+      - name: Docker - Copy exe to image
+        shell: bash
+        run: |
+          cp build/executable/* docker/app/kestra && chmod +x docker/app/kestra
+
+      # Docker Build and push
+      - name: Docker - Build image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          tags: kestra/kestra:${{ steps.vars.outputs.tag }}
+          platforms: linux/amd64,linux/arm64
+          build-args: |
+            KESTRA_PLUGINS=${{ steps.vars.outputs.plugins }}
+            APT_PACKAGES=${{ matrix.image.packages }}
+            PYTHON_LIBRARIES=${{ matrix.image.python-libraries }}

.github/workflows/workflow-publish-maven.yml

@@ -0,0 +1,57 @@
+name: Publish - Maven
+
+on:
+  workflow_call:
+    secrets:
+      SONATYPE_USER:
+        description: "The Sonatype username."
+        required: true
+      SONATYPE_PASSWORD:
+        description: "The Sonatype password."
+        required: true
+      SONATYPE_GPG_KEYID:
+        description: "The Sonatype GPG key id."
+        required: true
+      SONATYPE_GPG_PASSWORD:
+        description: "The Sonatype GPG password."
+        required: true
+      SONATYPE_GPG_FILE:
+        description: "The Sonatype GPG file."
+        required: true
+
+jobs:
+  publish:
+    name: Publish - Maven
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout - Current ref
+        uses: actions/checkout@v4
+
+      # Setup build
+      - name: Setup - Build
+        uses: kestra-io/actions/.github/actions/setup-build@main
+        id: build
+        with:
+          java-enabled: true
+          node-enabled: true
+
+      # Publish
+      - name: Publish - Release package to Maven Central
+        shell: bash
+        env:
+          ORG_GRADLE_PROJECT_sonatypeUsername: ${{ secrets.SONATYPE_USER }}
+          ORG_GRADLE_PROJECT_sonatypePassword: ${{ secrets.SONATYPE_PASSWORD }}
+          SONATYPE_GPG_KEYID: ${{ secrets.SONATYPE_GPG_KEYID }}
+          SONATYPE_GPG_PASSWORD: ${{ secrets.SONATYPE_GPG_PASSWORD }}
+          SONATYPE_GPG_FILE: ${{ secrets.SONATYPE_GPG_FILE}}
+        run: |
+          mkdir -p ~/.gradle/
+          echo "signing.keyId=${SONATYPE_GPG_KEYID}" > ~/.gradle/gradle.properties
+          echo "signing.password=${SONATYPE_GPG_PASSWORD}" >> ~/.gradle/gradle.properties
+          echo "signing.secretKeyRingFile=${HOME}/.gradle/secring.gpg" >> ~/.gradle/gradle.properties
+          echo ${SONATYPE_GPG_FILE} | base64 -d > ~/.gradle/secring.gpg
+          ./gradlew publishToSonatype ${{ startsWith(github.ref, 'refs/tags/v')  && 'closeAndReleaseSonatypeStagingRepository' || '' }}
+
+      # Gradle dependency
+      - name: Java - Gradle dependency graph
+        uses: gradle/actions/dependency-submission@v4

.github/workflows/workflow-release.yml

@@ -0,0 +1,80 @@
+name: Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      plugin-version:
+        description: "Kestra version"
+        default: 'LATEST'
+        required: false
+        type: string
+      publish-docker:
+        description: "Publish Docker image"
+        default: 'false'
+        required: false
+        type: string
+  workflow_call:
+    inputs:
+      plugin-version:
+        description: "Kestra version"
+        default: 'LATEST'
+        required: false
+        type: string
+    secrets:
+      DOCKERHUB_USERNAME:
+        description: "The Dockerhub username."
+        required: true
+      DOCKERHUB_PASSWORD:
+        description: "The Dockerhub password."
+        required: true
+      SONATYPE_USER:
+        description: "The Sonatype username."
+        required: true
+      SONATYPE_PASSWORD:
+        description: "The Sonatype password."
+        required: true
+      SONATYPE_GPG_KEYID:
+        description: "The Sonatype GPG key id."
+        required: true
+      SONATYPE_GPG_PASSWORD:
+        description: "The Sonatype GPG password."
+        required: true
+      SONATYPE_GPG_FILE:
+        description: "The Sonatype GPG file."
+        required: true
+jobs:
+  build-artifacts:
+    name: Build - Artifacts
+    uses: ./.github/workflows/workflow-build-artifacts.yml
+    with:
+      plugin-version: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
+
+  Docker:
+    name: Publish Docker
+    needs: build-artifacts
+    uses: ./.github/workflows/workflow-publish-docker.yml
+    if: startsWith(github.ref, 'refs/heads/develop') || github.event.inputs.publish-docker == 'true'
+    with:
+      force-download-artifact: 'false'
+      plugin-version: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
+    secrets:
+      DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+      DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
+
+  Maven:
+    name: Publish Maven
+    uses: ./.github/workflows/workflow-publish-maven.yml
+    secrets:
+      SONATYPE_USER: ${{ secrets.SONATYPE_USER }}
+      SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
+      SONATYPE_GPG_KEYID: ${{ secrets.SONATYPE_GPG_KEYID }}
+      SONATYPE_GPG_PASSWORD: ${{ secrets.SONATYPE_GPG_PASSWORD }}
+      SONATYPE_GPG_FILE: ${{ secrets.SONATYPE_GPG_FILE }}
+
+  Github:
+    name: Github Release
+    needs: build-artifacts
+    if: startsWith(github.ref, 'refs/tags/v')
+    uses: ./.github/workflows/workflow-github-release.yml
+    secrets:
+      GH_PERSONAL_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}

.github/workflows/workflow-test.yml

@@ -0,0 +1,97 @@
+name: Tests
+
+on:
+  schedule:
+    - cron: '0 4 * * 1,2,3,4,5'
+  workflow_call:
+    inputs:
+      report-status:
+        description: "Report status of the jobs in outputs"
+        type: string
+        required: false
+        default: false
+    outputs:
+      frontend_status:
+        description: "Status of the frontend job"
+        value: ${{ jobs.set-frontend-status.outputs.frontend_status }}
+      backend_status:
+        description: "Status of the backend job"
+        value: ${{ jobs.set-backend-status.outputs.backend_status }}
+
+jobs:
+  file-changes:
+    name: File changes detection
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    outputs:
+      ui: ${{ steps.changes.outputs.ui }}
+      backend: ${{ steps.changes.outputs.backend }}
+    steps:
+      - uses: actions/checkout@v4
+        if: "!startsWith(github.ref, 'refs/tags/v')"
+      - uses: dorny/paths-filter@v3
+        if: "!startsWith(github.ref, 'refs/tags/v')"
+        id: changes
+        with:
+          filters: |
+            ui:
+              - 'ui/**'
+            backend:
+              - '!{ui,.github}/**'
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+  frontend:
+    name: Frontend - Tests
+    needs: file-changes
+    if: "needs.file-changes.outputs.ui == 'true' || startsWith(github.ref, 'refs/tags/v')"
+    uses: ./.github/workflows/workflow-frontend-test.yml
+    secrets:
+      GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+
+  backend:
+    name: Backend - Tests
+    needs: file-changes
+    if: "needs.file-changes.outputs.backend == 'true' || startsWith(github.ref, 'refs/tags/v')"
+    uses: ./.github/workflows/workflow-backend-test.yml
+    secrets:
+      GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+      GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
+
+  # Output every job status
+  # To be used in other workflows
+  report-status:
+    name: Report Status
+    runs-on: ubuntu-latest
+    needs: [ frontend, backend ]
+    if: always() && (inputs.report-status == 'true')
+    outputs:
+      frontend_status: ${{ steps.set-frontend-status.outputs.frontend_status }}
+      backend_status: ${{ steps.set-backend-status.outputs.backend_status }}
+    steps:
+      - id: set-frontend-status
+        name: Set frontend job status
+        run: echo "::set-output name=frontend_status::${{ needs.frontend.result }}"
+
+      - id: set-backend-status
+        name: Set backend job status
+        run: echo "::set-output name=backend_status::${{ needs.backend.result }}"
+
+  notify:
+    name: Notify - Slack
+    runs-on: ubuntu-latest
+    needs: [ frontend, backend ]
+    if: github.event_name == 'schedule'
+    steps:
+      - name: Notify failed CI
+        id: send-ci-failed
+        if: |
+          always() && (needs.frontend.result != 'success' ||
+          needs.backend.result != 'success')
+        uses: kestra-io/actions/.github/actions/send-ci-failed@main
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}

.gitignore

@@ -7,6 +7,7 @@ target/
 out/
 .idea
 .vscode
+prettierrc.js
 *.iml
 *.ipr
 *.iws
@@ -14,11 +15,12 @@ out/
 .settings
 .classpath
 .attach*
+**/*.class
+**/bin/*
 
 ### Configurations
 docker-compose.override.yml
-cli/src/main/resources/application-override.yml
-*/src/test/resources/application-test.yml
+cli/src/main/resources/application-*.yml
 /local
 
 ### Javascript
@@ -32,6 +34,10 @@ ui/.env.*.local
 webserver/src/main/resources/ui
 yarn.lock
 ui/coverage
+ui/stats.html
+ui/.frontend-gradle-plugin
+ui/utils/CHANGELOG.md
+ui/test-report.junit.xml
 
 ### Docker
 /.env
@@ -42,4 +48,14 @@ docker/app/confs/*.yml
 docker/app/secrets/*.yml
 
 ### Build
-core/src/main/resources/gradle.properties
+core/src/main/resources/gradle.properties
+.plugins.override
+
+# H2 Database
+/data
+
+# Allure Reports
+**/allure-results/*
+
+*storybook.log
+storybook-static

.gitpod.yml

@@ -0,0 +1,9 @@
+
+tasks:
+  - init: ./gradlew build --priority=normal
+
+
+vscode:
+  extensions:
+    - vscjava.vscode-java-pack
+    - ms-azuretools.vscode-docker

.plugins

@@ -0,0 +1,107 @@
+#
+# List of plugins to install locally with: $ make install-plugins
+# Format: <RepositoryName>:<GroupId>:<ArtifactId>:<Version>
+#
+# Uncomment the lines corresponding to the plugins to be installed:
+#plugin-airbyte:io.kestra.plugin:plugin-airbyte:LATEST
+#plugin-airflow:io.kestra.plugin:plugin-airflow:LATEST
+#plugin-amqp:io.kestra.plugin:plugin-amqp:LATEST
+#plugin-ansible:io.kestra.plugin:plugin-ansible:LATEST
+#plugin-aws:io.kestra.plugin:plugin-aws:LATEST
+#plugin-azure:io.kestra.plugin:plugin-azure:LATEST
+#plugin-cassandra:io.kestra.plugin:plugin-cassandra:LATEST
+#plugin-cloudquery:io.kestra.plugin:plugin-cloudquery:LATEST
+#plugin-compress:io.kestra.plugin:plugin-compress:LATEST
+#plugin-couchbase:io.kestra.plugin:plugin-couchbase:LATEST
+#plugin-crypto:io.kestra.plugin:plugin-crypto:LATEST
+#plugin-databricks:io.kestra.plugin:plugin-databricks:LATEST
+#plugin-datahub:io.kestra.plugin:plugin-datahub:LATEST
+#plugin-dataform:io.kestra.plugin:plugin-dataform:LATEST
+#plugin-dbt:io.kestra.plugin:plugin-dbt:LATEST
+#plugin-debezium:io.kestra.plugin:plugin-debezium-db2:LATEST
+#plugin-debezium:io.kestra.plugin:plugin-debezium-mongodb:LATEST
+#plugin-debezium:io.kestra.plugin:plugin-debezium-mysql:LATEST
+#plugin-debezium:io.kestra.plugin:plugin-debezium-oracle:LATEST
+#plugin-debezium:io.kestra.plugin:plugin-debezium-postgres:LATEST
+#plugin-debezium:io.kestra.plugin:plugin-debezium-sqlserver:LATEST
+#plugin-docker:io.kestra.plugin:plugin-docker:LATEST
+#plugin-elasticsearch:io.kestra.plugin:plugin-elasticsearch:LATEST
+#plugin-fivetran:io.kestra.plugin:plugin-fivetran:LATEST
+#plugin-fs:io.kestra.plugin:plugin-fs:LATEST
+#plugin-gcp:io.kestra.plugin:plugin-gcp:LATEST
+#plugin-git:io.kestra.plugin:plugin-git:LATEST
+#plugin-github:io.kestra.plugin:plugin-github:LATEST
+#plugin-googleworkspace:io.kestra.plugin:plugin-googleworkspace:LATEST
+#plugin-graalvm:io.kestra.plugin:plugin-graalvm:LATEST
+#plugin-hightouch:io.kestra.plugin:plugin-hightouch:LATEST
+#plugin-hubspot:io.kestra.plugin:plugin-hubspot:LATEST
+#plugin-huggingface:io.kestra.plugin:plugin-huggingface:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-as400:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-clickhouse:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-db2:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-duckdb:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-druid:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-mariadb:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-mysql:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-oracle:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-pinot:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-postgres:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-redshift:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-snowflake:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-sqlserver:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-trino:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-vectorwise:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-vertica:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-dremio:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-arrow-flight:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-sqlite:LATEST
+#plugin-jdbc:io.kestra.plugin:plugin-jdbc-sybase:LATEST
+#plugin-jira:io.kestra.plugin:plugin-jira:LATEST
+#plugin-kafka:io.kestra.plugin:plugin-kafka:LATEST
+#plugin-kubernetes:io.kestra.plugin:plugin-kubernetes:LATEST
+#plugin-ldap:io.kestra.plugin:plugin-ldap:LATEST
+#plugin-linear:io.kestra.plugin:plugin-linear:LATEST
+#plugin-malloy:io.kestra.plugin:plugin-malloy:LATEST
+#plugin-meilisearch:io.kestra.plugin:plugin-meilisearch:LATEST
+#plugin-minio:io.kestra.plugin:plugin-minio:LATEST
+#plugin-modal:io.kestra.plugin:plugin-modal:LATEST
+#plugin-mongodb:io.kestra.plugin:plugin-mongodb:LATEST
+#plugin-mqtt:io.kestra.plugin:plugin-mqtt:LATEST
+#plugin-nats:io.kestra.plugin:plugin-nats:LATEST
+#plugin-neo4j:io.kestra.plugin:plugin-neo4j:LATEST
+#plugin-notifications:io.kestra.plugin:plugin-notifications:LATEST
+#plugin-openai:io.kestra.plugin:plugin-openai:LATEST
+#plugin-opensearch:io.kestra.plugin:plugin-opensearch:LATEST
+#plugin-powerbi:io.kestra.plugin:plugin-powerbi:LATEST
+#plugin-pulsar:io.kestra.plugin:plugin-pulsar:LATEST
+#plugin-redis:io.kestra.plugin:plugin-redis:LATEST
+#plugin-scripts:io.kestra.plugin:plugin-script-groovy:LATEST
+#plugin-scripts:io.kestra.plugin:plugin-script-jbang:LATEST
+#plugin-scripts:io.kestra.plugin:plugin-script-julia:LATEST
+#plugin-scripts:io.kestra.plugin:plugin-script-jython:LATEST
+#plugin-scripts:io.kestra.plugin:plugin-script-nashorn:LATEST
+#plugin-scripts:io.kestra.plugin:plugin-script-node:LATEST
+#plugin-scripts:io.kestra.plugin:plugin-script-powershell:LATEST
+#plugin-scripts:io.kestra.plugin:plugin-script-python:LATEST
+#plugin-scripts:io.kestra.plugin:plugin-script-r:LATEST
+#plugin-scripts:io.kestra.plugin:plugin-script-ruby:LATEST
+#plugin-scripts:io.kestra.plugin:plugin-script-shell:LATEST
+#plugin-serdes:io.kestra.plugin:plugin-serdes:LATEST
+#plugin-servicenow:io.kestra.plugin:plugin-servicenow:LATEST
+#plugin-singer:io.kestra.plugin:plugin-singer:LATEST
+#plugin-soda:io.kestra.plugin:plugin-soda:LATEST
+#plugin-solace:io.kestra.plugin:plugin-solace:LATEST
+#plugin-spark:io.kestra.plugin:plugin-spark:LATEST
+#plugin-sqlmesh:io.kestra.plugin:plugin-sqlmesh:LATEST
+#plugin-surrealdb:io.kestra.plugin:plugin-surrealdb:LATEST
+#plugin-terraform:io.kestra.plugin:plugin-terraform:LATEST
+#plugin-transform:io.kestra.plugin:plugin-transform-grok:LATEST
+#plugin-transform:io.kestra.plugin:plugin-transform-json:LATEST
+#plugin-tika:io.kestra.plugin:plugin-tika:LATEST
+#plugin-weaviate:io.kestra.plugin:plugin-weaviate:LATEST
+#plugin-zendesk:io.kestra.plugin:plugin-zendesk:LATEST
+#plugin-typesense:io.kestra.plugin:plugin-typesense:LATEST
+#storage-azure:io.kestra.storage:storage-azure:LATEST
+#storage-gcs:io.kestra.storage:storage-gcs:LATEST
+#storage-minio:io.kestra.storage:storage-minio:LATEST
+#storage-s3:io.kestra.storage:storage-s3:LATEST

.prettierignore

@@ -0,0 +1 @@
+**/*.*

Dockerfile

@@ -1,13 +1,26 @@
-FROM openjdk:11-jre-slim
+FROM eclipse-temurin:21-jre-jammy
 
 ARG KESTRA_PLUGINS=""
 ARG APT_PACKAGES=""
+ARG PYTHON_LIBRARIES=""
 
 WORKDIR /app
-COPY docker /
 
-RUN if [ -n "${APT_PACKAGES}" ]; then apt-get update -y; apt-get install -y --no-install-recommends ${APT_PACKAGES}; apt-get clean && rm -rf /var/lib/apt/lists/* /var/tmp/*; fi && \
-    if [ -n "${KESTRA_PLUGINS}" ]; then /app/kestra plugins install ${KESTRA_PLUGINS}; fi
+RUN groupadd kestra && \
+    useradd -m -g kestra kestra
+
+COPY --chown=kestra:kestra docker /
+
+RUN apt-get update -y && \
+    apt-get upgrade -y && \
+    if [ -n "${APT_PACKAGES}" ]; then apt-get install -y --no-install-recommends ${APT_PACKAGES}; fi && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/* /var/tmp/* /tmp/* && \
+    if [ -n "${KESTRA_PLUGINS}" ]; then /app/kestra plugins install ${KESTRA_PLUGINS} && rm -rf /tmp/*; fi && \
+    if [ -n "${PYTHON_LIBRARIES}" ]; then pip install ${PYTHON_LIBRARIES}; fi && \
+    chown -R kestra:kestra /app
+
+USER kestra
 
 ENTRYPOINT ["docker-entrypoint.sh"]
 

Makefile

@@ -0,0 +1,263 @@
+#
+# Makefile used to build and deploy Kestra locally.
+# By default Kestra will be installed under: $HOME/.kestra/current. Set $KESTRA_HOME to override default.
+#
+# Usage:
+# make install
+# make install-plugins
+# make start-standalone-postgres
+#
+# NOTE: This file is intended for development purposes only.
+
+SHELL := /bin/bash
+
+KESTRA_BASEDIR := $(shell echo $${KESTRA_HOME:-$$HOME/.kestra/current})
+KESTRA_WORKER_THREAD := $(shell echo $${KESTRA_WORKER_THREAD:-4})
+VERSION := $(shell ./gradlew properties -q | awk '/^version:/ {print $$2}')
+GIT_COMMIT := $(shell git rev-parse --short HEAD)
+GIT_BRANCH := $(shell git rev-parse --abbrev-ref HEAD)
+DATE := $(shell date --rfc-3339=seconds)
+PLUGIN_GIT_DIR ?= $(pwd)/..
+PLUGIN_JARS_DIR ?= $(pwd)/locals/plugins
+
+DOCKER_IMAGE = kestra/kestra
+DOCKER_PATH = ./
+
+.SILENT:
+
+.PHONY: clean build build-exec test install
+
+all: clean build-exec install
+
+version:
+	echo "${VERSION}"
+
+clean:
+	./gradlew clean
+
+build: clean
+	./gradlew build
+
+buildSkipTests: clean
+	./gradlew build -x test -x integrationTest -x testCodeCoverageReport --refresh-dependencies
+
+test: clean
+	./gradlew test
+
+build-exec:
+	./gradlew -q executableJar --no-daemon --priority=normal
+
+install: build-exec
+	echo "Installing Kestra: ${KESTRA_BASEDIR}"
+	mkdir -p ${KESTRA_BASEDIR}/bin ${KESTRA_BASEDIR}/plugins ${KESTRA_BASEDIR}/flows ${KESTRA_BASEDIR}/logs
+	cp build/executable/* ${KESTRA_BASEDIR}/bin/kestra && chmod +x ${KESTRA_BASEDIR}/bin
+	VERSION_INSTALLED=$$(${KESTRA_BASEDIR}/bin/kestra --version); \
+	echo "Kestra installed successfully (version=$$VERSION_INSTALLED) 🚀"
+
+# Install plugins for Kestra from (.plugins file).
+install-plugins:
+	if [[ ! -f ".plugins" && ! -f ".plugins.override" ]]; then \
+		echo "[ERROR] file '$$(pwd)/.plugins' and '$$(pwd)/.plugins.override' not found."; \
+		exit 1; \
+	fi; \
+
+	PLUGIN_LIST="./.plugins"; \
+	if [[ -f ".plugins.override" ]]; then \
+		PLUGIN_LIST="./.plugins.override"; \
+	fi; \
+	while IFS= read -r plugin; do \
+		[[ $$plugin =~ ^#.* ]] && continue; \
+		PLUGINS_PATH="${KESTRA_INSTALL_DIR}/plugins"; \
+		CURRENT_PLUGIN=$${plugin/LATEST/"${VERSION}"}; \
+		CURRENT_PLUGIN=$$(echo $$CURRENT_PLUGIN | cut -d':' -f2-); \
+		PLUGIN_FILE="$$PLUGINS_PATH/$$(echo $$CURRENT_PLUGIN | awk -F':' '{print $$2"-"$$3}').jar"; \
+		echo "Installing Kestra plugin $$CURRENT_PLUGIN > ${KESTRA_INSTALL_DIR}/plugins"; \
+		if [ -f "$$PLUGIN_FILE" ]; then \
+		    echo "Plugin already installed in > $$PLUGIN_FILE"; \
+        else \
+		${KESTRA_BASEDIR}/bin/kestra plugins install $$CURRENT_PLUGIN \
+		--plugins ${KESTRA_BASEDIR}/plugins \
+		--repositories=https://s01.oss.sonatype.org/content/repositories/snapshots || exit 1; \
+		fi \
+    done < $$PLUGIN_LIST
+
+# Build docker image from Kestra source.
+build-docker: build-exec
+	cp build/executable/* docker/app/kestra && chmod +x docker/app/kestra
+	echo "${DOCKER_IMAGE}:${VERSION}"
+	docker build \
+		--compress \
+		--rm \
+		-f ./Dockerfile \
+		--build-arg="APT_PACKAGES=python3 python3-venv python-is-python3 python3-pip nodejs npm curl zip unzip jattach" \
+		--build-arg="PYTHON_LIBRARIES=kestra" \
+		-t ${DOCKER_IMAGE}:${VERSION} ${DOCKER_PATH} || exit 1 ;
+
+# Verify whether Kestra is running
+health:
+	PID=$$(ps aux | grep java | grep 'kestra' | grep -v 'grep' | awk '{print $$2}'); \
+	if [ ! -z "$$PID" ]; then \
+	    echo -e "\n⏳ Waiting for Kestra server..."; \
+        KESTRA_URL=http://localhost:8080; \
+        while [ $$(curl -s -L -o /dev/null -w %{http_code} $$KESTRA_URL) != 200 ]; do \
+          echo -e $$(date) "\tKestra server HTTP state: " $$(curl -k -L -s -o /dev/null -w %{http_code} $$KESTRA_URL) " (waiting for 200)"; \
+          sleep 2; \
+        done; \
+		echo "Kestra is running (pid=$$PID): $$KESTRA_URL 🚀"; \
+	fi
+
+
+# Kill Kestra running process
+kill:
+	PID=$$(ps aux | grep java | grep 'kestra' | grep -v 'grep' | awk '{print $$2}'); \
+	if [ ! -z "$$PID" ]; then \
+		echo "Killing Kestra process (pid=$$PID)."; \
+		kill $$PID; \
+	else \
+		echo "No Kestra process to kill."; \
+	fi
+	docker compose -f ./docker-compose-ci.yml down;
+
+# Default configuration for using Kestra with Postgres as backend.
+define KESTRA_POSTGRES_CONFIGURATION =
+micronaut:
+  server:
+    port: 8080
+datasources:
+  postgres:
+    url: jdbc:postgresql://localhost:5432/kestra_unit
+    driverClassName: org.postgresql.Driver
+    username: kestra
+    password: k3str4
+kestra:
+  server:
+    basic-auth:
+    enabled: false
+  encryption:
+    secret-key: 3ywuDa/Ec61VHkOX3RlI9gYq7CaD0mv0Pf3DHtAXA6U=
+  repository:
+    type: postgres
+  storage:
+    type: local
+    local:
+      base-path: "/tmp/kestra/storage"
+  queue:
+    type: postgres
+endef
+export KESTRA_POSTGRES_CONFIGURATION
+
+# Build and deploy Kestra in standalone mode (using Postgres backend)
+--private-start-standalone-postgres:
+	docker compose -f ./docker-compose-ci.yml up postgres -d;
+	echo "Waiting for postgres to be running"
+	until [ "`docker inspect -f {{.State.Running}} kestra-postgres-1`"=="true" ]; do \
+		sleep 1; \
+	done; \
+	rm -rf ${KESTRA_BASEDIR}/bin/confs/ && \
+	mkdir -p ${KESTRA_BASEDIR}/bin/confs/ ${KESTRA_BASEDIR}/logs/ && \
+	touch ${KESTRA_BASEDIR}/bin/confs/application.yml
+	echo "Starting Kestra Standalone server"
+	KESTRA_CONFIGURATION=$$KESTRA_POSTGRES_CONFIGURATION ${KESTRA_BASEDIR}/bin/kestra \
+	server standalone \
+	--worker-thread ${KESTRA_WORKER_THREAD} \
+	--plugins "${KESTRA_BASEDIR}/plugins" \
+	--flow-path "${KESTRA_BASEDIR}/flows" 2>${KESTRA_BASEDIR}/logs/err.log 1>${KESTRA_BASEDIR}/logs/out.log &
+
+start-standalone-postgres: kill --private-start-standalone-postgres health
+
+# Build and deploy Kestra in standalone mode (using In-Memory backend)
+--private-start-standalone-local:
+	rm -f "${KESTRA_BASEDIR}/logs/*.log"; \
+	${KESTRA_BASEDIR}/bin/kestra \
+	server local \
+	--worker-thread ${KESTRA_WORKER_THREAD} \
+	--plugins "${KESTRA_BASEDIR}/plugins" \
+	--flow-path "${KESTRA_BASEDIR}/flows" 2>${KESTRA_BASEDIR}/logs/err.log 1>${KESTRA_BASEDIR}/logs/out.log &
+
+start-standalone-local: kill --private-start-standalone-local health
+
+#checkout all plugins
+clone-plugins:
+	@echo "Using PLUGIN_GIT_DIR: $(PLUGIN_GIT_DIR)"
+	@mkdir -p "$(PLUGIN_GIT_DIR)"
+	@echo "Fetching repository list from GitHub..."
+	@REPOS=$$(gh repo list kestra-io -L 1000 --json name | jq -r .[].name | sort | grep "^plugin-"); \
+		for repo in $$REPOS; do \
+	    if [[ $$repo == plugin-* ]]; then \
+	        if [ -d "$(PLUGIN_GIT_DIR)/$$repo" ]; then \
+	            echo "Skipping: $$repo (Already cloned)"; \
+	        else \
+	            echo "Cloning: $$repo using SSH..."; \
+	            git clone "git@github.com:kestra-io/$$repo.git" "$(PLUGIN_GIT_DIR)/$$repo"; \
+	        fi; \
+	    fi; \
+	done
+	@echo "Done!"
+
+# Pull every plugins in main or master branch
+pull-plugins:
+	@echo "🔍 Pulling repositories in '$(PLUGIN_GIT_DIR)'..."
+	@for repo in "$(PLUGIN_GIT_DIR)"/*; do \
+	    if [ -d "$$repo/.git" ]; then \
+	        branch=$$(git -C "$$repo" rev-parse --abbrev-ref HEAD); \
+	        if [[ "$$branch" == "master" || "$$branch" == "main" ]]; then \
+	            echo "🔄 Pulling: $$(basename "$$repo") (branch: $$branch)"; \
+	            git -C "$$repo" pull; \
+	        else \
+	            echo "❌ Skipping: $$(basename "$$repo") (Not on master or main branch, currently on $$branch)"; \
+	        fi; \
+	    fi; \
+	done
+	@echo "✅ Done pulling!"
+
+# Update all plugins jar
+build-plugins:
+	@echo "🔍 Scanning repositories in '$(PLUGIN_GIT_DIR)'..."
+	@MASTER_REPOS=(); \
+	for repo in "$(PLUGIN_GIT_DIR)"/*; do \
+	    if [ -d "$$repo/.git" ]; then \
+	        branch=$$(git -C "$$repo" rev-parse --abbrev-ref HEAD); \
+	        if [[ "$$branch" == "master" || "$$branch" == "main" ]]; then \
+	            MASTER_REPOS+=("$$repo"); \
+	        else \
+	            echo "❌ Skipping: $$(basename "$$repo") (Not on master or main branch)"; \
+	        fi; \
+	    fi; \
+	done; \
+	\
+	# === STEP 2: Update Repos on Master or Main Branch === \
+	echo "⬇️ Updating repositories on master or main branch..."; \
+	for repo in "$${MASTER_REPOS[@]}"; do \
+	    echo "🔄 Updating: $$(basename "$$repo")"; \
+	    git -C "$$repo" pull --rebase; \
+	done; \
+	\
+	# === STEP 3: Build with Gradle === \
+	echo "⚙️ Building repositories with Gradle..."; \
+	for repo in "$${MASTER_REPOS[@]}"; do \
+	    echo "🔨 Building: $$(basename "$$repo")"; \
+	    gradle clean build -x test shadowJar -p "$$repo"; \
+	done; \
+	\
+	# === STEP 4: Copy Latest JARs (Ignoring javadoc & sources) === \
+	echo "📦 Organizing built JARs..."; \
+	mkdir -p "$(PLUGIN_JARS_DIR)"; \
+	for repo in "$${MASTER_REPOS[@]}"; do \
+	    REPO_NAME=$$(basename "$$repo"); \
+	    \
+	    JARS=($$(find "$$repo" -type f -name "plugin-*.jar" ! -name "*-javadoc.jar" ! -name "*-sources.jar")); \
+	    if [ $${#JARS[@]} -eq 0 ]; then \
+	        echo "⚠️ Warning: No valid plugin JARs found for $$REPO_NAME"; \
+	        continue; \
+	    fi; \
+	    \
+	    for jar in "$${JARS[@]}"; do \
+	        JAR_NAME=$$(basename "$$jar"); \
+	        BASE_NAME=$$(echo "$$JAR_NAME" | sed -E 's/(-[0-9]+.*)?\.jar$$//'); \
+	        rm -f "$(PLUGIN_JARS_DIR)/$$BASE_NAME"-[0-9]*.jar; \
+	        cp "$$jar" "$(PLUGIN_JARS_DIR)/"; \
+	        echo "✅ Copied JAR: $$JAR_NAME"; \
+	    done; \
+	done; \
+	\
+	echo "🎉 Done! All master and main branch repos updated, built, and organized."

README.md

@@ -1,24 +1,230 @@
+<p align="center">
+  <a href="https://www.kestra.io">
+    <img src="https://kestra.io/banner.png"  alt="Kestra workflow orchestrator" />
+  </a>
+</p>
 
-# Kestra
-![Last Version](https://img.shields.io/github/tag-pre/kestra-io/kestra.svg)
-![License](https://img.shields.io/github/license/kestra-io/kestra)
-![Docker Pull](https://img.shields.io/docker/pulls/kestra/kestra.svg)
-![Github Downloads](https://img.shields.io/github/downloads/kestra-io/kestra/total)
-![Github Star](https://img.shields.io/github/stars/kestra-io/kestra.svg)
-[![codecov](https://codecov.io/gh/kestra-io/kestra/branch/develop/graph/badge.svg?token=It6L7BTaWK)](https://codecov.io/gh/kestra-io/kestra)
-![Github Actions](https://github.com/kestra-io/kestra/workflows/Main/badge.svg?branch=master)
+<h1 align="center" style="border-bottom: none">
+    Event-Driven Declarative Orchestration Platform
+</h1>
+
+<div align="center">
+ <a href="https://github.com/kestra-io/kestra/releases"><img src="https://img.shields.io/github/tag-pre/kestra-io/kestra.svg?color=blueviolet" alt="Last Version" /></a>
+  <a href="https://github.com/kestra-io/kestra/blob/develop/LICENSE"><img src="https://img.shields.io/github/license/kestra-io/kestra?color=blueviolet" alt="License" /></a>
+  <a href="https://github.com/kestra-io/kestra/stargazers"><img src="https://img.shields.io/github/stars/kestra-io/kestra?color=blueviolet&logo=github" alt="Github star" /></a> <br>
+<a href="https://kestra.io"><img src="https://img.shields.io/badge/Website-kestra.io-192A4E?color=blueviolet" alt="Kestra infinitely scalable orchestration and scheduling platform"></a>
+<a href="https://kestra.io/slack"><img src="https://img.shields.io/badge/Slack-Join%20Community-blueviolet?logo=slack" alt="Slack"></a>
+</div>
+
+<br />
+
+<p align="center">
+    <a href="https://x.com/kestra_io"><img height="25" src="https://kestra.io/twitter.svg" alt="X(formerly Twitter)" /></a> &nbsp;
+    <a href="https://www.linkedin.com/company/kestra/"><img height="25" src="https://kestra.io/linkedin.svg" alt="linkedin" /></a> &nbsp;
+<a href="https://www.youtube.com/@kestra-io"><img height="25" src="https://kestra.io/youtube.svg" alt="youtube" /></a> &nbsp;
+</p>
+
+<p align="center">
+  <a href="https://trendshift.io/repositories/2714" target="_blank">
+    <img src="https://trendshift.io/api/badge/repositories/2714" alt="kestra-io%2Fkestra | Trendshift" width="250" height="55"/>
+  </a>
+  <a href="https://www.producthunt.com/posts/kestra?embed=true&utm_source=badge-top-post-badge&utm_medium=badge&utm_souce=badge-kestra" target="_blank"><img src="https://api.producthunt.com/widgets/embed-image/v1/top-post-badge.svg?post_id=612077&theme=light&period=daily&t=1740737506162" alt="Kestra - All&#0045;in&#0045;one&#0032;automation&#0032;&#0038;&#0032;orchestration&#0032;platform | Product Hunt" style="width: 250px; height: 54px;" width="250" height="54" /></a>
+</p>
+
+<p align="center">
+    <a href="https://go.kestra.io/video/product-overview" target="_blank">
+        <img src="https://kestra.io/startvideo.png" alt="Get started in 4 minutes with Kestra" width="640px" />
+    </a>
+</p>
+<p align="center" style="color:grey;"><i>Click on the image to learn how to get started with Kestra in 4 minutes.</i></p>
+
+
+## 🌟 What is Kestra?
+
+Kestra is an open-source, event-driven orchestration platform that makes both **scheduled** and **event-driven** workflows easy. By bringing **Infrastructure as Code** best practices to data, process, and microservice orchestration, you can build reliable [workflows](https://kestra.io/docs/getting-started) directly from the UI in just a few lines of YAML.
+
+**Key Features:**
+- **Everything as Code and from the UI:** keep **workflows as code** with a **Git Version Control** integration, even when building them from the UI.
+- **Event-Driven & Scheduled Workflows:** automate both **scheduled** and **real-time** event-driven workflows via a simple `trigger` definition.
+- **Declarative YAML Interface:** define workflows using a simple configuration in the **built-in code editor**.
+- **Rich Plugin Ecosystem:** hundreds of plugins built in to extract data from any database, cloud storage, or API, and **run scripts in any language**.
+- **Intuitive UI & Code Editor:** build and visualize workflows directly from the UI with syntax highlighting, auto-completion and real-time syntax validation.
+- **Scalable:** designed to handle millions of workflows, with high availability and fault tolerance.
+- **Version Control Friendly:** write your workflows from the built-in code Editor and push them to your preferred Git branch directly from Kestra, enabling best practices with CI/CD pipelines and version control systems.
+- **Structure & Resilience**: tame chaos and bring resilience to your workflows with **namespaces**, **labels**, **subflows**, **retries**, **timeout**, **error handling**, **inputs**, **outputs** that generate artifacts in the UI, **variables**, **conditional branching**, **advanced scheduling**, **event triggers**, **backfills**, **dynamic tasks**, **sequential and parallel tasks**, and skip tasks or triggers when needed by setting the flag `disabled` to `true`.
+
+
+🧑‍💻 The YAML definition gets automatically adjusted any time you make changes to a workflow from the UI or via an API call. Therefore, the orchestration logic is **always managed declaratively in code**, even if you modify your workflows in other ways (UI, CI/CD, Terraform, API calls).
 
 
 <p align="center">
-  <img width="460" src="https://kestra.io/logo.svg"  alt="Kestra workflow orchestrator" />
+  <img src="https://kestra.io/adding-tasks.gif" alt="Adding new tasks in the UI">
 </p>
 
-> The modern, scalable orchestrator & scheduler open source platform.
+---
 
-![Kestra orchestrator](https://kestra.io/ui.gif)
+## 🚀 Quick Start
 
-## Documentation
-* The official Kestra documentation can be found under: [kestra.io](https://kestra.io)
+### Try the Live Demo
+
+Try Kestra with our [**Live Demo**](https://demo.kestra.io/ui/login?auto). No installation required!
+
+### Get Started Locally in 5 Minutes
+
+#### Launch Kestra in Docker
+
+Make sure that Docker is running. Then, start Kestra in a single command:
+
+```bash
+docker run --pull=always --rm -it -p 8080:8080 --user=root \
+  -v /var/run/docker.sock:/var/run/docker.sock \
+  -v /tmp:/tmp kestra/kestra:latest server local
+```
+
+If you're on Windows and use PowerShell:
+```powershell
+docker run --pull=always --rm -it -p 8080:8080 --user=root `
+    -v "/var/run/docker.sock:/var/run/docker.sock" `
+    -v "C:/Temp:/tmp" kestra/kestra:latest server local
+```
+
+If you're on Windows and use Command Prompt (CMD):
+```cmd
+docker run --pull=always --rm -it -p 8080:8080 --user=root ^
+    -v "/var/run/docker.sock:/var/run/docker.sock" ^
+    -v "C:/Temp:/tmp" kestra/kestra:latest server local
+```
+
+If you're on Windows and use WSL (Linux-based environment in Windows):
+```bash
+docker run --pull=always --rm -it -p 8080:8080 --user=root \
+    -v "/var/run/docker.sock:/var/run/docker.sock" \
+    -v "C:/Temp:/tmp" kestra/kestra:latest server local
+```
+
+Check our [Installation Guide](https://kestra.io/docs/installation) for other deployment options (Docker Compose, Podman, Kubernetes, AWS, GCP, Azure, and more).
+
+Access the Kestra UI at [http://localhost:8080](http://localhost:8080) and start building your first flow!
+
+#### Your First Hello World Flow
+
+Create a new flow with the following content:
+
+```yaml
+id: hello_world
+namespace: dev
+
+tasks:
+  - id: say_hello
+    type: io.kestra.plugin.core.log.Log
+    message: "Hello, World!"
+```
+
+
+Run the flow and see the output in the UI!
+
+---
+
+## 🧩 Plugin Ecosystem
+
+Kestra's functionality is extended through a rich [ecosystem of plugins](https://kestra.io/plugins) that empower you to run tasks anywhere and code in any language, including Python, Node.js, R, Go, Shell, and more. Here's how Kestra plugins enhance your workflows:
+
+- **Run Anywhere:**
+  - **Local or Remote Execution:** Execute tasks on your local machine, remote servers via SSH, or scale out to serverless containers using [Task Runners](https://kestra.io/docs/task-runners).
+  - **Docker and Kubernetes Support:** Seamlessly run Docker containers within your workflows or launch Kubernetes jobs to handle compute-intensive workloads.
+
+- **Code in Any Language:**
+  - **Scripting Support:** Write scripts in your preferred programming language. Kestra supports Python, Node.js, R, Go, Shell, and others, allowing you to integrate existing codebases and deployment patterns.
+  - **Flexible Automation:** Execute shell commands, run SQL queries against various databases, and make HTTP requests to interact with APIs.
+
+- **Event-Driven and Real-Time Processing:**
+  - **Real-Time Triggers:** React to events from external systems in real-time, such as file arrivals, new messages in message buses (Kafka, Redis, Pulsar, AMQP, MQTT, NATS, AWS SQS, Google Pub/Sub, Azure Event Hubs), and more.
+  - **Custom Events:** Define custom events to trigger flows based on specific conditions or external signals, enabling highly responsive workflows.
+
+- **Cloud Integrations:**
+  - **AWS, Google Cloud, Azure:** Integrate with a variety of cloud services to interact with storage solutions, messaging systems, compute resources, and more.
+  - **Big Data Processing:** Run big data processing tasks using tools like Apache Spark or interact with analytics platforms like Google BigQuery.
+
+- **Monitoring and Notifications:**
+  - **Stay Informed:** Send messages to Slack channels, email notifications, or trigger alerts in PagerDuty to keep your team updated on workflow statuses.
+
+Kestra's plugin ecosystem is continually expanding, allowing you to tailor the platform to your specific needs. Whether you're orchestrating complex data pipelines, automating scripts across multiple environments, or integrating with cloud services, there's likely a plugin to assist. And if not, you can always [build your own plugins](https://kestra.io/docs/plugin-developer-guide/) to extend Kestra's capabilities.
+
+🧑‍💻 **Note:** This is just a glimpse of what Kestra plugins can do. Explore the full list on our [Plugins Page](https://kestra.io/plugins).
+
+---
+
+## 📚 Key Concepts
+
+- **Flows:** the core unit in Kestra, representing a workflow composed of tasks.
+- **Tasks:** individual units of work, such as running a script, moving data, or calling an API.
+- **Namespaces:** logical grouping of flows for organization and isolation.
+- **Triggers:** schedule or events that initiate the execution of flows.
+- **Inputs & Variables:** parameters and dynamic data passed into flows and tasks.
+
+---
+
+## 🎨 Build Workflows Visually
+
+Kestra provides an intuitive UI that allows you to interactively build and visualize your workflows:
+
+- **Drag-and-Drop Interface:** add and rearrange tasks from the Topology Editor.
+- **Real-Time Validation:** instant feedback on your workflow's syntax and structure to catch errors early.
+- **Auto-Completion:** smart suggestions as you type to write flow code quickly and without syntax errors.
+- **Live Topology View:** see your workflow as a Directed Acyclic Graph (DAG) that updates in real-time.
+
+---
+
+
+## 🔧 Extensible and Developer-Friendly
+
+### Plugin Development
+
+Create custom plugins to extend Kestra's capabilities. Check out our [Plugin Developer Guide](https://kestra.io/docs/plugin-developer-guide/) to get started.
+
+### Infrastructure as Code
+
+- **Version Control:** store your flows in Git repositories.
+- **CI/CD Integration:** automate deployment of flows using CI/CD pipelines.
+- **Terraform Provider:** manage Kestra resources with the [official Terraform provider](https://kestra.io/docs/terraform/).
+
+---
+
+## 🌐 Join the Community
+
+Stay connected and get support:
+
+- **Slack:** Join our [Slack community](https://kestra.io/slack) to ask questions and share ideas.
+- **LinkedIn:** Follow us on [LinkedIn](https://www.linkedin.com/company/kestra/) — next to Slack and GitHub, this is our main channel to share updates and product announcements.
+- **YouTube:** Subscribe to our [YouTube channel](https://www.youtube.com/@kestra-io) for educational video content. We publish new videos every week!
+- **X:** Follow us on [X](https://x.com/kestra_io) if you're still active there.
+
+---
+
+## 🤝 Contributing
+
+We welcome contributions of all kinds!
+
+- **Report Issues:** Found a bug or have a feature request? Open an [issue on GitHub](https://github.com/kestra-io/kestra/issues).
+- **Contribute Code:** Check out our [Contributor Guide](https://kestra.io/docs/getting-started/contributing) for initial guidelines, and explore our [good first issues](https://go.kestra.io/contributing) for beginner-friendly tasks to tackle first.
+- **Develop Plugins:** Build and share plugins using our [Plugin Developer Guide](https://kestra.io/docs/plugin-developer-guide/).
+- **Contribute to our Docs:** Contribute edits or updates to keep our [documentation](https://github.com/kestra-io/docs) top-notch.
+
+---
+
+## 📄 License
+
+Kestra is licensed under the Apache 2.0 License © [Kestra Technologies](https://kestra.io).
+
+---
+
+## ⭐️ Stay Updated
+
+Give our repository a star to stay informed about the latest features and updates!
+
+[![Star the Repo](https://kestra.io/star.gif)](https://github.com/kestra-io/kestra)
+
+---
+
+Thank you for considering Kestra for your workflow orchestration needs. We can't wait to see what you'll build!
 
-## License
-Apache 2.0 © [Nigh Tech](https://nigh.tech)

SECURITY.md

@@ -0,0 +1,33 @@
+# Security Policy
+
+## Supported Versions
+
+We provide security updates for the following versions of Kestra:
+
+- The `latest` release 
+- Up to two previous minor versions released as a backport upon customer request.
+
+If you are using an unsupported version, we recommend upgrading to the `latest` version to receive security fixes.
+
+## Reporting a Vulnerability
+
+If you discover a security vulnerability in Kestra, please report it to us privately to ensure a responsible disclosure process. You can contact our security team at:
+
+**security@kestra.io**
+
+### Guidelines for Reporting
+- Provide a detailed description of the issue, including steps to reproduce it if possible.
+- Do not disclose the vulnerability publicly until we have confirmed and patched the issue.
+- If you believe the issue has critical severity, please indicate so in your report to help us prioritize.
+
+## Our Commitment
+
+- We will acknowledge your report within **2 business days**.
+- We will work to verify and address the issue as quickly as possible.
+- Once the issue is resolved, we will notify you of the fix.
+
+## Acknowledgments
+
+We are happy to credit those who report vulnerabilities responsibly in our release notes, unless you prefer to remain anonymous. If you would like to be acknowledged, please include this in your report.
+
+Thank you for helping to make Kestra more secure!

build.gradle

@@ -1,28 +1,45 @@
+import net.e175.klaus.zip.ZipPrefixer
+import org.owasp.dependencycheck.gradle.extension.AnalyzerExtension
+
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "net.e175.klaus:zip-prefixer:0.3.1"
+    }
+}
+
 plugins {
     // micronaut
     id "java"
     id 'java-library'
     id "idea"
-    id "com.github.johnrengelman.shadow" version "6.1.0"
+    id "com.gradleup.shadow" version "8.3.6"
     id "application"
 
     // test
-    id 'com.adarshr.test-logger' version '2.1.1'
-    id 'org.gradle.test-retry' version '1.2.0'
+    id "com.adarshr.test-logger" version "4.0.0"
+    id "org.sonarqube" version "6.1.0.5360"
+    id 'jacoco-report-aggregation'
 
     // helper
-    id "com.github.ben-manes.versions" version "0.36.0"
+    id "com.github.ben-manes.versions" version "0.52.0"
 
     // front
-    id 'org.siouan.frontend-jdk11' version '5.0.0' apply false
+    id 'com.github.node-gradle.node' version '7.1.0'
 
     // release
-    id "io.github.gradle-nexus.publish-plugin" version "1.0.0"
-    id 'net.researchgate.release' version '2.8.1'
-    id "com.gorylenko.gradle-git-properties" version "2.2.4"
+    id "io.github.gradle-nexus.publish-plugin" version "2.0.0"
+    id 'net.researchgate.release' version '3.1.0'
+    id "com.gorylenko.gradle-git-properties" version "2.5.0"
     id 'signing'
-    id 'ru.vyarus.pom' version '2.1.0' apply false
-    id 'ru.vyarus.github-info' version '1.2.0' apply false
+    id 'ru.vyarus.pom' version '3.0.0' apply false
+    id 'ru.vyarus.github-info' version '2.0.0' apply false
+
+    // OWASP dependency check
+    id "org.owasp.dependencycheck" version "12.1.1" apply false
 }
 
 idea {
@@ -35,8 +52,17 @@ idea {
 /**********************************************************************************************************************\
  * Main
  **********************************************************************************************************************/
-mainClassName = "io.kestra.cli.App"
-sourceCompatibility = 11
+final mainClassName = "io.kestra.cli.App"
+final targetJavaVersion = JavaVersion.VERSION_21
+
+application {
+    mainClass = mainClassName
+}
+
+java {
+    sourceCompatibility = targetJavaVersion
+    targetCompatibility = targetJavaVersion
+}
 
 dependencies {
     implementation project(":cli")
@@ -47,76 +73,91 @@ dependencies {
  * Dependencies
  **********************************************************************************************************************/
 allprojects {
-    group "io.kestra"
+    if (it.name != 'platform') {
+        group = "io.kestra"
 
-    sourceCompatibility = 11
-
-    repositories {
-        mavenCentral()
-        maven { url "https://jcenter.bintray.com" }
-    }
-
-    // micronaut
-    apply plugin: "java"
-    apply plugin: "java-library"
-    apply plugin: "idea"
-    apply plugin: "jacoco"
-
-    configurations {
-        developmentOnly // for dependencies that are needed for development only
-    }
-
-    //
-    configurations.all {
-        resolutionStrategy {
-            force("org.apache.kafka:kafka-clients:" + kafkaVersion)
-            force("org.apache.kafka:kafka-streams:" + kafkaVersion)
+        java {
+            sourceCompatibility = targetJavaVersion
+            targetCompatibility = targetJavaVersion
         }
-    }
 
-    // dependencies
-    dependencies {
-        // lombok
-        annotationProcessor "org.projectlombok:lombok:" + lombokVersion
-        compileOnly 'org.projectlombok:lombok:' + lombokVersion
+        repositories {
+            mavenCentral()
+        }
 
         // micronaut
-        annotationProcessor platform("io.micronaut:micronaut-bom:$micronautVersion")
-        annotationProcessor "io.micronaut:micronaut-inject-java"
-        annotationProcessor "io.micronaut:micronaut-validation"
-        implementation platform("io.micronaut:micronaut-bom:$micronautVersion")
-        implementation "io.micronaut:micronaut-inject"
-        implementation "io.micronaut:micronaut-validation"
-        implementation "io.micronaut:micronaut-runtime"
-        implementation "javax.annotation:javax.annotation-api"
-        implementation "io.micronaut.data:micronaut-data-model"
-        implementation "io.micronaut:micronaut-management"
-        implementation "io.micrometer:micrometer-core:1.6.4"
-        implementation "io.micronaut.micrometer:micronaut-micrometer-registry-prometheus"
-        api "io.micronaut:micronaut-http-client"
+        apply plugin: "java"
+        apply plugin: "java-library"
+        apply plugin: "idea"
+        apply plugin: "jacoco"
 
-        // logs
-        runtime "ch.qos.logback:logback-classic:1.2.3"
-        runtime group: 'org.apache.logging.log4j', name: 'log4j-to-slf4j', version: '2.14.0'
-        runtime group: 'org.slf4j', name: 'jul-to-slf4j', version: '1.7.30'
-        runtime group: 'io.micronaut.gcp', name: 'micronaut-gcp-logging', version: '3.4.0'
+        configurations {
+            developmentOnly // for dependencies that are needed for development only
+            micronaut
+        }
 
-        // jackson
-        implementation group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.12.1'
-        implementation group: 'com.fasterxml.jackson.dataformat', name: 'jackson-dataformat-yaml', version: '2.12.1'
-        implementation group: 'com.fasterxml.jackson.module', name: 'jackson-module-parameter-names', version: '2.12.1'
-        implementation group: 'com.fasterxml.jackson.datatype', name: 'jackson-datatype-guava', version: '2.12.1'
+        // dependencies
+        dependencies {
+            // Platform
+            annotationProcessor enforcedPlatform(project(":platform"))
+            implementation enforcedPlatform(project(":platform"))
+            api enforcedPlatform(project(":platform"))
+            micronaut enforcedPlatform(project(":platform"))
 
-        // kestra
-        implementation group: 'com.devskiller.friendly-id', name: 'friendly-id', version: '1.1.0'
-        implementation 'com.github.jknack:handlebars:4.2.0'
-        implementation group: 'net.thisptr', name: 'jackson-jq', version: '1.0.0-preview.20201123'
+            // lombok
+            annotationProcessor "org.projectlombok:lombok"
+            compileOnly 'org.projectlombok:lombok'
 
-        // exposed utils
-        api group: 'com.google.guava', name: 'guava', version: '30.1-jre'
-        api group: 'commons-io', name: 'commons-io', version: '2.8.0'
-        api group: 'org.apache.commons', name: 'commons-lang3', version: '3.12.0'
-        api "io.swagger.core.v3:swagger-annotations"
+            // micronaut
+            annotationProcessor "io.micronaut:micronaut-inject-java"
+            annotationProcessor "io.micronaut.validation:micronaut-validation-processor"
+            micronaut "io.micronaut:micronaut-inject"
+            micronaut "io.micronaut.validation:micronaut-validation"
+            micronaut "io.micronaut.beanvalidation:micronaut-hibernate-validator"
+            micronaut "io.micronaut:micronaut-runtime"
+            micronaut "io.micronaut:micronaut-retry"
+            micronaut "io.micronaut:micronaut-jackson-databind"
+            micronaut "io.micronaut.data:micronaut-data-model"
+            micronaut "io.micronaut:micronaut-management"
+            micronaut "io.micrometer:micrometer-core"
+            micronaut "io.micronaut.micrometer:micronaut-micrometer-registry-prometheus"
+            micronaut "io.micronaut:micronaut-http-client"
+            micronaut "io.micronaut.reactor:micronaut-reactor-http-client"
+            micronaut "io.micronaut.tracing:micronaut-tracing-opentelemetry-http"
+
+            // logs
+            implementation "org.slf4j:slf4j-api"
+            implementation "ch.qos.logback:logback-classic"
+            implementation "org.codehaus.janino:janino"
+            implementation group: 'org.apache.logging.log4j', name: 'log4j-to-slf4j'
+            implementation group: 'org.slf4j', name: 'jul-to-slf4j'
+            implementation group: 'org.slf4j', name: 'jcl-over-slf4j'
+            implementation group: 'org.fusesource.jansi', name: 'jansi'
+
+            // OTEL
+            implementation "io.opentelemetry:opentelemetry-exporter-otlp"
+
+            // jackson
+            implementation group: 'com.fasterxml.jackson.core', name: 'jackson-core'
+            implementation group: 'com.fasterxml.jackson.core', name: 'jackson-databind'
+            implementation group: 'com.fasterxml.jackson.core', name: 'jackson-annotations'
+            implementation group: 'com.fasterxml.jackson.dataformat', name: 'jackson-dataformat-yaml'
+            implementation group: 'com.fasterxml.jackson.module', name: 'jackson-module-parameter-names'
+            implementation group: 'com.fasterxml.jackson.datatype', name: 'jackson-datatype-guava'
+            implementation group: 'com.fasterxml.jackson.datatype', name: 'jackson-datatype-jsr310'
+
+            // kestra
+            implementation group: 'com.devskiller.friendly-id', name: 'friendly-id'
+            implementation (group: 'net.thisptr', name: 'jackson-jq') {
+                exclude group: 'com.fasterxml.jackson.core'
+            }
+
+            // exposed utils
+            api group: 'com.google.guava', name: 'guava'
+            api group: 'commons-io', name: 'commons-io'
+            api group: 'org.apache.commons', name: 'commons-lang3'
+            api "io.swagger.core.v3:swagger-annotations"
+        }
     }
 }
 
@@ -124,59 +165,206 @@ allprojects {
  * Test
  **********************************************************************************************************************/
 subprojects {
-    apply plugin: "com.adarshr.test-logger"
-    apply plugin: "org.gradle.test-retry"
+    if (it.name != 'platform') {
+        apply plugin: "com.adarshr.test-logger"
 
-    dependencies {
-        // lombok
-        testAnnotationProcessor "org.projectlombok:lombok:" + lombokVersion
-        testCompileOnly 'org.projectlombok:lombok:' + lombokVersion
+        java {
+            sourceCompatibility = targetJavaVersion
+            targetCompatibility = targetJavaVersion
+        }
 
-        // micronaut
-        testAnnotationProcessor platform("io.micronaut:micronaut-bom:$micronautVersion")
-        testAnnotationProcessor "io.micronaut:micronaut-inject-java"
-        testImplementation platform("io.micronaut:micronaut-bom:$micronautVersion")
+        dependencies {
+            // Platform
+            testAnnotationProcessor enforcedPlatform(project(":platform"))
+            testImplementation enforcedPlatform(project(":platform"))
 
-        testImplementation "org.junit.jupiter:junit-jupiter-api"
-        testImplementation "io.micronaut.test:micronaut-test-junit5"
-        testImplementation "org.junit.jupiter:junit-jupiter-engine"
-        testImplementation "org.junit.jupiter:junit-jupiter-params"
+            // lombok
+            testAnnotationProcessor "org.projectlombok:lombok:"
+            testCompileOnly 'org.projectlombok:lombok'
 
-        // hamcrest
-        testImplementation 'org.hamcrest:hamcrest:2.2'
-        testImplementation 'org.hamcrest:hamcrest-library:2.2'
-        testImplementation group: 'org.exparity', name: 'hamcrest-date', version: '2.0.7'
+            // micronaut
+            testAnnotationProcessor "io.micronaut:micronaut-inject-java"
+            testAnnotationProcessor "io.micronaut.validation:micronaut-validation-processor"
+            testImplementation "io.micronaut.test:micronaut-test-junit5"
+
+            testImplementation "org.junit.jupiter:junit-jupiter-engine"
+            testImplementation "org.junit.jupiter:junit-jupiter-params"
+            testImplementation "org.junit-pioneer:junit-pioneer"
+            testImplementation 'org.mockito:mockito-junit-jupiter'
+
+            // hamcrest
+            testImplementation 'org.hamcrest:hamcrest'
+            testImplementation 'org.hamcrest:hamcrest-library'
+            testImplementation 'org.exparity:hamcrest-date'
+
+            //assertj
+            testImplementation 'org.assertj:assertj-core'
+        }
+
+        test {
+            useJUnitPlatform()
+
+            // set Xmx for test workers
+            maxHeapSize = '4g'
+
+            // configure en_US default locale for tests
+            systemProperty 'user.language', 'en'
+            systemProperty 'user.country', 'US'
+
+            environment 'SECRET_MY_SECRET', "{\"secretKey\":\"secretValue\"}".bytes.encodeBase64().toString()
+            environment 'SECRET_NEW_LINE', "cGFzc3dvcmR2ZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2ZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2\nZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2ZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2ZXJ5dmVyeXZl\neXJsb25n"
+            environment 'SECRET_WEBHOOK_KEY', "secretKey".bytes.encodeBase64().toString()
+            environment 'SECRET_NON_B64_SECRET', "some secret value"
+            environment 'SECRET_PASSWORD', "cGFzc3dvcmQ="
+            environment 'ENV_TEST1', "true"
+            environment 'ENV_TEST2', "Pass by env"
+        }
+
+        testlogger {
+            theme 'mocha-parallel'
+            showExceptions true
+            showFullStackTraces true
+            showCauses true
+            slowThreshold 2000
+            showStandardStreams true
+            showPassedStandardStreams false
+            showSkippedStandardStreams true
+        }
     }
+}
 
-    test {
-        useJUnitPlatform()
+/**********************************************************************************************************************\
+ * End-to-End Tests
+ **********************************************************************************************************************/
+def e2eTestsCheck = tasks.register('e2eTestsCheck') {
+    group = 'verification'
+    description = "Runs the 'check' task for all e2e-tests modules"
+    doFirst {
+        project.ext.set("e2e-tests", true)
+    }
+}
 
-        maxHeapSize = "2048m"
-
-        retry {
-            maxRetries = 5
-            maxFailures = 15
+subprojects {
+    // Add e2e-tests modules check tasks to e2eTestsCheck
+    if (project.name.startsWith("e2e-tests")) {
+        test {
+            onlyIf {
+                project.hasProperty("e2e-tests")
+            }
         }
     }
 
-    testlogger {
-        theme 'mocha-parallel'
-        showExceptions true
-        showFullStackTraces true
-        showCauses true
-        slowThreshold 2000
-        showStandardStreams true
-        showPassedStandardStreams false
-        showSkippedStandardStreams true
+    afterEvaluate {
+        // Add e2e-tests modules check tasks to e2eTestsCheck
+        if (project.name.startsWith("e2e-tests")) {
+            e2eTestsCheck.configure {
+                finalizedBy(check)
+            }
+        }
     }
 }
 
+/**********************************************************************************************************************\
+ * Allure Reports
+ **********************************************************************************************************************/
+subprojects {
+    if (it.name != 'platform') {
+        dependencies {
+            testImplementation platform("io.qameta.allure:allure-bom")
+            testImplementation "io.qameta.allure:allure-junit5"
+        }
+
+        configurations {
+            agent {
+                canBeResolved = true
+                canBeConsumed = true
+            }
+        }
+
+        dependencies {
+            agent "org.aspectj:aspectjweaver:1.9.24"
+        }
+
+        test {
+            jvmArgs = ["-javaagent:${configurations.agent.singleFile}"]
+        }
+    }
+}
+
+/**********************************************************************************************************************\
+ * Jacoco
+ **********************************************************************************************************************/
+subprojects {
+    if (it.name != 'platform') {
+        apply plugin: 'jacoco'
+
+        test {
+            finalizedBy jacocoTestReport
+        }
+
+        jacocoTestReport {
+            dependsOn test
+        }
+    }
+}
+
+tasks.named('check') {
+    dependsOn tasks.named('testCodeCoverageReport', JacocoReport)
+}
+
+tasks.named('testCodeCoverageReport') {
+    dependsOn ':core:copyGradleProperties'
+    dependsOn ':ui:assembleFrontend'
+}
+
+/**********************************************************************************************************************\
+ * Sonar
+ **********************************************************************************************************************/
+subprojects {
+    sonar {
+        properties {
+            property "sonar.coverage.jacoco.xmlReportPaths", "$projectDir.parentFile.path/build/reports/jacoco/testCodeCoverageReport/testCodeCoverageReport.xml"
+        }
+    }
+}
+
+sonar {
+    properties {
+        property "sonar.projectKey", "kestra-io_kestra"
+        property "sonar.organization", "kestra-io"
+        property "sonar.host.url", "https://sonarcloud.io"
+    }
+}
+
+/**********************************************************************************************************************\
+ * OWASP Dependency check
+ **********************************************************************************************************************/
+apply plugin: 'org.owasp.dependencycheck'
+
+dependencyCheck {
+    // fail only on HIGH and CRITICAL vulnerabilities, we may want to lower to 5 (mid-medium) later
+    failBuildOnCVSS = 7
+
+    // disable the .NET assembly analyzer as otherwise it wants to analyze EXE file
+    analyzers(new Action<AnalyzerExtension>() {
+        @Override
+        void execute(AnalyzerExtension analyzerExtension) {
+            analyzerExtension.assemblyEnabled = false
+        }
+    })
+
+    // configure a suppression file
+    suppressionFile = "$projectDir/owasp-dependency-suppressions.xml"
+
+    nvd.apiKey = System.getenv("NVD_API_KEY")
+}
+
 /**********************************************************************************************************************\
  * Micronaut
  **********************************************************************************************************************/
 allprojects {
     gradle.projectsEvaluated {
-        tasks.withType(JavaCompile) {
+        tasks.withType(JavaCompile).configureEach {
             options.encoding = "UTF-8"
             options.compilerArgs.add("-parameters")
             options.compilerArgs.add("-Xlint:all")
@@ -185,7 +373,7 @@ allprojects {
     }
 }
 
-tasks.withType(JavaCompile) {
+tasks.withType(JavaCompile).configureEach {
     options.encoding = "UTF-8"
     options.compilerArgs.add("-parameters")
 }
@@ -205,106 +393,83 @@ run.jvmArgs(
  **********************************************************************************************************************/
 jar {
     manifest {
-        attributes (
+        attributes(
             "Main-Class": mainClassName,
-                "X-Kestra-Title": project.name,
-                "X-Kestra-Group": project.group,
-                "X-Kestra-Version": project.version
+            "X-Kestra-Name": project.name,
+            "X-Kestra-Title": project.name,
+            "X-Kestra-Group": project.group,
+            "X-Kestra-Version": project.version
         )
     }
 }
 
 shadowJar {
-    dependsOn = ['ui:assembleFrontend']
-
     archiveClassifier.set(null)
     mergeServiceFiles()
+    zip64 true
 }
 
+distZip.dependsOn shadowJar
+distTar.dependsOn shadowJar
+startScripts.dependsOn shadowJar
+startShadowScripts.dependsOn jar
+shadowJar.dependsOn 'ui:assembleFrontend'
+
 /**********************************************************************************************************************\
  * Executable Jar
  **********************************************************************************************************************/
-def executableDir = file("${buildDir}/executable")
-def executable = file("${buildDir}/executable/${project.name}-${project.version}")
+def executableDir = layout.buildDirectory.dir("executable")
+def executable = layout.buildDirectory.file("executable/${project.name}-${project.version}").get().asFile
 
-task writeExecutableJar()  {
+tasks.register('writeExecutableJar') {
     group "build"
     description "Write an executable jar from shadow jar"
     dependsOn = [shadowJar]
 
+    final shadowJarFile =  tasks.shadowJar.outputs.files.singleFile
+    inputs.file shadowJarFile
+    outputs.file executable
+    outputs.cacheIf { true }
+
     doFirst {
-        executableDir.mkdirs()
+        executableDir.get().asFile.mkdirs()
     }
 
     doLast {
-        executable.write("")
-        executable.append("\n: <<END_OF_KESTRA_SELFRUN\r\n")
-        executable.append(file("gradle/jar/selfrun.bat").readBytes())
-        executable.append("\r\nEND_OF_KESTRA_SELFRUN\r\n\n")
-        executable.append(file("gradle/jar/selfrun.sh").readBytes())
-        executable.append(file("${buildDir}/libs/${project.name}-${project.version}.jar").readBytes())
+        executable.setBytes(shadowJarFile.readBytes())
+        ByteArrayOutputStream executableBytes = new ByteArrayOutputStream()
+        executableBytes.write("\n: <<END_OF_KESTRA_SELFRUN\r\n".getBytes())
+        executableBytes.write(file("gradle/jar/selfrun.bat").readBytes())
+        executableBytes.write("\r\n".getBytes())
+        executableBytes.write("END_OF_KESTRA_SELFRUN\r\n\n".getBytes())
+        executableBytes.write(file("gradle/jar/selfrun.sh").readBytes())
+        ZipPrefixer.applyPrefixBytesToZip(executable.toPath(), executableBytes.toByteArray())
         executable.setExecutable(true)
     }
-
 }
 
-task executableJar(type: Zip) {
+tasks.register('executableJar', Zip) {
     group "build"
     description "Zip the executable jar"
     dependsOn = [writeExecutableJar]
 
     archiveFileName = "${project.name}-${project.version}.zip"
-    destinationDirectory = file("${buildDir}/archives")
+    destinationDirectory = layout.buildDirectory.dir('archives')
 
     from executableDir
     archiveClassifier.set(null)
 }
 
-/**********************************************************************************************************************\
- * Jacoco
- **********************************************************************************************************************/
-subprojects {
-    test {
-        finalizedBy jacocoTestReport
-    }
-
-    jacoco {
-        toolVersion = "0.8.4"
-    }
-
-    jacocoTestReport {
-        getAdditionalSourceDirs().setFrom(files(sourceSets.main.allSource.srcDirs))
-        getSourceDirectories().setFrom(files(sourceSets.main.allSource.srcDirs))
-        getClassDirectories().setFrom(files(sourceSets.main.output))
-    }
-}
-
-
-task jacoco(type: JacocoReport) {
-    dependsOn = subprojects.test
-
-    def javaProject = subprojects.findAll { it.name != 'ui' };
-
-    getAdditionalSourceDirs().setFrom(files(javaProject.sourceSets.main.allSource.srcDirs))
-    getSourceDirectories().setFrom(files(javaProject.sourceSets.main.allSource.srcDirs))
-    getClassDirectories().setFrom(files(javaProject.sourceSets.main.output))
-    getExecutionData().setFrom(files(javaProject.jacocoTestReport.executionData))
-
-    reports {
-        html.enabled = true
-        xml.enabled = true
-        csv.enabled = true
-    }
-}
-
 /**********************************************************************************************************************\
  * Standalone
  **********************************************************************************************************************/
-task runStandalone(type: JavaExec) {
+tasks.register('runLocal', JavaExec) {
     group = "application"
+    description = "Run Kestra as server local"
     classpath = project(":cli").sourceSets.main.runtimeClasspath
-    main = mainClassName
-    args 'server', 'standalone'
+    mainClass = mainClassName
+    environment 'MICRONAUT_ENVIRONMENTS', 'override'
+    args 'server', 'local', '--plugins', 'local/plugins'
 }
 
 /**********************************************************************************************************************\
@@ -331,19 +496,34 @@ subprojects {
         options {
             locale = 'en_US'
             encoding = 'UTF-8'
+            addStringOption("Xdoclint:none", "-quiet")
         }
     }
 
-    task sourcesJar(type: Jar) {
+    tasks.register('sourcesJar', Jar) {
+        dependsOn = [':core:copyGradleProperties']
+        dependsOn = [':ui:assembleFrontend']
         archiveClassifier.set('sources')
         from sourceSets.main.allSource
     }
+    sourcesJar.dependsOn ':core:copyGradleProperties'
+    sourcesJar.dependsOn ':ui:assembleFrontend'
 
-    task javadocJar(type: Jar) {
+    tasks.register('javadocJar', Jar) {
         archiveClassifier.set('javadoc')
         from javadoc
     }
 
+    tasks.register('testsJar', Jar) {
+        group = 'build'
+        description = 'Build the tests jar'
+
+        archiveClassifier.set('tests')
+        if (sourceSets.matching { it.name == 'test'}) {
+            from sourceSets.named('test').get().output
+        }
+    }
+
     github {
         user 'kestra-io'
         license 'Apache'
@@ -351,13 +531,13 @@ subprojects {
         site 'https://kestra.io'
     }
 
-    pom {
-        description 'The modern, scalable orchestrator & scheduler open source platform'
+    maven.pom {
+        description = 'The modern, scalable orchestrator & scheduler open source platform'
 
         developers {
             developer {
-                id "tchiotludo"
-                name "Ludovic Dehon"
+                id = "tchiotludo"
+                name = "Ludovic Dehon"
             }
         }
     }
@@ -373,6 +553,9 @@ subprojects {
 
                     artifact shadowJar
                     artifact executableJar
+                } else if (project.name.contains('platform')){
+                    groupId project.group
+                    artifactId project.name
                 } else {
                     from components.java
 
@@ -381,14 +564,22 @@ subprojects {
 
                     artifact sourcesJar
                     artifact javadocJar
+                    artifact testsJar
                 }
             }
         }
     }
 
     signing {
+        // only sign JARs that we publish to Sonatype
+        required { gradle.taskGraph.hasTask("publishSonatypePublicationPublicationToSonatypeRepository") }
         sign publishing.publications.sonatypePublication
     }
+
+    tasks.withType(GenerateModuleMetadata).configureEach {
+        // Suppression this validation error as we want to enforce the Kestra platform
+        suppressedValidationErrors.add('enforced-platform')
+    }
 }
 
 
@@ -401,10 +592,17 @@ release {
     tagCommitMessage = 'tag version'
     newVersionCommitMessage = 'update snapshot version'
     tagTemplate = 'v${version}'
-    pushReleaseVersionBranch = 'master'
     buildTasks = ['classes']
 
     git {
-        requireBranch = 'release'
+        requireBranch.set('develop')
     }
+
+    // Dynamically set properties with default values
+    failOnSnapshotDependencies = providers.gradleProperty("release.failOnSnapshotDependencies")
+            .map(val -> Boolean.parseBoolean(val))
+            .getOrElse(true)
+
+    pushReleaseVersionBranch = providers.gradleProperty("release.pushReleaseVersionBranch")
+            .getOrElse(null)
 }

cli/build.gradle

@@ -1,3 +1,6 @@
+configurations {
+    implementation.extendsFrom(micronaut)
+}
 dependencies {
     // micronaut
     implementation "info.picocli:picocli"
@@ -5,31 +8,33 @@ dependencies {
     implementation "io.micronaut:micronaut-management"
     implementation "io.micronaut:micronaut-http-server-netty"
 
-    // plugins
-    implementation 'org.eclipse.aether:aether-api:1.1.0'
-    implementation 'org.eclipse.aether:aether-spi:1.1.0'
-    implementation 'org.eclipse.aether:aether-util:1.1.0'
-    implementation 'org.eclipse.aether:aether-impl:1.1.0'
-    implementation 'org.eclipse.aether:aether-connector-basic:1.1.0'
-    implementation 'org.eclipse.aether:aether-transport-file:1.1.0'
-    implementation 'org.eclipse.aether:aether-transport-http:1.1.0'
-    implementation('org.apache.maven:maven-aether-provider:3.3.9') {
-        // sisu dependency injector is not used
-        exclude group: 'org.eclipse.sisu'
-    }
+    // logs
+    implementation 'ch.qos.logback.contrib:logback-json-classic'
+    implementation 'ch.qos.logback.contrib:logback-jackson'
+
+    // OTLP metrics
+    implementation "io.micronaut.micrometer:micronaut-micrometer-registry-otlp"
+
+    // aether still use javax.inject
+    compileOnly 'javax.inject:javax.inject:1'
 
     // modules
     implementation project(":core")
+    implementation project(":script")
 
     implementation project(":repository-memory")
-    implementation project(":repository-elasticsearch")
 
     implementation project(":runner-memory")
-    implementation project(":runner-kafka")
 
-    implementation project(":indexer-kafka-elasticsearch")
+    implementation project(":jdbc")
+    implementation project(":jdbc-h2")
+    implementation project(":jdbc-mysql")
+    implementation project(":jdbc-postgres")
 
     implementation project(":storage-local")
 
     implementation project(":webserver")
+
+    //test
+    testImplementation "org.wiremock:wiremock-jetty12"
 }

cli/src/main/java/io/kestra/cli/AbstractApiCommand.java

@@ -1,31 +1,68 @@
 package io.kestra.cli;
 
+import io.micronaut.core.annotation.Nullable;
+import io.micronaut.http.HttpHeaders;
 import io.micronaut.http.HttpRequest;
+import io.micronaut.http.MediaType;
 import io.micronaut.http.MutableHttpRequest;
+import io.micronaut.http.body.ContextlessMessageBodyHandlerRegistry;
+import io.micronaut.http.body.MessageBodyHandlerRegistry;
+import io.micronaut.http.client.DefaultHttpClientConfiguration;
+import io.micronaut.http.client.HttpClientConfiguration;
 import io.micronaut.http.client.netty.DefaultHttpClient;
+import io.micronaut.http.netty.body.NettyJsonHandler;
+import io.micronaut.json.JsonMapper;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import lombok.Builder;
+import lombok.Value;
+import lombok.extern.jackson.Jacksonized;
 import picocli.CommandLine;
 
+import java.net.URISyntaxException;
 import java.net.URL;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 
 public abstract class AbstractApiCommand extends AbstractCommand {
-    @CommandLine.Option(names = {"--server"}, description = "Also write core tasks plugins")
+    @CommandLine.Option(names = {"--server"}, description = "Kestra server url", defaultValue = "http://localhost:8080")
     protected URL server;
 
-    @CommandLine.Option(names = {"--headers"}, description = "Also write core tasks plugins")
+    @CommandLine.Option(names = {"--headers"}, paramLabel = "<name=value>", description = "Headers to add to the request")
     protected Map<CharSequence, CharSequence> headers;
 
-    @CommandLine.Option(names = {"--user"}, description = "<user:password> Server user and password")
+    @CommandLine.Option(names = {"--user"}, paramLabel = "<user:password>", description = "Server user and password")
     protected String user;
 
-    public AbstractApiCommand(boolean withServer) {
-        super(withServer);
+    @CommandLine.Option(names = {"--tenant"}, description = "Tenant identifier (EE only, when multi-tenancy is enabled)")
+    protected String tenantId;
+
+    @CommandLine.Option(names = {"--api-token"}, description = "API Token (EE only).")
+    protected String apiToken;
+
+    @Inject
+    @Named("remote-api")
+    @Nullable
+    private HttpClientConfiguration httpClientConfiguration;
+
+    /**
+     * {@inheritDoc}
+     */
+    protected boolean loadExternalPlugins() {
+        return false;
     }
 
-    protected DefaultHttpClient client() {
-        return new DefaultHttpClient(server);
+    protected DefaultHttpClient client() throws URISyntaxException {
+        DefaultHttpClient defaultHttpClient = DefaultHttpClient.builder()
+            .uri(server.toURI())
+            .configuration(httpClientConfiguration != null ? httpClientConfiguration : new DefaultHttpClientConfiguration())
+            .build();
+        MessageBodyHandlerRegistry defaultHandlerRegistry = defaultHttpClient.getHandlerRegistry();
+        if (defaultHandlerRegistry instanceof ContextlessMessageBodyHandlerRegistry modifiableRegistry) {
+            modifiableRegistry.add(MediaType.TEXT_JSON_TYPE, new NettyJsonHandler<>(JsonMapper.createDefault()));
+        }
+        return defaultHttpClient;
     }
 
     protected <T> HttpRequest<T> requestOptions(MutableHttpRequest<T> request) {
@@ -35,12 +72,32 @@ public abstract class AbstractApiCommand extends AbstractCommand {
 
         if (this.user != null) {
             List<String> split = Arrays.asList(this.user.split(":"));
-            String user = split.get(0);
+            String user = split.getFirst();
             String password = String.join(":", split.subList(1, split.size()));
 
             request.basicAuth(user, password);
         }
 
+        if (this.apiToken != null) {
+            request.header(HttpHeaders.AUTHORIZATION, "Bearer " + apiToken);
+        }
+
         return request;
     }
+
+    protected String apiUri(String path) {
+        if (path == null || !path.startsWith("/")) {
+            throw new IllegalArgumentException("'path' must be non-null and start with '/'");
+        }
+
+        return tenantId == null ? "/api/v1" + path : "/api/v1/" + tenantId + path;
+    }
+
+    @Builder
+    @Value
+    @Jacksonized
+    public static class UpdateResult {
+        String id;
+        String namespace;
+    }
 }

cli/src/main/java/io/kestra/cli/AbstractCommand.java

@@ -2,16 +2,19 @@ package io.kestra.cli;
 
 import ch.qos.logback.classic.LoggerContext;
 import com.google.common.collect.ImmutableMap;
+import io.kestra.cli.commands.servers.ServerCommandInterface;
+import io.kestra.cli.services.StartupHookInterface;
+import io.kestra.core.plugins.PluginManager;
+import io.kestra.core.plugins.PluginRegistry;
+import io.kestra.webserver.services.FlowAutoLoaderService;
 import io.micronaut.context.ApplicationContext;
 import io.micronaut.context.env.yaml.YamlPropertySourceLoader;
+import io.micronaut.core.annotation.Introspected;
+import io.micronaut.http.uri.UriBuilder;
 import io.micronaut.management.endpoint.EndpointDefaultConfiguration;
 import io.micronaut.runtime.server.EmbeddedServer;
+import jakarta.inject.Provider;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.http.client.utils.URIBuilder;
-import io.kestra.core.contexts.KestraClassLoader;
-import io.kestra.core.plugins.PluginRegistry;
-import io.kestra.core.plugins.PluginScanner;
-import io.kestra.core.plugins.RegisteredPlugin;
 import io.kestra.core.utils.Rethrow;
 import picocli.CommandLine;
 
@@ -22,38 +25,56 @@ import java.net.URISyntaxException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.text.MessageFormat;
-import java.util.List;
+import java.time.temporal.ChronoUnit;
 import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.Callable;
-import javax.inject.Inject;
+import jakarta.inject.Inject;
+import picocli.CommandLine.Command;
+import picocli.CommandLine.Option;
 
-@CommandLine.Command(
-    mixinStandardHelpOptions = true
+@Command(
+    versionProvider = VersionProvider.class,
+    mixinStandardHelpOptions = true,
+    showDefaultValues = true
 )
 @Slf4j
+@Introspected
 abstract public class AbstractCommand implements Callable<Integer> {
-    private final boolean withServer;
-
     @Inject
     private ApplicationContext applicationContext;
 
     @Inject
     private EndpointDefaultConfiguration endpointConfiguration;
 
-    @CommandLine.Option(names = {"-v", "--verbose"}, description = "Change log level. Multiple -v options increase the verbosity.")
+    @Inject
+    private StartupHookInterface startupHook;
+
+    @Inject
+    private io.kestra.core.utils.VersionProvider versionProvider;
+
+    @Inject
+    protected Provider<PluginRegistry> pluginRegistryProvider;
+
+    @Inject
+    protected Provider<PluginManager> pluginManagerProvider;
+
+    private PluginRegistry pluginRegistry;
+
+    @Option(names = {"-v", "--verbose"}, description = "Change log level. Multiple -v options increase the verbosity.", showDefaultValue = CommandLine.Help.Visibility.NEVER)
     private boolean[] verbose = new boolean[0];
 
-    @CommandLine.Option(names = {"-l", "--log-level"}, description = "Change log level (values: ${COMPLETION-CANDIDATES}; default: ${DEFAULT-VALUE})")
+    @Option(names = {"-l", "--log-level"}, description = "Change log level (values: ${COMPLETION-CANDIDATES})")
     private LogLevel logLevel = LogLevel.INFO;
 
-    @CommandLine.Option(names = {"--internal-log"}, description = "Change also log level for internal log, default: ${DEFAULT-VALUE})")
+    @Option(names = {"--internal-log"}, description = "Change also log level for internal log")
     private boolean internalLog = false;
 
-    @CommandLine.Option(names = {"-c", "--config"}, description = "Path to a configuration file, default: ${DEFAULT-VALUE})")
+    @Option(names = {"-c", "--config"}, description = "Path to a configuration file")
     private Path config = Paths.get(System.getProperty("user.home"), ".kestra/config.yml");
 
-    @CommandLine.Option(names = {"-p", "--plugins"}, description = "Path to plugins directory , default: ${DEFAULT-VALUE})")
-    protected Path pluginsPath = System.getenv("KESTRA_PLUGINS_PATH") != null ? Paths.get(System.getenv("KESTRA_PLUGINS_PATH")) : null;
+    @Option(names = {"-p", "--plugins"}, description = "Path to plugins directory")
+    protected Path pluginsPath = Optional.ofNullable(System.getenv("KESTRA_PLUGINS_PATH")).map(Paths::get).orElse(null);
 
     public enum LogLevel {
         TRACE,
@@ -63,20 +84,51 @@ abstract public class AbstractCommand implements Callable<Integer> {
         ERROR
     }
 
-    public AbstractCommand(boolean withServer) {
-        this.withServer = withServer;
-    }
-
     @Override
     public Integer call() throws Exception {
-        Thread.currentThread().setName(this.getClass().getDeclaredAnnotation(CommandLine.Command.class).name());
+        Thread.currentThread().setName(this.getClass().getDeclaredAnnotation(Command.class).name());
         startLogger();
         sendServerLog();
-        startWebserver();
+        if (this.startupHook != null) {
+            this.startupHook.start(this);
+        }
 
+        if (this.pluginsPath != null && loadExternalPlugins()) {
+            pluginRegistry = pluginRegistryProvider.get();
+            pluginRegistry.registerIfAbsent(pluginsPath);
+
+            // PluginManager mus only be initialized if a registry is also instantiated
+            if (isPluginManagerEnabled()) {
+                PluginManager manager = pluginManagerProvider.get();
+                manager.start();
+            }
+        }
+
+        startWebserver();
         return 0;
     }
 
+    /**
+     * Specifies whether external plugins must be loaded.
+     * This method can be overridden by concrete commands.
+     *
+     * @return {@code true} if external plugins must be loaded.
+     */
+    protected boolean loadExternalPlugins() {
+        return true;
+    }
+
+    /**
+     * Specifies whether the {@link PluginManager} service must be initialized.
+     * <p>
+     * This method can be overridden by concrete commands.
+     *
+     * @return {@code true} if the {@link PluginManager} service must be initialized.
+     */
+    protected boolean isPluginManagerEnabled() {
+        return true;
+    }
+
     private static String message(String message, Object... format) {
         return CommandLine.Help.Ansi.AUTO.string(
             format.length == 0 ? message : MessageFormat.format(message, format)
@@ -98,8 +150,25 @@ abstract public class AbstractCommand implements Callable<Integer> {
             this.logLevel = LogLevel.TRACE;
         }
 
-        if (this.withServer) {
-            log.info("Starting Kestra with environments {}", applicationContext.getEnvironment().getActiveNames());
+
+        if (this instanceof ServerCommandInterface) {
+            String buildInfo = "";
+            if (versionProvider.getRevision() != null) {
+                buildInfo += " [revision " + versionProvider.getRevision();
+
+                if (versionProvider.getDate() != null) {
+                    buildInfo += " / " + versionProvider.getDate().toLocalDateTime().truncatedTo(ChronoUnit.MINUTES);
+                }
+
+                buildInfo += "]";
+            }
+
+            log.info(
+                "Starting Kestra {} with environments {}{}",
+                versionProvider.getVersion(),
+                applicationContext.getEnvironment().getActiveNames(),
+                buildInfo
+            );
         }
 
         ((LoggerContext) org.slf4j.LoggerFactory.getILoggerFactory())
@@ -109,9 +178,8 @@ abstract public class AbstractCommand implements Callable<Integer> {
                 (
                     this.internalLog && (
                         logger.getName().startsWith("io.kestra") &&
-                            !logger.getName().startsWith("io.kestra.runner.kafka.services"))
+                            !logger.getName().startsWith("io.kestra.ee.runner.kafka.services"))
                 )
-                    || logger.getName().startsWith("flow")
             )
             .forEach(
                 logger -> logger.setLevel(ch.qos.logback.classic.Level.valueOf(this.logLevel.name()))
@@ -119,16 +187,13 @@ abstract public class AbstractCommand implements Callable<Integer> {
     }
 
     private void sendServerLog() {
-        if (log.isTraceEnabled() && KestraClassLoader.instance().getPluginRegistry() != null) {
-            KestraClassLoader.instance()
-                .getPluginRegistry()
-                .getPlugins()
-                .forEach(c -> log.trace(c.toString()));
+        if (log.isTraceEnabled() && pluginRegistry != null) {
+            pluginRegistry.plugins().forEach(c -> log.trace(c.toString()));
         }
     }
 
     private void startWebserver() {
-        if (!this.withServer) {
+        if (!(this instanceof ServerCommandInterface)) {
             return;
         }
 
@@ -140,9 +205,9 @@ abstract public class AbstractCommand implements Callable<Integer> {
                 if (this.endpointConfiguration.getPort().isPresent()) {
                     URI endpoint = null;
                     try {
-                        endpoint = new URIBuilder(server.getURL().toURI())
-                            .setPort(this.endpointConfiguration.getPort().get())
-                            .setPath("/health")
+                        endpoint = UriBuilder.of(server.getURL().toURI())
+                            .port(this.endpointConfiguration.getPort().get())
+                            .path("/health")
                             .build();
                     } catch (URISyntaxException e) {
                         e.printStackTrace();
@@ -151,19 +216,33 @@ abstract public class AbstractCommand implements Callable<Integer> {
                 } else {
                     log.info("Server Running: {}", server.getURL());
                 }
+
+                if (isFlowAutoLoadEnabled()) {
+                    applicationContext
+                        .findBean(FlowAutoLoaderService.class)
+                        .ifPresent(FlowAutoLoaderService::load);
+                }
             });
     }
 
-    protected void shutdownHook(Rethrow.RunnableChecked<Exception> run) {
-        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
-            log.warn("Receiving shutdown ! Try to graceful exit");
+    public boolean isFlowAutoLoadEnabled() {
+        return false;
+    }
 
-            try {
-                run.run();
-            } catch (Exception e) {
-                log.error("Failed to close gracefully!", e);
-            }
-        }));
+    protected void shutdownHook(boolean logShutdown, Rethrow.RunnableChecked<Exception> run) {
+        Runtime.getRuntime().addShutdownHook(new Thread(
+            () -> {
+                if (logShutdown) {
+                    log.warn("Receiving shutdown ! Try to graceful exit");
+                }
+                try {
+                    run.run();
+                } catch (Exception e) {
+                    log.error("Failed to close gracefully!", e);
+                }
+            },
+            "command-shutdown"
+        ));
     }
 
     @SuppressWarnings({"unused"})
@@ -180,19 +259,4 @@ abstract public class AbstractCommand implements Callable<Integer> {
 
         return ImmutableMap.of();
     }
-
-    @SuppressWarnings("unused")
-    public PluginRegistry initPluginRegistry() {
-        if (this.pluginsPath == null || !this.pluginsPath.toFile().exists()) {
-            return null;
-        }
-
-        PluginScanner pluginScanner = new PluginScanner(KestraClassLoader.instance());
-        List<RegisteredPlugin> scan = pluginScanner.scan(this.pluginsPath);
-
-        PluginRegistry pluginRegistry = new PluginRegistry(scan);
-        KestraClassLoader.instance().setPluginRegistry(pluginRegistry);
-
-        return pluginRegistry;
-    }
 }

cli/src/main/java/io/kestra/cli/AbstractValidateCommand.java

@@ -0,0 +1,141 @@
+package io.kestra.cli;
+
+import io.kestra.core.models.validations.ModelValidator;
+import io.kestra.core.models.validations.ValidateConstraintViolation;
+import io.kestra.core.serializers.YamlParser;
+import io.micronaut.core.type.Argument;
+import io.micronaut.http.HttpRequest;
+import io.micronaut.http.MediaType;
+import io.micronaut.http.MutableHttpRequest;
+import io.micronaut.http.client.exceptions.HttpClientResponseException;
+import io.micronaut.http.client.netty.DefaultHttpClient;
+import picocli.CommandLine;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import jakarta.validation.ConstraintViolationException;
+
+import static io.kestra.core.utils.Rethrow.throwConsumer;
+import static io.kestra.core.utils.Rethrow.throwFunction;
+
+public abstract class AbstractValidateCommand extends AbstractApiCommand {
+    @CommandLine.Option(names = {"--local"}, description = "If validation should be done locally or using a remote server", defaultValue = "false")
+    protected boolean local;
+
+    @CommandLine.Parameters(index = "0", description = "the directory containing files to check")
+    protected Path directory;
+
+    /** {@inheritDoc} **/
+    @Override
+    protected boolean loadExternalPlugins() {
+        return local;
+    }
+
+    public static void handleException(ConstraintViolationException e, String resource) {
+        stdErr("\t@|fg(red) Unable to parse {0} due to the following error(s):|@", resource);
+        e.getConstraintViolations()
+            .forEach(constraintViolation -> {
+                stdErr(
+                    "\t- @|bold,yellow {0} : {1} |@",
+                    constraintViolation.getMessage().replace("\n"," - "),
+                    constraintViolation.getPropertyPath()
+                );
+            });
+    }
+
+    public static void handleHttpException(HttpClientResponseException e, String resource) {
+        stdErr("\t@|fg(red) Unable to parse {0}s due to the following error:|@", resource);
+        stdErr(
+            "\t- @|bold,yellow {0}|@",
+            e.getMessage()
+        );
+    }
+
+    public static void handleValidateConstraintViolation(ValidateConstraintViolation validateConstraintViolation, String resource){
+        stdErr("\t@|fg(red) Unable to parse {0}s due to the following error:|@", resource);
+        stdErr(
+            "\t- @|bold,yellow {0}|@",
+            validateConstraintViolation.getConstraints()
+        );
+    }
+
+    public static String buildYamlBody(Path directory) throws IOException {
+        try(var files = Files.walk(directory)) {
+            return files.filter(Files::isRegularFile)
+                .filter(YamlParser::isValidExtension)
+                .map(throwFunction(path -> Files.readString(path, Charset.defaultCharset())))
+                .collect(Collectors.joining("\n---\n"));
+        }
+    }
+
+    // bug in micronaut, we can't inject ModelValidator, so we inject from implementation
+    public Integer call(
+        Class<?> cls,
+        ModelValidator modelValidator,
+        Function<Object, String> identity,
+        Function<Object, List<String>> warningsFunction,
+        Function<Object, List<String>> infosFunction
+    ) throws Exception {
+        super.call();
+
+        AtomicInteger returnCode = new AtomicInteger(0);
+        String clsName = cls.getSimpleName().toLowerCase();
+
+        if(this.local) {
+            try(var files = Files.walk(directory)) {
+                files.filter(Files::isRegularFile)
+                    .filter(YamlParser::isValidExtension)
+                    .forEach(path -> {
+                        try {
+                            Object parse = YamlParser.parse(path.toFile(), cls);
+                            modelValidator.validate(parse);
+                            stdOut("@|green \u2713|@ - " + identity.apply(parse));
+                            List<String> warnings = warningsFunction.apply(parse);
+                            warnings.forEach(warning -> stdOut("@|bold,yellow \u26A0|@ - " + warning));
+                            List<String> infos = infosFunction.apply(parse);
+                            infos.forEach(info -> stdOut("@|bold,blue \u2139|@ - " + info));
+                        } catch (ConstraintViolationException e) {
+                            stdErr("@|red \u2718|@ - " + path);
+                            AbstractValidateCommand.handleException(e, clsName);
+                            returnCode.set(1);
+                        }
+                    });
+            }
+        } else {
+            String body = AbstractValidateCommand.buildYamlBody(directory);
+
+            try(DefaultHttpClient client = client()) {
+                MutableHttpRequest<String> request = HttpRequest
+                    .POST(apiUri("/flows/validate"), body).contentType(MediaType.APPLICATION_YAML);
+
+                List<ValidateConstraintViolation> validations = client.toBlocking().retrieve(
+                    this.requestOptions(request),
+                    Argument.listOf(ValidateConstraintViolation.class)
+                );
+
+                validations
+                    .forEach(throwConsumer(validation -> {
+                        if (validation.getConstraints() == null) {
+                            stdOut("@|green \u2713|@ - " + validation.getIdentity());
+                        } else {
+                            stdErr("@|red \u2718|@ - " + validation.getIdentity(directory));
+                            AbstractValidateCommand.handleValidateConstraintViolation(validation, clsName);
+                            returnCode.set(1);
+                        }
+                    }));
+            } catch (HttpClientResponseException e){
+                AbstractValidateCommand.handleHttpException(e, clsName);
+
+                return 1;
+            }
+        }
+
+        return returnCode.get();
+    }
+}

cli/src/main/java/io/kestra/cli/App.java

@@ -1,22 +1,27 @@
 package io.kestra.cli;
 
-import io.micronaut.configuration.picocli.MicronautFactory;
-import io.micronaut.configuration.picocli.PicocliRunner;
-import io.micronaut.context.ApplicationContext;
-import io.micronaut.context.env.Environment;
 import io.kestra.cli.commands.configs.sys.ConfigCommand;
 import io.kestra.cli.commands.flows.FlowCommand;
+import io.kestra.cli.commands.namespaces.NamespaceCommand;
 import io.kestra.cli.commands.plugins.PluginCommand;
 import io.kestra.cli.commands.servers.ServerCommand;
 import io.kestra.cli.commands.sys.SysCommand;
-import io.kestra.core.contexts.KestraApplicationContextBuilder;
-import io.kestra.core.contexts.KestraClassLoader;
+import io.kestra.cli.commands.templates.TemplateCommand;
+import io.micronaut.configuration.picocli.MicronautFactory;
+import io.micronaut.configuration.picocli.PicocliRunner;
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.context.ApplicationContextBuilder;
+import io.micronaut.context.env.Environment;
+import io.micronaut.core.annotation.Introspected;
 import org.slf4j.bridge.SLF4JBridgeHandler;
 import picocli.CommandLine;
 
+import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.Callable;
 
@@ -33,10 +38,13 @@ import java.util.concurrent.Callable;
         PluginCommand.class,
         ServerCommand.class,
         FlowCommand.class,
+        TemplateCommand.class,
         SysCommand.class,
         ConfigCommand.class,
+        NamespaceCommand.class,
     }
 )
+@Introspected
 public class App implements Callable<Integer> {
     public static void main(String[] args) {
         execute(App.class, args);
@@ -52,9 +60,6 @@ public class App implements Callable<Integer> {
         SLF4JBridgeHandler.removeHandlersForRootLogger();
         SLF4JBridgeHandler.install();
 
-        // Register a ClassLoader with isolation for plugins
-        Thread.currentThread().setContextClassLoader(KestraClassLoader.create(Thread.currentThread().getContextClassLoader()));
-
         // Init ApplicationContext
         ApplicationContext applicationContext = App.applicationContext(cls, args);
 
@@ -74,34 +79,53 @@ public class App implements Callable<Integer> {
      * @param args args passed to java app
      * @return the application context created
      */
-    protected static ApplicationContext applicationContext(Class<?> mainClass, String[] args) {
-        KestraApplicationContextBuilder builder = new KestraApplicationContextBuilder()
+    protected static ApplicationContext applicationContext(Class<?> mainClass,
+                                                           String[] args) {
+
+        ApplicationContextBuilder builder = ApplicationContext
+            .builder()
             .mainClass(mainClass)
-            .environments(Environment.CLI)
-            .classLoader(KestraClassLoader.instance());
+            .environments(Environment.CLI);
 
         CommandLine cmd = new CommandLine(mainClass, CommandLine.defaultFactory());
+        continueOnParsingErrors(cmd);
 
         CommandLine.ParseResult parseResult = cmd.parseArgs(args);
         List<CommandLine> parsedCommands = parseResult.asCommandLineList();
 
-        CommandLine commandLine = parsedCommands.get(parsedCommands.size() - 1);
+        CommandLine commandLine = parsedCommands.getLast();
         Class<?> cls = commandLine.getCommandSpec().userObject().getClass();
 
         if (AbstractCommand.class.isAssignableFrom(cls)) {
             // if class have propertiesFromConfig, add configuration files
             builder.properties(getPropertiesFromMethod(cls, "propertiesFromConfig", commandLine.getCommandSpec().userObject()));
 
+            Map<String, Object> properties = new HashMap<>();
+
             // if class have propertiesOverrides, add force properties for this class
-            builder.properties(getPropertiesFromMethod(cls, "propertiesOverrides", null));
+            Map<String, Object> propertiesOverrides = getPropertiesFromMethod(cls, "propertiesOverrides", null);
+            if (propertiesOverrides != null && isPracticalCommand(commandLine)) {
+                properties.putAll(propertiesOverrides);
+            }
 
-            // add plugins registry if plugin path defined
-            builder.pluginRegistry(getPropertiesFromMethod(cls, "initPluginRegistry", commandLine.getCommandSpec().userObject()));
+            // custom server configuration
+            commandLine
+                .getParseResult()
+                .matchedArgs()
+                .stream()
+                .filter(argSpec -> ((Field) argSpec.userObject()).getName().equals("serverPort"))
+                .findFirst()
+                .ifPresent(argSpec -> properties.put("micronaut.server.port", argSpec.getValue()));
+
+            builder.properties(properties);
         }
-
         return builder.build();
     }
 
+    private static void continueOnParsingErrors(CommandLine cmd) {
+        cmd.getCommandSpec().parser().collectErrors(true);
+    }
+
     @SuppressWarnings("unchecked")
     private static <T> T getPropertiesFromMethod(Class<?> cls, String methodName, Object instance) {
         try {
@@ -118,4 +142,12 @@ public class App implements Callable<Integer> {
 
         return null;
     }
+
+    /**
+     * @param commandLine parsed command
+     * @return false if the command is a help or version request, true otherwise
+     */
+    private static boolean isPracticalCommand(CommandLine commandLine) {
+        return !(commandLine.isUsageHelpRequested() || commandLine.isVersionHelpRequested());
+    }
 }

cli/src/main/java/io/kestra/cli/ServerCommandValidator.java

@@ -0,0 +1,55 @@
+package io.kestra.cli;
+
+import io.micronaut.context.annotation.Context;
+import io.micronaut.context.annotation.Requires;
+import io.micronaut.context.env.Environment;
+import jakarta.annotation.PostConstruct;
+import jakarta.inject.Inject;
+import lombok.extern.slf4j.Slf4j;
+
+import java.io.Serial;
+import java.util.List;
+import java.util.Map;
+
+@Slf4j
+@Context
+@Requires(property = "kestra.server-type")
+public class ServerCommandValidator {
+    private static final Map<String, String> VALIDATED_PROPERTIES = Map.of(
+        "kestra.queue.type", "https://kestra.io/docs/configuration-guide/setup#queue-configuration",
+        "kestra.repository.type", "https://kestra.io/docs/configuration-guide/setup#repository-configuration",
+        "kestra.storage.type", "https://kestra.io/docs/configuration-guide/setup#internal-storage-configuration"
+    );
+
+    private final Environment environment;
+
+    @Inject
+    public ServerCommandValidator(final Environment environment) {
+        this.environment = environment;
+    }
+
+    @PostConstruct
+    void validate() {
+        final List<Map.Entry<String, String>> missingProperties = VALIDATED_PROPERTIES.entrySet().stream()
+            .filter((property) -> !environment.containsProperty(property.getKey()))
+            .toList();
+
+        missingProperties.forEach(property -> log.error("""
+            Server configuration requires the '{}' property to be defined.
+            For more details, please follow the official setup guide at: {}""", property.getKey(), property.getValue())
+        );
+
+        if (!missingProperties.isEmpty()) {
+            throw new ServerCommandException("Incomplete server configuration - missing required properties");
+        }
+    }
+
+    public static class ServerCommandException extends RuntimeException {
+        @Serial
+        private static final long serialVersionUID = 1L;
+
+        public ServerCommandException(String errorMessage) {
+            super(errorMessage);
+        }
+    }
+}

cli/src/main/java/io/kestra/cli/VersionProvider.java

@@ -4,8 +4,8 @@ import io.micronaut.context.event.StartupEvent;
 import io.micronaut.runtime.event.annotation.EventListener;
 import picocli.CommandLine;
 
-import javax.inject.Inject;
-import javax.inject.Singleton;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 
 class VersionProvider implements CommandLine.IVersionProvider {
     private static io.kestra.core.utils.VersionProvider versionProvider;

cli/src/main/java/io/kestra/cli/commands/AbstractServiceNamespaceUpdateCommand.java

@@ -0,0 +1,18 @@
+package io.kestra.cli.commands;
+
+import io.kestra.cli.AbstractApiCommand;
+import picocli.CommandLine;
+
+import java.nio.file.Path;
+
+public abstract class AbstractServiceNamespaceUpdateCommand extends AbstractApiCommand {
+    @CommandLine.Parameters(index = "0", description = "The namespace to update")
+    public String namespace;
+
+    @CommandLine.Parameters(index = "1", description = "The directory containing flow files for current namespace")
+    public Path directory;
+
+    @CommandLine.Option(names = {"--delete"}, negatable = true, description = "Whether missing should be deleted")
+    public boolean delete = false;
+
+}

cli/src/main/java/io/kestra/cli/commands/configs/sys/ConfigCommand.java

@@ -8,7 +8,7 @@ import picocli.CommandLine;
 
 @CommandLine.Command(
     name = "configs",
-    description = "handle configs",
+    description = "Manage configuration",
     mixinStandardHelpOptions = true,
     subcommands = {
         ConfigPropertiesCommand.class,
@@ -16,10 +16,6 @@ import picocli.CommandLine;
 )
 @Slf4j
 public class ConfigCommand extends AbstractCommand {
-    public ConfigCommand() {
-        super(false);
-    }
-
     @Override
     public Integer call() throws Exception {
         super.call();

cli/src/main/java/io/kestra/cli/commands/configs/sys/ConfigPropertiesCommand.java

@@ -1,33 +1,22 @@
 package io.kestra.cli.commands.configs.sys;
 
-import io.micronaut.context.ApplicationContext;
-import io.micronaut.context.env.Environment;
-import io.micronaut.context.env.PropertySource;
-import io.micronaut.core.order.Ordered;
-import io.micronaut.management.endpoint.env.EnvironmentEndpoint;
-import lombok.extern.slf4j.Slf4j;
 import io.kestra.cli.AbstractCommand;
 import io.kestra.core.serializers.JacksonMapper;
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.management.endpoint.env.EnvironmentEndpoint;
+import jakarta.inject.Inject;
+import lombok.extern.slf4j.Slf4j;
 import picocli.CommandLine;
 
-import java.util.*;
-import java.util.stream.Collectors;
-import java.util.stream.StreamSupport;
-import javax.inject.Inject;
-
 @CommandLine.Command(
     name = "properties",
-    description = {"Display actual configurations properties."}
+    description = {"Display current configuration properties."}
 )
 @Slf4j
 public class ConfigPropertiesCommand extends AbstractCommand {
     @Inject
     private ApplicationContext applicationContext;
 
-    public ConfigPropertiesCommand() {
-        super(false);
-    }
-
     @Override
     public Integer call() throws Exception {
         super.call();

cli/src/main/java/io/kestra/cli/commands/flows/FlowCommand.java

@@ -10,21 +10,20 @@ import picocli.CommandLine;
 
 @CommandLine.Command(
     name = "flow",
-    description = "handle flows",
+    description = "Manage flows",
     mixinStandardHelpOptions = true,
     subcommands = {
-        ValidateCommand.class,
+        FlowValidateCommand.class,
         FlowTestCommand.class,
         FlowNamespaceCommand.class,
-        FlowDotCommand.class
+        FlowDotCommand.class,
+        FlowExportCommand.class,
+        FlowUpdateCommand.class,
+        FlowUpdatesCommand.class
     }
 )
 @Slf4j
 public class FlowCommand extends AbstractCommand {
-    public FlowCommand() {
-        super(false);
-    }
-
     @SneakyThrows
     @Override
     public Integer call() throws Exception {

cli/src/main/java/io/kestra/cli/commands/flows/FlowCreateCommand.java

@@ -0,0 +1,59 @@
+package io.kestra.cli.commands.flows;
+
+import io.kestra.cli.AbstractApiCommand;
+import io.kestra.cli.AbstractValidateCommand;
+import io.micronaut.http.HttpRequest;
+import io.micronaut.http.MediaType;
+import io.micronaut.http.MutableHttpRequest;
+import io.micronaut.http.client.exceptions.HttpClientResponseException;
+import io.micronaut.http.client.netty.DefaultHttpClient;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+@CommandLine.Command(
+    name = "create",
+    description = "Create a single flow",
+    mixinStandardHelpOptions = true
+)
+@Slf4j
+public class FlowCreateCommand extends AbstractApiCommand {
+    @CommandLine.Parameters(index = "0", description = "The file containing the flow")
+    public Path flowFile;
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        checkFile();
+
+        String body = Files.readString(flowFile);
+
+        try(DefaultHttpClient client = client()) {
+            MutableHttpRequest<String> request = HttpRequest
+                .POST(apiUri("/flows"), body).contentType(MediaType.APPLICATION_YAML);
+
+            client.toBlocking().retrieve(
+                this.requestOptions(request),
+                String.class
+            );
+
+            stdOut("Flow successfully created !");
+        } catch (HttpClientResponseException e){
+            AbstractValidateCommand.handleHttpException(e, "flow");
+            return 1;
+        }
+
+
+        return 0;
+    }
+
+    protected void checkFile() {
+        if (!Files.isRegularFile(flowFile)) {
+            throw new IllegalArgumentException("The file '" + flowFile.toFile().getAbsolutePath() + "' is not a file");
+        }
+    }
+}

cli/src/main/java/io/kestra/cli/commands/flows/FlowDeleteCommand.java

@@ -0,0 +1,47 @@
+package io.kestra.cli.commands.flows;
+
+import io.kestra.cli.AbstractApiCommand;
+import io.kestra.cli.AbstractValidateCommand;
+import io.micronaut.http.HttpRequest;
+import io.micronaut.http.MutableHttpRequest;
+import io.micronaut.http.client.exceptions.HttpClientResponseException;
+import io.micronaut.http.client.netty.DefaultHttpClient;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+@CommandLine.Command(
+    name = "delete",
+    description = "Delete a single flow",
+    mixinStandardHelpOptions = true
+)
+@Slf4j
+public class FlowDeleteCommand extends AbstractApiCommand {
+
+    @CommandLine.Parameters(index = "0", description = "The namespace of the flow")
+    public String namespace;
+
+    @CommandLine.Parameters(index = "1", description = "The ID of the flow")
+    public String id;
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        try(DefaultHttpClient client = client()) {
+            MutableHttpRequest<String> request = HttpRequest
+                .DELETE(apiUri("/flows/" + namespace + "/" + id ));
+
+            client.toBlocking().exchange(
+                this.requestOptions(request)
+            );
+
+            stdOut("Flow successfully deleted !");
+        } catch (HttpClientResponseException e){
+            AbstractValidateCommand.handleHttpException(e, "flow");
+            return 1;
+        }
+
+        return 0;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/flows/FlowDotCommand.java

@@ -1,58 +1,37 @@
 package io.kestra.cli.commands.flows;
 
-import io.micronaut.context.ApplicationContext;
-import io.micronaut.context.annotation.Prototype;
-import lombok.extern.slf4j.Slf4j;
 import io.kestra.cli.AbstractCommand;
 import io.kestra.core.models.flows.Flow;
-import io.kestra.core.models.hierarchies.FlowGraph;
 import io.kestra.core.models.hierarchies.GraphCluster;
-import io.kestra.core.serializers.YamlFlowParser;
+import io.kestra.core.serializers.YamlParser;
 import io.kestra.core.services.Graph2DotService;
-import io.kestra.core.services.GraphService;
+import io.kestra.core.utils.GraphUtils;
+import io.micronaut.context.ApplicationContext;
+import jakarta.inject.Inject;
+import lombok.extern.slf4j.Slf4j;
 import picocli.CommandLine;
 
 import java.nio.file.Path;
-import java.security.SecureRandom;
-import javax.inject.Inject;
 
 @CommandLine.Command(
     name = "dot",
-    description = "generate a dot graph from a file"
+    description = "Generate a DOT graph from a file"
 )
 @Slf4j
-@Prototype
 public class FlowDotCommand extends AbstractCommand {
-    @CommandLine.Parameters(index = "0", description = "the flow file to display")
-    private Path file;
-
-    @CommandLine.Spec
-    CommandLine.Model.CommandSpec spec;
-
     @Inject
     private ApplicationContext applicationContext;
 
-    private static final SecureRandom random = new SecureRandom();
-
-    public FlowDotCommand() {
-        super(false);
-    }
+    @CommandLine.Parameters(index = "0", description = "The flow file to display")
+    private Path file;
 
     @Override
     public Integer call() throws Exception {
         super.call();
 
-        YamlFlowParser parser = applicationContext.getBean(YamlFlowParser.class);
-        Flow flow = parser.parse(file.toFile());
-        GraphCluster graph = new GraphCluster();
+        Flow flow = YamlParser.parse(file.toFile(), Flow.class);
 
-        GraphService.sequential(
-            graph,
-            flow.getTasks(),
-            flow.getErrors(),
-            null,
-            null
-        );
+        GraphCluster graph = GraphUtils.of(flow, null);
 
         stdOut(Graph2DotService.dot(graph.getGraph()));
 

cli/src/main/java/io/kestra/cli/commands/flows/FlowExpandCommand.java

@@ -0,0 +1,36 @@
+package io.kestra.cli.commands.flows;
+
+import io.kestra.cli.AbstractCommand;
+import io.kestra.core.models.flows.Flow;
+import io.kestra.core.models.validations.ModelValidator;
+import io.kestra.core.serializers.YamlParser;
+import jakarta.inject.Inject;
+import picocli.CommandLine;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+@CommandLine.Command(
+    name = "expand",
+    description = "Deprecated - expand a flow"
+)
+@Deprecated
+public class FlowExpandCommand extends AbstractCommand {
+
+    @CommandLine.Parameters(index = "0", description = "The flow file to expand")
+    private Path file;
+
+    @Inject
+    private ModelValidator modelValidator;
+
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+        stdErr("Warning, this functionality is deprecated and will be removed at some point.");
+        String content = IncludeHelperExpander.expand(Files.readString(file), file.getParent());
+        Flow flow = YamlParser.parse(content, Flow.class);
+        modelValidator.validate(flow);
+        stdOut(content);
+        return 0;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/flows/FlowExportCommand.java

@@ -0,0 +1,61 @@
+package io.kestra.cli.commands.flows;
+
+import io.kestra.cli.AbstractApiCommand;
+import io.kestra.cli.AbstractValidateCommand;
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.http.HttpRequest;
+import io.micronaut.http.HttpResponse;
+import io.micronaut.http.MediaType;
+import io.micronaut.http.MutableHttpRequest;
+import io.micronaut.http.client.exceptions.HttpClientResponseException;
+import io.micronaut.http.client.netty.DefaultHttpClient;
+import jakarta.inject.Inject;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+@CommandLine.Command(
+    name = "export",
+    description = "Export flows to a ZIP file",
+    mixinStandardHelpOptions = true
+)
+@Slf4j
+public class FlowExportCommand extends AbstractApiCommand {
+    private static final String DEFAULT_FILE_NAME = "flows.zip";
+
+    // @FIXME: Keep it for bug in micronaut that need to have inject on top level command to inject on abstract classe
+    @Inject
+    private ApplicationContext applicationContext;
+
+    @CommandLine.Option(names = {"--namespace"}, description = "The namespace of flows to export")
+    public String namespace;
+
+    @CommandLine.Parameters(index = "0", description = "The directory to export the ZIP file to")
+    public Path directory;
+
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        try(DefaultHttpClient client = client()) {
+            MutableHttpRequest<Object> request = HttpRequest
+                .GET(apiUri("/flows/export/by-query") + (namespace != null ? "?namespace=" + namespace : ""))
+                .accept(MediaType.APPLICATION_OCTET_STREAM);
+
+            HttpResponse<byte[]> response = client.toBlocking().exchange(this.requestOptions(request), byte[].class);
+            Path zipFile = Path.of(directory.toString(), DEFAULT_FILE_NAME);
+            zipFile.toFile().createNewFile();
+            Files.write(zipFile, response.body());
+
+            stdOut("Exporting flow(s) for namespace '" + namespace + "' successfully done !");
+        } catch (HttpClientResponseException e) {
+            AbstractValidateCommand.handleHttpException(e, "flow");
+            return 1;
+        }
+
+        return 0;
+    }
+
+}

cli/src/main/java/io/kestra/cli/commands/flows/FlowTestCommand.java

@@ -1,17 +1,18 @@
 package io.kestra.cli.commands.flows;
 
 import com.google.common.collect.ImmutableMap;
-import io.micronaut.context.ApplicationContext;
-import io.micronaut.context.annotation.Prototype;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.io.FileUtils;
 import io.kestra.cli.AbstractCommand;
-import io.kestra.core.exceptions.MissingRequiredInput;
 import io.kestra.core.models.flows.Flow;
 import io.kestra.core.repositories.FlowRepositoryInterface;
 import io.kestra.core.repositories.LocalFlowRepositoryLoader;
+import io.kestra.core.runners.FlowInputOutput;
 import io.kestra.core.runners.RunnerUtils;
-import io.kestra.runner.memory.MemoryRunner;
+import io.kestra.core.runners.StandAloneRunner;
+import io.micronaut.context.ApplicationContext;
+import jakarta.inject.Inject;
+import jakarta.validation.ConstraintViolationException;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.io.FileUtils;
 import picocli.CommandLine;
 
 import java.io.IOException;
@@ -23,21 +24,22 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.TimeoutException;
-import javax.inject.Inject;
 
 @CommandLine.Command(
     name = "test",
-    description = "test a flow"
+    description = "Test a flow"
 )
 @Slf4j
-@Prototype
 public class FlowTestCommand extends AbstractCommand {
-    @CommandLine.Parameters(index = "0", description = "the flow file to test")
+    @Inject
+    private ApplicationContext applicationContext;
+
+    @CommandLine.Parameters(index = "0", description = "The flow file to test")
     private Path file;
 
     @CommandLine.Parameters(
         index = "1..*",
-        description = "the inputs to pass as key pair value separated by space, " +
+        description = "The inputs to pass as key pair value separated by space, " +
             "for input type file, you need to pass an absolute path."
     )
     private List<String> inputs = new ArrayList<>();
@@ -45,15 +47,8 @@ public class FlowTestCommand extends AbstractCommand {
     @CommandLine.Spec
     CommandLine.Model.CommandSpec spec;
 
-    @Inject
-    private ApplicationContext applicationContext;
-
     private static final SecureRandom random = new SecureRandom();
 
-    public FlowTestCommand() {
-        super(false);
-    }
-
     @SuppressWarnings("unused")
     public static Map<String, Object> propertiesOverrides() {
         return ImmutableMap.of(
@@ -76,12 +71,13 @@ public class FlowTestCommand extends AbstractCommand {
     public Integer call() throws Exception {
         super.call();
 
-        MemoryRunner runner = applicationContext.getBean(MemoryRunner.class);
+        StandAloneRunner runner = applicationContext.getBean(StandAloneRunner.class);
         LocalFlowRepositoryLoader repositoryLoader = applicationContext.getBean(LocalFlowRepositoryLoader.class);
         FlowRepositoryInterface flowRepository = applicationContext.getBean(FlowRepositoryInterface.class);
+        FlowInputOutput flowInputOutput = applicationContext.getBean(FlowInputOutput.class);
         RunnerUtils runnerUtils = applicationContext.getBean(RunnerUtils.class);
 
-        Map<String, String> inputs = new HashMap<>();
+        Map<String, Object> inputs = new HashMap<>();
 
         for (int i = 0; i < this.inputs.size(); i=i+2) {
             if (this.inputs.size() <= i + 1) {
@@ -95,19 +91,19 @@ public class FlowTestCommand extends AbstractCommand {
             runner.run();
             repositoryLoader.load(file.toFile());
 
-            List<Flow> all = flowRepository.findAll();
+            List<Flow> all = flowRepository.findAllForAllTenants();
             if (all.size() != 1) {
                 throw new IllegalArgumentException("Too many flow found, need 1, found " + all.size());
             }
 
             runnerUtils.runOne(
-                all.get(0),
-                (flow, execution) -> runnerUtils.typedInputs(flow, execution, inputs),
+                all.getFirst(),
+                (flow, execution) -> flowInputOutput.readExecutionInputs(flow, execution, inputs),
                 Duration.ofHours(1)
             );
 
             runner.close();
-        } catch (MissingRequiredInput e) {
+        } catch (ConstraintViolationException e) {
             throw new CommandLine.ParameterException(this.spec.commandLine(), e.getMessage());
         } catch (IOException | TimeoutException e) {
             throw new IllegalStateException(e);

cli/src/main/java/io/kestra/cli/commands/flows/FlowUpdateCommand.java

@@ -0,0 +1,64 @@
+package io.kestra.cli.commands.flows;
+
+import io.kestra.cli.AbstractApiCommand;
+import io.kestra.cli.AbstractValidateCommand;
+import io.micronaut.http.HttpRequest;
+import io.micronaut.http.MediaType;
+import io.micronaut.http.MutableHttpRequest;
+import io.micronaut.http.client.exceptions.HttpClientResponseException;
+import io.micronaut.http.client.netty.DefaultHttpClient;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+@CommandLine.Command(
+    name = "update",
+    description = "Update a single flow",
+    mixinStandardHelpOptions = true
+)
+@Slf4j
+public class FlowUpdateCommand extends AbstractApiCommand {
+    @CommandLine.Parameters(index = "0", description = "The file containing the flow")
+    public Path flowFile;
+
+    @CommandLine.Parameters(index = "1", description = "The namespace of the flow")
+    public String namespace;
+
+    @CommandLine.Parameters(index = "2", description = "The ID of the flow")
+    public String id;
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        checkFile();
+
+        String body = Files.readString(flowFile);
+
+        try(DefaultHttpClient client = client()) {
+            MutableHttpRequest<String> request = HttpRequest
+                .PUT(apiUri("/flows/" + namespace + "/" + id ), body).contentType(MediaType.APPLICATION_YAML);
+
+            client.toBlocking().retrieve(
+                this.requestOptions(request),
+                String.class
+            );
+
+            stdOut("Flow successfully updated !");
+        } catch (HttpClientResponseException e){
+            AbstractValidateCommand.handleHttpException(e, "flow");
+            return 1;
+        }
+
+        return 0;
+    }
+
+    protected void checkFile() {
+        if (!Files.isRegularFile(flowFile)) {
+            throw new IllegalArgumentException("The file '" + flowFile.toFile().getAbsolutePath() + "' is not a file");
+        }
+    }
+}

cli/src/main/java/io/kestra/cli/commands/flows/FlowUpdatesCommand.java

@@ -0,0 +1,95 @@
+package io.kestra.cli.commands.flows;
+
+import io.kestra.cli.AbstractApiCommand;
+import io.kestra.cli.AbstractValidateCommand;
+import io.kestra.core.serializers.YamlParser;
+import io.micronaut.core.type.Argument;
+import io.micronaut.http.HttpRequest;
+import io.micronaut.http.MediaType;
+import io.micronaut.http.MutableHttpRequest;
+import io.micronaut.http.client.exceptions.HttpClientResponseException;
+import io.micronaut.http.client.netty.DefaultHttpClient;
+import jakarta.validation.ConstraintViolationException;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+
+@CommandLine.Command(
+    name = "updates",
+    description = "Create or update flows from a folder, and optionally delete the ones not present",
+    mixinStandardHelpOptions = true
+)
+@Slf4j
+public class FlowUpdatesCommand extends AbstractApiCommand {
+
+    @CommandLine.Parameters(index = "0", description = "The directory containing files")
+    public Path directory;
+
+    @CommandLine.Option(names = {"--delete"}, negatable = true, description = "Whether missing should be deleted")
+    public boolean delete = false;
+
+    @CommandLine.Option(names = {"--namespace"}, description = "The parent namespace of the flows, if not set, every namespace are allowed.")
+    public String namespace;
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        try (var files = Files.walk(directory)) {
+            List<String> flows = files
+                .filter(Files::isRegularFile)
+                .filter(YamlParser::isValidExtension)
+                .map(path -> {
+                    try {
+                        return IncludeHelperExpander.expand(Files.readString(path, Charset.defaultCharset()), path.getParent());
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+                })
+                .toList();
+
+            String body = "";
+            if (flows.isEmpty()) {
+                stdOut("No flow found on '{}'", directory.toFile().getAbsolutePath());
+            } else {
+                body = String.join("\n---\n", flows);
+            }
+            try(DefaultHttpClient client = client()) {
+                String namespaceQuery = "";
+                if (namespace != null) {
+                    namespaceQuery = "&namespace=" + namespace;
+                }
+                MutableHttpRequest<String> request = HttpRequest
+                    .POST(apiUri("/flows/bulk") + "?allowNamespaceChild=true&delete=" + delete + namespaceQuery, body).contentType(MediaType.APPLICATION_YAML);
+
+                List<UpdateResult> updated = client.toBlocking().retrieve(
+                    this.requestOptions(request),
+                    Argument.listOf(UpdateResult.class)
+                );
+
+                stdOut(updated.size() + " flow(s) successfully updated !");
+                updated.forEach(flow -> stdOut("- " + flow.getNamespace() + "."  + flow.getId()));
+            } catch (HttpClientResponseException e){
+                AbstractValidateCommand.handleHttpException(e, "flow");
+                return 1;
+            }
+        } catch (ConstraintViolationException e) {
+            AbstractValidateCommand.handleException(e, "flow");
+
+            return 1;
+        }
+
+        return 0;
+    }
+
+    @Override
+    protected boolean loadExternalPlugins() {
+        return false;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/flows/FlowValidateCommand.java

@@ -0,0 +1,47 @@
+package io.kestra.cli.commands.flows;
+
+import io.kestra.cli.AbstractValidateCommand;
+import io.kestra.core.models.flows.FlowWithSource;
+import io.kestra.core.models.validations.ModelValidator;
+import io.kestra.core.services.FlowService;
+import jakarta.inject.Inject;
+import picocli.CommandLine;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@CommandLine.Command(
+    name = "validate",
+    description = "Validate a flow"
+)
+public class FlowValidateCommand extends AbstractValidateCommand {
+
+    @Inject
+    private ModelValidator modelValidator;
+
+    @Inject
+    private FlowService flowService;
+
+    @Override
+    public Integer call() throws Exception {
+        return this.call(
+            FlowWithSource.class,
+            modelValidator,
+            (Object object) -> {
+                FlowWithSource flow = (FlowWithSource) object;
+                return flow.getNamespace() + " / " + flow.getId();
+            },
+            (Object object) -> {
+                FlowWithSource flow = (FlowWithSource) object;
+                List<String> warnings = new ArrayList<>();
+                warnings.addAll(flowService.deprecationPaths(flow).stream().map(deprecation -> deprecation + " is deprecated").toList());
+                warnings.addAll(flowService.warnings(flow, this.tenantId));
+                return warnings;
+            },
+            (Object object) -> {
+                FlowWithSource flow = (FlowWithSource) object;
+                return flowService.relocations(flow.sourceOrGenerateIfNull()).stream().map(relocation -> relocation.from() + " is replaced by " + relocation.to()).toList();
+            }
+        );
+    }
+}

cli/src/main/java/io/kestra/cli/commands/flows/IncludeHelperExpander.java

@@ -0,0 +1,40 @@
+package io.kestra.cli.commands.flows;
+
+import com.google.common.io.Files;
+import lombok.SneakyThrows;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Deprecated
+public abstract class IncludeHelperExpander {
+
+    public static String expand(String value, Path directory) throws IOException {
+        return value.lines()
+            .map(line -> line.contains("[[>") && line.contains("]]") ? expandLine(line, directory) : line)
+            .collect(Collectors.joining("\n"));
+    }
+
+    @SneakyThrows
+    private static String expandLine(String line, Path directory) {
+        String prefix = line.substring(0, line.indexOf("[[>"));
+        String suffix = line.substring(line.indexOf("]]") + 2, line.length());
+        String file = line.substring(line.indexOf("[[>") + 3 , line.indexOf("]]")).strip();
+        Path includePath = directory.resolve(file);
+        List<String> include = Files.readLines(includePath.toFile(), Charset.defaultCharset());
+
+        // handle single line directly with the suffix (should be between quotes or double-quotes
+        if(include.size() == 1) {
+            String singleInclude = include.getFirst();
+            return prefix + singleInclude + suffix;
+        }
+
+        // multi-line will be expanded with the prefix but no suffix
+        return include.stream()
+            .map(includeLine -> prefix + includeLine)
+            .collect(Collectors.joining("\n"));
+    }
+}

cli/src/main/java/io/kestra/cli/commands/flows/ValidateCommand.java

@@ -1,59 +0,0 @@
-package io.kestra.cli.commands.flows;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import io.kestra.cli.AbstractCommand;
-import io.kestra.core.models.flows.Flow;
-import io.kestra.core.serializers.JacksonMapper;
-import io.kestra.core.serializers.YamlFlowParser;
-import picocli.CommandLine;
-
-import java.nio.file.Path;
-import javax.inject.Inject;
-import javax.validation.ConstraintViolationException;
-
-@CommandLine.Command(
-    name = "validate",
-    description = "validate a flow"
-)
-public class ValidateCommand extends AbstractCommand {
-    private static final ObjectMapper mapper = JacksonMapper.ofYaml();
-
-    @Inject
-    private YamlFlowParser yamlFlowParser;
-
-    @CommandLine.Parameters(index = "0", description = "the flow file to test")
-    private Path file;
-
-    public ValidateCommand() {
-        super(false);
-    }
-
-    @Override
-    public Integer call() throws Exception {
-        super.call();
-
-        try {
-            Flow parse = yamlFlowParser.parse(file.toFile());
-            stdOut(mapper.writeValueAsString(parse));
-        } catch (ConstraintViolationException e) {
-            ValidateCommand.handleException(e);
-
-            return 1;
-        }
-
-        return 0;
-    }
-
-    public static void handleException(ConstraintViolationException e) {
-        stdErr("@|fg(red) Unable to parse flow due to the following error(s):|@");
-        e.getConstraintViolations()
-            .forEach(constraintViolation -> {
-                stdErr(
-                    "- {0} at @|underline,blue {1}|@ with value @|bold,yellow {2}|@ ",
-                    constraintViolation.getMessage(),
-                    constraintViolation.getPropertyPath(),
-                    constraintViolation.getInvalidValue()
-                );
-            });
-    }
-}

cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceCommand.java

@@ -1,12 +1,15 @@
 package io.kestra.cli.commands.flows.namespaces;
 
+import io.kestra.cli.App;
+import io.micronaut.configuration.picocli.PicocliRunner;
+import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import io.kestra.cli.AbstractCommand;
 import picocli.CommandLine;
 
 @CommandLine.Command(
     name = "namespace",
-    description = "handle namespace flows",
+    description = "Manage namespace flows",
     mixinStandardHelpOptions = true,
     subcommands = {
         FlowNamespaceUpdateCommand.class,
@@ -14,7 +17,13 @@ import picocli.CommandLine;
 )
 @Slf4j
 public class FlowNamespaceCommand extends AbstractCommand {
-    public FlowNamespaceCommand() {
-        super(false);
+    @SneakyThrows
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        PicocliRunner.call(App.class, "flow", "namespace",  "--help");
+
+        return 0;
     }
 }

cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceUpdateCommand.java

@@ -1,76 +1,79 @@
 package io.kestra.cli.commands.flows.namespaces;
 
+import io.kestra.cli.AbstractValidateCommand;
+import io.kestra.cli.commands.AbstractServiceNamespaceUpdateCommand;
+import io.kestra.cli.commands.flows.IncludeHelperExpander;
+import io.kestra.core.serializers.YamlParser;
 import io.micronaut.core.type.Argument;
 import io.micronaut.http.HttpRequest;
+import io.micronaut.http.MediaType;
 import io.micronaut.http.MutableHttpRequest;
+import io.micronaut.http.client.exceptions.HttpClientResponseException;
 import io.micronaut.http.client.netty.DefaultHttpClient;
+import jakarta.validation.ConstraintViolationException;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.io.FilenameUtils;
-import io.kestra.cli.AbstractApiCommand;
-import io.kestra.cli.commands.flows.ValidateCommand;
-import io.kestra.core.models.flows.Flow;
-import io.kestra.core.serializers.YamlFlowParser;
 import picocli.CommandLine;
 
+import java.io.IOException;
+import java.nio.charset.Charset;
 import java.nio.file.Files;
-import java.nio.file.Path;
 import java.util.List;
-import java.util.stream.Collectors;
-import javax.inject.Inject;
-import javax.validation.ConstraintViolationException;
-
-import static io.kestra.core.utils.Rethrow.throwFunction;
 
 @CommandLine.Command(
     name = "update",
-    description = "handle namespace flows",
+    description = "Update flows in namespace",
     mixinStandardHelpOptions = true
 )
 @Slf4j
-public class FlowNamespaceUpdateCommand extends AbstractApiCommand {
-    @Inject
-    private YamlFlowParser yamlFlowParser;
+public class FlowNamespaceUpdateCommand extends AbstractServiceNamespaceUpdateCommand {
 
-    @CommandLine.Parameters(index = "0", description = "the namespace of flow to update")
-    private String namespace;
-
-    @CommandLine.Parameters(index = "1", description = "the directory containing flows to from current namespace")
-    private Path directory;
-
-    public FlowNamespaceUpdateCommand() {
-        super(false);
-    }
+    @CommandLine.Option(names = {"--override-namespaces"}, negatable = true, description = "Replace namespace of all flows by the one provided")
+    public boolean override = false;
 
+    @SuppressWarnings("deprecation")
     @Override
     public Integer call() throws Exception {
         super.call();
 
-        try {
-            List<Flow> flows = Files.walk(directory)
+        try (var files = Files.walk(directory)) {
+            List<String> flows = files
                 .filter(Files::isRegularFile)
-                .filter(YamlFlowParser::isValidExtension)
-                .map(path -> yamlFlowParser.parse(path.toFile()))
-                .collect(Collectors.toList());
+                .filter(YamlParser::isValidExtension)
+                .map(path -> {
+                    try {
+                        return IncludeHelperExpander.expand(Files.readString(path, Charset.defaultCharset()), path.getParent());
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+                })
+                .toList();
 
-            if (flows.size() == 0) {
-                stdErr("No flow found on '{}'", directory.toFile().getAbsolutePath());
-                return 1;
+            String body = "";
+            if (flows.isEmpty()) {
+                stdOut("No flow found on '{}'", directory.toFile().getAbsolutePath());
+            } else {
+                body = String.join("\n---\n", flows);
+            }
+            if (override) {
+                body = body.replaceAll("(?m)^namespace:.+", "namespace: " + namespace);
             }
-
             try(DefaultHttpClient client = client()) {
-                MutableHttpRequest<List<Flow>> request = HttpRequest
-                    .POST("/api/v1/flows/" + namespace, flows);
+                MutableHttpRequest<String> request = HttpRequest
+                    .POST(apiUri("/flows/") + namespace + "?delete=" + delete, body).contentType(MediaType.APPLICATION_YAML);
 
-                List<Flow> updated = client.toBlocking().retrieve(
+                List<UpdateResult> updated = client.toBlocking().retrieve(
                     this.requestOptions(request),
-                    Argument.listOf(Flow.class)
+                    Argument.listOf(UpdateResult.class)
                 );
 
                 stdOut(updated.size() + " flow(s) for namespace '" + namespace + "' successfully updated !");
                 updated.forEach(flow -> stdOut("- " + flow.getNamespace() + "."  + flow.getId()));
+            } catch (HttpClientResponseException e){
+                AbstractValidateCommand.handleHttpException(e, "flow");
+                return 1;
             }
         } catch (ConstraintViolationException e) {
-            ValidateCommand.handleException(e);
+            AbstractValidateCommand.handleException(e, "flow");
 
             return 1;
         }

cli/src/main/java/io/kestra/cli/commands/namespaces/NamespaceCommand.java

@@ -0,0 +1,32 @@
+package io.kestra.cli.commands.namespaces;
+
+import io.kestra.cli.AbstractCommand;
+import io.kestra.cli.App;
+import io.kestra.cli.commands.namespaces.files.NamespaceFilesCommand;
+import io.kestra.cli.commands.namespaces.kv.KvCommand;
+import io.micronaut.configuration.picocli.PicocliRunner;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+@CommandLine.Command(
+    name = "namespace",
+    description = "Manage namespaces",
+    mixinStandardHelpOptions = true,
+    subcommands = {
+        NamespaceFilesCommand.class,
+        KvCommand.class
+    }
+)
+@Slf4j
+public class NamespaceCommand extends AbstractCommand {
+    @SneakyThrows
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        PicocliRunner.call(App.class, "namespace", "--help");
+
+        return 0;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/namespaces/files/NamespaceFilesCommand.java

@@ -0,0 +1,29 @@
+package io.kestra.cli.commands.namespaces.files;
+
+import io.kestra.cli.AbstractCommand;
+import io.kestra.cli.App;
+import io.micronaut.configuration.picocli.PicocliRunner;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+@CommandLine.Command(
+    name = "files",
+    description = "Manage namespace files",
+    mixinStandardHelpOptions = true,
+    subcommands = {
+        NamespaceFilesUpdateCommand.class,
+    }
+)
+@Slf4j
+public class NamespaceFilesCommand extends AbstractCommand {
+    @SneakyThrows
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        PicocliRunner.call(App.class, "namespace", "files",  "--help");
+
+        return 0;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/namespaces/files/NamespaceFilesUpdateCommand.java

@@ -0,0 +1,79 @@
+package io.kestra.cli.commands.namespaces.files;
+
+import io.kestra.cli.AbstractApiCommand;
+import io.kestra.cli.AbstractValidateCommand;
+import io.kestra.core.utils.KestraIgnore;
+import io.micronaut.http.HttpRequest;
+import io.micronaut.http.MediaType;
+import io.micronaut.http.client.exceptions.HttpClientResponseException;
+import io.micronaut.http.client.multipart.MultipartBody;
+import io.micronaut.http.client.netty.DefaultHttpClient;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+
+@CommandLine.Command(
+    name = "update",
+    description = "Update namespace files",
+    mixinStandardHelpOptions = true
+)
+@Slf4j
+public class NamespaceFilesUpdateCommand extends AbstractApiCommand {
+    @CommandLine.Parameters(index = "0", description = "The namespace to update")
+    public String namespace;
+
+    @CommandLine.Parameters(index = "1", description = "The local directory containing files for current namespace")
+    public Path from;
+
+    @CommandLine.Parameters(index = "2", description = "The remote namespace path to upload files to", defaultValue = "/")
+    public String to;
+
+    @CommandLine.Option(names = {"--delete"}, negatable = true, description = "Whether missing should be deleted")
+    public boolean delete = false;
+
+    private static final String KESTRA_IGNORE_FILE = ".kestraignore";
+
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+        to = to.startsWith("/") ? to : "/" + to;
+        to = to.endsWith("/") ? to : to + "/";
+
+        try (var files = Files.walk(from); DefaultHttpClient client = client()) {
+            if (delete) {
+                client.toBlocking().exchange(this.requestOptions(HttpRequest.DELETE(apiUri("/namespaces/") + namespace + "/files?path=" + to, null)));
+            }
+
+            KestraIgnore kestraIgnore = new KestraIgnore(from);
+
+            List<Path> paths = files
+                .filter(Files::isRegularFile)
+                .filter(path -> !kestraIgnore.isIgnoredFile(path.toString(), true))
+                .toList();
+            paths.forEach(path -> {
+                MultipartBody body = MultipartBody.builder()
+                    .addPart("fileContent", path.toFile())
+                    .build();
+                String relativizedPath = from.relativize(path).toString();
+                String destination = to + relativizedPath;
+                client.toBlocking().exchange(
+                    this.requestOptions(
+                        HttpRequest.POST(
+                            apiUri("/namespaces/") + namespace + "/files?path=" + destination,
+                            body
+                        ).contentType(MediaType.MULTIPART_FORM_DATA)
+                    )
+                );
+                stdOut("Successfully uploaded {0} to {1}", path.toString(), destination);
+            });
+        } catch (HttpClientResponseException e) {
+            AbstractValidateCommand.handleHttpException(e, "namespace");
+            return 1;
+        }
+
+        return 0;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/namespaces/kv/KvCommand.java

@@ -0,0 +1,29 @@
+package io.kestra.cli.commands.namespaces.kv;
+
+import io.kestra.cli.AbstractCommand;
+import io.kestra.cli.App;
+import io.micronaut.configuration.picocli.PicocliRunner;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+@CommandLine.Command(
+    name = "kv",
+    description = "Manage KV Store",
+    mixinStandardHelpOptions = true,
+    subcommands = {
+        KvUpdateCommand.class,
+    }
+)
+@Slf4j
+public class KvCommand extends AbstractCommand {
+    @SneakyThrows
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        PicocliRunner.call(App.class, "namespace", "kv",  "--help");
+
+        return 0;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/namespaces/kv/KvUpdateCommand.java

@@ -0,0 +1,90 @@
+package io.kestra.cli.commands.namespaces.kv;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.kestra.cli.AbstractApiCommand;
+import io.kestra.core.serializers.JacksonMapper;
+import io.micronaut.http.HttpRequest;
+import io.micronaut.http.MediaType;
+import io.micronaut.http.MutableHttpRequest;
+import io.micronaut.http.client.netty.DefaultHttpClient;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+import picocli.CommandLine.Option;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.Duration;
+
+@CommandLine.Command(
+    name = "update",
+    description = "Update value for a KV Store key",
+    mixinStandardHelpOptions = true
+)
+@Slf4j
+public class KvUpdateCommand extends AbstractApiCommand {
+
+    @CommandLine.Parameters(index = "0", description = "The namespace to update")
+    public String namespace;
+
+    @CommandLine.Parameters(index = "1", description = "The key to update")
+    public String key;
+
+    @CommandLine.Parameters(index = "2", description = "The value to assign to the key. If the value is an object, it must be in JSON format. If the value must be read from file, use -f parameter.")
+    public String value;
+
+    @Option(names = {"-e", "--expiration"}, description = "The duration after which the key should expire.")
+    public String expiration;
+
+    @Option(names = {"-t", "--type"}, description = "The type of the value. Optional and useful to override the deduced type (eg. numbers, booleans or JSON as full string). Valid values: ${COMPLETION-CANDIDATES}.")
+    public Type type;
+
+    @Option(names = {"-f", "--file-value"}, description = "The file from which to read the value to set. If this is provided, it will take precedence over any specified value.")
+    public Path fileValue;
+
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        if (fileValue != null) {
+            value = Files.readString(Path.of(fileValue.toString().trim()));
+        }
+
+        if (isLiteral(value) || type == Type.STRING) {
+            value = wrapAsJsonLiteral(value);
+        }
+
+        Duration ttl = expiration == null ? null : Duration.parse(expiration);
+        MutableHttpRequest<String> request = HttpRequest
+            .PUT(apiUri("/namespaces/") + namespace + "/kv/" + key, value)
+            .contentType(MediaType.APPLICATION_JSON_TYPE);
+
+        if (ttl != null) {
+            request.header("ttl", ttl.toString());
+        }
+
+        try (DefaultHttpClient client = client()) {
+            client.toBlocking().exchange(this.requestOptions(request));
+        }
+        return 0;
+    }
+
+    private static boolean isLiteral(final String input) {
+        // use ION mapper to properly handle timestamp
+        ObjectMapper mapper = JacksonMapper.ofIon();
+        try {
+            mapper.readTree(input);
+            return false;
+        } catch (JsonProcessingException e) {
+            return true;
+        }
+    }
+
+    public static String wrapAsJsonLiteral(final String input) {
+        return "\"" + input.replace("\"", "\\\"") + "\"";
+    }
+
+    enum Type {
+        STRING, NUMBER, BOOLEAN, DATETIME, DATE, DURATION, JSON;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/plugins/PluginCommand.java

@@ -1,35 +1,37 @@
 package io.kestra.cli.commands.plugins;
 
-import io.micronaut.configuration.picocli.PicocliRunner;
-import lombok.SneakyThrows;
-import lombok.extern.slf4j.Slf4j;
 import io.kestra.cli.AbstractCommand;
 import io.kestra.cli.App;
-import picocli.CommandLine;
+import io.micronaut.configuration.picocli.PicocliRunner;
+import lombok.SneakyThrows;
+import picocli.CommandLine.Command;
 
-@CommandLine.Command(
+@Command(
     name = "plugins",
-    description = "handle plugins",
+    description = "Manage plugins",
     mixinStandardHelpOptions = true,
     subcommands = {
         PluginInstallCommand.class,
+        PluginUninstallCommand.class,
         PluginListCommand.class,
-        PluginDocCommand.class
+        PluginDocCommand.class,
+        PluginSearchCommand.class
     }
 )
-@Slf4j
 public class PluginCommand extends AbstractCommand {
-    public PluginCommand() {
-        super(false);
-    }
 
     @SneakyThrows
     @Override
     public Integer call() throws Exception {
         super.call();
 
-        PicocliRunner.call(App.class, "plugins",  "--help");
+        PicocliRunner.call(App.class, "plugins", "--help");
 
         return 0;
     }
+
+    @Override
+    protected boolean loadExternalPlugins() {
+        return false;
+    }
 }

cli/src/main/java/io/kestra/cli/commands/plugins/PluginDocCommand.java

@@ -1,72 +1,112 @@
 package io.kestra.cli.commands.plugins;
 
-import com.google.common.base.Charsets;
+import com.google.common.io.Files;
 import io.kestra.cli.AbstractCommand;
 import io.kestra.core.docs.DocumentationGenerator;
-import io.kestra.core.plugins.PluginScanner;
+import io.kestra.core.plugins.PluginRegistry;
 import io.kestra.core.plugins.RegisteredPlugin;
+import io.kestra.core.serializers.JacksonMapper;
+import io.micronaut.context.ApplicationContext;
+import jakarta.inject.Inject;
 import picocli.CommandLine;
 
 import java.io.File;
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.ArrayList;
+import java.util.Base64;
 import java.util.List;
 
 @CommandLine.Command(
     name = "doc",
-    description = "write documentation for all plugins currently installed"
+    description = "Generate documentation for all plugins currently installed"
 )
 public class PluginDocCommand extends AbstractCommand {
-    @CommandLine.Parameters(index = "0", description = "Path to write documentations files")
-    private Path output = Paths.get(System.getProperty("user.dir"), "docs");
+    @Inject
+    private ApplicationContext applicationContext;
 
-    public PluginDocCommand() {
-        super(false);
-    }
+    @CommandLine.Parameters(index = "0", description = "Path to write documentation files")
+    private Path output = Paths.get(System.getProperty("user.dir"), "docs");
 
     @CommandLine.Option(names = {"--core"}, description = "Also write core tasks docs files")
     private boolean core = false;
 
+    @CommandLine.Option(names = {"--icons"}, description = "Also write icon for each task")
+    private boolean icons = false;
+
+    @CommandLine.Option(names = {"--schema"}, description = "Also write JSON Schema for each task")
+    private boolean schema = false;
+
     @Override
     public Integer call() throws Exception {
         super.call();
+        DocumentationGenerator documentationGenerator = applicationContext.getBean(DocumentationGenerator.class);
 
-        PluginScanner pluginScanner = new PluginScanner(PluginDocCommand.class.getClassLoader());
-        List<RegisteredPlugin> scan = new ArrayList<>(pluginScanner.scan(this.pluginsPath));
+        PluginRegistry registry = pluginRegistryProvider.get();
+        List<RegisteredPlugin> plugins = core ? registry.plugins() : registry.externalPlugins();
+        boolean hasFailures = false;
 
-        if (core) {
-            PluginScanner corePluginScanner = new PluginScanner(PluginDocCommand.class.getClassLoader());
-            scan.add(corePluginScanner.scan());
+        for (RegisteredPlugin registeredPlugin : plugins) {
+            try {
+                documentationGenerator
+                    .generate(registeredPlugin)
+                    .forEach(s -> {
+                            File file = Paths.get(output.toAbsolutePath().toString(), s.getPath()).toFile();
+
+                            if (!file.getParentFile().exists()) {
+                                //noinspection ResultOfMethodCallIgnored
+                                file.getParentFile().mkdirs();
+                            }
+
+                            try {
+                                Files
+                                    .asCharSink(
+                                        file,
+                                        StandardCharsets.UTF_8
+                                    ).write(s.getBody());
+                                stdOut("Generate doc in: {0}", file);
+
+                                if (s.getIcon() != null && this.icons) {
+                                    File iconFile = new File(
+                                        file.getParent(),
+                                        file.getName().substring(0, file.getName().lastIndexOf(".")) + ".svg"
+                                    );
+
+                                    Files
+                                        .asByteSink(iconFile)
+                                        .write(Base64.getDecoder().decode(s.getIcon().getBytes(StandardCharsets.UTF_8)));
+                                    stdOut("Generate icon in: {0}", iconFile);
+                                }
+
+                                if (this.schema && s.getSchema() != null) {
+                                    File jsonSchemaFile = new File(
+                                        file.getParent(),
+                                        file.getName().substring(0, file.getName().lastIndexOf(".")) + ".json"
+                                    );
+
+                                    Files
+                                        .asByteSink(jsonSchemaFile)
+                                        .write(JacksonMapper.ofJson().writeValueAsBytes(s.getSchema()));
+                                    stdOut("Generate json schema in: {0}", jsonSchemaFile);
+                                }
+                            } catch (IOException e) {
+                                throw new RuntimeException(e);
+                            }
+                        }
+                    );
+            } catch (Error e) {
+                stdErr("Failure to generate documentation for plugin {0}: {1}", registeredPlugin.name(), e);
+                hasFailures = true;
+            }
         }
 
-        for (RegisteredPlugin registeredPlugin : scan) {
-            DocumentationGenerator
-                .generate(registeredPlugin)
-                .forEach(s -> {
-                        File file = Paths.get(output.toAbsolutePath().toString(), s.getPath()).toFile();
+        return hasFailures ? 1 : 0;
+    }
 
-                        if (!file.getParentFile().exists()) {
-                            //noinspection ResultOfMethodCallIgnored
-                            file.getParentFile().mkdirs();
-                        }
-
-                        try {
-                            com.google.common.io.Files
-                                .asCharSink(
-                                    file,
-                                    Charsets.UTF_8
-                                ).write(s.getBody());
-
-                            stdOut("Generate doc in: {0}", file);
-                        } catch (IOException e) {
-                            throw new RuntimeException(e);
-                        }
-                    }
-                );
-        }
-
-        return 0;
+    /** {@inheritDoc} **/
+    @Override
+    protected boolean isPluginManagerEnabled() {
+        return false;
     }
 }

cli/src/main/java/io/kestra/cli/commands/plugins/PluginInstallCommand.java

@@ -1,77 +1,127 @@
 package io.kestra.cli.commands.plugins;
 
-import org.apache.commons.io.FilenameUtils;
+import io.kestra.core.contexts.MavenPluginRepositoryConfig;
+import io.kestra.core.plugins.LocalPluginManager;
+import io.kestra.core.plugins.MavenPluginDownloader;
+import io.kestra.core.plugins.PluginArtifact;
+import io.kestra.core.plugins.PluginCatalogService;
+import io.kestra.core.plugins.PluginManager;
+import io.micronaut.http.client.HttpClient;
+import io.micronaut.http.client.annotation.Client;
+import io.micronaut.http.uri.UriBuilder;
 import io.kestra.cli.AbstractCommand;
-import io.kestra.cli.plugins.PluginDownloader;
-import io.kestra.cli.plugins.RepositoryConfig;
 import io.kestra.core.utils.IdUtils;
+import jakarta.inject.Provider;
 import picocli.CommandLine;
 
 import java.net.URI;
-import java.net.URL;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.nio.file.StandardCopyOption;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import javax.inject.Inject;
+import java.util.Objects;
 
-@CommandLine.Command(
+import jakarta.inject.Inject;
+import picocli.CommandLine.Command;
+import picocli.CommandLine.Parameters;
+import picocli.CommandLine.Option;
+import picocli.CommandLine.Spec;
+
+@Command(
     name = "install",
-    description = "install a plugin"
+    description = "Install plugins"
 )
 public class PluginInstallCommand extends AbstractCommand {
-    @CommandLine.Parameters(index = "0..*", description = "the plugins to install")
+
+    @Option(names = {"--locally"}, description = "Specifies if plugins must be installed locally. If set to false the installation depends on your Kestra configuration.")
+    boolean locally = true;
+
+    @Option(names = {"--all"}, description = "Install all available plugins")
+    boolean all = false;
+
+    @Parameters(index = "0..*", description = "Plugins to install. Represented as Maven artifact coordinates (i.e., <groupId>:<artifactId>:(<version>|LATEST)")
     List<String> dependencies = new ArrayList<>();
 
-    @CommandLine.Option(names = {"--repositories"}, description = "url to additional maven repositories")
+    @Option(names = {"--repositories"}, description = "URL to additional Maven repositories")
     private URI[] repositories;
 
-    @CommandLine.Spec
+    @Spec
     CommandLine.Model.CommandSpec spec;
 
     @Inject
-    PluginDownloader pluginDownloader;
+    Provider<MavenPluginDownloader> mavenPluginRepositoryProvider;
 
-    public PluginInstallCommand() {
-        super(false);
-    }
+    @Inject
+    @Client("api") HttpClient httpClient;
 
     @Override
     public Integer call() throws Exception {
         super.call();
 
-        if (this.pluginsPath == null) {
+        if (this.locally && this.pluginsPath == null) {
             throw new CommandLine.ParameterException(this.spec.commandLine(), "Missing required options '--plugins' " +
                 "or environment variable 'KESTRA_PLUGINS_PATH"
             );
         }
 
-        if (!pluginsPath.toFile().exists()) {
-            if (!pluginsPath.toFile().mkdir()) {
-                throw new RuntimeException("Cannot create directory: " + pluginsPath.toFile().getAbsolutePath());
-            }
-        }
-
+        List<MavenPluginRepositoryConfig> repositoryConfigs = List.of();
         if (repositories != null) {
-            Arrays.stream(repositories)
-                .forEach(s -> pluginDownloader.addRepository(new RepositoryConfig(IdUtils.create(), "default", s.toString())));
+            repositoryConfigs = Arrays.stream(repositories)
+                .map(uri -> {
+                    MavenPluginRepositoryConfig.MavenPluginRepositoryConfigBuilder builder = MavenPluginRepositoryConfig
+                        .builder()
+                        .id(IdUtils.create());
+
+                    String userInfo = uri.getUserInfo();
+                    if (userInfo != null) {
+                        String[] userInfoParts = userInfo.split(":");
+                        builder = builder.basicAuth(new MavenPluginRepositoryConfig.BasicAuth(
+                            userInfoParts[0],
+                            userInfoParts[1]
+                        ));
+                    }
+                    builder.url(UriBuilder.of(uri).userInfo(null).build().toString());
+                    return builder.build();
+                }).toList();
         }
 
-        List<URL> resolveUrl = pluginDownloader.resolve(dependencies);
-        stdOut("Resolved Plugin(s) with {0}", resolveUrl);
+        if (all) {
+            PluginCatalogService service = new PluginCatalogService(httpClient, false, true);
+            dependencies = service.get().stream().map(Objects::toString).toList();
+        }
 
-        for (URL url: resolveUrl) {
-            Files.copy(
-                Paths.get(url.toURI()),
-                Paths.get(pluginsPath.toString(), FilenameUtils.getName(url.toString())),
-                StandardCopyOption.REPLACE_EXISTING
+        if (dependencies.isEmpty()) {
+            stdErr("Error: No plugin to install.");
+            return CommandLine.ExitCode.OK;
+        }
+
+        final List<PluginArtifact> pluginArtifacts;
+        try {
+           pluginArtifacts = dependencies.stream().map(PluginArtifact::fromCoordinates).toList();
+        } catch (IllegalArgumentException e) {
+            stdErr(e.getMessage());
+            return CommandLine.ExitCode.USAGE;
+        }
+
+        try (final PluginManager pluginManager = getPluginManager()) {
+            List<PluginArtifact> installed = pluginManager.install(
+                pluginArtifacts,
+                repositoryConfigs,
+                false,
+                pluginsPath
             );
+
+            List<URI> uris = installed.stream().map(PluginArtifact::uri).toList();
+            stdOut("Successfully installed plugins {0} into {1}", dependencies, uris);
+            return CommandLine.ExitCode.OK;
         }
+    }
 
-        stdOut("Successfully installed plugins {0} into {1}", dependencies, pluginsPath);
+    private PluginManager getPluginManager() {
+        return locally ? new LocalPluginManager(mavenPluginRepositoryProvider.get()) : this.pluginManagerProvider.get();
+    }
 
-        return 0;
+    @Override
+    protected boolean loadExternalPlugins() {
+        return false;
     }
 }

cli/src/main/java/io/kestra/cli/commands/plugins/PluginListCommand.java

@@ -1,28 +1,31 @@
 package io.kestra.cli.commands.plugins;
 
 import io.kestra.cli.AbstractCommand;
-import io.kestra.core.contexts.KestraClassLoader;
-import io.kestra.core.plugins.PluginScanner;
+import io.kestra.core.plugins.PluginRegistry;
 import io.kestra.core.plugins.RegisteredPlugin;
+import jakarta.inject.Inject;
+import jakarta.inject.Provider;
 import picocli.CommandLine;
+import picocli.CommandLine.Command;
+import picocli.CommandLine.Option;
+import picocli.CommandLine.Spec;
 
 import java.util.List;
 
-@CommandLine.Command(
+@Command(
     name = "list",
-    description = "list all plugins already installed"
+    description = "List all plugins already installed"
 )
 public class PluginListCommand extends AbstractCommand {
-    @CommandLine.Spec
+    @Spec
     CommandLine.Model.CommandSpec spec;
 
-    public PluginListCommand() {
-        super(false);
-    }
-
-    @CommandLine.Option(names = {"--core"}, description = "Also write core tasks plugins")
+    @Option(names = {"--core"}, description = "Also write core tasks plugins")
     private boolean core = false;
 
+    @Inject
+    private PluginRegistry registry;
+
     @Override
     public Integer call() throws Exception {
         super.call();
@@ -33,15 +36,9 @@ public class PluginListCommand extends AbstractCommand {
             );
         }
 
-        PluginScanner pluginScanner = new PluginScanner(KestraClassLoader.instance());
-        List<RegisteredPlugin> scan = pluginScanner.scan(this.pluginsPath);
+        List<RegisteredPlugin> plugins = core ? registry.plugins() : registry.externalPlugins();
 
-        if (core) {
-            PluginScanner corePluginScanner = new PluginScanner(PluginDocCommand.class.getClassLoader());
-            scan.add(corePluginScanner.scan());
-        }
-
-        scan.forEach(registeredPlugin -> stdOut(registeredPlugin.toString()));
+        plugins.forEach(registeredPlugin -> stdOut(registeredPlugin.toString()));
 
         return 0;
     }

cli/src/main/java/io/kestra/cli/commands/plugins/PluginSearchCommand.java

@@ -0,0 +1,149 @@
+package io.kestra.cli.commands.plugins;
+
+import io.kestra.cli.AbstractCommand;
+import io.micronaut.core.type.Argument;
+import io.micronaut.http.HttpRequest;
+import io.micronaut.http.client.HttpClient;
+import io.micronaut.http.client.annotation.Client;
+import jakarta.inject.Inject;
+import picocli.CommandLine.Command;
+import picocli.CommandLine.Parameters;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Command(
+    name = "search",
+    description = "Search for available Kestra plugins"
+)
+public class PluginSearchCommand extends AbstractCommand {
+    @Inject
+    @Client("api")
+    private HttpClient httpClient;
+
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+    private static final char SPACE = ' ';
+
+    @Parameters(index = "0", description = "Search term (optional)", defaultValue = "")
+    private String searchTerm;
+
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        try {
+            JsonNode root = fetchPlugins();
+            List<PluginInfo> plugins = findPlugins(root);
+            printResults(plugins);
+            return 0;
+        } catch (Exception e) {
+            stdOut("Error processing plugins: {0}", e.getMessage());
+            return 1;
+        }
+    }
+
+    private JsonNode fetchPlugins() throws Exception {
+        String response = httpClient.toBlocking()
+            .retrieve(
+                HttpRequest.GET("/v1/plugins")
+                    .header("Accept", "application/json")
+            );
+        return MAPPER.readTree(response);
+    }
+
+    private List<PluginInfo> findPlugins(JsonNode root) {
+        String searchTermLower = searchTerm.toLowerCase();
+        List<PluginInfo> plugins = new ArrayList<>();
+
+        for (JsonNode plugin : root) {
+            if (matchesSearch(plugin, searchTermLower)) {
+                plugins.add(new PluginInfo(
+                    plugin.path("name").asText(),
+                    plugin.path("title").asText(),
+                    plugin.path("group").asText(),
+                    plugin.path("version").asText("")
+                ));
+            }
+        }
+
+        plugins.sort((p1, p2) -> p1.name.compareToIgnoreCase(p2.name));
+        return plugins;
+    }
+
+    private boolean matchesSearch(JsonNode plugin, String term) {
+        if (term.isEmpty()) {
+            return true;
+        }
+
+        return plugin.path("name").asText().toLowerCase().contains(term) ||
+            plugin.path("title").asText().toLowerCase().contains(term) ||
+            plugin.path("group").asText().toLowerCase().contains(term);
+    }
+
+    private void printResults(List<PluginInfo> plugins) {
+        if (plugins.isEmpty()) {
+            stdOut("No plugins found{0}",
+                searchTerm.isEmpty() ? "" : " matching '" + searchTerm + "'");
+            return;
+        }
+
+        stdOut("\nFound {0} plugins{1}",
+            plugins.size(),
+            searchTerm.isEmpty() ? "" : " matching '" + searchTerm + "'"
+        );
+
+        printPluginsTable(plugins);
+    }
+
+    private void printPluginsTable(List<PluginInfo> plugins) {
+        int maxName = 4, maxTitle = 5, maxGroup = 5;
+        for (PluginInfo plugin : plugins) {
+            maxName = Math.max(maxName, plugin.name.length());
+            maxTitle = Math.max(maxTitle, plugin.title.length());
+            maxGroup = Math.max(maxGroup, plugin.group.length());
+        }
+
+        StringBuilder namePad = new StringBuilder(maxName);
+        StringBuilder titlePad = new StringBuilder(maxTitle);
+        StringBuilder groupPad = new StringBuilder(maxGroup);
+
+        stdOut("");
+        printRow(namePad, titlePad, groupPad, "NAME", "TITLE", "GROUP", "VERSION",
+            maxName, maxTitle, maxGroup);
+
+        for (PluginInfo plugin : plugins) {
+            printRow(namePad, titlePad, groupPad, plugin.name, plugin.title, plugin.group, plugin.version,
+                maxName, maxTitle, maxGroup);
+        }
+        stdOut("");
+    }
+
+    private void printRow(StringBuilder namePad, StringBuilder titlePad, StringBuilder groupPad,
+                          String name, String title, String group, String version,
+                          int maxName, int maxTitle, int maxGroup) {
+        stdOut("{0}  {1}  {2}  {3}",
+            pad(namePad, name, maxName),
+            pad(titlePad, title, maxTitle),
+            pad(groupPad, group, maxGroup),
+            version
+        );
+    }
+
+    private String pad(StringBuilder sb, String str, int length) {
+        sb.setLength(0);
+        sb.append(str);
+        while (sb.length() < length) {
+            sb.append(SPACE);
+        }
+        return sb.toString();
+    }
+
+    private record PluginInfo(String name, String title, String group, String version) {}
+
+    @Override
+    protected boolean loadExternalPlugins() {
+        return false;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/plugins/PluginUninstallCommand.java

@@ -0,0 +1,69 @@
+package io.kestra.cli.commands.plugins;
+
+import io.kestra.cli.AbstractCommand;
+import io.kestra.core.plugins.LocalPluginManager;
+import io.kestra.core.plugins.MavenPluginDownloader;
+import io.kestra.core.plugins.PluginArtifact;
+import io.kestra.core.plugins.PluginManager;
+import jakarta.inject.Inject;
+import jakarta.inject.Provider;
+import picocli.CommandLine;
+import picocli.CommandLine.Parameters;
+import picocli.CommandLine.Spec;
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.List;
+
+@CommandLine.Command(
+    name = "uninstall",
+    description = "Uninstall plugins"
+)
+public class PluginUninstallCommand extends AbstractCommand {
+    @Parameters(index = "0..*", description = "The plugins to uninstall. Represented as Maven artifact coordinates (i.e., <groupId>:<artifactId>:(<version>|LATEST)")
+    List<String> dependencies = new ArrayList<>();
+
+    @Spec
+    CommandLine.Model.CommandSpec spec;
+
+    @Inject
+    Provider<MavenPluginDownloader> mavenPluginRepositoryProvider;
+
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        List<PluginArtifact> pluginArtifacts;
+        try {
+            pluginArtifacts = dependencies.stream().map(PluginArtifact::fromCoordinates).toList();
+        } catch (IllegalArgumentException e) {
+            stdErr(e.getMessage());
+            return CommandLine.ExitCode.USAGE;
+        }
+
+        final PluginManager pluginManager;
+
+        // If a PLUGIN_PATH is provided, then use the LocalPluginManager
+        if (pluginsPath != null) {
+            pluginManager = new LocalPluginManager(mavenPluginRepositoryProvider.get());
+        } else {
+            // Otherwise, we delegate to the configured plugin-manager.
+            pluginManager = this.pluginManagerProvider.get();
+        }
+
+        List<PluginArtifact> uninstalled = pluginManager.uninstall(
+            pluginArtifacts,
+            false,
+            pluginsPath
+        );
+
+        List<URI> uris = uninstalled.stream().map(PluginArtifact::uri).toList();
+        stdOut("Successfully uninstalled plugins {0} from {1}", dependencies, uris);
+        return CommandLine.ExitCode.OK;
+    }
+
+    @Override
+    protected boolean loadExternalPlugins() {
+        return false;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/servers/AbstractServerCommand.java

@@ -0,0 +1,21 @@
+package io.kestra.cli.commands.servers;
+
+import io.kestra.cli.AbstractCommand;
+import io.kestra.core.contexts.KestraContext;
+import jakarta.annotation.PostConstruct;
+import picocli.CommandLine;
+
+abstract public class AbstractServerCommand extends AbstractCommand implements ServerCommandInterface {
+    @CommandLine.Option(names = {"--port"}, description = "The port to bind")
+    Integer serverPort;
+
+    @Override
+    public Integer call()  throws Exception {
+        this.shutdownHook(true, () -> KestraContext.getContext().shutdown());
+        return super.call();
+    }
+
+    protected static int defaultWorkerThread() {
+        return Runtime.getRuntime().availableProcessors() * 4;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/servers/ExecutorCommand.java

@@ -1,29 +1,50 @@
 package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
-import io.micronaut.context.ApplicationContext;
-import lombok.extern.slf4j.Slf4j;
-import io.kestra.cli.AbstractCommand;
 import io.kestra.core.models.ServerType;
-import io.kestra.core.runners.AbstractExecutor;
+import io.kestra.core.runners.ExecutorInterface;
+import io.kestra.core.services.SkipExecutionService;
+import io.kestra.core.services.StartExecutorService;
 import io.kestra.core.utils.Await;
+import io.micronaut.context.ApplicationContext;
+import jakarta.inject.Inject;
 import picocli.CommandLine;
 
+import java.util.Collections;
+import java.util.List;
 import java.util.Map;
-import javax.inject.Inject;
 
 @CommandLine.Command(
     name = "executor",
-    description = "start an executor"
+    description = "Start the Kestra executor"
 )
-@Slf4j
-public class ExecutorCommand extends AbstractCommand {
+public class ExecutorCommand extends AbstractServerCommand {
     @Inject
     private ApplicationContext applicationContext;
 
-    public ExecutorCommand() {
-        super(true);
-    }
+    @Inject
+    private SkipExecutionService skipExecutionService;
+
+    @Inject
+    private StartExecutorService startExecutorService;
+
+    @CommandLine.Option(names = {"--skip-executions"}, split=",", description = "The list of execution identifiers to skip, separated by a coma; for troubleshooting purpose only")
+    private List<String> skipExecutions = Collections.emptyList();
+
+    @CommandLine.Option(names = {"--skip-flows"}, split=",", description = "The list of flow identifiers (tenant|namespace|flowId) to skip, separated by a coma; for troubleshooting purpose only")
+    private List<String> skipFlows = Collections.emptyList();
+
+    @CommandLine.Option(names = {"--skip-namespaces"}, split=",", description = "The list of namespace identifiers (tenant|namespace) to skip, separated by a coma; for troubleshooting purpose only")
+    private List<String> skipNamespaces = Collections.emptyList();
+
+    @CommandLine.Option(names = {"--skip-tenants"}, split=",", description = "The list of tenants to skip, separated by a coma; for troubleshooting purpose only")
+    private List<String> skipTenants = Collections.emptyList();
+
+    @CommandLine.Option(names = {"--start-executors"}, split=",", description = "The list of Kafka Stream executors to start, separated by a command. Use it only with the Kafka queue, for debugging purpose.")
+    private List<String> startExecutors = Collections.emptyList();
+
+    @CommandLine.Option(names = {"--not-start-executors"}, split=",", description = "The list of Kafka Stream executors to not start, separated by a command. Use it only with the Kafka queue, for debugging purpose.")
+    private List<String> notStartExecutors = Collections.emptyList();
 
     @SuppressWarnings("unused")
     public static Map<String, Object> propertiesOverrides() {
@@ -34,14 +55,17 @@ public class ExecutorCommand extends AbstractCommand {
 
     @Override
     public Integer call() throws Exception {
+        this.skipExecutionService.setSkipExecutions(skipExecutions);
+        this.skipExecutionService.setSkipFlows(skipFlows);
+        this.skipExecutionService.setSkipNamespaces(skipNamespaces);
+        this.skipExecutionService.setSkipTenants(skipTenants);
+
+        this.startExecutorService.applyOptions(startExecutors, notStartExecutors);
+
         super.call();
 
-        AbstractExecutor abstractExecutor = applicationContext.getBean(AbstractExecutor.class);
-        abstractExecutor.run();
-
-        log.info("Executor started");
-
-        this.shutdownHook(abstractExecutor::close);
+        ExecutorInterface executorService = applicationContext.getBean(ExecutorInterface.class);
+        executorService.run();
 
         Await.until(() -> !this.applicationContext.isRunning());
 

cli/src/main/java/io/kestra/cli/commands/servers/IndexerCommand.java

@@ -1,31 +1,23 @@
 package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
-import io.micronaut.context.ApplicationContext;
-import lombok.extern.slf4j.Slf4j;
-import io.kestra.cli.AbstractCommand;
 import io.kestra.core.models.ServerType;
-import io.kestra.core.runners.Indexer;
 import io.kestra.core.runners.IndexerInterface;
 import io.kestra.core.utils.Await;
+import io.micronaut.context.ApplicationContext;
+import jakarta.inject.Inject;
 import picocli.CommandLine;
 
 import java.util.Map;
-import javax.inject.Inject;
 
 @CommandLine.Command(
     name = "indexer",
-    description = "start an indexer"
+    description = "Start the Kestra indexer"
 )
-@Slf4j
-public class IndexerCommand extends AbstractCommand {
+public class IndexerCommand extends AbstractServerCommand {
     @Inject
     private ApplicationContext applicationContext;
 
-    public IndexerCommand() {
-        super(true);
-    }
-
     @SuppressWarnings("unused")
     public static Map<String, Object> propertiesOverrides() {
         return ImmutableMap.of(
@@ -40,10 +32,6 @@ public class IndexerCommand extends AbstractCommand {
         IndexerInterface indexer = applicationContext.getBean(IndexerInterface.class);
         indexer.run();
 
-        log.info("Indexer started");
-
-        this.shutdownHook(indexer::close);
-
         Await.until(() -> !this.applicationContext.isRunning());
 
         return 0;

cli/src/main/java/io/kestra/cli/commands/servers/LocalCommand.java

@@ -0,0 +1,43 @@
+package io.kestra.cli.commands.servers;
+
+import com.google.common.collect.ImmutableMap;
+import io.kestra.core.models.ServerType;
+import io.micronaut.context.ApplicationContext;
+import jakarta.inject.Inject;
+import picocli.CommandLine;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Map;
+
+@CommandLine.Command(
+    name = "local",
+    description = "Start the local development server"
+)
+public class LocalCommand extends StandAloneCommand {
+    // @FIXME: Keep it for bug in micronaut that need to have inject on top level command to inject on abstract classe
+    @Inject
+    private ApplicationContext applicationContext;
+
+    @SuppressWarnings("unused")
+    public static Map<String, Object> propertiesOverrides() {
+        Path data = Paths.get("").toAbsolutePath().resolve("data");
+
+        //noinspection ResultOfMethodCallIgnored
+        data.toFile().mkdirs();
+
+        return ImmutableMap.of(
+            "kestra.server-type", ServerType.STANDALONE,
+            "kestra.repository.type", "h2",
+            "kestra.queue.type", "h2",
+            "kestra.storage.type", "local",
+            "kestra.storage.local.base-path", data.toString(),
+            "datasources.h2.url", "jdbc:h2:file:" + data.resolve("database") + ";TIME ZONE=UTC;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE;LOCK_TIMEOUT=30000",
+            "datasources.h2.username", "sa",
+            "datasources.h2.password", "",
+            "datasources.h2.driverClassName", "org.h2.Driver",
+            "endpoints.all.port", "${random.port}"
+        );
+    }
+
+}

cli/src/main/java/io/kestra/cli/commands/servers/SchedulerCommand.java

@@ -1,30 +1,25 @@
 package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
-import io.micronaut.context.ApplicationContext;
-import lombok.extern.slf4j.Slf4j;
-import io.kestra.cli.AbstractCommand;
 import io.kestra.core.models.ServerType;
 import io.kestra.core.schedulers.AbstractScheduler;
 import io.kestra.core.utils.Await;
+import io.micronaut.context.ApplicationContext;
+import jakarta.inject.Inject;
+import lombok.extern.slf4j.Slf4j;
 import picocli.CommandLine;
 
 import java.util.Map;
-import javax.inject.Inject;
 
 @CommandLine.Command(
     name = "scheduler",
-    description = "start an scheduler"
+    description = "Start the Kestra scheduler"
 )
 @Slf4j
-public class SchedulerCommand extends AbstractCommand {
+public class SchedulerCommand extends AbstractServerCommand {
     @Inject
     private ApplicationContext applicationContext;
 
-    public SchedulerCommand() {
-        super(true);
-    }
-
     @SuppressWarnings("unused")
     public static Map<String, Object> propertiesOverrides() {
         return ImmutableMap.of(
@@ -39,10 +34,6 @@ public class SchedulerCommand extends AbstractCommand {
         AbstractScheduler scheduler = applicationContext.getBean(AbstractScheduler.class);
         scheduler.run();
 
-        log.info("Scheduler started");
-
-        this.shutdownHook(scheduler::close);
-
         Await.until(() -> !this.applicationContext.isRunning());
 
         return 0;

cli/src/main/java/io/kestra/cli/commands/servers/ServerCommand.java

@@ -9,7 +9,7 @@ import picocli.CommandLine;
 
 @CommandLine.Command(
     name = "server",
-    description = "handle servers",
+    description = "Manage servers",
     mixinStandardHelpOptions = true,
     subcommands = {
         ExecutorCommand.class,
@@ -18,14 +18,11 @@ import picocli.CommandLine;
         StandAloneCommand.class,
         WebServerCommand.class,
         WorkerCommand.class,
+        LocalCommand.class,
     }
 )
 @Slf4j
 public class ServerCommand extends AbstractCommand {
-    public ServerCommand() {
-        super(false);
-    }
-
     @SneakyThrows
     @Override
     public Integer call() throws Exception {

cli/src/main/java/io/kestra/cli/commands/servers/ServerCommandInterface.java

@@ -0,0 +1,4 @@
+package io.kestra.cli.commands.servers;
+
+public interface ServerCommandInterface {
+}

cli/src/main/java/io/kestra/cli/commands/servers/StandAloneCommand.java

@@ -1,40 +1,79 @@
 package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
-import io.micronaut.context.ApplicationContext;
-import lombok.extern.slf4j.Slf4j;
-import io.kestra.cli.AbstractCommand;
+import io.kestra.cli.services.FileChangedEventListener;
+import io.kestra.core.contexts.KestraContext;
 import io.kestra.core.models.ServerType;
 import io.kestra.core.repositories.LocalFlowRepositoryLoader;
-import io.kestra.core.runners.AbstractExecutor;
 import io.kestra.core.runners.StandAloneRunner;
+import io.kestra.core.services.SkipExecutionService;
+import io.kestra.core.services.StartExecutorService;
 import io.kestra.core.utils.Await;
-import io.kestra.runner.kafka.KafkaExecutor;
+import io.micronaut.context.ApplicationContext;
+import jakarta.annotation.Nullable;
+import jakarta.inject.Inject;
 import picocli.CommandLine;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
 import java.util.Map;
-import java.util.Optional;
-import javax.inject.Inject;
 
 @CommandLine.Command(
     name = "standalone",
-    description = "start a standalone server"
+    description = "Start the standalone all-in-one server"
 )
-@Slf4j
-public class StandAloneCommand extends AbstractCommand {
+public class StandAloneCommand extends AbstractServerCommand {
     @CommandLine.Spec
     CommandLine.Model.CommandSpec spec;
 
     @Inject
     private ApplicationContext applicationContext;
 
+    @Inject
+    private SkipExecutionService skipExecutionService;
+
+    @Inject
+    private StartExecutorService startExecutorService;
+
+    @Inject
+    @Nullable
+    private FileChangedEventListener fileWatcher;
+
     @CommandLine.Option(names = {"-f", "--flow-path"}, description = "the flow path containing flow to inject at startup (when running with a memory flow repository)")
     private File flowPath;
 
-    public StandAloneCommand() {
-        super(true);
+    @CommandLine.Option(names = {"--worker-thread"}, description = "the number of worker threads, defaults to four times the number of available processors. Set it to 0 to avoid starting a worker.")
+    private int workerThread = defaultWorkerThread();
+
+    @CommandLine.Option(names = {"--skip-executions"}, split=",", description = "a list of execution identifiers to skip, separated by a coma; for troubleshooting purpose only")
+    private List<String> skipExecutions = Collections.emptyList();
+
+    @CommandLine.Option(names = {"--skip-flows"}, split=",", description = "a list of flow identifiers (namespace.flowId) to skip, separated by a coma; for troubleshooting purpose only")
+    private List<String> skipFlows = Collections.emptyList();
+
+    @CommandLine.Option(names = {"--skip-namespaces"}, split=",", description = "a list of namespace identifiers (tenant|namespace) to skip, separated by a coma; for troubleshooting purpose only")
+    private List<String> skipNamespaces = Collections.emptyList();
+
+    @CommandLine.Option(names = {"--skip-tenants"}, split=",", description = "a list of tenants to skip, separated by a coma; for troubleshooting purpose only")
+    private List<String> skipTenants = Collections.emptyList();
+
+    @CommandLine.Option(names = {"--no-tutorials"}, description = "Flag to disable auto-loading of tutorial flows.")
+    boolean tutorialsDisabled = false;
+
+    @CommandLine.Option(names = {"--start-executors"}, split=",", description = "a list of Kafka Stream executors to start, separated by a command. Use it only with the Kafka queue, for debugging purpose.")
+    private List<String> startExecutors = Collections.emptyList();
+
+    @CommandLine.Option(names = {"--not-start-executors"}, split=",", description = "a list of Kafka Stream executors to not start, separated by a command. Use it only with the Kafka queue, for debugging purpose.")
+    private List<String> notStartExecutors = Collections.emptyList();
+
+    @CommandLine.Option(names = {"--no-indexer"}, description = "Flag to disable starting an embedded indexer.")
+    boolean indexerDisabled = false;
+
+    @Override
+    public boolean isFlowAutoLoadEnabled() {
+        return !tutorialsDisabled;
     }
 
     @SuppressWarnings("unused")
@@ -46,6 +85,14 @@ public class StandAloneCommand extends AbstractCommand {
 
     @Override
     public Integer call() throws Exception {
+        this.skipExecutionService.setSkipExecutions(skipExecutions);
+        this.skipExecutionService.setSkipFlows(skipFlows);
+        this.skipExecutionService.setSkipNamespaces(skipNamespaces);
+        this.skipExecutionService.setSkipTenants(skipTenants);
+        this.startExecutorService.applyOptions(startExecutors, notStartExecutors);
+
+        KestraContext.getContext().injectWorkerConfigs(workerThread, null);
+
         super.call();
 
         if (flowPath != null) {
@@ -58,9 +105,22 @@ public class StandAloneCommand extends AbstractCommand {
         }
 
         StandAloneRunner standAloneRunner = applicationContext.getBean(StandAloneRunner.class);
+
+        if (this.workerThread == 0) {
+            standAloneRunner.setWorkerEnabled(false);
+        } else {
+            standAloneRunner.setWorkerThread(this.workerThread);
+        }
+
+        if (this.indexerDisabled) {
+            standAloneRunner.setIndexerEnabled(false);
+        }
+
         standAloneRunner.run();
 
-        this.shutdownHook(standAloneRunner::close);
+        if (fileWatcher != null) {
+            fileWatcher.startListeningFromConfig();
+        }
 
         Await.until(() -> !this.applicationContext.isRunning());
 

cli/src/main/java/io/kestra/cli/commands/servers/WebServerCommand.java

@@ -1,27 +1,42 @@
 package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
-import io.micronaut.context.ApplicationContext;
-import lombok.extern.slf4j.Slf4j;
-import io.kestra.cli.AbstractCommand;
 import io.kestra.core.models.ServerType;
+import io.kestra.core.runners.IndexerInterface;
 import io.kestra.core.utils.Await;
+import io.kestra.core.utils.ExecutorsUtils;
+import io.micronaut.context.ApplicationContext;
+import jakarta.inject.Inject;
+import lombok.extern.slf4j.Slf4j;
 import picocli.CommandLine;
+import picocli.CommandLine.Option;
 
 import java.util.Map;
-import javax.inject.Inject;
+import java.util.concurrent.ExecutorService;
 
 @CommandLine.Command(
     name = "webserver",
-    description = "start the webserver"
+    description = "Start the Kestra webserver"
 )
 @Slf4j
-public class WebServerCommand extends AbstractCommand {
+public class WebServerCommand extends AbstractServerCommand {
+    private ExecutorService poolExecutor;
+
     @Inject
     private ApplicationContext applicationContext;
 
-    public WebServerCommand() {
-        super(true);
+    @Inject
+    private ExecutorsUtils executorsUtils;
+
+    @Option(names = {"--no-tutorials"}, description = "Flag to disable auto-loading of tutorial flows.")
+    boolean tutorialsDisabled = false;
+
+    @Option(names = {"--no-indexer"}, description = "Flag to disable starting an embedded indexer.")
+    boolean indexerDisabled = false;
+
+    @Override
+    public boolean isFlowAutoLoadEnabled() {
+        return !tutorialsDisabled;
     }
 
     @SuppressWarnings("unused")
@@ -35,14 +50,16 @@ public class WebServerCommand extends AbstractCommand {
     public Integer call() throws Exception {
         super.call();
 
+        // start the indexer
+        if (!indexerDisabled) {
+            log.info("Starting an embedded indexer, this can be disabled by using `--no-indexer`.");
+            poolExecutor = executorsUtils.cachedThreadPool("webserver-indexer");
+            poolExecutor.execute(applicationContext.getBean(IndexerInterface.class));
+            shutdownHook(false, () -> poolExecutor.shutdown());
+        }
+
         log.info("Webserver started");
-
-        this.shutdownHook(() -> {
-            this.applicationContext.close();
-        });
-
         Await.until(() -> !this.applicationContext.isRunning());
-
         return 0;
     }
 }

cli/src/main/java/io/kestra/cli/commands/servers/WorkerCommand.java

@@ -1,32 +1,32 @@
 package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
-import io.micronaut.context.ApplicationContext;
-import lombok.extern.slf4j.Slf4j;
-import io.kestra.cli.AbstractCommand;
+import io.kestra.core.contexts.KestraContext;
 import io.kestra.core.models.ServerType;
 import io.kestra.core.runners.Worker;
 import io.kestra.core.utils.Await;
+import io.micronaut.context.ApplicationContext;
+import jakarta.inject.Inject;
 import picocli.CommandLine;
+import picocli.CommandLine.Option;
 
 import java.util.Map;
-import javax.inject.Inject;
+import java.util.UUID;
 
 @CommandLine.Command(
     name = "worker",
-    description = "start a worker"
+    description = "Start the Kestra worker"
 )
-@Slf4j
-public class WorkerCommand extends AbstractCommand {
+public class WorkerCommand extends AbstractServerCommand {
+
     @Inject
     private ApplicationContext applicationContext;
 
-    @CommandLine.Option(names = {"-t", "--thread"}, description = "the number of concurrent threads to launch")
-    private int thread = Runtime.getRuntime().availableProcessors();
+    @Option(names = {"-t", "--thread"}, description = "The max number of worker threads, defaults to four times the number of available processors")
+    private int thread = defaultWorkerThread();
 
-    public WorkerCommand() {
-        super(true);
-    }
+    @Option(names = {"-g", "--worker-group"}, description = "The worker group key, must match the regex [a-zA-Z0-9_-]+ (EE only)")
+    private String workerGroupKey = null;
 
     @SuppressWarnings("unused")
     public static Map<String, Object> propertiesOverrides() {
@@ -37,19 +37,28 @@ public class WorkerCommand extends AbstractCommand {
 
     @Override
     public Integer call() throws Exception {
+
+        KestraContext.getContext().injectWorkerConfigs(thread, workerGroupKey);
+
         super.call();
 
-        Worker worker = new Worker(applicationContext, this.thread);
+        if (this.workerGroupKey != null && !this.workerGroupKey.matches("[a-zA-Z0-9_-]+")) {
+            throw new IllegalArgumentException("The --worker-group option must match the [a-zA-Z0-9_-]+ pattern");
+        }
+
+        // FIXME: For backward-compatibility with Kestra 0.15.x and earliest we still used UUID for Worker ID instead of IdUtils
+        String workerID = UUID.randomUUID().toString();
+        Worker worker = applicationContext.createBean(Worker.class, workerID, this.thread, this.workerGroupKey);
         applicationContext.registerSingleton(worker);
 
         worker.run();
 
-        log.info("Workers started with {} thread(s)", this.thread);
-
-        this.shutdownHook(worker::close);
-
         Await.until(() -> !this.applicationContext.isRunning());
 
         return 0;
     }
+
+    public String workerGroupKey() {
+        return workerGroupKey;
+    }
 }

cli/src/main/java/io/kestra/cli/commands/sys/FlowListenersRestoreCommand.java

@@ -1,52 +0,0 @@
-package io.kestra.cli.commands.sys;
-
-import io.micronaut.context.ApplicationContext;
-import lombok.extern.slf4j.Slf4j;
-import io.kestra.cli.AbstractCommand;
-import io.kestra.core.services.FlowListenersInterface;
-import io.kestra.core.utils.Await;
-import picocli.CommandLine;
-
-import java.time.Duration;
-import java.time.ZonedDateTime;
-import java.util.concurrent.atomic.AtomicReference;
-import javax.inject.Inject;
-
-@CommandLine.Command(
-    name = "restore-flow-listeners",
-    description = {"restore state-store for FlowListeners",
-        "Mostly usefull in case of restore of flow queue, the state store need to be init to avoid sending old revisions."
-    }
-)
-@Slf4j
-public class FlowListenersRestoreCommand extends AbstractCommand {
-    @Inject
-    private ApplicationContext applicationContext;
-
-    @CommandLine.Option(names = {"--timeout"}, description = "Timeout before quit, considering we complete the restore")
-    private Duration timeout = Duration.ofSeconds(15);
-
-    public FlowListenersRestoreCommand() {
-        super(false);
-    }
-
-    @Override
-    public Integer call() throws Exception {
-        super.call();
-
-        FlowListenersInterface flowListeners = applicationContext.getBean(FlowListenersInterface.class);
-
-        AtomicReference<ZonedDateTime> lastTime = new AtomicReference<>(ZonedDateTime.now());
-
-        flowListeners.listen(flows -> {
-            stdOut("Received {0} flows", flows.size());
-
-            lastTime.set(ZonedDateTime.now());
-        });
-
-        // we can't know when it's over to wait no more flow received
-        Await.until(() -> lastTime.get().compareTo(ZonedDateTime.now().minus(this.timeout)) < 0);
-
-        return 0;
-    }
-}

cli/src/main/java/io/kestra/cli/commands/sys/ReindexCommand.java

@@ -0,0 +1,49 @@
+package io.kestra.cli.commands.sys;
+
+import io.kestra.cli.AbstractCommand;
+import io.kestra.core.models.flows.Flow;
+import io.kestra.core.models.flows.GenericFlow;
+import io.kestra.core.repositories.FlowRepositoryInterface;
+import io.micronaut.context.ApplicationContext;
+import jakarta.inject.Inject;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+import java.util.List;
+import java.util.Objects;
+
+@CommandLine.Command(
+    name = "reindex",
+    description = "Reindex all records of a type: read them from the database then update them",
+    mixinStandardHelpOptions = true
+)
+@Slf4j
+public class ReindexCommand extends AbstractCommand {
+    @Inject
+    private ApplicationContext applicationContext;
+
+    @CommandLine.Option(names = {"-t", "--type"}, description = "The type of the records to reindex, only 'flow' is supported for now.")
+    private String type;
+
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        if ("flow".equals(type)) {
+            FlowRepositoryInterface flowRepository = applicationContext.getBean(FlowRepositoryInterface.class);
+
+            List<Flow> allFlow = flowRepository.findAllForAllTenants();
+            allFlow.stream()
+                .map(flow -> flowRepository.findByIdWithSource(flow.getTenantId(), flow.getNamespace(), flow.getId()).orElse(null))
+                .filter(Objects::nonNull)
+                .forEach(flow -> flowRepository.update(GenericFlow.of(flow), flow));
+
+            stdOut("Successfully reindex " + allFlow.size() + " flow(s).");
+        }
+        else {
+            throw new IllegalArgumentException("Reindexing type '" + type + "' is not supported");
+        }
+
+        return 0;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/sys/RestoreQueueCommand.java

@@ -1,109 +0,0 @@
-package io.kestra.cli.commands.sys;
-
-import io.micronaut.context.ApplicationContext;
-import io.micronaut.inject.qualifiers.Qualifiers;
-import lombok.SneakyThrows;
-import lombok.extern.slf4j.Slf4j;
-import io.kestra.cli.AbstractCommand;
-import io.kestra.core.models.flows.Flow;
-import io.kestra.core.models.templates.Template;
-import io.kestra.core.models.triggers.Trigger;
-import io.kestra.core.queues.QueueFactoryInterface;
-import io.kestra.core.queues.QueueInterface;
-import io.kestra.core.repositories.FlowRepositoryInterface;
-import io.kestra.core.repositories.TemplateRepositoryInterface;
-import io.kestra.core.repositories.TriggerRepositoryInterface;
-import io.kestra.runner.kafka.services.KafkaAdminService;
-import picocli.CommandLine;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-import java.util.stream.Collectors;
-import javax.inject.Inject;
-
-@CommandLine.Command(
-    name = "restore-queue",
-    description = {"send all data from a repository to kafka.",
-        "Mostly usefull to send all flows, templates & triggers from repository to kafka in case of restore."
-    }
-)
-@Slf4j
-public class RestoreQueueCommand extends AbstractCommand {
-    @Inject
-    private ApplicationContext applicationContext;
-
-    @CommandLine.Option(names = {"--no-recreate"}, description = "Don't drop the topic and recreate it")
-    private boolean noRecreate = false;
-
-    @CommandLine.Option(names = {"--no-flows"}, description = "Don't send flow")
-    private boolean noFlows = false;
-
-    @CommandLine.Option(names = {"--no-templates"}, description = "Don't send flow")
-    private boolean noTemplates = false;
-
-    @CommandLine.Option(names = {"--no-triggers"}, description = "Don't send flow")
-    private boolean noTriggers = false;
-
-    public RestoreQueueCommand() {
-        super(false);
-    }
-
-    @Override
-    public Integer call() throws Exception {
-        super.call();
-
-        // flows
-        if (!noFlows) {
-            FlowRepositoryInterface flowRepository = applicationContext.getBean(FlowRepositoryInterface.class);
-            List<Flow> flows = flowRepository
-                .findAll()
-                .stream()
-                .flatMap(flow -> flowRepository.findRevisions(flow.getNamespace(), flow.getId()).stream())
-                .collect(Collectors.toList());
-            this.send(flows, QueueFactoryInterface.FLOW_NAMED, Flow.class);
-        }
-
-        // templates
-        if (!this.noTemplates) {
-            TemplateRepositoryInterface templateRepository = applicationContext.getBean(TemplateRepositoryInterface.class);
-            List<Template> templates = new ArrayList<>(templateRepository.findAll());
-            this.send(templates, QueueFactoryInterface.TEMPLATE_NAMED, Template.class);
-        }
-
-        // trigger
-        if (!this.noTriggers) {
-            TriggerRepositoryInterface triggerRepository = applicationContext.getBean(TriggerRepositoryInterface.class);
-            List<Trigger> triggers = new ArrayList<>(triggerRepository.findAll());
-            this.send(triggers, QueueFactoryInterface.TRIGGER_NAMED, Trigger.class);
-        }
-
-        return 0;
-    }
-
-    @SneakyThrows
-    @SuppressWarnings("unchecked")
-    private <T> void send(List<T> list, String queueName, Class<?> cls) {
-        Optional<String> queueType = applicationContext.getProperty("kestra.queue.type", String.class);
-
-        if (queueType.isPresent() && queueType.get().equals("kafka")) {
-            KafkaAdminService kafkaAdminService = applicationContext.getBean(KafkaAdminService.class);
-            if (!noRecreate) {
-                kafkaAdminService.delete(cls);
-            }
-
-            // need some wait to be sure the topic are deleted before recreated with right configuration
-            Thread.sleep(2000);
-            kafkaAdminService.createIfNotExist(cls);
-        }
-
-        QueueInterface<T> queue = (QueueInterface<T>) applicationContext.getBean(
-            QueueInterface.class,
-            Qualifiers.byName(queueName)
-        );
-
-        list.forEach(queue::emit);
-
-        stdOut("Successfully send {0} flows to {1}", list.size(), queueName);
-    }
-}

cli/src/main/java/io/kestra/cli/commands/sys/SubmitQueuedCommand.java

@@ -0,0 +1,66 @@
+package io.kestra.cli.commands.sys;
+
+import io.kestra.cli.AbstractCommand;
+import io.kestra.core.models.executions.Execution;
+import io.kestra.core.models.flows.State;
+import io.kestra.core.queues.QueueFactoryInterface;
+import io.kestra.core.queues.QueueInterface;
+import io.kestra.core.runners.ExecutionQueued;
+import io.kestra.jdbc.runner.AbstractJdbcExecutionQueuedStorage;
+import io.micronaut.context.ApplicationContext;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+import java.util.Optional;
+
+import static io.kestra.core.utils.Rethrow.throwConsumer;
+
+@CommandLine.Command(
+    name = "submit-queued-execution",
+    description = {"Submit all queued execution to the executor",
+        "All queued execution will be submitted to the executor. Warning, if there is still running executions and concurrency limit configured, the executions may be queued again."
+    }
+)
+@Slf4j
+public class SubmitQueuedCommand extends AbstractCommand {
+    @Inject
+    private ApplicationContext applicationContext;
+
+    @Inject
+    @Named(QueueFactoryInterface.EXECUTION_NAMED)
+    private QueueInterface<Execution> executionQueue;
+
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        Optional<String> queueType = applicationContext.getProperty("kestra.queue.type", String.class);
+        if (queueType.isEmpty()) {
+            stdOut("Unable to submit queued executions, the 'kestra.queue.type' configuration is not set");
+            return 0;
+        }
+
+        int cpt = 0;
+        if (queueType.get().equals("kafka")) {
+            stdOut("Unable to submit queued executions, the 'kestra.queue.type' configuration is set to 'kafka', use the corresponding sys-ee command");
+            return 1;
+        }
+        else if (queueType.get().equals("postgres") || queueType.get().equals("mysql") || queueType.get().equals("h2")) {
+            var executionQueuedStorage = applicationContext.getBean(AbstractJdbcExecutionQueuedStorage.class);
+
+            for (ExecutionQueued queued : executionQueuedStorage.getAllForAllTenants()) {
+                executionQueuedStorage.pop(queued.getTenantId(), queued.getNamespace(), queued.getFlowId(), throwConsumer(execution -> executionQueue.emit(execution.withState(State.Type.CREATED))));
+                cpt++;
+            }
+        }
+        else {
+            stdOut("Unable to submit queued executions, the 'kestra.queue.type' is set to an unknown type '{0}'", queueType.get());
+            return 1;
+        }
+
+        stdOut("Successfully submitted {0} queued executions", cpt);
+        return 0;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/sys/SysCommand.java

@@ -1,5 +1,7 @@
 package io.kestra.cli.commands.sys;
 
+import io.kestra.cli.commands.sys.database.DatabaseCommand;
+import io.kestra.cli.commands.sys.statestore.StateStoreCommand;
 import io.micronaut.configuration.picocli.PicocliRunner;
 import lombok.extern.slf4j.Slf4j;
 import io.kestra.cli.AbstractCommand;
@@ -8,19 +10,17 @@ import picocli.CommandLine;
 
 @CommandLine.Command(
     name = "sys",
-    description = "handle systems maintenance",
+    description = "Manage system maintenance mode",
     mixinStandardHelpOptions = true,
     subcommands = {
-        RestoreQueueCommand.class,
-        FlowListenersRestoreCommand.class
+        ReindexCommand.class,
+        DatabaseCommand.class,
+        SubmitQueuedCommand.class,
+        StateStoreCommand.class
     }
 )
 @Slf4j
 public class SysCommand extends AbstractCommand {
-    public SysCommand() {
-        super(false);
-    }
-
     @Override
     public Integer call() throws Exception {
         super.call();

cli/src/main/java/io/kestra/cli/commands/sys/database/DatabaseCommand.java

@@ -0,0 +1,27 @@
+package io.kestra.cli.commands.sys.database;
+
+import io.kestra.cli.AbstractCommand;
+import io.kestra.cli.App;
+import io.micronaut.configuration.picocli.PicocliRunner;
+import lombok.SneakyThrows;
+import picocli.CommandLine;
+
+@CommandLine.Command(
+    name = "database",
+    description = "Manage Kestra database",
+    mixinStandardHelpOptions = true,
+    subcommands = {
+        DatabaseMigrateCommand.class,
+    }
+)
+public class DatabaseCommand extends AbstractCommand {
+    @SneakyThrows
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        PicocliRunner.call(App.class, "sys", "database", "--help");
+
+        return 0;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/sys/database/DatabaseMigrateCommand.java

@@ -0,0 +1,32 @@
+package io.kestra.cli.commands.sys.database;
+
+import io.kestra.cli.AbstractCommand;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+import java.util.Map;
+
+@CommandLine.Command(
+    name = "migrate",
+    description = "Force database schema migration.\nKestra uses Flyway to manage database schema evolution, this command will run Flyway then exit.",
+    mixinStandardHelpOptions = true
+)
+@Slf4j
+public class DatabaseMigrateCommand extends AbstractCommand {
+    @Override
+    public Integer call() throws Exception {
+        // Flyway will run automatically
+        super.call();
+        stdOut("Successfully run the database schema migration.");
+        return 0;
+    }
+
+    public static Map<String, Object> propertiesOverrides() {
+        // Forcing the props to enabled Flyway: it allows to disable Flyway globally and still using this command.
+        return Map.of(
+            "flyway.datasources.postgres.enabled", "true",
+            "flyway.datasources.mysql.enabled", "true",
+            "flyway.datasources.h2.enabled", "true"
+        );
+    }
+}

cli/src/main/java/io/kestra/cli/commands/sys/statestore/StateStoreCommand.java

@@ -0,0 +1,27 @@
+package io.kestra.cli.commands.sys.statestore;
+
+import io.kestra.cli.AbstractCommand;
+import io.kestra.cli.App;
+import io.micronaut.configuration.picocli.PicocliRunner;
+import lombok.SneakyThrows;
+import picocli.CommandLine;
+
+@CommandLine.Command(
+    name = "state-store",
+    description = "Manage Kestra State Store",
+    mixinStandardHelpOptions = true,
+    subcommands = {
+        StateStoreMigrateCommand.class,
+    }
+)
+public class StateStoreCommand extends AbstractCommand {
+    @SneakyThrows
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        PicocliRunner.call(App.class, "sys", "state-store", "--help");
+
+        return 0;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/sys/statestore/StateStoreMigrateCommand.java

@@ -0,0 +1,81 @@
+package io.kestra.cli.commands.sys.statestore;
+
+import io.kestra.cli.AbstractCommand;
+import io.kestra.core.models.flows.Flow;
+import io.kestra.core.repositories.FlowRepositoryInterface;
+import io.kestra.core.runners.RunContext;
+import io.kestra.core.runners.RunContextFactory;
+import io.kestra.core.storages.StateStore;
+import io.kestra.core.storages.StorageInterface;
+import io.kestra.core.utils.Slugify;
+import io.micronaut.context.ApplicationContext;
+import jakarta.inject.Inject;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Stream;
+
+@CommandLine.Command(
+    name = "migrate",
+    description = "Migrate old state store files to use the new KV Store implementation.",
+    mixinStandardHelpOptions = true
+)
+@Slf4j
+public class StateStoreMigrateCommand extends AbstractCommand {
+    @Inject
+    private ApplicationContext applicationContext;
+
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        FlowRepositoryInterface flowRepository = this.applicationContext.getBean(FlowRepositoryInterface.class);
+        StorageInterface storageInterface = this.applicationContext.getBean(StorageInterface.class);
+        RunContextFactory runContextFactory = this.applicationContext.getBean(RunContextFactory.class);
+
+        flowRepository.findAllForAllTenants().stream().map(flow -> Map.entry(flow, List.of(
+            URI.create("/" + flow.getNamespace().replace(".", "/") + "/" + Slugify.of(flow.getId()) + "/states"),
+            URI.create("/" + flow.getNamespace().replace(".", "/") + "/states")
+        ))).map(potentialStateStoreUrisForAFlow -> Map.entry(potentialStateStoreUrisForAFlow.getKey(), potentialStateStoreUrisForAFlow.getValue().stream().flatMap(uri -> {
+            try {
+                return storageInterface.allByPrefix(potentialStateStoreUrisForAFlow.getKey().getTenantId(), potentialStateStoreUrisForAFlow.getKey().getNamespace(), uri, false).stream();
+            } catch (IOException e) {
+                return Stream.empty();
+            }
+        }).toList())).forEach(stateStoreFileUrisForAFlow -> stateStoreFileUrisForAFlow.getValue().forEach(stateStoreFileUri -> {
+            Flow flow = stateStoreFileUrisForAFlow.getKey();
+            String[] flowQualifierWithStateQualifiers = stateStoreFileUri.getPath().split("/states/");
+            String[] statesUriPart = flowQualifierWithStateQualifiers[1].split("/");
+
+            String stateName = statesUriPart[0];
+            String taskRunValue = statesUriPart.length > 2 ? statesUriPart[1] : null;
+            String stateSubName = statesUriPart[statesUriPart.length - 1];
+            boolean flowScoped = flowQualifierWithStateQualifiers[0].endsWith("/" + flow.getId());
+            StateStore stateStore = new StateStore(runContext(runContextFactory, flow), false);
+
+            try (InputStream is = storageInterface.get(flow.getTenantId(), flow.getNamespace(), stateStoreFileUri)) {
+                stateStore.putState(flowScoped, stateName, stateSubName, taskRunValue, is.readAllBytes());
+                storageInterface.delete(flow.getTenantId(), flow.getNamespace(), stateStoreFileUri);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }));
+
+        stdOut("Successfully ran the state-store migration.");
+        return 0;
+    }
+
+    private RunContext runContext(RunContextFactory runContextFactory, Flow flow) {
+        Map<String, String> flowVariables = new HashMap<>();
+        flowVariables.put("tenantId", flow.getTenantId());
+        flowVariables.put("id", flow.getId());
+        flowVariables.put("namespace", flow.getNamespace());
+        return runContextFactory.of(flow, Map.of("flow", flowVariables));
+    }
+}

cli/src/main/java/io/kestra/cli/commands/templates/TemplateCommand.java

@@ -0,0 +1,34 @@
+package io.kestra.cli.commands.templates;
+
+import io.kestra.cli.AbstractCommand;
+import io.kestra.cli.App;
+import io.kestra.cli.commands.templates.namespaces.TemplateNamespaceCommand;
+import io.kestra.core.models.templates.TemplateEnabled;
+import io.micronaut.configuration.picocli.PicocliRunner;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+@CommandLine.Command(
+    name = "template",
+    description = "Manage templates",
+    mixinStandardHelpOptions = true,
+    subcommands = {
+        TemplateNamespaceCommand.class,
+        TemplateValidateCommand.class,
+        TemplateExportCommand.class,
+    }
+)
+@Slf4j
+@TemplateEnabled
+public class TemplateCommand extends AbstractCommand {
+    @SneakyThrows
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        PicocliRunner.call(App.class, "template",  "--help");
+
+        return 0;
+    }
+}

cli/src/main/java/io/kestra/cli/commands/templates/TemplateExportCommand.java

@@ -0,0 +1,62 @@
+package io.kestra.cli.commands.templates;
+
+import io.kestra.cli.AbstractApiCommand;
+import io.kestra.cli.AbstractValidateCommand;
+import io.kestra.core.models.templates.TemplateEnabled;
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.http.HttpRequest;
+import io.micronaut.http.HttpResponse;
+import io.micronaut.http.MediaType;
+import io.micronaut.http.MutableHttpRequest;
+import io.micronaut.http.client.exceptions.HttpClientResponseException;
+import io.micronaut.http.client.netty.DefaultHttpClient;
+import jakarta.inject.Inject;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+@CommandLine.Command(
+    name = "export",
+    description = "Export templates to a ZIP file",
+    mixinStandardHelpOptions = true
+)
+@Slf4j
+@TemplateEnabled
+public class TemplateExportCommand extends AbstractApiCommand {
+    private static final String DEFAULT_FILE_NAME = "templates.zip";
+
+    // @FIXME: Keep it for bug in micronaut that need to have inject on top level command to inject on abstract classe
+    @Inject
+    private ApplicationContext applicationContext;
+
+    @CommandLine.Option(names = {"--namespace"}, description = "The namespace of templates to export")
+    public String namespace;
+
+    @CommandLine.Parameters(index = "0", description = "The directory to export the file to")
+    public Path directory;
+
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        try(DefaultHttpClient client = client()) {
+            MutableHttpRequest<Object> request = HttpRequest
+                .GET(apiUri("/templates/export/by-query") + (namespace != null ? "?namespace=" + namespace : ""))
+                .accept(MediaType.APPLICATION_OCTET_STREAM);
+
+            HttpResponse<byte[]> response = client.toBlocking().exchange(this.requestOptions(request), byte[].class);
+            Path zipFile = Path.of(directory.toString(), DEFAULT_FILE_NAME);
+            zipFile.toFile().createNewFile();
+            Files.write(zipFile, response.body());
+
+            stdOut("Exporting template(s) for namespace '" + namespace + "' successfully done !");
+        } catch (HttpClientResponseException e) {
+            AbstractValidateCommand.handleHttpException(e, "template");
+            return 1;
+        }
+
+        return 0;
+    }
+}