chore(version): update to version 'v0.21.0-rc1-SNAPSHOT'

fix: #7087

.github/CONTRIBUTING.md

@@ -31,8 +31,8 @@ Watch out for duplicates! If you are creating a new issue, please check existing
 
 #### Requirements
 The following dependencies are required to build Kestra locally:
-- Java 17+, Kestra runs on Java 11 but we hit a Java compiler bug fixed in Java 17
-- Node 14+ and npm
+- Java 21+
+- Node 18+ and npm
 - Python 3, pip and python venv
 - Docker & Docker Compose
 - an IDE (Intellij IDEA, Eclipse or VS Code)
@@ -52,14 +52,17 @@ 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 it a lot.
-- The main class is `io.kestra.cli.App` from module `kestra.cli.main`
-- Pass as program arguments the server you want to develop, for example `server local` will start the [standalone local](https://kestra.io/docs/administrator-guide/server-cli#kestra-local-development-server-with-no-dependencies)
-- ![Intellij Idea Configuration ](https://user-images.githubusercontent.com/2064609/161399626-1b681add-cfa8-4e0e-a843-2631cc59758d.png) Intellij Idea configuration can be found in screenshot below.
-  - `MICRONAUT_ENVIRONMENTS`: can be set 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 the startup.
-- You can also use the gradle task `./gradlew runLocal` that will run a standalone server with `MICRONAUT_ENVIRONMENTS=override` and plugins path `local/plugins`
-- The server start by default on port 8080 and is reachable on `http://localhost:8080`
+- 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:
 
@@ -72,14 +75,14 @@ python3 -m pip install virtualenv
 #### Develop frontend
 The frontend is made with [Vue.js](https://vuejs.org/) and located on the `/ui` folder.
 
-- `npm install --force` (force is need because of some conflicting package)
-- create a files `ui/.env.development.local` with content `VITE_APP_API_URL=http://localhost:8080` (or your actual server url)
+- `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 8090 and is reachable on `http://localhost:5173`
+- 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 database using this docker-compose file already configured with CORS enabled:
+- 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:
@@ -99,7 +102,7 @@ services:
     ports:
       - "8080:8080"
 ```
-- start the [Develop backend](#develop-backend) from your IDE and 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`
+- 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:
@@ -133,4 +136,4 @@ A complete documentation for developing plugin can be found [here](https://kestr
 
 ### 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 on 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))
+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/blueprint.yml

@@ -1,54 +0,0 @@
-name: Blueprint
-description: Add a new blueprint
-
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Please fill out all the fields listed below. This will help us review and add your blueprint faster.
-  
-  - type: textarea
-    attributes:
-      label: Blueprint title
-      description: A title briefly describing what the blueprint does, ideally in a verb phrase + noun format.
-      placeholder: E.g. "Upload a file to service X, then run Y and Z"
-    validations:
-      required: true
-  
-  - type: textarea
-    attributes:
-      label: Source code
-      description: Flow code that will appear on the Blueprint page.
-      placeholder: |
-        ```yaml
-        id: yourFlowId
-        namespace: blueprint
-        tasks:
-          - id: taskName
-            type: task_type
-        ```
-    validations:
-      required: true
-  
-  - type: textarea
-    attributes:
-      label: About this blueprint
-      description: "A concise markdown documentation about the blueprint's configuration and usage."
-      placeholder: |
-        E.g. "This flow downloads a file and uploads it to an S3 bucket. This flow assumes AWS credentials stored as environment variables `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`."
-    validations:
-      required: false
-  
-  - type: textarea
-    attributes:
-      label: Tags (optional)
-      description: Blueprint categories such as Ingest, Transform, Analyze, Python, Docker, AWS, GCP, Azure, etc.
-      placeholder: |
-        - Ingest
-        - Transform
-        - AWS
-    validations:
-      required: false
-
-labels:
-  - blueprint

.github/ISSUE_TEMPLATE/bug.yml

@@ -4,9 +4,7 @@ body:
   - type: markdown
     attributes:
       value: |
-        Thanks for reporting an issue! Please provide a [Minima 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.
-        NOTE: If your issue is more of a question, please ping us directly on [Slack](https://kestra.io/slack).
+        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
@@ -19,10 +17,10 @@ body:
       label: Environment
       description: Environment information where the problem occurs.
       value: |
-        - Kestra Version:
-        - Operating System (OS/Docker/Kubernetes):
-        - Java Version (if you don't run kestra in Docker):
+        - Kestra Version: develop
     validations:
       required: false
 labels:
-  - bug
+  - bug
+  - area/backend
+  - area/frontend

.github/ISSUE_TEMPLATE/feature.yml

@@ -1,15 +1,13 @@
 name: Feature request
 description: Create a new feature request
 body:
-  - type: markdown
-    attributes:
-      value: |
-        Please describe the feature you want for Kestra to implement, before that check if there is already an existing issue to add it.
   - type: textarea
     attributes:
       label: Feature description
-      placeholder: Tell us what feature you would like for Kestra to have and what problem is it going to solve
+      placeholder: Tell us more about your feature request
     validations:
       required: true
 labels:
   - enhancement
+  - area/backend
+  - area/frontend

.github/ISSUE_TEMPLATE/other.yml

@@ -1,8 +0,0 @@
-name: Other
-description: Something different
-body:
-  - type: textarea
-    attributes:
-      label: Issue description
-    validations:
-      required: true

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

@@ -13,6 +13,9 @@ 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:
@@ -20,5 +23,7 @@ runs:
       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" | xargs || echo '');
+        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/dependabot.yml

@@ -32,11 +32,7 @@ updates:
       timezone: "Europe/Paris"
     open-pull-requests-limit: 50
     labels: ["dependency-upgrade"]
-    reviewers: ["MilosPaunovic"]
     ignore:
       # Ignore updates of version 1.x, as we're using beta of 2.x
       - dependency-name: "vue-virtual-scroller"
         versions: ["1.x"]
-      # Ignore major versions greater than 8, as it's still known to be flaky
-      - dependency-name: "eslint"
-        versions: [">8"]

.github/workflows/check.yml

@@ -9,6 +9,8 @@ jobs:
     env:
       SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
       GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
+      # to save corepack from itself
+      COREPACK_INTEGRITY_KEYS: 0
     name: Check & Publish
     runs-on: ubuntu-latest
     timeout-minutes: 60
@@ -65,10 +67,10 @@ jobs:
         with:
           credentials_json: '${{ secrets.GOOGLE_SERVICE_ACCOUNT }}'
 
-      - uses: rlespinasse/github-slug-action@v4
+      - uses: rlespinasse/github-slug-action@v5
 
       - name: Publish allure report
-        uses: andrcuns/allure-publish-action@v2.7.1
+        uses: andrcuns/allure-publish-action@v2.9.0
         if: ${{ always() && env.GOOGLE_SERVICE_ACCOUNT != 0 && (github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '') }}
         env:
           GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -77,33 +79,33 @@ jobs:
           storageType: gcs
           resultsGlob: "**/build/allure-results"
           bucket: internal-kestra-host
-          baseUrl: "https://internal.kestra.io"
-          prefix: ${{ format('{0}/{1}/{2}', github.repository, env.GITHUB_HEAD_REF_SLUG != '' && env.GITHUB_HEAD_REF_SLUG || github.ref_name, 'allure/java') }}
+          baseUrl: "https://internal.dev.kestra.io"
+          prefix: ${{ format('{0}/{1}', github.repository, 'allure/java') }}
           copyLatest: true
           ignoreMissingResults: true
 
       # Jacoco
       - name: 'Set up Cloud SDK'
-        if: ${{ env.GOOGLE_SERVICE_ACCOUNT != 0 && (github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '') }}
+        if: ${{ github.ref == 'refs/heads/develop' && env.GOOGLE_SERVICE_ACCOUNT != 0 && (github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '') }}
         uses: 'google-github-actions/setup-gcloud@v2'
 
       - name: 'Copy jacoco files'
-        if: ${{ env.GOOGLE_SERVICE_ACCOUNT != 0 && (github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '') }}
+        if: ${{ github.ref == 'refs/heads/develop' && env.GOOGLE_SERVICE_ACCOUNT != 0 && (github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '') }}
         run: |
           mv build/reports/jacoco/testCodeCoverageReport build/reports/jacoco/test/
-          mv build/reports/jacoco/test/testCodeCoverageReport.xml build/reports/jacoco/jacocoTestReport.xml
-          gsutil -m rsync -d -r  build/reports/jacoco/test/ gs://internal-kestra-host/${{ format('{0}/{1}/{2}', github.repository, env.GITHUB_HEAD_REF_SLUG != '' && env.GITHUB_HEAD_REF_SLUG || github.ref_name, 'jacoco') }}
+          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') }}
 
 
       # report test
       - name: Test Report
-        uses: mikepenz/action-junit-report@v4
+        uses: mikepenz/action-junit-report@v5
         if: success() || failure()
         with:
           report_paths: '**/build/test-results/**/TEST-*.xml'
 
       # Codecov
-      - uses: codecov/codecov-action@v4
+      - uses: codecov/codecov-action@v5
         if: ${{ github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '' }}
         with:
           token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/docker.yml

@@ -1,4 +1,4 @@
-name: Create Docker images on tag
+name: Create Docker images on Release
 
 on:
   workflow_dispatch:
@@ -11,6 +11,10 @@ on:
         options:
           - "true"
           - "false"
+      release-tag:
+        description: 'Kestra Release Tag'
+        required: false
+        type: string
       plugin-version:
         description: 'Plugin version'
         required: false
@@ -38,7 +42,6 @@ jobs:
     name: Publish Docker
     needs: [ plugins ]
     runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/v')
     strategy:
       matrix:
         image:
@@ -57,10 +60,19 @@ jobs:
       - name: Set image name
         id: vars
         run: |
-          TAG=${GITHUB_REF#refs/*/}
-          echo "tag=${TAG}" >> $GITHUB_OUTPUT
-          echo "plugins=${{ matrix.image.plugins }}" >> $GITHUB_OUTPUT
-
+          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.11

.github/workflows/e2e.yml

@@ -146,10 +146,10 @@ jobs:
         with:
           credentials_json: '${{ secrets.GOOGLE_SERVICE_ACCOUNT }}'
 
-      - uses: rlespinasse/github-slug-action@v4
+      - uses: rlespinasse/github-slug-action@v5
 
       - name: Publish allure report
-        uses: andrcuns/allure-publish-action@v2.7.1
+        uses: andrcuns/allure-publish-action@v2.9.0
         if: ${{ !cancelled() && env.GOOGLE_SERVICE_ACCOUNT != 0 }}
         env:
           GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_AUTH_TOKEN }}
@@ -158,7 +158,7 @@ jobs:
           storageType: gcs
           resultsGlob: build/allure-results
           bucket: internal-kestra-host
-          baseUrl: "https://internal.kestra.io"
+          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

@@ -1,45 +1,111 @@
 name: Generate Translations
 
 on:
+  pull_request:
+    types: [opened, synchronize]
+    paths:
+      - "ui/src/translations/en.json"
+
   push:
     branches:
       - develop
-    paths:
-      - 'ui/src/translations/en.json'
 
 env:
   OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
 
 jobs:
-  generate-translations:
-    name: Generate Translations and Create PR
+  commit:
+    name: Commit directly to PR
     runs-on: ubuntu-latest
+    if: ${{ github.event.pull_request.head.repo.fork == false }}
     steps:
-    - name: Checkout code
-      uses: actions/checkout@v4
-      with:
-        fetch-depth: 10  # Ensures that at least 10 commits are fetched for comparison
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 50
+          ref: ${{ github.head_ref }}
 
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.x'
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
 
-    - name: Install dependencies
-      run: pip install gitpython openai
+      - name: Install Python dependencies
+        run: pip install gitpython openai
 
-    - name: Generate translations
-      run: python ui/src/translations/generate_translations.py
+      - name: Generate translations
+        run: python ui/src/translations/generate_translations.py
 
-    - name: Commit, push changes, and create PR
-      env:
-        GH_TOKEN: ${{ github.token }}
-      run: |
-        git config --global user.name "GitHub Action"
-        git config --global user.email "actions@github.com"
-        BRANCH_NAME="translations/update-translations-$(date +%s)"
-        git checkout -b $BRANCH_NAME
-        git add ui/src/translations/*.json
-        git commit -m "Auto-generate translations from en.json"
-        git push --set-upstream origin $BRANCH_NAME
-        gh pr create --title "Auto-generate 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
+      - 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: Check for changes and commit
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          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(translations): auto generate values for languages other than english"
+          git push origin ${{ github.head_ref }}
+
+  pull_request:
+    name: Open PR for a forked repository
+    runs-on: ubuntu-latest
+    if: ${{ github.event.pull_request.head.repo.fork == true }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 10
+
+      - 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
+
+      - 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: Create and push a new branch
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          BRANCH_NAME="generated-translations-${{ github.event.pull_request.head.repo.name }}"
+
+          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(translations): auto generate values for languages other than english"
+          git push origin $BRANCH_NAME

.github/workflows/main.yml

@@ -10,19 +10,19 @@ on:
     branches:
       - develop
   repository_dispatch:
-    types: [ rebuild ]
+    types: [rebuild]
   workflow_dispatch:
     inputs:
       skip-test:
-        description: 'Skip test'
+        description: "Skip test"
         type: choice
         required: true
-        default: 'false'
+        default: "false"
         options:
           - "true"
           - "false"
       plugin-version:
-        description: 'Plugin version'
+        description: "Plugin version"
         required: false
         type: string
         default: "LATEST"
@@ -31,32 +31,41 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 env:
-  JAVA_VERSION: '21'
+  JAVA_VERSION: "21"
   DOCKER_APT_PACKAGES: python3 python3-venv python-is-python3 python3-pip nodejs npm curl zip unzip
   DOCKER_PYTHON_LIBRARIES: kestra
   PLUGIN_VERSION: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
+  # to save corepack from itself
+  COREPACK_INTEGRITY_KEYS: 0
 jobs:
   build-artifacts:
     name: Build Artifacts
     runs-on: ubuntu-latest
     timeout-minutes: 60
     outputs:
-      docker-tag:  ${{ steps.vars.outputs.tag }}
-      docker-artifact-name:  ${{ steps.vars.outputs.artifact }}
+      docker-tag: ${{ steps.vars.outputs.tag }}
+      docker-artifact-name: ${{ steps.vars.outputs.artifact }}
       plugins: ${{ steps.plugins-list.outputs.plugins }}
     steps:
-      # Checkout
-      - uses: actions/checkout@v4
+
+      - name: Checkout current ref
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
-      # Checkout GitHub Actions
-      - uses: actions/checkout@v4
+      - name: Checkout GitHub Actions
+        uses: actions/checkout@v4
         with:
           repository: kestra-io/actions
           path: actions
           ref: main
 
+      # Npm
+      - name: Npm install
+        shell: bash
+        working-directory: ui
+        run: npm ci
+
       # Setup build
       - uses: ./actions/.github/actions/setup-build
         id: build
@@ -68,6 +77,7 @@ jobs:
       # Get Plugins List
       - name: Get Plugins List
         uses: ./.github/actions/plugins-list
+        if: "!startsWith(github.ref, 'refs/tags/v')"
         id: plugins-list
         with:
           plugin-version: ${{ env.PLUGIN_VERSION }}
@@ -75,6 +85,7 @@ jobs:
       # Set Plugins List
       - name: Set Plugin List
         id: plugins
+        if: "!startsWith(github.ref, 'refs/tags/v')"
         run: |
           PLUGINS="${{ steps.plugins-list.outputs.plugins }}"
           TAG=${GITHUB_REF#refs/*/}
@@ -83,6 +94,7 @@ jobs:
           else
             echo "plugins=--repositories=https://s01.oss.sonatype.org/content/repositories/snapshots $PLUGINS" >> $GITHUB_OUTPUT
           fi
+
       # Build
       - name: Build with Gradle
         run: |
@@ -122,6 +134,7 @@ jobs:
       # Docker Build
       - name: Build & Export Docker Image
         uses: docker/build-push-action@v6
+        if: "!startsWith(github.ref, 'refs/tags/v')"
         with:
           context: .
           push: false
@@ -149,14 +162,58 @@ jobs:
 
       - name: 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
+
+
+  check-frontend:
+    name: Run frontend tests
+    runs-on: ubuntu-latest
+    steps:
+      - 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_TOKEN }}
+          reporter: github-pr-review # Change reporter.
+          workdir: "ui"
+
+      - name: Run front-end unit tests
+        shell: bash
+        working-directory: ui
+        run: npm run test:unit
+
+      - name: Install Playwright
+        shell: bash
+        working-directory: ui
+        run: npx playwright install --with-deps
+
+      - name: Build Storybook
+        shell: bash
+        working-directory: ui
+        run: npm run build-storybook --quiet
+
+      - name: Serve Storybook and run tests
+        shell: bash
+        working-directory: ui
+        run: |
+          npx concurrently -k -s first -n "SB,TEST" -c "magenta,blue" \
+            "npx http-server storybook-static --port 6006 --silent" \
+            "npx wait-on tcp:127.0.0.1:6006 && npm run test-storybook"
+
   # Run Reusable Workflow from QA repository
   check-e2e:
     name: Check E2E Tests
     needs: build-artifacts
-    if: ${{ github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '' }}
+    if: ${{ (github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '') && !startsWith(github.ref, 'refs/tags/v') }}
     uses: ./.github/workflows/e2e.yml
     strategy:
       fail-fast: false
@@ -226,14 +283,14 @@ jobs:
       - name: Auth to Google Cloud
         id: auth
         if: ${{ always() && env.GOOGLE_SERVICE_ACCOUNT != 0 }}
-        uses: 'google-github-actions/auth@v2'
+        uses: "google-github-actions/auth@v2"
         with:
-          credentials_json: '${{ secrets.GOOGLE_SERVICE_ACCOUNT }}'
+          credentials_json: "${{ secrets.GOOGLE_SERVICE_ACCOUNT }}"
 
-      - uses: rlespinasse/github-slug-action@v4
+      - uses: rlespinasse/github-slug-action@v5
 
       - name: Publish allure report
-        uses: andrcuns/allure-publish-action@v2.7.1
+        uses: andrcuns/allure-publish-action@v2.9.0
         if: ${{ always() && env.GOOGLE_SERVICE_ACCOUNT != 0 && (github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '') }}
         env:
           GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -242,32 +299,32 @@ jobs:
           storageType: gcs
           resultsGlob: "**/build/allure-results"
           bucket: internal-kestra-host
-          baseUrl: "https://internal.kestra.io"
-          prefix: ${{ format('{0}/{1}/{2}', github.repository, env.GITHUB_HEAD_REF_SLUG != '' && env.GITHUB_HEAD_REF_SLUG || github.ref_name, 'allure/java') }}
+          baseUrl: "https://internal.dev.kestra.io"
+          prefix: ${{ format('{0}/{1}', github.repository, 'allure/java') }}
           copyLatest: true
           ignoreMissingResults: true
 
       # Jacoco
-      - name: 'Set up Cloud SDK'
+      - name: "Set up Cloud SDK"
         if: ${{ env.GOOGLE_SERVICE_ACCOUNT != 0 && (github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '') }}
-        uses: 'google-github-actions/setup-gcloud@v2'
+        uses: "google-github-actions/setup-gcloud@v2"
 
-      - name: 'Copy jacoco files'
+      - name: "Copy jacoco files"
         if: ${{ env.GOOGLE_SERVICE_ACCOUNT != 0 && (github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '') }}
         run: |
           mv build/reports/jacoco/testCodeCoverageReport build/reports/jacoco/test/
-          mv build/reports/jacoco/test/testCodeCoverageReport.xml build/reports/jacoco/jacocoTestReport.xml
-          gsutil -m rsync -d -r  build/reports/jacoco/test/ gs://internal-kestra-host/${{ format('{0}/{1}/{2}', github.repository, env.GITHUB_HEAD_REF_SLUG != '' && env.GITHUB_HEAD_REF_SLUG || github.ref_name, 'jacoco') }}
+          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') }}
 
       # report test
       - name: Test Report
-        uses: mikepenz/action-junit-report@v4
+        uses: mikepenz/action-junit-report@v5
         if: success() || failure()
         with:
-          report_paths: '**/build/test-results/**/TEST-*.xml'
+          report_paths: "**/build/test-results/**/TEST-*.xml"
 
       # Codecov
-      - uses: codecov/codecov-action@v4
+      - uses: codecov/codecov-action@v5
         if: ${{ github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '' }}
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
@@ -275,8 +332,15 @@ jobs:
   release:
     name: Github Release
     runs-on: ubuntu-latest
-    needs: [ check, check-e2e ]
-    if: startsWith(github.ref, 'refs/tags/v')
+    needs: [check, check-e2e]
+    if: |
+      always() &&
+      startsWith(github.ref, 'refs/tags/v') &&
+      needs.check.result == 'success' &&
+      (
+        github.event.inputs.skip-test == 'true' ||
+        (needs.check-e2e.result == 'skipped' || needs.check-e2e.result == 'success')
+      )
     steps:
       # Download Exec
       - name: Download executable
@@ -288,6 +352,7 @@ jobs:
 
       # GitHub Release
       - name: Create GitHub release
+        id: create_github_release
         uses: "marvinpinto/action-automatic-releases@latest"
         if: startsWith(github.ref, 'refs/tags/v')
         continue-on-error: true
@@ -297,11 +362,33 @@ jobs:
           files: |
             build/executable/*
 
+      # Trigger gha workflow to bump helm chart version
+      - name: 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 }}"
+            }
+
   docker:
     name: Publish Docker
     runs-on: ubuntu-latest
     needs: [build-artifacts, check, check-e2e]
-    if: github.ref == 'refs/heads/develop'
+    if: |
+      always() &&
+      github.ref == 'refs/heads/develop' &&
+      needs.check.result == 'success' &&
+      (
+        github.event.inputs.skip-test == 'true' ||
+        (needs.check-e2e.result == 'skipped' || needs.check-e2e.result == 'success')
+      )
     strategy:
       matrix:
         image:
@@ -368,7 +455,14 @@ jobs:
     name: Publish to Maven
     runs-on: ubuntu-latest
     needs: [check, check-e2e]
-    if: github.ref == 'refs/heads/develop' || startsWith(github.ref, 'refs/tags/v')
+    if: |
+      always() &&
+      (github.ref == 'refs/heads/develop' || startsWith(github.ref, 'refs/tags/v')) &&
+      needs.check.result == 'success' &&
+      (
+        github.event.inputs.skip-test == 'true' ||
+        (needs.check-e2e.result == 'skipped' || needs.check-e2e.result == 'success')
+      )
     steps:
       - uses: actions/checkout@v4
 
@@ -431,7 +525,6 @@ jobs:
     env:
       SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
     steps:
-
       # Update
       - name: Update internal
         uses: benc-uk/workflow-dispatch@v1
@@ -450,5 +543,5 @@ jobs:
           repo_token: ${{ secrets.GITHUB_TOKEN }}
           slack_webhook_url: ${{ secrets.SLACK_WEBHOOK_URL }}
           name: GitHub Actions
-          icon_emoji: ':github-actions:'
-          channel: 'C02DQ1A7JLR' # _int_git channel
+          icon_emoji: ":github-actions:"
+          channel: "C02DQ1A7JLR" # _int_git channel

.github/workflows/release-plugins.yml

@@ -0,0 +1,69 @@
+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: kestra-private-standard
+    steps:
+      # Checkout
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # 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
+        if: "!startsWith(github.ref, 'refs/tags/v')"
+        id: plugins-list
+        with:
+          plugin-version: 'LATEST'
+
+      # Execute
+      - name: Run Gradle Release
+        if: ${{ github.event.inputs.dryRun == 'false' }}
+        env:
+          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
+        run: |
+          chmod +x ./release-plugins.sh;
+          ./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 ./release-plugins.sh;
+          ./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/tag-plugins.yml

@@ -0,0 +1,63 @@
+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: kestra-private-standard
+    steps:
+      # Checkout
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # 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
+        if: "!startsWith(github.ref, 'refs/tags/v')"
+        id: plugins-list
+        with:
+          plugin-version: 'LATEST'
+
+      # Execute
+      - name: Set Version and Tag Plugins
+        if: ${{ github.event.inputs.dryRun == 'false' }}
+        env:
+          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
+        run: |
+          chmod +x ./tag-release-plugins.sh;
+          ./tag-release-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 ./tag-release-plugins.sh;
+          ./tag-release-plugins.sh \
+          --release-version=${{github.event.inputs.releaseVersion}} \
+          --dry-run \
+          --yes \
+          ${{ steps.plugins-list.outputs.repositories }}

.github/workflows/vulnerabilities-check.yml

@@ -35,6 +35,8 @@ jobs:
 
       # Run OWASP dependency check plugin
       - name: Gradle Dependency Check
+        env:
+          NVD_API_KEY: ${{ secrets.NIST_APIKEY }}
         run: |
           ./gradlew dependencyCheckAggregate
 
@@ -72,7 +74,7 @@ jobs:
 
       # Run Trivy image scan for Docker vulnerabilities, see https://github.com/aquasecurity/trivy-action
       - name: Docker Vulnerabilities Check
-        uses: aquasecurity/trivy-action@0.24.0
+        uses: aquasecurity/trivy-action@0.29.0
         with:
           image-ref: kestra/kestra:develop
           format: table
@@ -105,7 +107,7 @@ jobs:
 
       # Run Trivy image scan for Docker vulnerabilities, see https://github.com/aquasecurity/trivy-action
       - name: Docker Vulnerabilities Check
-        uses: aquasecurity/trivy-action@0.24.0
+        uses: aquasecurity/trivy-action@0.29.0
         with:
           image-ref: kestra/kestra:latest
           format: table

.gitignore

@@ -54,3 +54,5 @@ core/src/main/resources/gradle.properties
 
 # Allure Reports
 **/allure-results/*
+
+*storybook.log

.plugins

@@ -1,102 +1,105 @@
 #
 # 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:
-#
-#io.kestra.plugin:plugin-airbyte:LATEST
-#io.kestra.plugin:plugin-airflow:LATEST
-#io.kestra.plugin:plugin-amqp:LATEST
-#io.kestra.plugin:plugin-ansible:LATEST
-#io.kestra.plugin:plugin-aws:LATEST
-#io.kestra.plugin:plugin-azure:LATEST
-#io.kestra.plugin:plugin-cassandra:LATEST
-#io.kestra.plugin:plugin-cloudquery:LATEST
-#io.kestra.plugin:plugin-compress:LATEST
-#io.kestra.plugin:plugin-couchbase:LATEST
-#io.kestra.plugin:plugin-crypto:LATEST
-#io.kestra.plugin:plugin-databricks:LATEST
-#io.kestra.plugin:plugin-datahub:LATEST
-#io.kestra.plugin:plugin-dataform:LATEST
-#io.kestra.plugin:plugin-dbt:LATEST
-#io.kestra.plugin:plugin-debezium-db2:LATEST
-#io.kestra.plugin:plugin-debezium-mongodb:LATEST
-#io.kestra.plugin:plugin-debezium-mysql:LATEST
-#io.kestra.plugin:plugin-debezium-oracle:LATEST
-#io.kestra.plugin:plugin-debezium-postgres:LATEST
-#io.kestra.plugin:plugin-debezium-sqlserver:LATEST
-#io.kestra.plugin:plugin-docker:LATEST
-#io.kestra.plugin:plugin-elasticsearch:LATEST
-#io.kestra.plugin:plugin-fivetran:LATEST
-#io.kestra.plugin:plugin-fs:LATEST
-#io.kestra.plugin:plugin-gcp:LATEST
-#io.kestra.plugin:plugin-git:LATEST
-#io.kestra.plugin:plugin-github:LATEST
-#io.kestra.plugin:plugin-googleworkspace:LATEST
-#io.kestra.plugin:plugin-hightouch:LATEST
-#io.kestra.plugin:plugin-hubspot:LATEST
-#io.kestra.plugin:plugin-jdbc-as400:LATEST
-#io.kestra.plugin:plugin-jdbc-clickhouse:LATEST
-#io.kestra.plugin:plugin-jdbc-db2:LATEST
-#io.kestra.plugin:plugin-jdbc-duckdb:LATEST
-#io.kestra.plugin:plugin-jdbc-druid:LATEST
-#io.kestra.plugin:plugin-jdbc-mysql:LATEST
-#io.kestra.plugin:plugin-jdbc-oracle:LATEST
-#io.kestra.plugin:plugin-jdbc-pinot:LATEST
-#io.kestra.plugin:plugin-jdbc-postgres:LATEST
-#io.kestra.plugin:plugin-jdbc-redshift:LATEST
-#io.kestra.plugin:plugin-jdbc-snowflake:LATEST
-#io.kestra.plugin:plugin-jdbc-sqlserver:LATEST
-#io.kestra.plugin:plugin-jdbc-trino:LATEST
-#io.kestra.plugin:plugin-jdbc-vectorwise:LATEST
-#io.kestra.plugin:plugin-jdbc-vertica:LATEST
-#io.kestra.plugin:plugin-jdbc-dremio:LATEST
-#io.kestra.plugin:plugin-jdbc-arrow-flight:LATEST
-#io.kestra.plugin:plugin-jdbc-sqlite:LATEST
-#io.kestra.plugin:plugin-jdbc-sybase:LATEST
-#io.kestra.plugin:plugin-jira:LATEST
-#io.kestra.plugin:plugin-kafka:LATEST
-#io.kestra.plugin:plugin-kubernetes:LATEST
-#io.kestra.plugin:plugin-ldap:LATEST
-#io.kestra.plugin:plugin-linear:LATEST
-#io.kestra.plugin:plugin-malloy:LATEST
-#io.kestra.plugin:plugin-meilisearch:LATEST
-#io.kestra.plugin:plugin-minio:LATEST
-#io.kestra.plugin:plugin-modal:LATEST
-#io.kestra.plugin:plugin-mongodb:LATEST
-#io.kestra.plugin:plugin-mqtt:LATEST
-#io.kestra.plugin:plugin-nats:LATEST
-#io.kestra.plugin:plugin-neo4j:LATEST
-#io.kestra.plugin:plugin-notifications:LATEST
-#io.kestra.plugin:plugin-openai:LATEST
-#io.kestra.plugin:plugin-powerbi:LATEST
-#io.kestra.plugin:plugin-pulsar:LATEST
-#io.kestra.plugin:plugin-redis:LATEST
-#io.kestra.plugin:plugin-script-groovy:LATEST
-#io.kestra.plugin:plugin-script-jbang:LATEST
-#io.kestra.plugin:plugin-script-julia:LATEST
-#io.kestra.plugin:plugin-script-jython:LATEST
-#io.kestra.plugin:plugin-script-nashorn:LATEST
-#io.kestra.plugin:plugin-script-node:LATEST
-#io.kestra.plugin:plugin-script-powershell:LATEST
-#io.kestra.plugin:plugin-script-python:LATEST
-#io.kestra.plugin:plugin-script-r:LATEST
-#io.kestra.plugin:plugin-script-ruby:LATEST
-#io.kestra.plugin:plugin-script-shell:LATEST
-#io.kestra.plugin:plugin-serdes:LATEST
-#io.kestra.plugin:plugin-servicenow:LATEST
-#io.kestra.plugin:plugin-singer:LATEST
-#io.kestra.plugin:plugin-soda:LATEST
-#io.kestra.plugin:plugin-solace:LATEST
-#io.kestra.plugin:plugin-spark:LATEST
-#io.kestra.plugin:plugin-sqlmesh:LATEST
-#io.kestra.plugin:plugin-surrealdb:LATEST
-#io.kestra.plugin:plugin-terraform:LATEST
-#io.kestra.plugin:plugin-transform-grok:LATEST
-#io.kestra.plugin:plugin-transform-json:LATEST
-#io.kestra.plugin:plugin-tika:LATEST
-#io.kestra.plugin:plugin-weaviate:LATEST
-#io.kestra.plugin:plugin-zendesk:LATEST
-#io.kestra.storage:storage-azure:LATEST
-#io.kestra.storage:storage-gcs:LATEST
-#io.kestra.storage:storage-minio:LATEST
-#io.kestra.storage:storage-s3:LATEST
+#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-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-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 @@
+**/*.*

Makefile

@@ -67,6 +67,7 @@ install-plugins:
 		[[ $$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 \

README.md

@@ -19,7 +19,7 @@
 <br />
 
 <p align="center">
-    <a href="https://twitter.com/kestra_io"><img height="25" src="https://kestra.io/twitter.svg" alt="twitter" /></a> &nbsp;
+    <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>
@@ -74,6 +74,27 @@ docker run --pull=always --rm -it -p 8080:8080 --user=root \
   -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!
@@ -142,7 +163,7 @@ Kestra provides an intuitive UI that allows you to interactively build and visua
 
 - **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.
+- **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.
 
 ---
@@ -167,9 +188,9 @@ Create custom plugins to extend Kestra's capabilities. Check out our [Plugin Dev
 Stay connected and get support:
 
 - **Slack:** Join our [Slack community](https://kestra.io/slack) to ask questions and share ideas.
-- **Twitter:** Follow us on [Twitter](https://twitter.com/kestra_io) for the latest updates.
-- **YouTube:** Subscribe to our [YouTube channel](https://www.youtube.com/@kestra-io) for tutorials and webinars.
-- **LinkedIn:** Connect with us on [LinkedIn](https://www.linkedin.com/company/kestra/).
+- **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.
 
 ---
 
@@ -178,8 +199,9 @@ Stay connected and get support:
 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) to start contributing.
+- **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.
 
 ---
 

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,4 +1,5 @@
 import net.e175.klaus.zip.ZipPrefixer
+import org.owasp.dependencycheck.gradle.extension.AnalyzerExtension
 
 buildscript {
     repositories {
@@ -15,30 +16,30 @@ plugins {
     id "java"
     id 'java-library'
     id "idea"
-    id "com.github.johnrengelman.shadow" version "8.1.1"
+    id "com.gradleup.shadow" version "8.3.5"
     id "application"
 
     // test
     id "com.adarshr.test-logger" version "4.0.0"
-    id "org.sonarqube" version "5.1.0.4882"
+    id "org.sonarqube" version "6.0.1.5171"
     id 'jacoco-report-aggregation'
 
     // helper
-    id "com.github.ben-manes.versions" version "0.51.0"
+    id "com.github.ben-manes.versions" version "0.52.0"
 
     // front
-    id 'org.siouan.frontend-jdk17' version '8.1.0' apply false
+    id 'org.siouan.frontend-jdk21' version '10.0.0' apply false
 
     // release
     id "io.github.gradle-nexus.publish-plugin" version "2.0.0"
-    id 'net.researchgate.release' version '3.0.2'
+    id 'net.researchgate.release' version '3.1.0'
     id "com.gorylenko.gradle-git-properties" version "2.4.2"
     id 'signing'
     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 "10.0.4" apply false
+    id "org.owasp.dependencycheck" version "12.0.1" apply false
 }
 
 idea {
@@ -51,9 +52,17 @@ idea {
 /**********************************************************************************************************************\
  * Main
  **********************************************************************************************************************/
-mainClassName = "io.kestra.cli.App"
-sourceCompatibility = 21
-targetCompatibility = 21
+final mainClassName = "io.kestra.cli.App"
+final targetJavaVersion = JavaVersion.VERSION_21
+
+application {
+    mainClass = mainClassName
+}
+
+java {
+    sourceCompatibility = targetJavaVersion
+    targetCompatibility = targetJavaVersion
+}
 
 dependencies {
     implementation project(":cli")
@@ -67,8 +76,10 @@ allprojects {
     if (it.name != 'platform') {
         group "io.kestra"
 
-        sourceCompatibility = 21
-        targetCompatibility = 21
+        java {
+            sourceCompatibility = targetJavaVersion
+            targetCompatibility = targetJavaVersion
+        }
 
         repositories {
             mavenCentral()
@@ -110,8 +121,10 @@ allprojects {
             micronaut "io.micronaut:micronaut-management"
             micronaut "io.micrometer:micrometer-core"
             micronaut "io.micronaut.micrometer:micronaut-micrometer-registry-prometheus"
+            micronaut "io.micronaut.micrometer:micronaut-micrometer-registry-otlp"
             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"
@@ -122,6 +135,9 @@ allprojects {
             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'
@@ -153,8 +169,10 @@ subprojects {
     if (it.name != 'platform') {
         apply plugin: "com.adarshr.test-logger"
 
-        sourceCompatibility = 21
-        targetCompatibility = 21
+        java {
+            sourceCompatibility = targetJavaVersion
+            targetCompatibility = targetJavaVersion
+        }
 
         dependencies {
             // Platform
@@ -184,7 +202,8 @@ subprojects {
         test {
             useJUnitPlatform()
 
-            maxHeapSize = "4048m"
+            // set Xmx for test workers
+            maxHeapSize = '4g'
 
             // configure en_US default locale for tests
             systemProperty 'user.language', 'en'
@@ -325,12 +344,17 @@ dependencyCheck {
     failBuildOnCVSS = 7
 
     // disable the .NET assembly analyzer as otherwise it wants to analyze EXE file
-    analyzers {
-        assemblyEnabled = false
-    }
+    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")
 }
 
 /**********************************************************************************************************************\
@@ -338,7 +362,7 @@ dependencyCheck {
  **********************************************************************************************************************/
 allprojects {
     gradle.projectsEvaluated {
-        tasks.withType(JavaCompile) {
+        tasks.withType(JavaCompile).configureEach {
             options.encoding = "UTF-8"
             options.compilerArgs.add("-parameters")
             options.compilerArgs.add("-Xlint:all")
@@ -347,7 +371,7 @@ allprojects {
     }
 }
 
-tasks.withType(JavaCompile) {
+tasks.withType(JavaCompile).configureEach {
     options.encoding = "UTF-8"
     options.compilerArgs.add("-parameters")
 }
@@ -392,20 +416,25 @@ 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.setBytes(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())
@@ -417,13 +446,13 @@ task writeExecutableJar() {
     }
 }
 
-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)
@@ -432,8 +461,9 @@ task executableJar(type: Zip) {
 /**********************************************************************************************************************\
  * Standalone
  **********************************************************************************************************************/
-task runLocal(type: JavaExec) {
+tasks.register('runLocal', JavaExec) {
     group = "application"
+    description = "Run Kestra as server local"
     classpath = project(":cli").sourceSets.main.runtimeClasspath
     mainClass = mainClassName
     environment 'MICRONAUT_ENVIRONMENTS', 'override'
@@ -468,7 +498,7 @@ subprojects {
         }
     }
 
-    task sourcesJar(type: Jar) {
+    tasks.register('sourcesJar', Jar) {
         dependsOn = [':core:copyGradleProperties']
         dependsOn = [':ui:assembleFrontend']
         archiveClassifier.set('sources')
@@ -477,14 +507,19 @@ subprojects {
     sourcesJar.dependsOn ':core:copyGradleProperties'
     sourcesJar.dependsOn ':ui:assembleFrontend'
 
-    task javadocJar(type: Jar) {
+    tasks.register('javadocJar', Jar) {
         archiveClassifier.set('javadoc')
         from javadoc
     }
 
-    task testsJar(type: Jar) {
+    tasks.register('testsJar', Jar) {
+        group = 'build'
+        description = 'Build the tests jar'
+
         archiveClassifier.set('tests')
-        from sourceSets.test.output
+        if (sourceSets.matching { it.name == 'test'}) {
+            from sourceSets.named('test').get().output
+        }
     }
 
     github {
@@ -560,4 +595,13 @@ release {
     git {
         requireBranch.set('develop')
     }
+
+    // Dynamically set properties with default values
+    failOnSnapshotDependencies = (project.hasProperty('release.failOnSnapshotDependencies')
+            ? project.property('release.failOnSnapshotDependencies').toBoolean()
+            : true)
+
+    pushReleaseVersionBranch = (project.hasProperty('release.pushReleaseVersionBranch')
+            ? project.property('release.pushReleaseVersionBranch').toString()
+            : null)
 }

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

@@ -14,6 +14,9 @@ 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;
@@ -79,4 +82,12 @@ public abstract class AbstractApiCommand extends AbstractCommand {
 
         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/AbstractValidateCommand.java

@@ -1,9 +1,8 @@
 package io.kestra.cli;
 
-import io.kestra.cli.commands.flows.FlowValidateCommand;
 import io.kestra.core.models.validations.ModelValidator;
 import io.kestra.core.models.validations.ValidateConstraintViolation;
-import io.kestra.core.serializers.YamlFlowParser;
+import io.kestra.core.serializers.YamlParser;
 import io.micronaut.core.type.Argument;
 import io.micronaut.http.HttpRequest;
 import io.micronaut.http.MediaType;
@@ -63,7 +62,7 @@ public abstract class AbstractValidateCommand extends AbstractApiCommand {
     public static String buildYamlBody(Path directory) throws IOException {
         try(var files = Files.walk(directory)) {
             return files.filter(Files::isRegularFile)
-                .filter(YamlFlowParser::isValidExtension)
+                .filter(YamlParser::isValidExtension)
                 .map(throwFunction(path -> Files.readString(path, Charset.defaultCharset())))
                 .collect(Collectors.joining("\n---\n"));
         }
@@ -72,10 +71,11 @@ public abstract class AbstractValidateCommand extends AbstractApiCommand {
     // bug in micronaut, we can't inject YamlFlowParser & ModelValidator, so we inject from implementation
     public Integer call(
         Class<?> cls,
-        YamlFlowParser yamlFlowParser,
+        YamlParser yamlParser,
         ModelValidator modelValidator,
         Function<Object, String> identity,
-        Function<Object, List<String>> warningsFunction
+        Function<Object, List<String>> warningsFunction,
+        Function<Object, List<String>> infosFunction
     ) throws Exception {
         super.call();
 
@@ -85,14 +85,16 @@ public abstract class AbstractValidateCommand extends AbstractApiCommand {
         if(this.local) {
             try(var files = Files.walk(directory)) {
                 files.filter(Files::isRegularFile)
-                    .filter(YamlFlowParser::isValidExtension)
+                    .filter(YamlParser::isValidExtension)
                     .forEach(path -> {
                         try {
-                            Object parse = yamlFlowParser.parse(path.toFile(), cls);
+                            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);

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

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

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,

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

@@ -10,7 +10,7 @@ import picocli.CommandLine;
 
 @CommandLine.Command(
     name = "properties",
-    description = {"Display actual configurations properties."}
+    description = {"Display current configuration properties."}
 )
 @Slf4j
 public class ConfigPropertiesCommand extends AbstractCommand {

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

@@ -10,7 +10,7 @@ import picocli.CommandLine;
 
 @CommandLine.Command(
     name = "flow",
-    description = "handle flows",
+    description = "Manage flows",
     mixinStandardHelpOptions = true,
     subcommands = {
         FlowValidateCommand.class,

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

@@ -3,7 +3,7 @@ package io.kestra.cli.commands.flows;
 import io.kestra.cli.AbstractCommand;
 import io.kestra.core.models.flows.Flow;
 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.utils.GraphUtils;
 import io.micronaut.context.ApplicationContext;
@@ -15,21 +15,21 @@ import java.nio.file.Path;
 
 @CommandLine.Command(
     name = "dot",
-    description = "generate a dot graph from a file"
+    description = "Generate a DOT graph from a file"
 )
 @Slf4j
 public class FlowDotCommand extends AbstractCommand {
     @Inject
     private ApplicationContext applicationContext;
 
-    @CommandLine.Parameters(index = "0", description = "the flow file to display")
+    @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);
+        YamlParser parser = applicationContext.getBean(YamlParser.class);
         Flow flow = parser.parse(file.toFile(), Flow.class);
 
         GraphCluster graph = GraphUtils.of(flow, null);

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

@@ -3,7 +3,7 @@ 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.YamlFlowParser;
+import io.kestra.core.serializers.YamlParser;
 import jakarta.inject.Inject;
 import picocli.CommandLine;
 
@@ -12,16 +12,16 @@ import java.nio.file.Path;
 
 @CommandLine.Command(
     name = "expand",
-    description = "deprecated - expand a flow"
+    description = "Deprecated - expand a flow"
 )
 @Deprecated
 public class FlowExpandCommand extends AbstractCommand {
 
-    @CommandLine.Parameters(index = "0", description = "the flow file to expand")
+    @CommandLine.Parameters(index = "0", description = "The flow file to expand")
     private Path file;
 
     @Inject
-    private YamlFlowParser yamlFlowParser;
+    private YamlParser yamlParser;
 
     @Inject
     private ModelValidator modelValidator;
@@ -31,7 +31,7 @@ public class FlowExpandCommand extends AbstractCommand {
         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 = yamlFlowParser.parse(content, Flow.class);
+        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

@@ -18,7 +18,7 @@ import java.nio.file.Path;
 
 @CommandLine.Command(
     name = "export",
-    description = "export flows to a zip file",
+    description = "Export flows to a ZIP file",
     mixinStandardHelpOptions = true
 )
 @Slf4j
@@ -29,10 +29,10 @@ public class FlowExportCommand extends AbstractApiCommand {
     @Inject
     private ApplicationContext applicationContext;
 
-    @CommandLine.Option(names = {"--namespace"}, description = "the namespace of flows to export")
+    @CommandLine.Option(names = {"--namespace"}, description = "The namespace of flows to export")
     public String namespace;
 
-    @CommandLine.Parameters(index = "0", description = "the directory to export the file to")
+    @CommandLine.Parameters(index = "0", description = "The directory to export the ZIP file to")
     public Path directory;
 
     @Override

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

@@ -27,19 +27,19 @@ import java.util.concurrent.TimeoutException;
 
 @CommandLine.Command(
     name = "test",
-    description = "test a flow"
+    description = "Test a flow"
 )
 @Slf4j
 public class FlowTestCommand extends AbstractCommand {
     @Inject
     private ApplicationContext applicationContext;
 
-    @CommandLine.Parameters(index = "0", description = "the flow file to test")
+    @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<>();

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,83 @@
+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;
+
+    @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()) {
+                MutableHttpRequest<String> request = HttpRequest
+                    .POST(apiUri("/flows/bulk") + "?delete=" + delete, 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;
+    }
+}

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

@@ -3,7 +3,7 @@ package io.kestra.cli.commands.flows;
 import io.kestra.cli.AbstractValidateCommand;
 import io.kestra.core.models.flows.Flow;
 import io.kestra.core.models.validations.ModelValidator;
-import io.kestra.core.serializers.YamlFlowParser;
+import io.kestra.core.serializers.YamlParser;
 import io.kestra.core.services.FlowService;
 import jakarta.inject.Inject;
 import picocli.CommandLine;
@@ -13,11 +13,11 @@ import java.util.List;
 
 @CommandLine.Command(
     name = "validate",
-    description = "validate a flow"
+    description = "Validate a flow"
 )
 public class FlowValidateCommand extends AbstractValidateCommand {
     @Inject
-    private YamlFlowParser yamlFlowParser;
+    private YamlParser yamlParser;
 
     @Inject
     private ModelValidator modelValidator;
@@ -29,7 +29,7 @@ public class FlowValidateCommand extends AbstractValidateCommand {
     public Integer call() throws Exception {
         return this.call(
             Flow.class,
-            yamlFlowParser,
+            yamlParser,
             modelValidator,
             (Object object) -> {
                 Flow flow = (Flow) object;
@@ -39,9 +39,12 @@ public class FlowValidateCommand extends AbstractValidateCommand {
                 Flow flow = (Flow) object;
                 List<String> warnings = new ArrayList<>();
                 warnings.addAll(flowService.deprecationPaths(flow).stream().map(deprecation -> deprecation + " is deprecated").toList());
-                warnings.addAll(flowService.relocations(flow.generateSource()).stream().map(relocation -> relocation.from() + " is replaced by " + relocation.to()).toList());
                 warnings.addAll(flowService.warnings(flow));
                 return warnings;
+            },
+            (Object object) -> {
+                Flow flow = (Flow) object;
+                return flowService.relocations(flow.generateSource()).stream().map(relocation -> relocation.from() + " is replaced by " + relocation.to()).toList();
             }
         );
     }

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

@@ -9,7 +9,7 @@ import picocli.CommandLine;
 
 @CommandLine.Command(
     name = "namespace",
-    description = "handle namespace flows",
+    description = "Manage namespace flows",
     mixinStandardHelpOptions = true,
     subcommands = {
         FlowNamespaceUpdateCommand.class,

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

@@ -2,9 +2,8 @@ package io.kestra.cli.commands.flows.namespaces;
 
 import io.kestra.cli.AbstractValidateCommand;
 import io.kestra.cli.commands.AbstractServiceNamespaceUpdateCommand;
-import io.kestra.cli.commands.flows.FlowValidateCommand;
 import io.kestra.cli.commands.flows.IncludeHelperExpander;
-import io.kestra.core.serializers.YamlFlowParser;
+import io.kestra.core.serializers.YamlParser;
 import io.micronaut.core.type.Argument;
 import io.micronaut.http.HttpRequest;
 import io.micronaut.http.MediaType;
@@ -12,10 +11,10 @@ import io.micronaut.http.MutableHttpRequest;
 import io.micronaut.http.client.exceptions.HttpClientResponseException;
 import io.micronaut.http.client.netty.DefaultHttpClient;
 import jakarta.inject.Inject;
+import jakarta.validation.ConstraintViolationException;
 import lombok.extern.slf4j.Slf4j;
 import picocli.CommandLine;
 
-import jakarta.validation.ConstraintViolationException;
 import java.io.IOException;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
@@ -23,13 +22,16 @@ import java.util.List;
 
 @CommandLine.Command(
     name = "update",
-    description = "handle namespace flows",
+    description = "Update flows in namespace",
     mixinStandardHelpOptions = true
 )
 @Slf4j
 public class FlowNamespaceUpdateCommand extends AbstractServiceNamespaceUpdateCommand {
     @Inject
-    public YamlFlowParser yamlFlowParser;
+    public YamlParser yamlParser;
+
+    @CommandLine.Option(names = {"--override-namespaces"}, negatable = true, description = "Replace namespace of all flows by the one provided")
+    public boolean override = false;
 
     @SuppressWarnings("deprecation")
     @Override
@@ -39,7 +41,7 @@ public class FlowNamespaceUpdateCommand extends AbstractServiceNamespaceUpdateCo
         try (var files = Files.walk(directory)) {
             List<String> flows = files
                 .filter(Files::isRegularFile)
-                .filter(YamlFlowParser::isValidExtension)
+                .filter(YamlParser::isValidExtension)
                 .map(path -> {
                     try {
                         return IncludeHelperExpander.expand(Files.readString(path, Charset.defaultCharset()), path.getParent());
@@ -55,6 +57,9 @@ public class FlowNamespaceUpdateCommand extends AbstractServiceNamespaceUpdateCo
             } else {
                 body = String.join("\n---\n", flows);
             }
+            if (override) {
+                body = body.replaceAll("(?m)^namespace:.+", "namespace: " + namespace);
+            }
             try(DefaultHttpClient client = client()) {
                 MutableHttpRequest<String> request = HttpRequest
                     .POST(apiUri("/flows/") + namespace + "?delete=" + delete, body).contentType(MediaType.APPLICATION_YAML);

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

@@ -11,7 +11,7 @@ import picocli.CommandLine;
 
 @CommandLine.Command(
     name = "namespace",
-    description = "handle namespaces",
+    description = "Manage namespaces",
     mixinStandardHelpOptions = true,
     subcommands = {
         NamespaceFilesCommand.class,

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

@@ -9,7 +9,7 @@ import picocli.CommandLine;
 
 @CommandLine.Command(
     name = "files",
-    description = "handle namespace files",
+    description = "Manage namespace files",
     mixinStandardHelpOptions = true,
     subcommands = {
         NamespaceFilesUpdateCommand.class,

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

@@ -17,21 +17,21 @@ import java.util.List;
 
 @CommandLine.Command(
     name = "update",
-    description = "update namespace files",
+    description = "Update namespace files",
     mixinStandardHelpOptions = true
 )
 @Slf4j
 public class NamespaceFilesUpdateCommand extends AbstractApiCommand {
-    @CommandLine.Parameters(index = "0", description = "the namespace to update")
+    @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")
+    @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 = "/")
+    @CommandLine.Parameters(index = "2", description = "The remote namespace path to upload files to", defaultValue = "/")
     public String to;
 
-    @CommandLine.Option(names = {"--delete"}, negatable = true, description = "if missing should be deleted")
+    @CommandLine.Option(names = {"--delete"}, negatable = true, description = "Whether missing should be deleted")
     public boolean delete = false;
 
     private static final String KESTRA_IGNORE_FILE = ".kestraignore";

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

@@ -9,7 +9,7 @@ import picocli.CommandLine;
 
 @CommandLine.Command(
     name = "kv",
-    description = "handle KV Store",
+    description = "Manage KV Store",
     mixinStandardHelpOptions = true,
     subcommands = {
         KvUpdateCommand.class,

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

@@ -18,28 +18,28 @@ import java.time.Duration;
 
 @CommandLine.Command(
     name = "update",
-    description = "update value for a KV Store key",
+    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")
+    @CommandLine.Parameters(index = "0", description = "The namespace to update")
     public String namespace;
 
-    @CommandLine.Parameters(index = "1", description = "the key to update")
+    @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.")
+    @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.")
+    @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}.")
+    @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.")
+    @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

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

@@ -9,7 +9,7 @@ import picocli.CommandLine;
 
 @CommandLine.Command(
     name = "plugins",
-    description = "handle plugins",
+    description = "Manage plugins",
     mixinStandardHelpOptions = true,
     subcommands = {
         PluginInstallCommand.class,

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

@@ -1,10 +1,11 @@
 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.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;
@@ -19,13 +20,13 @@ 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 {
     @Inject
     private ApplicationContext applicationContext;
 
-    @CommandLine.Parameters(index = "0", description = "Path to write documentations files")
+    @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")
@@ -34,51 +35,70 @@ public class PluginDocCommand extends AbstractCommand {
     @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);
 
         List<RegisteredPlugin> plugins = core ?  pluginRegistry().plugins() : pluginRegistry().externalPlugins();
+        boolean hasFailures = false;
         for (RegisteredPlugin registeredPlugin : plugins) {
-            documentationGenerator
-                .generate(registeredPlugin)
-                .forEach(s -> {
-                        File file = Paths.get(output.toAbsolutePath().toString(), s.getPath()).toFile();
+            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 {
-                            com.google.common.io.Files
-                                .asCharSink(
-                                    file,
-                                    Charsets.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"
-                                );
-
-                                com.google.common.io.Files
-                                    .asByteSink(iconFile)
-                                    .write(Base64.getDecoder().decode(s.getIcon().getBytes(StandardCharsets.UTF_8)));
-                                stdOut("Generate icon in: {0}", iconFile);
+                            if (!file.getParentFile().exists()) {
+                                //noinspection ResultOfMethodCallIgnored
+                                file.getParentFile().mkdirs();
                             }
 
-                            stdOut("Generate doc in: {0}", file);
-                        } catch (IOException e) {
-                            throw new RuntimeException(e);
+                            try {
+                                Files
+                                    .asCharSink(
+                                        file,
+                                        Charsets.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;
+            }
         }
 
-        return 0;
+        return hasFailures ? 1 : 0;
     }
 }

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

@@ -1,6 +1,5 @@
 package io.kestra.cli.commands.plugins;
 
-import io.micronaut.http.uri.UriBuilder;
 import org.apache.commons.io.FilenameUtils;
 import io.kestra.cli.AbstractCommand;
 import io.kestra.cli.plugins.PluginDownloader;
@@ -17,7 +16,6 @@ import java.nio.file.StandardCopyOption;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import java.util.Objects;
 
 import jakarta.inject.Inject;
 
@@ -25,13 +23,13 @@ import static io.kestra.core.utils.Rethrow.throwConsumer;
 
 @CommandLine.Command(
     name = "install",
-    description = "install a plugin"
+    description = "Install plugins"
 )
 public class PluginInstallCommand extends AbstractCommand {
-    @CommandLine.Parameters(index = "0..*", description = "the plugins to install")
+    @CommandLine.Parameters(index = "0..*", description = "Plugins to install. Represented as Maven artifact coordinates.")
     List<String> dependencies = new ArrayList<>();
 
-    @CommandLine.Option(names = {"--repositories"}, description = "url to additional maven repositories")
+    @CommandLine.Option(names = {"--repositories"}, description = "URL to additional Maven repositories")
     private URI[] repositories;
 
     @CommandLine.Spec

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

@@ -8,7 +8,7 @@ import java.util.List;
 
 @CommandLine.Command(
     name = "list",
-    description = "list all plugins already installed"
+    description = "List all plugins already installed"
 )
 public class PluginListCommand extends AbstractCommand {
     @CommandLine.Spec
@@ -16,7 +16,7 @@ public class PluginListCommand extends AbstractCommand {
 
     @CommandLine.Option(names = {"--core"}, description = "Also write core tasks plugins")
     private boolean core = false;
-    
+
     @Override
     public Integer call() throws Exception {
         super.call();
@@ -26,7 +26,7 @@ public class PluginListCommand extends AbstractCommand {
                 "or environment variable 'KESTRA_PLUGINS_PATH"
             );
         }
-        
+
         List<RegisteredPlugin> plugins = core ?  pluginRegistry().plugins() :  pluginRegistry().externalPlugins();
         plugins.forEach(registeredPlugin -> stdOut(registeredPlugin.toString()));
 

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

@@ -4,7 +4,7 @@ import io.kestra.cli.AbstractCommand;
 import picocli.CommandLine;
 
 abstract public class AbstractServerCommand extends AbstractCommand implements ServerCommandInterface {
-    @CommandLine.Option(names = {"--port"}, description = "the port to bind")
+    @CommandLine.Option(names = {"--port"}, description = "The port to bind")
     Integer serverPort;
 
     protected static int defaultWorkerThread() {

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

@@ -18,7 +18,7 @@ import java.util.Map;
 
 @CommandLine.Command(
     name = "executor",
-    description = "start an executor"
+    description = "Start the Kestra executor"
 )
 @Slf4j
 public class ExecutorCommand extends AbstractServerCommand {
@@ -31,22 +31,22 @@ public class ExecutorCommand extends AbstractServerCommand {
     @Inject
     private StartExecutorService startExecutorService;
 
-    @CommandLine.Option(names = {"--skip-executions"}, split=",", description = "a list of execution identifiers to skip, separated by a coma; for troubleshooting purpose only")
+    @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 = "a list of flow identifiers (tenant|namespace|flowId) to skip, separated by a coma; for troubleshooting purpose only")
+    @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 = "a list of namespace identifiers (tenant|namespace) to skip, separated by a coma; for troubleshooting purpose only")
+    @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 = "a list of tenants to skip, separated by a coma; for troubleshooting purpose only")
+    @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 = "a list of Kafka Stream executors to start, separated by a command. Use it only with the Kafka queue, for debugging purpose.")
+    @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 = "a list of Kafka Stream executors to not start, separated by a command. Use it only with the Kafka queue, for debugging purpose.")
+    @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")

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

@@ -14,7 +14,7 @@ import java.util.Map;
 
 @CommandLine.Command(
     name = "indexer",
-    description = "start an indexer"
+    description = "Start the Kestra indexer"
 )
 @Slf4j
 public class IndexerCommand extends AbstractServerCommand {

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

@@ -12,7 +12,7 @@ import java.util.Map;
 
 @CommandLine.Command(
     name = "local",
-    description = "start a local server"
+    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

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

@@ -14,7 +14,7 @@ import java.util.Map;
 
 @CommandLine.Command(
     name = "scheduler",
-    description = "start an scheduler"
+    description = "Start the Kestra scheduler"
 )
 @Slf4j
 public class SchedulerCommand extends AbstractServerCommand {

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,

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

@@ -1,6 +1,7 @@
 package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
+import io.kestra.cli.services.FileChangedEventListener;
 import io.kestra.core.contexts.KestraContext;
 import io.kestra.core.models.ServerType;
 import io.kestra.core.repositories.LocalFlowRepositoryLoader;
@@ -9,6 +10,7 @@ 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.annotation.Nullable;
 import jakarta.inject.Inject;
 import lombok.extern.slf4j.Slf4j;
 import picocli.CommandLine;
@@ -21,7 +23,7 @@ import java.util.Map;
 
 @CommandLine.Command(
     name = "standalone",
-    description = "start a standalone server"
+    description = "Start the standalone all-in-one server"
 )
 @Slf4j
 public class StandAloneCommand extends AbstractServerCommand {
@@ -37,10 +39,14 @@ public class StandAloneCommand extends AbstractServerCommand {
     @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;
 
-    @CommandLine.Option(names = {"--worker-thread"}, description = "the number of worker threads, defaults to two times the number of available processors. Set it to 0 to avoid starting a worker.")
+    @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")
@@ -64,6 +70,9 @@ public class StandAloneCommand extends AbstractServerCommand {
     @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;
@@ -105,8 +114,18 @@ public class StandAloneCommand extends AbstractServerCommand {
             standAloneRunner.setWorkerThread(this.workerThread);
         }
 
+        if (this.indexerDisabled) {
+            standAloneRunner.setIndexerEnabled(false);
+        }
+
         standAloneRunner.run();
 
+        if (fileWatcher != null) {
+            fileWatcher.startListeningFromConfig();
+        }
+
+        this.shutdownHook(standAloneRunner::close);
+
         Await.until(() -> !this.applicationContext.isRunning());
 
         return 0;

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

@@ -3,7 +3,10 @@ package io.kestra.cli.commands.servers;
 import com.google.common.collect.ImmutableMap;
 import io.kestra.core.contexts.KestraContext;
 import io.kestra.core.models.ServerType;
+import io.kestra.core.runners.ExecutorInterface;
+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;
@@ -11,19 +14,27 @@ import picocli.CommandLine;
 import picocli.CommandLine.Option;
 
 import java.util.Map;
+import java.util.concurrent.ExecutorService;
 
 @CommandLine.Command(
     name = "webserver",
-    description = "start the webserver"
+    description = "Start the Kestra webserver"
 )
 @Slf4j
 public class WebServerCommand extends AbstractServerCommand {
+    private ExecutorService poolExecutor;
+
     @Inject
     private ApplicationContext applicationContext;
 
+    @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() {
@@ -40,9 +51,26 @@ public class WebServerCommand extends AbstractServerCommand {
     @Override
     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));
+        }
+
         log.info("Webserver started");
-        this.shutdownHook(() -> KestraContext.getContext().shutdown());
+        this.shutdownHook(() -> {
+            this.close();
+            KestraContext.getContext().shutdown();
+        });
         Await.until(() -> !this.applicationContext.isRunning());
         return 0;
     }
+
+    private void close() {
+        if (this.poolExecutor != null) {
+            this.poolExecutor.shutdown();
+        }
+    }
 }

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

@@ -16,7 +16,7 @@ import java.util.UUID;
 
 @CommandLine.Command(
     name = "worker",
-    description = "start a worker"
+    description = "Start the Kestra worker"
 )
 @Slf4j
 public class WorkerCommand extends AbstractServerCommand {
@@ -24,10 +24,10 @@ public class WorkerCommand extends AbstractServerCommand {
     @Inject
     private ApplicationContext applicationContext;
 
-    @Option(names = {"-t", "--thread"}, description = "the max number of worker threads, defaults to two times the number of available processors")
+    @Option(names = {"-t", "--thread"}, description = "The max number of worker threads, defaults to four times the number of available processors")
     private int thread = defaultWorkerThread();
 
-    @Option(names = {"-g", "--worker-group"}, description = "the worker group key, must match the regex [a-zA-Z0-9_-]+ (EE only)")
+    @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")

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

@@ -12,7 +12,7 @@ import java.util.List;
 
 @CommandLine.Command(
     name = "reindex",
-    description = "reindex all records of a type: read them from the database then update them",
+    description = "Reindex all records of a type: read them from the database then update them",
     mixinStandardHelpOptions = true
 )
 @Slf4j

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

@@ -10,7 +10,7 @@ import picocli.CommandLine;
 
 @CommandLine.Command(
     name = "sys",
-    description = "handle systems maintenance",
+    description = "Manage system maintenance mode",
     mixinStandardHelpOptions = true,
     subcommands = {
         ReindexCommand.class,

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

@@ -1,6 +1,5 @@
 package io.kestra.cli.commands.sys.database;
 
-import ch.qos.logback.classic.Level;
 import io.kestra.cli.AbstractCommand;
 import lombok.extern.slf4j.Slf4j;
 import picocli.CommandLine;

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

@@ -44,7 +44,7 @@ public class StateStoreMigrateCommand extends AbstractCommand {
             URI.create("/" + flow.getNamespace().replace(".", "/") + "/states")
         ))).map(potentialStateStoreUrisForAFlow -> Map.entry(potentialStateStoreUrisForAFlow.getKey(), potentialStateStoreUrisForAFlow.getValue().stream().flatMap(uri -> {
             try {
-                return storageInterface.allByPrefix(potentialStateStoreUrisForAFlow.getKey().getTenantId(), uri, false).stream();
+                return storageInterface.allByPrefix(potentialStateStoreUrisForAFlow.getKey().getTenantId(), potentialStateStoreUrisForAFlow.getKey().getNamespace(), uri, false).stream();
             } catch (IOException e) {
                 return Stream.empty();
             }
@@ -59,9 +59,9 @@ public class StateStoreMigrateCommand extends AbstractCommand {
             boolean flowScoped = flowQualifierWithStateQualifiers[0].endsWith("/" + flow.getId());
             StateStore stateStore = new StateStore(runContext(runContextFactory, flow), false);
 
-            try (InputStream is = storageInterface.get(flow.getTenantId(), stateStoreFileUri)) {
+            try (InputStream is = storageInterface.get(flow.getTenantId(), flow.getNamespace(), stateStoreFileUri)) {
                 stateStore.putState(flowScoped, stateName, stateSubName, taskRunValue, is.readAllBytes());
-                storageInterface.delete(flow.getTenantId(), stateStoreFileUri);
+                storageInterface.delete(flow.getTenantId(), flow.getNamespace(), stateStoreFileUri);
             } catch (IOException e) {
                 throw new RuntimeException(e);
             }

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

@@ -11,7 +11,7 @@ import picocli.CommandLine;
 
 @CommandLine.Command(
     name = "template",
-    description = "handle templates",
+    description = "Manage templates",
     mixinStandardHelpOptions = true,
     subcommands = {
         TemplateNamespaceCommand.class,

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

@@ -19,7 +19,7 @@ import java.nio.file.Path;
 
 @CommandLine.Command(
     name = "export",
-    description = "export templates to a zip file",
+    description = "Export templates to a ZIP file",
     mixinStandardHelpOptions = true
 )
 @Slf4j
@@ -31,10 +31,10 @@ public class TemplateExportCommand extends AbstractApiCommand {
     @Inject
     private ApplicationContext applicationContext;
 
-    @CommandLine.Option(names = {"--namespace"}, description = "the namespace of templates to export")
+    @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")
+    @CommandLine.Parameters(index = "0", description = "The directory to export the file to")
     public Path directory;
 
     @Override

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

@@ -4,7 +4,7 @@ import io.kestra.cli.AbstractValidateCommand;
 import io.kestra.core.models.templates.Template;
 import io.kestra.core.models.templates.TemplateEnabled;
 import io.kestra.core.models.validations.ModelValidator;
-import io.kestra.core.serializers.YamlFlowParser;
+import io.kestra.core.serializers.YamlParser;
 import jakarta.inject.Inject;
 import picocli.CommandLine;
 
@@ -12,12 +12,12 @@ import java.util.Collections;
 
 @CommandLine.Command(
     name = "validate",
-    description = "validate a template"
+    description = "Validate a template"
 )
 @TemplateEnabled
 public class TemplateValidateCommand extends AbstractValidateCommand {
     @Inject
-    private YamlFlowParser yamlFlowParser;
+    private YamlParser yamlParser;
 
     @Inject
     private ModelValidator modelValidator;
@@ -26,12 +26,13 @@ public class TemplateValidateCommand extends AbstractValidateCommand {
     public Integer call() throws Exception {
         return this.call(
             Template.class,
-            yamlFlowParser,
+            yamlParser,
             modelValidator,
             (Object object) -> {
                 Template template = (Template) object;
                 return template.getNamespace() + " / " + template.getId();
             },
+            (Object object) -> Collections.emptyList(),
             (Object object) -> Collections.emptyList()
         );
     }

cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceCommand.java

@@ -10,7 +10,7 @@ import picocli.CommandLine;
 
 @CommandLine.Command(
     name = "namespace",
-    description = "handle namespace templates",
+    description = "Manage namespace templates",
     mixinStandardHelpOptions = true,
     subcommands = {
         TemplateNamespaceUpdateCommand.class,

cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceUpdateCommand.java

@@ -2,10 +2,9 @@ package io.kestra.cli.commands.templates.namespaces;
 
 import io.kestra.cli.AbstractValidateCommand;
 import io.kestra.cli.commands.AbstractServiceNamespaceUpdateCommand;
-import io.kestra.cli.commands.templates.TemplateValidateCommand;
 import io.kestra.core.models.templates.Template;
 import io.kestra.core.models.templates.TemplateEnabled;
-import io.kestra.core.serializers.YamlFlowParser;
+import io.kestra.core.serializers.YamlParser;
 import io.micronaut.core.type.Argument;
 import io.micronaut.http.HttpRequest;
 import io.micronaut.http.MutableHttpRequest;
@@ -17,19 +16,19 @@ import picocli.CommandLine;
 
 import java.nio.file.Files;
 import java.util.List;
-import java.util.stream.Collectors;
+
 import jakarta.validation.ConstraintViolationException;
 
 @CommandLine.Command(
     name = "update",
-    description = "handle namespace templates",
+    description = "Update namespace templates",
     mixinStandardHelpOptions = true
 )
 @Slf4j
 @TemplateEnabled
 public class TemplateNamespaceUpdateCommand extends AbstractServiceNamespaceUpdateCommand {
     @Inject
-    public YamlFlowParser yamlFlowParser;
+    public YamlParser yamlParser;
 
     @Override
     public Integer call() throws Exception {
@@ -38,8 +37,8 @@ public class TemplateNamespaceUpdateCommand extends AbstractServiceNamespaceUpda
         try (var files = Files.walk(directory)) {
             List<Template> templates = files
                 .filter(Files::isRegularFile)
-                .filter(YamlFlowParser::isValidExtension)
-                .map(path -> yamlFlowParser.parse(path.toFile(), Template.class))
+                .filter(YamlParser::isValidExtension)
+                .map(path -> yamlParser.parse(path.toFile(), Template.class))
                 .toList();
 
             if (templates.isEmpty()) {

cli/src/main/java/io/kestra/cli/services/FileChangedEventListener.java

@@ -0,0 +1,265 @@
+package io.kestra.cli.services;
+
+import io.kestra.core.models.flows.Flow;
+import io.kestra.core.models.flows.FlowWithPath;
+import io.kestra.core.models.flows.FlowWithSource;
+import io.kestra.core.models.validations.ModelValidator;
+import io.kestra.core.repositories.FlowRepositoryInterface;
+import io.kestra.core.serializers.YamlParser;
+import io.kestra.core.services.FlowListenersInterface;
+import io.kestra.core.services.PluginDefaultService;
+import io.micronaut.context.annotation.Requires;
+import io.micronaut.context.annotation.Value;
+import io.micronaut.scheduling.io.watch.FileWatchConfiguration;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
+import jakarta.validation.ConstraintViolationException;
+import lombok.extern.slf4j.Slf4j;
+
+import javax.annotation.Nullable;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.*;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+@Singleton
+@Slf4j
+@Requires(property = "micronaut.io.watch.enabled", value = "true")
+public class FileChangedEventListener {
+    @Nullable
+    private final FileWatchConfiguration fileWatchConfiguration;
+    @Nullable
+    private final WatchService watchService;
+
+    @Inject
+    private FlowRepositoryInterface flowRepositoryInterface;
+
+    @Inject
+    private PluginDefaultService pluginDefaultService;
+
+    @Inject
+    private YamlParser yamlParser;
+
+    @Inject
+    private ModelValidator modelValidator;
+
+    @Inject
+    protected FlowListenersInterface flowListeners;
+
+    @Nullable
+    @Value("${micronaut.io.watch.tenantId}")
+    private String tenantId;
+
+    FlowFilesManager flowFilesManager;
+
+    private List<FlowWithPath> flows = new ArrayList<>();
+
+    private boolean isStarted = false;
+
+
+    @Inject
+    public FileChangedEventListener(@Nullable FileWatchConfiguration fileWatchConfiguration, @Nullable WatchService watchService) {
+        this.fileWatchConfiguration = fileWatchConfiguration;
+        this.watchService = watchService;
+    }
+
+    public void startListeningFromConfig() throws IOException, InterruptedException {
+        if (fileWatchConfiguration != null && fileWatchConfiguration.isEnabled()) {
+            this.flowFilesManager = new LocalFlowFileWatcher(flowRepositoryInterface, pluginDefaultService);
+            List<Path> paths = fileWatchConfiguration.getPaths();
+            this.setup(paths);
+
+            flowListeners.run();
+            // Init existing flows not already in files
+            flowListeners.listen(flows -> {
+                if (!isStarted) {
+                    for (FlowWithSource flow : flows) {
+                        if (this.flows.stream().noneMatch(flowWithPath -> flowWithPath.uidWithoutRevision().equals(flow.uidWithoutRevision()))) {
+                            flowToFile(flow, this.buildPath(flow));
+                            this.flows.add(FlowWithPath.of(flow, this.buildPath(flow).toString()));
+                        }
+                    }
+                    this.isStarted = true;
+                }
+            });
+
+            // Listen for new/updated/deleted flows
+            flowListeners.listen((current, previous) -> {
+                // If deleted
+                if (current.isDeleted()) {
+                    this.flows.stream().filter(flowWithPath -> flowWithPath.uidWithoutRevision().equals(current.uidWithoutRevision())).findFirst()
+                        .ifPresent(flowWithPath -> {
+                            deleteFile(Paths.get(flowWithPath.getPath()));
+                        });
+                    this.flows.removeIf(flowWithPath -> flowWithPath.uidWithoutRevision().equals(current.uidWithoutRevision()));
+                } else {
+                    // if updated/created
+                    Optional<FlowWithPath> flowWithPath = this.flows.stream().filter(fwp -> fwp.uidWithoutRevision().equals(current.uidWithoutRevision())).findFirst();
+                    if (flowWithPath.isPresent()) {
+                        flowToFile(current, Paths.get(flowWithPath.get().getPath()));
+                    } else {
+                        flows.add(FlowWithPath.of(current, this.buildPath(current).toString()));
+                        flowToFile(current, null);
+                    }
+                }
+            });
+
+            this.startListening(paths);
+        } else {
+            log.info("File watching is disabled.");
+        }
+    }
+
+    public void startListening(List<Path> paths) throws IOException, InterruptedException {
+        for (Path path : paths) {
+            path.register(watchService, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY);
+        }
+
+        WatchKey key;
+        while ((key = watchService.take()) != null) {
+            for (WatchEvent<?> watchEvent : key.pollEvents()) {
+                try {
+                    WatchEvent.Kind<?> kind = watchEvent.kind();
+                    Path entry = (Path) watchEvent.context();
+
+                    if (entry.toString().endsWith(".yml") || entry.toString().endsWith(".yaml")) {
+
+                        if (kind == StandardWatchEventKinds.ENTRY_CREATE || kind == StandardWatchEventKinds.ENTRY_MODIFY) {
+
+                            Path filePath = ((Path) key.watchable()).resolve(entry);
+                            if (Files.isDirectory(filePath)) {
+                                loadFlowsFromFolder(filePath);
+                            } else {
+
+                                try {
+                                    String content = Files.readString(filePath, Charset.defaultCharset());
+
+                                    Optional<Flow> flow = parseFlow(content, entry);
+                                    if (flow.isPresent()) {
+                                        if (kind == StandardWatchEventKinds.ENTRY_MODIFY) {
+                                            // Check if we already have a file with the given path
+                                            if (flows.stream().anyMatch(flowWithPath -> flowWithPath.getPath().equals(filePath.toString()))) {
+                                                Optional<FlowWithPath> previous = flows.stream().filter(flowWithPath -> flowWithPath.getPath().equals(filePath.toString())).findFirst();
+                                                // Check if Flow from file has id/namespace updated
+                                                if (previous.isPresent() && !previous.get().uidWithoutRevision().equals(flow.get().uidWithoutRevision())) {
+                                                    flows.removeIf(flowWithPath -> flowWithPath.getPath().equals(filePath.toString()));
+                                                    flowFilesManager.deleteFlow(previous.get().getTenantId(), previous.get().getNamespace(), previous.get().getId());
+                                                    flows.add(FlowWithPath.of(flow.get(), filePath.toString()));
+                                                }
+                                            } else {
+                                                flows.add(FlowWithPath.of(flow.get(), filePath.toString()));
+                                            }
+                                        } else {
+                                            flows.add(FlowWithPath.of(flow.get(), filePath.toString()));
+                                        }
+
+                                        flowFilesManager.createOrUpdateFlow(flow.get(), content);
+                                        log.info("Flow {} from file {} has been created or modified", flow.get().getId(), entry);
+                                    }
+
+                                } catch (NoSuchFileException e) {
+                                    log.error("File not found: {}", entry, e);
+                                } catch (IOException e) {
+                                    log.error("Error reading file: {}", entry, e);
+                                }
+                            }
+                        } else {
+                            Path filePath = ((Path) key.watchable()).resolve(entry);
+                            flows.stream()
+                                .filter(flow -> flow.getPath().equals(filePath.toString()))
+                                .findFirst()
+                                .ifPresent(flowWithPath -> {
+                                    flowFilesManager.deleteFlow(flowWithPath.getTenantId(), flowWithPath.getNamespace(), flowWithPath.getId());
+                                    this.flows.removeIf(fwp -> fwp.uidWithoutRevision().equals(flowWithPath.uidWithoutRevision()));
+                                });
+                        }
+                    }
+                } catch (Exception e) {
+                    log.error("Unexpected error while watching flows", e);
+                }
+            }
+            key.reset();
+        }
+    }
+
+    private void setup(List<Path> folders) {
+        for (Path folder : folders) {
+            this.loadFlowsFromFolder(folder);
+        }
+    }
+
+    private void loadFlowsFromFolder(Path folder) {
+        try {
+            Files.walkFileTree(folder, new SimpleFileVisitor<Path>() {
+                @Override
+                public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
+                    dir.register(watchService, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY);
+                    if (!dir.equals(folder)) {
+                        loadFlowsFromFolder(dir);
+                    }
+                    return FileVisitResult.CONTINUE;
+                }
+
+                @Override
+                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+                    if (file.toString().endsWith(".yml") || file.toString().endsWith(".yaml")) {
+                        String content = Files.readString(file, Charset.defaultCharset());
+                        Optional<Flow> flow = parseFlow(content, file);
+
+                        if (flow.isPresent() && flows.stream().noneMatch(flowWithPath -> flowWithPath.uidWithoutRevision().equals(flow.get().uidWithoutRevision()))) {
+                            flows.add(FlowWithPath.of(flow.get(), file.toString()));
+                            flowFilesManager.createOrUpdateFlow(flow.get(), content);
+                        }
+                    }
+                    return FileVisitResult.CONTINUE;
+                }
+            });
+            log.info("Loaded files from the folder {}", folder);
+        } catch (IOException e) {
+            log.error(e.getMessage());
+        }
+    }
+
+    private void flowToFile(FlowWithSource flow, Path path) {
+        Path defaultPath = path != null ? path : this.buildPath(flow);
+
+        try {
+            Files.writeString(defaultPath, flow.getSource());
+            log.info("Flow {} has been written to file {}", flow.getId(), defaultPath);
+        } catch (IOException e) {
+            log.error("Error writing file: {}", defaultPath, e);
+        }
+    }
+
+    private Optional<Flow> parseFlow(String content, Path entry) {
+        try {
+            Flow flow = yamlParser.parse(content, Flow.class);
+            FlowWithSource withPluginDefault = pluginDefaultService.injectDefaults(FlowWithSource.of(flow, content));
+            modelValidator.validate(withPluginDefault);
+            return Optional.of(flow);
+        } catch (ConstraintViolationException e) {
+            log.warn("Error while parsing flow: {}", entry, e);
+        }
+
+        return Optional.empty();
+    }
+
+    private void deleteFile(Path file) {
+        try {
+            if (Files.deleteIfExists(file)) {
+                log.info("File {} has been deleted successfully.", file);
+            } else {
+                log.warn("File {} does not exist.", file);
+            }
+        } catch (IOException e) {
+            log.error("Error deleting file: {}", file, e);
+        }
+    }
+
+    private Path buildPath(Flow flow) {
+        return fileWatchConfiguration.getPaths().getFirst().resolve(flow.uidWithoutRevision() + ".yml");
+    }
+}

cli/src/main/java/io/kestra/cli/services/FlowFilesManager.java

@@ -0,0 +1,13 @@
+package io.kestra.cli.services;
+
+import io.kestra.core.models.flows.Flow;
+import io.kestra.core.models.flows.FlowWithSource;
+
+public interface FlowFilesManager {
+
+    FlowWithSource createOrUpdateFlow(Flow flow, String content);
+
+    void deleteFlow(FlowWithSource toDelete);
+
+    void deleteFlow(String tenantId, String namespace, String id);
+}

cli/src/main/java/io/kestra/cli/services/LocalFlowFileWatcher.java

@@ -0,0 +1,38 @@
+package io.kestra.cli.services;
+
+import io.kestra.core.models.flows.Flow;
+import io.kestra.core.models.flows.FlowWithSource;
+import io.kestra.core.repositories.FlowRepositoryInterface;
+import io.kestra.core.services.PluginDefaultService;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class LocalFlowFileWatcher implements FlowFilesManager {
+    private final FlowRepositoryInterface flowRepository;
+    private final PluginDefaultService pluginDefaultService;
+
+    public LocalFlowFileWatcher(FlowRepositoryInterface flowRepository, PluginDefaultService pluginDefaultService) {
+        this.flowRepository = flowRepository;
+        this.pluginDefaultService = pluginDefaultService;
+    }
+
+    @Override
+    public FlowWithSource createOrUpdateFlow(Flow flow, String content) {
+        FlowWithSource withDefault = pluginDefaultService.injectDefaults(FlowWithSource.of(flow, content));
+        return flowRepository.findById(null, flow.getNamespace(), flow.getId())
+            .map(previous -> flowRepository.update(flow, previous, content, withDefault))
+            .orElseGet(() -> flowRepository.create(flow, content, withDefault));
+    }
+
+    @Override
+    public void deleteFlow(FlowWithSource toDelete) {
+        flowRepository.findByIdWithSource(toDelete.getTenantId(), toDelete.getNamespace(), toDelete.getId()).ifPresent(flowRepository::delete);
+        log.info("Flow {} has been deleted", toDelete.getId());
+    }
+
+    @Override
+    public void deleteFlow(String tenantId, String namespace, String id) {
+        flowRepository.findByIdWithSource(tenantId, namespace, id).ifPresent(flowRepository::delete);
+        log.info("Flow {} has been deleted", id);
+    }
+}

cli/src/main/resources/application.yml

@@ -37,6 +37,7 @@ micronaut:
         exclusions:
           - /ui/.+
           - /health
+          - /health/.+
           - /prometheus
     http-version: HTTP_1_1
   caches:
@@ -124,6 +125,7 @@ kestra:
     delay: 1s
     maxDelay: ""
 
+  jdbc:
     queues:
       min-poll-interval: 25ms
       max-poll-interval: 1000ms
@@ -158,6 +160,9 @@ kestra:
   metrics:
     prefix: kestra
 
+  traces:
+    root: DISABLED
+
   server:
     basic-auth:
       enabled: false
@@ -187,3 +192,17 @@ kestra:
     uri: https://api.kestra.io/v1/reports/usages
     initial-delay: 5m
     fixed-delay: 1h
+
+  hidden-labels:
+    prefixes:
+      - system.
+      - internal.
+
+otel:
+  exclusions:
+    - /ping
+    - /metrics
+    - /health
+    - /env
+    - /prometheus
+  propagators: tracecontext, baggage

cli/src/test/java/io/kestra/cli/commands/flows/FlowCreateOrUpdateCommandTest.java

@@ -0,0 +1,137 @@
+package io.kestra.cli.commands.flows;
+
+import io.micronaut.configuration.picocli.PicocliRunner;
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.context.env.Environment;
+import io.micronaut.runtime.server.EmbeddedServer;
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.net.URL;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.StringContains.containsString;
+
+class FlowCreateOrUpdateCommandTest {
+    @Test
+    void runWithDelete()  {
+        URL directory = FlowCreateOrUpdateCommandTest.class.getClassLoader().getResource("flows");
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(out));
+        URL subDirectory = FlowCreateOrUpdateCommandTest.class.getClassLoader().getResource("flows/same");
+
+        try (ApplicationContext ctx = ApplicationContext.run(Environment.CLI, Environment.TEST)) {
+
+            EmbeddedServer embeddedServer = ctx.getBean(EmbeddedServer.class);
+            embeddedServer.start();
+
+            String[] args = {
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                "--delete",
+                directory.getPath(),
+            };
+            PicocliRunner.call(FlowUpdatesCommand.class, ctx, args);
+
+            assertThat(out.toString(), containsString("4 flow(s)"));
+            out.reset();
+
+            args = new String[]{
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                "--delete",
+                subDirectory.getPath(),
+
+            };
+            PicocliRunner.call(FlowUpdatesCommand.class, ctx, args);
+
+            // 2 delete + 1 update
+            assertThat(out.toString(), containsString("4 flow(s)"));
+        }
+    }
+
+    @Test
+    void runNoDelete()  {
+        URL directory = FlowCreateOrUpdateCommandTest.class.getClassLoader().getResource("flows");
+        URL subDirectory = FlowCreateOrUpdateCommandTest.class.getClassLoader().getResource("flows/same/flowsSubFolder");
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(out));
+
+        try (ApplicationContext ctx = ApplicationContext.run(Environment.CLI, Environment.TEST)) {
+
+            EmbeddedServer embeddedServer = ctx.getBean(EmbeddedServer.class);
+            embeddedServer.start();
+
+            String[] args = {
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                directory.getPath(),
+
+            };
+            PicocliRunner.call(FlowUpdatesCommand.class, ctx, args);
+
+            assertThat(out.toString(), containsString("4 flow(s)"));
+            out.reset();
+
+            // no "delete" arg should behave as no-delete
+            args = new String[]{
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                subDirectory.getPath()
+            };
+            PicocliRunner.call(FlowUpdatesCommand.class, ctx, args);
+
+            assertThat(out.toString(), containsString("1 flow(s)"));
+            out.reset();
+
+            args = new String[]{
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                "--no-delete",
+                subDirectory.getPath()
+            };
+            PicocliRunner.call(FlowUpdatesCommand.class, ctx, args);
+
+            assertThat(out.toString(), containsString("1 flow(s)"));
+        }
+    }
+
+    @Test
+    void helper()  {
+        URL directory = FlowCreateOrUpdateCommandTest.class.getClassLoader().getResource("helper");
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(out));
+
+        try (ApplicationContext ctx = ApplicationContext.run(Environment.CLI, Environment.TEST)) {
+
+            EmbeddedServer embeddedServer = ctx.getBean(EmbeddedServer.class);
+            embeddedServer.start();
+
+            String[] args = {
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                directory.getPath(),
+
+            };
+            Integer call = PicocliRunner.call(FlowUpdatesCommand.class, ctx, args);
+
+            assertThat(call, is(0));
+            assertThat(out.toString(), containsString("1 flow(s)"));
+        }
+    }
+}

cli/src/test/java/io/kestra/cli/commands/flows/FlowDotCommandTest.java

@@ -16,7 +16,7 @@ import static org.hamcrest.core.StringContains.containsString;
 class FlowDotCommandTest {
     @Test
     void run()  {
-        URL directory = TemplateValidateCommandTest.class.getClassLoader().getResource("flows/first.yaml");
+        URL directory = TemplateValidateCommandTest.class.getClassLoader().getResource("flows/same/first.yaml");
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         System.setOut(new PrintStream(out));
 
@@ -27,7 +27,7 @@ class FlowDotCommandTest {
             Integer call = PicocliRunner.call(FlowDotCommand.class, ctx, args);
 
             assertThat(call, is(0));
-            assertThat(out.toString(), containsString("\"root.date\"[shape=box,label=\"date\"];"));
+            assertThat(out.toString(), containsString("\"root.date\"[shape=box];"));
         }
     }
 }

cli/src/test/java/io/kestra/cli/commands/flows/FlowExpandCommandTest.java

@@ -19,7 +19,7 @@ class FlowExpandCommandTest {
 
         try (ApplicationContext ctx = ApplicationContext.builder().deduceEnvironment(false).start()) {
             String[] args = {
-                "src/test/resources/helper/flow.yaml"
+                "src/test/resources/helper/include.yaml"
             };
             Integer call = PicocliRunner.call(FlowExpandCommand.class, ctx, args);
 

cli/src/test/java/io/kestra/cli/commands/flows/FlowExportCommandTest.java

@@ -22,7 +22,7 @@ import static org.hamcrest.core.StringContains.containsString;
 class FlowExportCommandTest {
     @Test
     void run() throws IOException {
-        URL directory = FlowExportCommandTest.class.getClassLoader().getResource("flows");
+        URL directory = FlowExportCommandTest.class.getClassLoader().getResource("flows/same");
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         System.setOut(new PrintStream(out));
 

cli/src/test/java/io/kestra/cli/commands/flows/FlowUpdatesCommandTest.java

@@ -0,0 +1,137 @@
+package io.kestra.cli.commands.flows;
+
+import io.micronaut.configuration.picocli.PicocliRunner;
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.context.env.Environment;
+import io.micronaut.runtime.server.EmbeddedServer;
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.net.URL;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.StringContains.containsString;
+
+class FlowUpdatesCommandTest {
+    @Test
+    void runWithDelete()  {
+        URL directory = FlowUpdatesCommandTest.class.getClassLoader().getResource("flows");
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(out));
+        URL subDirectory = FlowUpdatesCommandTest.class.getClassLoader().getResource("flows/same");
+
+        try (ApplicationContext ctx = ApplicationContext.run(Environment.CLI, Environment.TEST)) {
+
+            EmbeddedServer embeddedServer = ctx.getBean(EmbeddedServer.class);
+            embeddedServer.start();
+
+            String[] args = {
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                "--delete",
+                directory.getPath(),
+            };
+            PicocliRunner.call(FlowUpdatesCommand.class, ctx, args);
+
+            assertThat(out.toString(), containsString("successfully updated !"));
+            out.reset();
+
+            args = new String[]{
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                "--delete",
+                subDirectory.getPath(),
+
+            };
+            PicocliRunner.call(FlowUpdatesCommand.class, ctx, args);
+
+            // 2 delete + 1 update
+            assertThat(out.toString(), containsString("successfully updated !"));
+        }
+    }
+
+    @Test
+    void runNoDelete()  {
+        URL directory = FlowUpdatesCommandTest.class.getClassLoader().getResource("flows");
+        URL subDirectory = FlowUpdatesCommandTest.class.getClassLoader().getResource("flows/same/flowsSubFolder");
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(out));
+
+        try (ApplicationContext ctx = ApplicationContext.run(Environment.CLI, Environment.TEST)) {
+
+            EmbeddedServer embeddedServer = ctx.getBean(EmbeddedServer.class);
+            embeddedServer.start();
+
+            String[] args = {
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                directory.getPath(),
+
+            };
+            PicocliRunner.call(FlowUpdatesCommand.class, ctx, args);
+
+            assertThat(out.toString(), containsString("4 flow(s)"));
+            out.reset();
+
+            // no "delete" arg should behave as no-delete
+            args = new String[]{
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                subDirectory.getPath()
+            };
+            PicocliRunner.call(FlowUpdatesCommand.class, ctx, args);
+
+            assertThat(out.toString(), containsString("1 flow(s)"));
+            out.reset();
+
+            args = new String[]{
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                "--no-delete",
+                subDirectory.getPath()
+            };
+            PicocliRunner.call(FlowUpdatesCommand.class, ctx, args);
+
+            assertThat(out.toString(), containsString("1 flow(s)"));
+        }
+    }
+
+    @Test
+    void helper()  {
+        URL directory = FlowUpdatesCommandTest.class.getClassLoader().getResource("helper");
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(out));
+
+        try (ApplicationContext ctx = ApplicationContext.run(Environment.CLI, Environment.TEST)) {
+
+            EmbeddedServer embeddedServer = ctx.getBean(EmbeddedServer.class);
+            embeddedServer.start();
+
+            String[] args = {
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                directory.getPath(),
+
+            };
+            Integer call = PicocliRunner.call(FlowUpdatesCommand.class, ctx, args);
+
+            assertThat(call, is(0));
+            assertThat(out.toString(), containsString("1 flow(s)"));
+        }
+    }
+}

cli/src/test/java/io/kestra/cli/commands/flows/FlowValidateCommandTest.java

@@ -20,7 +20,7 @@ class FlowValidateCommandTest {
         try (ApplicationContext ctx = ApplicationContext.builder().deduceEnvironment(false).start()) {
             String[] args = {
                 "--local",
-                "src/test/resources/helper/flow.yaml"
+                "src/test/resources/helper/include.yaml"
             };
             Integer call = PicocliRunner.call(FlowValidateCommand.class, ctx, args);
 
@@ -42,7 +42,9 @@ class FlowValidateCommandTest {
             Integer call = PicocliRunner.call(FlowValidateCommand.class, ctx, args);
 
             assertThat(call, is(0));
-            assertThat(out.toString(), containsString("tasks[0] is deprecated"));
+            assertThat(out.toString(), containsString("✓ - system / warning"));
+            assertThat(out.toString(), containsString("⚠ - tasks[0] is deprecated"));
+            assertThat(out.toString(), containsString("ℹ - io.kestra.core.tasks.log.Log is replaced by io.kestra.plugin.core.log.Log"));
         }
     }
 }

cli/src/test/java/io/kestra/cli/commands/flows/SingleFlowCommandsTest.java

@@ -0,0 +1,71 @@
+package io.kestra.cli.commands.flows;
+
+import io.micronaut.configuration.picocli.PicocliRunner;
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.context.env.Environment;
+import io.micronaut.runtime.server.EmbeddedServer;
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.net.URL;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.StringContains.containsString;
+
+public class SingleFlowCommandsTest {
+
+
+    @Test
+    void all() {
+        URL flow = SingleFlowCommandsTest.class.getClassLoader().getResource("flows/quattro.yml");
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(out));
+
+        try (ApplicationContext ctx = ApplicationContext.run(Environment.CLI, Environment.TEST)) {
+
+            EmbeddedServer embeddedServer = ctx.getBean(EmbeddedServer.class);
+            embeddedServer.start();
+
+            String[] deleteArgs = {
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                "io.kestra.outsider",
+                "quattro"
+            };
+            PicocliRunner.call(FlowDeleteCommand.class, ctx, deleteArgs);
+
+            assertThat(out.toString(), containsString("Flow successfully deleted !"));
+            out.reset();
+
+            String[] createArgs = {
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                flow.getPath(),
+            };
+            PicocliRunner.call(FlowCreateCommand.class, ctx, createArgs);
+
+            assertThat(out.toString(), containsString("Flow successfully created !"));
+
+
+            out.reset();String[] updateArgs = {
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                flow.getPath(),
+                "io.kestra.outsider",
+                "quattro"
+            };
+            PicocliRunner.call(FlowUpdateCommand.class, ctx, updateArgs);
+
+            assertThat(out.toString(), containsString("Flow successfully updated !"));
+            out.reset();
+        }
+    }
+
+}

cli/src/test/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceUpdateCommandTest.java

@@ -11,16 +11,17 @@ import java.io.PrintStream;
 import java.net.URL;
 
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.not;
 import static org.hamcrest.core.StringContains.containsString;
 import static org.hamcrest.core.Is.is;
 
 class FlowNamespaceUpdateCommandTest {
     @Test
-    void runWithDelete()  {
-        URL directory = FlowNamespaceUpdateCommandTest.class.getClassLoader().getResource("flows");
+    void runWithDelete() {
+        URL directory = FlowNamespaceUpdateCommandTest.class.getClassLoader().getResource("flows/same");
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         System.setOut(new PrintStream(out));
-        URL subDirectory = FlowNamespaceUpdateCommandTest.class.getClassLoader().getResource("flows/flowsSubFolder");
+        URL subDirectory = FlowNamespaceUpdateCommandTest.class.getClassLoader().getResource("flows/same/flowsSubFolder");
 
         try (ApplicationContext ctx = ApplicationContext.run(Environment.CLI, Environment.TEST)) {
 
@@ -38,7 +39,7 @@ class FlowNamespaceUpdateCommandTest {
             };
             PicocliRunner.call(FlowNamespaceUpdateCommand.class, ctx, args);
 
-            assertThat(out.toString(), containsString("3 flow(s)"));
+            assertThat(out.toString(), containsString("namespace 'io.kestra.cli' successfully updated"));
             out.reset();
 
             args = new String[]{
@@ -54,12 +55,12 @@ class FlowNamespaceUpdateCommandTest {
             PicocliRunner.call(FlowNamespaceUpdateCommand.class, ctx, args);
 
             // 2 delete + 1 update
-            assertThat(out.toString(), containsString("3 flow(s)"));
+            assertThat(out.toString(), containsString("namespace 'io.kestra.cli' successfully updated"));
         }
     }
 
     @Test
-    void invalid()  {
+    void invalid() {
         URL directory = FlowNamespaceUpdateCommandTest.class.getClassLoader().getResource("invalids");
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         System.setErr(new PrintStream(out));
@@ -87,9 +88,9 @@ class FlowNamespaceUpdateCommandTest {
     }
 
     @Test
-    void runNoDelete()  {
-        URL directory = FlowNamespaceUpdateCommandTest.class.getClassLoader().getResource("flows");
-        URL subDirectory = FlowNamespaceUpdateCommandTest.class.getClassLoader().getResource("flows/flowsSubFolder");
+    void runNoDelete() {
+        URL directory = FlowNamespaceUpdateCommandTest.class.getClassLoader().getResource("flows/same");
+        URL subDirectory = FlowNamespaceUpdateCommandTest.class.getClassLoader().getResource("flows/same/flowsSubFolder");
 
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         System.setOut(new PrintStream(out));
@@ -143,7 +144,7 @@ class FlowNamespaceUpdateCommandTest {
     }
 
     @Test
-    void helper()  {
+    void helper() {
         URL directory = FlowNamespaceUpdateCommandTest.class.getClassLoader().getResource("helper");
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         System.setOut(new PrintStream(out));
@@ -168,4 +169,35 @@ class FlowNamespaceUpdateCommandTest {
             assertThat(out.toString(), containsString("1 flow(s)"));
         }
     }
+
+    @Test
+    void runOverride() {
+        URL directory = FlowNamespaceUpdateCommandTest.class.getClassLoader().getResource("flows");
+        URL subDirectory = FlowNamespaceUpdateCommandTest.class.getClassLoader().getResource("flows/same/flowsSubFolder");
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(out));
+
+        try (ApplicationContext ctx = ApplicationContext.run(Environment.CLI, Environment.TEST)) {
+
+            EmbeddedServer embeddedServer = ctx.getBean(EmbeddedServer.class);
+            embeddedServer.start();
+
+            String[] args = {
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                "io.kestra.override",
+                "--override-namespaces",
+                directory.getPath(),
+
+            };
+            PicocliRunner.call(FlowNamespaceUpdateCommand.class, ctx, args);
+
+            assertThat(out.toString(), containsString("io.kestra.override"));
+            assertThat(out.toString(), not(containsString("io.kestra.cli")));
+
+        }
+    }
 }

cli/src/test/java/io/kestra/cli/commands/sys/ReindexCommandTest.java

@@ -18,7 +18,7 @@ import static org.hamcrest.core.StringContains.containsString;
 class ReindexCommandTest {
     @Test
     void reindexFlow() {
-        URL directory = ReindexCommandTest.class.getClassLoader().getResource("flows");
+        URL directory = ReindexCommandTest.class.getClassLoader().getResource("flows/same");
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         System.setOut(new PrintStream(out));
 

cli/src/test/java/io/kestra/cli/commands/sys/statestore/StateStoreMigrateCommandTest.java

@@ -52,11 +52,12 @@ class StateStoreMigrateCommandTest {
             URI oldStateStoreUri = URI.create("/" + flow.getNamespace().replace(".", "/") + "/" + Slugify.of("a-flow") + "/states/my-state/" + Hashing.hashToString("my-taskrun-value") + "/sub-name");
             storage.put(
                 tenantId,
+                flow.getNamespace(),
                 oldStateStoreUri,
                 new ByteArrayInputStream("my-value".getBytes())
             );
             assertThat(
-                storage.exists(tenantId, oldStateStoreUri),
+                storage.exists(tenantId, flow.getNamespace(), oldStateStoreUri),
                 is(true)
             );
 
@@ -73,7 +74,7 @@ class StateStoreMigrateCommandTest {
 
             assertThat(new String(stateStore.getState(true, "my-state", "sub-name", "my-taskrun-value").readAllBytes()), is("my-value"));
             assertThat(
-                storage.exists(tenantId, oldStateStoreUri),
+                storage.exists(tenantId, flow.getNamespace(), oldStateStoreUri),
                 is(false)
             );
 

cli/src/test/java/io/kestra/cli/services/FileChangedEventListenerTest.java

@@ -0,0 +1,131 @@
+package io.kestra.cli.services;
+
+import io.kestra.core.models.flows.Flow;
+import io.kestra.core.repositories.FlowRepositoryInterface;
+import io.kestra.core.utils.Await;
+import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import jakarta.inject.Inject;
+import org.apache.commons.io.FileUtils;
+import org.junit.jupiter.api.*;
+import org.junitpioneer.jupiter.RetryingTest;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.Duration;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static io.kestra.core.utils.Rethrow.throwRunnable;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+@MicronautTest(environments = {"test", "file-watch"}, transactional = false)
+class FileChangedEventListenerTest {
+    public static final String FILE_WATCH = "build/file-watch";
+    @Inject
+    private FileChangedEventListener fileWatcher;
+
+    @Inject
+    private FlowRepositoryInterface flowRepository;
+
+    private final ExecutorService executorService = Executors.newSingleThreadExecutor();
+    private final AtomicBoolean started = new AtomicBoolean(false);
+
+    @BeforeAll
+    static void setup() throws IOException {
+        if (!Files.exists(Path.of(FILE_WATCH))) {
+            Files.createDirectories(Path.of(FILE_WATCH));
+        }
+    }
+
+    @AfterAll
+    static void tearDown() throws IOException {
+        if (Files.exists(Path.of(FILE_WATCH))) {
+            FileUtils.deleteDirectory(Path.of(FILE_WATCH).toFile());
+        }
+    }
+
+    @BeforeEach
+    void beforeEach() throws Exception {
+        if (started.compareAndSet(false, true)) {
+            executorService.execute(throwRunnable(() -> fileWatcher.startListeningFromConfig()));
+        }
+    }
+
+    @RetryingTest(5) // Flaky on CI but always pass locally
+    void test() throws IOException, TimeoutException {
+        // remove the flow if it already exists
+        flowRepository.findByIdWithSource(null, "io.kestra.tests.watch", "myflow").ifPresent(flow -> flowRepository.delete(flow));
+
+        // create a basic flow
+        String flow = """
+            id: myflow
+            namespace: io.kestra.tests.watch
+
+            tasks:
+              - id: hello
+                type: io.kestra.plugin.core.log.Log
+                message: Hello World! 🚀
+            """;
+        Files.write(Path.of(FILE_WATCH + "/myflow.yaml"), flow.getBytes());
+        Await.until(
+            () -> flowRepository.findById(null, "io.kestra.tests.watch", "myflow").isPresent(),
+            Duration.ofMillis(100),
+            Duration.ofSeconds(10)
+        );
+        Flow myflow = flowRepository.findById(null, "io.kestra.tests.watch", "myflow").orElseThrow();
+        assertThat(myflow.getTasks(), hasSize(1));
+        assertThat(myflow.getTasks().getFirst().getId(), is("hello"));
+        assertThat(myflow.getTasks().getFirst().getType(), is("io.kestra.plugin.core.log.Log"));
+
+        // delete the flow
+        Files.delete(Path.of(FILE_WATCH + "/myflow.yaml"));
+        Await.until(
+            () -> flowRepository.findById(null, "io.kestra.tests.watch", "myflow").isEmpty(),
+            Duration.ofMillis(100),
+            Duration.ofSeconds(10)
+        );
+    }
+
+    @RetryingTest(5) // Flaky on CI but always pass locally
+    void testWithPluginDefault() throws IOException, TimeoutException {
+        // remove the flow if it already exists
+        flowRepository.findByIdWithSource(null, "io.kestra.tests.watch", "pluginDefault").ifPresent(flow -> flowRepository.delete(flow));
+
+        // create a flow with plugin default
+        String pluginDefault = """
+            id: pluginDefault
+            namespace: io.kestra.tests.watch
+
+            tasks:
+              - id: helloWithDefault
+                type: io.kestra.plugin.core.log.Log
+
+            pluginDefaults:
+              - type: io.kestra.plugin.core.log.Log
+                values:
+                  message: Hello World!
+            """;
+        Files.write(Path.of(FILE_WATCH + "/plugin-default.yaml"), pluginDefault.getBytes());
+        Await.until(
+            () -> flowRepository.findById(null, "io.kestra.tests.watch", "pluginDefault").isPresent(),
+            Duration.ofMillis(100),
+            Duration.ofSeconds(10)
+        );
+        Flow pluginDefaultFlow = flowRepository.findById(null, "io.kestra.tests.watch", "pluginDefault").orElseThrow();
+        assertThat(pluginDefaultFlow.getTasks(), hasSize(1));
+        assertThat(pluginDefaultFlow.getTasks().getFirst().getId(), is("helloWithDefault"));
+        assertThat(pluginDefaultFlow.getTasks().getFirst().getType(), is("io.kestra.plugin.core.log.Log"));
+
+        // delete both files
+        Files.delete(Path.of(FILE_WATCH + "/plugin-default.yaml"));
+        Await.until(
+            () -> flowRepository.findById(null, "io.kestra.tests.watch", "pluginDefault").isEmpty(),
+            Duration.ofMillis(100),
+            Duration.ofSeconds(10)
+        );
+    }
+}

cli/src/test/resources/application-file-watch.yml

@@ -0,0 +1,12 @@
+micronaut:
+  io:
+    watch:
+      enabled: true
+      paths:
+        - build/file-watch
+
+kestra:
+  repository:
+    type: memory
+  queue:
+    type: memory

cli/src/test/resources/flows/quattro.yml

@@ -0,0 +1,7 @@
+id: quattro
+namespace: io.kestra.outsider
+
+tasks:
+  - id: date
+    type: io.kestra.plugin.core.debug.Return
+    format: "{{taskrun.startDate}}"

cli/src/test/resources/warning/flow-with-warning.yaml

@@ -4,4 +4,7 @@ namespace: system
 tasks:
   - id: deprecated
     type: io.kestra.plugin.core.debug.Echo
-    format: Hello World
+    format: Hello World
+  - id: alias
+    type: io.kestra.core.tasks.log.Log
+    message: I'm an alias

core/build.gradle

@@ -3,7 +3,7 @@ configurations {
     implementation.extendsFrom(micronaut)
 }
 
-task copyGradleProperties(type: Copy) {
+tasks.register('copyGradleProperties', Copy) {
     group = "build"
     shouldRunAfter compileJava
 
@@ -36,6 +36,7 @@ dependencies {
     implementation group: 'de.focus-shift', name: 'jollyday-jaxb'
     implementation 'nl.basjes.gitignore:gitignore-reader'
     implementation group: 'dev.failsafe', name: 'failsafe'
+    api 'org.apache.httpcomponents.client5:httpclient5'
 
     // scheduler
     implementation group: 'com.cronutils', name: 'cron-utils'
@@ -64,4 +65,8 @@ dependencies {
     testImplementation "io.micronaut:micronaut-http-client"
     testImplementation "io.micronaut:micronaut-http-server-netty"
     testImplementation "io.micronaut:micronaut-management"
+
+    testImplementation "org.testcontainers:testcontainers:1.20.4"
+    testImplementation "org.testcontainers:junit-jupiter:1.20.4"
+    testImplementation "org.bouncycastle:bcpkix-jdk18on:1.80"
 }

core/src/main/java/io/kestra/core/app/AppBlockInterface.java

@@ -0,0 +1,23 @@
+package io.kestra.core.app;
+
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import io.kestra.core.models.annotations.Plugin;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Pattern;
+
+/**
+ * Top-level marker interface for Kestra's plugin of type App.
+ */
+@Plugin
+@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, property = "type", visible = true, include = JsonTypeInfo.As.PROPERTY)
+public interface AppBlockInterface extends io.kestra.core.models.Plugin {
+    @Schema(
+        title = "The type of the block."
+    )
+    @NotNull
+    @NotBlank
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
+    String getType();
+}

core/src/main/java/io/kestra/core/app/AppPluginInterface.java

@@ -0,0 +1,23 @@
+package io.kestra.core.app;
+
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import io.kestra.core.models.annotations.Plugin;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Pattern;
+
+/**
+ * Top-level marker interface for Kestra's plugin of type App.
+ */
+@Plugin
+@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, property = "type", visible = true, include = JsonTypeInfo.As.PROPERTY)
+public interface AppPluginInterface extends io.kestra.core.models.Plugin {
+    @Schema(
+        title = "The type of the app."
+    )
+    @NotNull
+    @NotBlank
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
+    String getType();
+}

core/src/main/java/io/kestra/core/docs/AbstractClassDocumentation.java

@@ -54,6 +54,8 @@ public abstract class AbstractClassDocumentation<T> {
             // Remove the Task entry as it only contains a reference that is filtered in the doc template,
             // which prevent the Definitions section to be empty if no other def exist.
             .filter(entry -> !entry.getKey().equals("io.kestra.core.models.tasks.Task"))
+            // Remove definitions of all Input subtypes if base class is null
+            .filter(entry -> (baseCls == null) || !entry.getKey().startsWith("io.kestra.core.models.flows.input."))
             .map(entry -> {
                 Map<String, Object> value = (Map<String, Object>) entry.getValue();
                 value.put("properties", flatten(properties(value), required(value), isTypeToKeep(entry.getKey())));
@@ -126,8 +128,8 @@ public abstract class AbstractClassDocumentation<T> {
             }
 
             result.put(flattenKey(current.getKey(), parentName), finalValue);
-            if (current.getValue() instanceof Map) {
-                Map<String, Object> value = (Map<String, Object>) current.getValue();
+            if (current.getValue() instanceof Map<?, ?> mapValue) {
+                Map<String, Object> value = (Map<String, Object>) mapValue;
 
                 if (value.containsKey("properties")) {
                     result.putAll(flatten(properties(value), required(value), current.getKey()));

core/src/main/java/io/kestra/core/docs/Document.java

@@ -13,4 +13,5 @@ public class Document {
     private final String path;
     private final String body;
     private final String icon;
+    private final Schema schema;
 }

core/src/main/java/io/kestra/core/docs/DocumentationGenerator.java

@@ -4,6 +4,7 @@ import com.google.common.base.Charsets;
 import com.google.common.collect.ImmutableMap;
 import io.kestra.core.models.annotations.PluginSubGroup;
 import io.kestra.core.models.conditions.Condition;
+import io.kestra.core.models.tasks.logs.LogExporter;
 import io.kestra.core.models.tasks.runners.TaskRunner;
 import io.kestra.core.models.tasks.Task;
 import io.kestra.core.models.triggers.AbstractTrigger;
@@ -69,7 +70,9 @@ public class DocumentationGenerator {
         result.addAll(this.generate(registeredPlugin, registeredPlugin.getTasks(), Task.class, "tasks"));
         result.addAll(this.generate(registeredPlugin, registeredPlugin.getTriggers(), AbstractTrigger.class, "triggers"));
         result.addAll(this.generate(registeredPlugin, registeredPlugin.getConditions(), Condition.class, "conditions"));
-        result.addAll(this.generate(registeredPlugin, registeredPlugin.getTaskRunners(), TaskRunner.class, "task-runners"));
+        //noinspection unchecked
+        result.addAll(this.generate(registeredPlugin, registeredPlugin.getTaskRunners(), (Class) TaskRunner.class, "task-runners"));
+        result.addAll(this.generate(registeredPlugin, registeredPlugin.getLogExporters(), LogExporter.class, "log-exporters"));
 
         result.addAll(guides(registeredPlugin));
 
@@ -114,7 +117,8 @@ public class DocumentationGenerator {
         return Collections.singletonList(new Document(
             docPath(plugin),
             render("index", builder.build()),
-            plugin.icon("plugin-icon")
+            plugin.icon("plugin-icon"),
+            null
         ));
     }
 
@@ -203,12 +207,12 @@ public class DocumentationGenerator {
             .map(throwFunction(e -> new Document(
                 pluginName + "/guides/" + e.getKey()  + ".md",
                 e.getValue(),
+                null,
                 null
             )))
             .toList();
     }
 
-
     private <T> List<Document> generate(RegisteredPlugin registeredPlugin, List<Class<? extends T>> cls, Class<T> baseCls, String type) {
         return cls
             .stream()
@@ -218,7 +222,8 @@ public class DocumentationGenerator {
                     return new Document(
                         docPath(registeredPlugin, type, pluginDocumentation),
                         render(pluginDocumentation),
-                        pluginDocumentation.getIcon()
+                        pluginDocumentation.getIcon(),
+                        new Schema(pluginDocumentation.getPropertiesSchema(), pluginDocumentation.getOutputsSchema(), pluginDocumentation.getDefs())
                     );
                 } catch (IOException e) {
                     throw new RuntimeException(e);

core/src/main/java/io/kestra/core/docs/JsonSchemaGenerator.java

@@ -16,28 +16,32 @@ import com.github.victools.jsonschema.module.jakarta.validation.JakartaValidatio
 import com.github.victools.jsonschema.module.jakarta.validation.JakartaValidationOption;
 import com.github.victools.jsonschema.module.swagger2.Swagger2Module;
 import com.google.common.collect.ImmutableMap;
-import io.kestra.core.models.property.Property;
 import io.kestra.core.models.annotations.Plugin;
 import io.kestra.core.models.annotations.PluginProperty;
 import io.kestra.core.models.conditions.Condition;
 import io.kestra.core.models.conditions.ScheduleCondition;
+import io.kestra.core.models.dashboards.DataFilter;
+import io.kestra.core.models.dashboards.charts.Chart;
+import io.kestra.core.models.dashboards.charts.DataChart;
+import io.kestra.core.models.property.Data;
+import io.kestra.core.models.property.Property;
 import io.kestra.core.models.tasks.Output;
 import io.kestra.core.models.tasks.Task;
+import io.kestra.core.models.tasks.common.EncryptedString;
+import io.kestra.core.models.tasks.logs.LogExporter;
 import io.kestra.core.models.tasks.runners.TaskRunner;
 import io.kestra.core.models.triggers.AbstractTrigger;
 import io.kestra.core.plugins.PluginRegistry;
 import io.kestra.core.plugins.RegisteredPlugin;
 import io.kestra.core.serializers.JacksonMapper;
 import io.micronaut.core.annotation.Nullable;
+import io.swagger.v3.oas.annotations.media.Content;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
 
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.lang.reflect.ParameterizedType;
-import java.time.Duration;
+import java.lang.reflect.*;
+import java.time.*;
 import java.util.*;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
@@ -45,6 +49,7 @@ import java.util.stream.StreamSupport;
 
 @Singleton
 public class JsonSchemaGenerator {
+    private static final List<Class<?>> TYPES_RESOLVED_AS_STRING = List.of(Duration.class, LocalTime.class, LocalDate.class, LocalDateTime.class, ZonedDateTime.class, OffsetDateTime.class, OffsetTime.class);
 
     private final PluginRegistry pluginRegistry;
 
@@ -76,6 +81,7 @@ public class JsonSchemaGenerator {
                 objectNode.put("type", "array");
             }
             replaceAnyOfWithOneOf(objectNode);
+            pullOfDefaultFromOneOf(objectNode);
 
             return JacksonMapper.toMap(objectNode);
         } catch (IllegalArgumentException e) {
@@ -83,7 +89,7 @@ public class JsonSchemaGenerator {
         }
     }
 
-    private static void replaceAnyOfWithOneOf(ObjectNode objectNode) {
+    private void replaceAnyOfWithOneOf(ObjectNode objectNode) {
         objectNode.findParents("anyOf").forEach(jsonNode -> {
             if (jsonNode instanceof ObjectNode oNode) {
                 oNode.set("oneOf", oNode.remove("anyOf"));
@@ -91,6 +97,30 @@ public class JsonSchemaGenerator {
         });
     }
 
+    // This hack exists because for Property we generate a oneOf for properties that are not strings.
+    // By default, the 'default' is in each oneOf which Monaco editor didn't take into account.
+    // So, we pull off the 'default' from any of the oneOf to the parent.
+    private void pullOfDefaultFromOneOf(ObjectNode objectNode) {
+        objectNode.findParents("oneOf").forEach(jsonNode -> {
+            if (jsonNode instanceof ObjectNode oNode) {
+                JsonNode oneOf = oNode.get("oneOf");
+                if (oneOf instanceof ArrayNode arrayNode) {
+                    Iterator<JsonNode> it = arrayNode.elements();
+                    JsonNode defaultNode = null;
+                    while (it.hasNext() && defaultNode == null) {
+                        JsonNode next = it.next();
+                        if (next instanceof ObjectNode nextAsObj) {
+                            defaultNode = nextAsObj.get("default");
+                        }
+                    }
+                    if (defaultNode != null) {
+                        oNode.set("default", defaultNode);
+                    }
+                }
+            }
+        });
+    }
+
     private void mutateDescription(ObjectNode collectedTypeAttributes) {
         if (collectedTypeAttributes.has("description")) {
             collectedTypeAttributes.set("markdownDescription", collectedTypeAttributes.get("description"));
@@ -203,7 +233,11 @@ public class JsonSchemaGenerator {
                         ObjectNode definitionReference = context
                             .createDefinitionReference(context.getTypeContext().resolve(String.class))
                             .put("format", "duration");
-
+                        return new CustomDefinition(definitionReference, true);
+                    } else if (javaType.isInstanceOf(LocalTime.class)) {
+                        ObjectNode definitionReference = context
+                            .createDefinitionReference(context.getTypeContext().resolve(String.class))
+                            .put("format", "partial-time"); // we change the default 'time' format for 'partial-time' as Monaco Editor mandates an offset or a timezone for 'time' format
                         return new CustomDefinition(definitionReference, true);
                     } else {
                         return null;
@@ -211,12 +245,13 @@ public class JsonSchemaGenerator {
                 }
             });
 
-        // resolve dynamic types from Property
+        // resolve dynamic types from Property and make EncryptedString looks like a string
         builder.forFields().withTargetTypeOverridesResolver(target -> {
             ResolvedType javaType = target.getType();
             if (javaType.isInstanceOf(Property.class)) {
                 TypeContext context = target.getContext();
                 Class<?> erasedType = javaType.getTypeParameters().getFirst().getErasedType();
+
                 if(String.class.isAssignableFrom(erasedType)) {
                     return List.of(
                         context.resolve(String.class)
@@ -233,12 +268,21 @@ public class JsonSchemaGenerator {
                     return List.of(
                         javaType.getTypeParameters().getFirst()
                     );
+                } else if (isAssignableFromResolvedAsString(erasedType)) {
+                    return List.of(
+                        javaType.getTypeParameters().getFirst()
+                    );
                 } else {
                     return List.of(
                         javaType.getTypeParameters().getFirst(),
                         context.resolve(String.class)
                     );
                 }
+            } else if (javaType.isInstanceOf(EncryptedString.class)) {
+                TypeContext context = target.getContext();
+                return List.of(
+                    context.resolve(String.class)
+                );
             }
 
             return null;
@@ -266,11 +310,13 @@ public class JsonSchemaGenerator {
 
             if (member.getDeclaredType().isInstanceOf(Property.class)) {
                 memberAttributes.put("$dynamic", true);
-                // if we are in the String definition of a Property but the target type is not String: we configure the format
+                // if we are in the String definition of a Property but the target type is not String: we configure the pattern
                 Class<?> targetType = member.getDeclaredType().getTypeParameters().getFirst().getErasedType();
                 if (!String.class.isAssignableFrom(targetType) && String.class.isAssignableFrom(member.getType().getErasedType())) {
-                    memberAttributes.put("format", ".*{{.*}}.*");
+                    memberAttributes.put("pattern", ".*{{.*}}.*");
                 }
+            } else if (member.getDeclaredType().isInstanceOf(Data.class)) {
+                memberAttributes.put("$dynamic", false);
             }
         });
 
@@ -320,11 +366,20 @@ public class JsonSchemaGenerator {
                 }
             });
 
-        // PluginProperty additionalProperties
         builder.forFields().withAdditionalPropertiesResolver(target -> {
             PluginProperty pluginPropertyAnnotation = target.getAnnotationConsideringFieldAndGetter(PluginProperty.class);
+            Schema schemaAnnotation = target.getAnnotationConsideringFieldAndGetter(Schema.class);
+            Content contentAnnotation = target.getAnnotationConsideringFieldAndGetter(Content.class);
+            Schema contentSchemaAnnotation = contentAnnotation == null ? null : contentAnnotation.additionalPropertiesSchema();
+
             if (pluginPropertyAnnotation != null) {
                 return pluginPropertyAnnotation.additionalProperties();
+            } else if (target.getType().isInstanceOf(Map.class)) {
+                return target.getTypeParameterFor(Map.class, 1);
+            } else if (schemaAnnotation != null && schemaAnnotation.additionalPropertiesSchema() != Void.class) {
+                return schemaAnnotation.additionalPropertiesSchema();
+            } else if (contentSchemaAnnotation != null && contentSchemaAnnotation.additionalPropertiesSchema() != Void.class) {
+                return contentSchemaAnnotation.additionalPropertiesSchema();
             }
 
             return Object.class;
@@ -335,44 +390,8 @@ public class JsonSchemaGenerator {
             builder.forTypesInGeneral()
                 .withSubtypeResolver((declaredType, context) -> {
                     TypeContext typeContext = context.getTypeContext();
-                    if (declaredType.getErasedType() == Task.class) {
-                        return getRegisteredPlugins()
-                            .stream()
-                            .flatMap(registeredPlugin -> registeredPlugin.getTasks().stream())
-                            .filter(Predicate.not(io.kestra.core.models.Plugin::isInternal))
-                            .flatMap(clz -> safelyResolveSubtype(declaredType, clz, typeContext).stream())
-                            .toList();
-                    } else if (declaredType.getErasedType() == AbstractTrigger.class) {
-                        return getRegisteredPlugins()
-                            .stream()
-                            .flatMap(registeredPlugin -> registeredPlugin.getTriggers().stream())
-                            .filter(Predicate.not(io.kestra.core.models.Plugin::isInternal))
-                            .flatMap(clz -> safelyResolveSubtype(declaredType, clz, typeContext).stream())
-                            .toList();
-                    } else if (declaredType.getErasedType() == Condition.class) {
-                        return getRegisteredPlugins()
-                            .stream()
-                            .flatMap(registeredPlugin -> registeredPlugin.getConditions().stream())
-                            .filter(Predicate.not(io.kestra.core.models.Plugin::isInternal))
-                            .flatMap(clz -> safelyResolveSubtype(declaredType, clz, typeContext).stream())
-                            .toList();
-                    } else if (declaredType.getErasedType() == ScheduleCondition.class) {
-                        return getRegisteredPlugins()
-                            .stream()
-                            .flatMap(registeredPlugin -> registeredPlugin.getConditions().stream())
-                            .filter(ScheduleCondition.class::isAssignableFrom)
-                            .filter(Predicate.not(io.kestra.core.models.Plugin::isInternal))
-                            .flatMap(clz -> safelyResolveSubtype(declaredType, clz, typeContext).stream())
-                            .toList();
-                    } else if (declaredType.getErasedType() == TaskRunner.class) {
-                        return getRegisteredPlugins()
-                            .stream()
-                            .flatMap(registeredPlugin -> registeredPlugin.getTaskRunners().stream())
-                            .filter(Predicate.not(io.kestra.core.models.Plugin::isInternal))
-                            .flatMap(clz -> safelyResolveSubtype(declaredType, clz, typeContext).stream())
-                            .toList();
-                    }
-                    return null;
+
+                    return this.subtypeResolver(declaredType, typeContext);
                 });
 
             // description as Markdown
@@ -457,7 +476,88 @@ public class JsonSchemaGenerator {
         }
     }
 
-    private static Optional<ResolvedType> safelyResolveSubtype(ResolvedType declaredType, Class<?> clz, TypeContext typeContext) {
+    private boolean isAssignableFromResolvedAsString(Class<?> declaredType) {
+        for (Class<?> clazz : TYPES_RESOLVED_AS_STRING) {
+            if (clazz.isAssignableFrom(declaredType)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    protected List<ResolvedType> subtypeResolver(ResolvedType declaredType, TypeContext typeContext) {
+        if (declaredType.getErasedType() == Task.class) {
+            return getRegisteredPlugins()
+                .stream()
+                .flatMap(registeredPlugin -> registeredPlugin.getTasks().stream())
+                .filter(Predicate.not(io.kestra.core.models.Plugin::isInternal))
+                .flatMap(clz -> safelyResolveSubtype(declaredType, clz, typeContext).stream())
+                .toList();
+        } else if (declaredType.getErasedType() == AbstractTrigger.class) {
+            return getRegisteredPlugins()
+                .stream()
+                .flatMap(registeredPlugin -> registeredPlugin.getTriggers().stream())
+                .filter(Predicate.not(io.kestra.core.models.Plugin::isInternal))
+                .flatMap(clz -> safelyResolveSubtype(declaredType, clz, typeContext).stream())
+                .toList();
+        } else if (declaredType.getErasedType() == Condition.class) {
+            return getRegisteredPlugins()
+                .stream()
+                .flatMap(registeredPlugin -> registeredPlugin.getConditions().stream())
+                .filter(Predicate.not(io.kestra.core.models.Plugin::isInternal))
+                .flatMap(clz -> safelyResolveSubtype(declaredType, clz, typeContext).stream())
+                .toList();
+        } else if (declaredType.getErasedType() == ScheduleCondition.class) {
+            return getRegisteredPlugins()
+                .stream()
+                .flatMap(registeredPlugin -> registeredPlugin.getConditions().stream())
+                .filter(ScheduleCondition.class::isAssignableFrom)
+                .filter(Predicate.not(io.kestra.core.models.Plugin::isInternal))
+                .flatMap(clz -> safelyResolveSubtype(declaredType, clz, typeContext).stream())
+                .toList();
+        } else if (declaredType.getErasedType() == TaskRunner.class) {
+            return getRegisteredPlugins()
+                .stream()
+                .flatMap(registeredPlugin -> registeredPlugin.getTaskRunners().stream())
+                .filter(Predicate.not(io.kestra.core.models.Plugin::isInternal))
+                .map(typeContext::resolve)
+                .toList();
+        } else if (declaredType.getErasedType() == LogExporter.class) {
+            return getRegisteredPlugins()
+                .stream()
+                .flatMap(registeredPlugin -> registeredPlugin.getLogExporters().stream())
+                .filter(Predicate.not(io.kestra.core.models.Plugin::isInternal))
+                .map(typeContext::resolve)
+                .toList();
+        } else if (declaredType.getErasedType() == Chart.class) {
+            return getRegisteredPlugins()
+                .stream()
+                .flatMap(registeredPlugin -> registeredPlugin.getCharts().stream())
+                .filter(Predicate.not(io.kestra.core.models.Plugin::isInternal))
+                .<ResolvedType>mapMulti((clz, consumer) -> {
+                    if (DataChart.class.isAssignableFrom(clz)) {
+                        List<Class<? extends DataFilter<?, ?>>> dataFilters = getRegisteredPlugins()
+                            .stream()
+                            .flatMap(registeredPlugin -> registeredPlugin.getDataFilters().stream())
+                            .filter(Predicate.not(io.kestra.core.models.Plugin::isInternal))
+                            .toList();
+
+                        TypeVariable<? extends Class<? extends Chart<?>>> dataFilterType = clz.getTypeParameters()[1];
+                        ParameterizedType chartAwareColumnDescriptor = ((ParameterizedType) ((WildcardType) ((ParameterizedType) dataFilterType.getBounds()[0]).getActualTypeArguments()[1]).getUpperBounds()[0]);
+                        dataFilters.forEach(dataFilter -> {
+                            Type fieldsEnum = ((ParameterizedType) dataFilter.getGenericSuperclass()).getActualTypeArguments()[0];
+                            consumer.accept(typeContext.resolve(clz, fieldsEnum, typeContext.resolve(dataFilter, typeContext.resolve(chartAwareColumnDescriptor, fieldsEnum))));
+                        });
+                    } else {
+                        consumer.accept(typeContext.resolve(clz));
+                    }
+                }).toList();
+        }
+
+        return null;
+    }
+
+    protected static Optional<ResolvedType> safelyResolveSubtype(ResolvedType declaredType, Class<?> clz, TypeContext typeContext) {
         try {
             return Optional.ofNullable(typeContext.resolveSubtype(declaredType, clz));
         } catch (Exception e) {
@@ -502,6 +602,7 @@ public class JsonSchemaGenerator {
         try {
             ObjectNode objectNode = generator.generateSchema(cls);
             replaceAnyOfWithOneOf(objectNode);
+            pullOfDefaultFromOneOf(objectNode);
 
             return JacksonMapper.toMap(extractMainRef(objectNode));
         } catch (IllegalArgumentException e) {

core/src/main/java/io/kestra/core/docs/Plugin.java

@@ -31,10 +31,19 @@ public class Plugin {
     private List<String> taskRunners;
     private List<String> guides;
     private List<String> aliases;
+    private List<String> apps;
+    private List<String> appBlocks;
+    private List<String> charts;
+    private List<String> dataFilters;
+    private List<String> logExporters;
     private List<PluginSubGroup.PluginCategory> categories;
     private String subGroup;
 
     public static Plugin of(RegisteredPlugin registeredPlugin, @Nullable String subgroup) {
+        return Plugin.of(registeredPlugin, subgroup, true);
+    }
+
+    public static Plugin of(RegisteredPlugin registeredPlugin, @Nullable String subgroup, boolean includeDeprecated) {
         Plugin plugin = new Plugin();
         plugin.name = registeredPlugin.name();
         PluginSubGroup subGroupInfos = null;
@@ -75,13 +84,17 @@ public class Plugin {
 
         plugin.subGroup = subgroup;
 
-        plugin.tasks = filterAndGetClassName(registeredPlugin.getTasks()).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
-        plugin.triggers = filterAndGetClassName(registeredPlugin.getTriggers()).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
-        plugin.conditions = filterAndGetClassName(registeredPlugin.getConditions()).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
-        plugin.storages = filterAndGetClassName(registeredPlugin.getStorages()).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
-        plugin.secrets = filterAndGetClassName(registeredPlugin.getSecrets()).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
-        plugin.taskRunners = filterAndGetClassName(registeredPlugin.getTaskRunners()).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
-
+        plugin.tasks = filterAndGetClassName(registeredPlugin.getTasks(), includeDeprecated).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
+        plugin.triggers = filterAndGetClassName(registeredPlugin.getTriggers(), includeDeprecated).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
+        plugin.conditions = filterAndGetClassName(registeredPlugin.getConditions(), includeDeprecated).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
+        plugin.storages = filterAndGetClassName(registeredPlugin.getStorages(), includeDeprecated).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
+        plugin.secrets = filterAndGetClassName(registeredPlugin.getSecrets(), includeDeprecated).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
+        plugin.taskRunners = filterAndGetClassName(registeredPlugin.getTaskRunners(), includeDeprecated).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
+        plugin.apps = filterAndGetClassName(registeredPlugin.getApps(), includeDeprecated).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
+        plugin.appBlocks = filterAndGetClassName(registeredPlugin.getAppBlocks(), includeDeprecated).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
+        plugin.charts = filterAndGetClassName(registeredPlugin.getCharts(), includeDeprecated).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
+        plugin.dataFilters = filterAndGetClassName(registeredPlugin.getDataFilters(), includeDeprecated).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
+        plugin.logExporters = filterAndGetClassName(registeredPlugin.getLogExporters(), includeDeprecated).stream().filter(c -> subgroup == null || c.startsWith(subgroup)).toList();
 
         return plugin;
     }
@@ -91,12 +104,14 @@ public class Plugin {
      * Those classes are only filtered from the documentation to ensure backward compatibility.
      *
      * @param list The list of classes?
+     * @param includeDeprecated whether to include deprecated plugins or not
      * @return  a filtered streams.
      */
-    private static List<String> filterAndGetClassName(final List<? extends Class<?>> list) {
+    private static List<String> filterAndGetClassName(final List<? extends Class<?>> list, boolean includeDeprecated) {
         return list
             .stream()
             .filter(not(io.kestra.core.models.Plugin::isInternal))
+            .filter(p -> includeDeprecated || !io.kestra.core.models.Plugin.isDeprecated(p))
             .map(Class::getName)
             .filter(c -> !c.startsWith("org.kestra."))
             .toList();

core/src/main/java/io/kestra/core/docs/SchemaType.java

@@ -5,5 +5,7 @@ public enum SchemaType {
     template,
     task,
     trigger,
-    plugindefault
+    plugindefault,
+    apps,
+    dashboard
 }

core/src/main/java/io/kestra/core/endpoints/BasicAuthEndpointsFilter.java

@@ -31,8 +31,8 @@ public class BasicAuthEndpointsFilter implements HttpServerFilter {
     @Override
     public Publisher<MutableHttpResponse<?>> doFilter(HttpRequest<?> request, ServerFilterChain chain) {
         Optional<RouteMatch> routeMatch = RouteMatchUtils.findRouteMatch(request);
-        if (routeMatch.isPresent() && routeMatch.get() instanceof MethodBasedRouteMatch) {
-            ExecutableMethod<?, ?> method = ((MethodBasedRouteMatch<?, ?>) routeMatch.get()).getExecutableMethod();
+        if (routeMatch.isPresent() && routeMatch.get() instanceof MethodBasedRouteMatch<?, ?> methodBasedRouteMatch) {
+            ExecutableMethod<?, ?> method = methodBasedRouteMatch.getExecutableMethod();
             if (method.getAnnotation(Endpoint.class) != null) {
                 if (!validateUser(request)) {
                     return Publishers.just(HttpResponse.status(HttpStatus.UNAUTHORIZED));