WIP

.devcontainer/README.md

@@ -23,19 +23,9 @@ In the meantime, you can move onto the next step...
 
 ---
 
-### Requirements
-
-- Java 21 (LTS versions).
-  > ⚠️ Java 24 and above are not supported yet and will fail with `invalid source release: 21`.
-- Gradle (comes with wrapper `./gradlew`)
-- Docker (optional, for running Kestra in containers)
-
 ### Development:
 
-- (Optional) By default, your dev server will target `localhost:8080`. If your backend is running elsewhere, you can create `.env.development.local` under `ui` folder with this content:
-```
-VITE_APP_API_URL={myApiUrl}
-```
+- Create a `.env.development.local` file in the `ui` folder and paste the following:
 
 - Navigate into the `ui` folder and run `npm install` to install the dependencies for the frontend project.
 

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

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

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

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

.github/workflows/auto-translate-ui-keys.yml

@@ -26,7 +26,7 @@ jobs:
             fetch-depth: 0
 
         - name: Set up Python
-          uses: actions/setup-python@v6
+          uses: actions/setup-python@v5
           with:
             python-version: "3.x"
 
@@ -39,7 +39,7 @@ jobs:
             OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
 
         - name: Set up Node
-          uses: actions/setup-node@v5
+          uses: actions/setup-node@v4
           with:
             node-version: "20.x"
 

.github/workflows/codeql-analysis.yml

@@ -50,7 +50,7 @@ jobs:
 
     # Set up JDK
     - name: Set up JDK
-      uses: actions/setup-java@v5
+      uses: actions/setup-java@v4
       if: ${{ matrix.language == 'java' }}
       with:
         distribution: 'temurin'

.github/workflows/e2e-scheduling.yml

@@ -1,15 +0,0 @@
-name: 'E2E tests scheduling'
-# 'New E2E tests implementation started by Roman. Based on playwright in npm UI project, tests Kestra OSS develop docker image. These tests are written from zero, lets make them unflaky from the start!.'
-on:
-  schedule:
-    - cron: "0 * * * *"  # Every hour
-  workflow_dispatch:
-    inputs:
-      noInputYet:
-        description: 'not input yet.'
-        required: false
-        type: string
-        default: "no input"
-jobs:
-  e2e:
-    uses: kestra-io/actions/.github/workflows/kestra-oss-e2e-tests.yml@main

.github/workflows/e2e.yml

@@ -0,0 +1,86 @@
+name: 'E2E tests revival'
+description: 'New E2E tests implementation started by Roman. Based on playwright in npm UI project, tests Kestra OSS develop docker image. These tests are written from zero, lets make them unflaky from the start!.'
+on:
+  schedule:
+    - cron: "0 * * * *"  # Every hour
+  workflow_call:
+    inputs:
+      noInputYet:
+        description: 'not input yet.'
+        required: false
+        type: string
+        default: "no input"
+  workflow_dispatch:
+    inputs:
+      noInputYet:
+        description: 'not input yet.'
+        required: false
+        type: string
+        default: "no input"
+jobs:
+  check:
+    timeout-minutes: 15
+    runs-on: ubuntu-latest
+    env:
+      GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
+    steps:
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ github.token }}
+
+      - name: Checkout kestra
+        uses: actions/checkout@v5
+        with:
+          path: kestra
+
+      # Setup build
+      - uses: kestra-io/actions/.github/actions/setup-build@main
+        name: Setup - Build
+        id: build
+        with:
+          java-enabled: true
+          node-enabled: true
+          python-enabled: true
+
+      - name: Install Npm dependencies
+        run: |
+          cd kestra/ui
+          npm i
+          npx playwright install --with-deps chromium
+
+      - name: Run E2E Tests
+        run: |
+          cd kestra
+          sh build-and-start-e2e-tests.sh
+
+      - name: Upload Playwright Report as Github artifact
+        # 'With this report, you can analyze locally the results of the tests. see https://playwright.dev/docs/ci-intro#html-report'
+        uses: actions/upload-artifact@v4
+        if: ${{ !cancelled() }}
+        with:
+          name: playwright-report
+          path: kestra/ui/playwright-report/
+          retention-days: 7
+        # Allure check
+        # TODO I don't know what it should do
+#      - uses: rlespinasse/github-slug-action@v5
+#        name: Allure - Generate slug variables
+#
+#      - name: Allure - Publish report
+#        uses: andrcuns/allure-publish-action@v2.9.0
+#        if: always() && env.GOOGLE_SERVICE_ACCOUNT != ''
+#        continue-on-error: true
+#        env:
+#          GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_AUTH_TOKEN }}
+#          JAVA_HOME: /usr/lib/jvm/default-jvm/
+#        with:
+#          storageType: gcs
+#          resultsGlob: "**/build/allure-results"
+#          bucket: internal-kestra-host
+#          baseUrl: "https://internal.dev.kestra.io"
+#          prefix: ${{ format('{0}/{1}', github.repository, 'allure/java') }}
+#          copyLatest: true
+#          ignoreMissingResults: true

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

@@ -4,7 +4,7 @@ on:
   workflow_dispatch:
     inputs:
       releaseVersion:
-        description: 'The release version (e.g., 0.21.0)'
+        description: 'The release version (e.g., 0.21.0-rc1)'
         required: true
         type: string
       nextVersion:
@@ -25,17 +25,25 @@ jobs:
         with:
           fetch-depth: 0
 
+      # Checkout GitHub Actions
+      - uses: actions/checkout@v5
+        with:
+          repository: kestra-io/actions
+          path: actions
+          ref: main
+
       # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
+      - 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: kestra-io/actions/composite/kestra-oss/kestra-oss-plugins-list@main
+        uses: ./.github/actions/plugins-list
         id: plugins-list
         with:
           plugin-version: 'LATEST'
@@ -52,7 +60,7 @@ jobs:
           GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
         run: |
           chmod +x ./dev-tools/release-plugins.sh;
-
+          
           ./dev-tools/release-plugins.sh \
           --release-version=${{github.event.inputs.releaseVersion}} \
           --next-version=${{github.event.inputs.nextVersion}} \
@@ -65,10 +73,10 @@ jobs:
           GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
         run: |
           chmod +x ./dev-tools/release-plugins.sh;
-
+          
           ./dev-tools/release-plugins.sh \
           --release-version=${{github.event.inputs.releaseVersion}} \
           --next-version=${{github.event.inputs.nextVersion}} \
           --dry-run \
           --yes \
-          ${{ steps.plugins-list.outputs.repositories }}
+          ${{ steps.plugins-list.outputs.repositories }}

.github/workflows/gradle-release.yml

@@ -1,10 +1,10 @@
-name: Create new release branch
-run-name: "Create new release branch Kestra ${{ github.event.inputs.releaseVersion }} 🚀"
+name: Run Gradle Release
+run-name: "Releasing Kestra ${{ github.event.inputs.releaseVersion }} 🚀"
 on:
   workflow_dispatch:
     inputs:
       releaseVersion:
-        description: 'The release version (e.g., 0.21.0)'
+        description: 'The release version (e.g., 0.21.0-rc1)'
         required: true
         type: string
       nextVersion:
@@ -23,8 +23,8 @@ jobs:
       # Checks
       - name: Check Inputs
         run: |
-          if ! [[ "$RELEASE_VERSION" =~ ^[0-9]+(\.[0-9]+)\.0$ ]]; then
-            echo "Invalid release version. Must match regex: ^[0-9]+(\.[0-9]+)\.0$"
+          if ! [[ "$RELEASE_VERSION" =~ ^[0-9]+(\.[0-9]+)\.0-rc[01](-SNAPSHOT)?$ ]]; then
+            echo "Invalid release version. Must match regex: ^[0-9]+(\.[0-9]+)\.0-rc[01](-SNAPSHOT)?$"
             exit 1
           fi
 
@@ -38,8 +38,15 @@ jobs:
           fetch-depth: 0
           path: kestra
 
+      # Checkout GitHub Actions
+      - uses: actions/checkout@v5
+        with:
+          repository: kestra-io/actions
+          path: actions
+          ref: main
+
       # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
+      - uses: ./actions/.github/actions/setup-build
         id: build
         with:
           java-enabled: true
@@ -71,6 +78,7 @@ jobs:
           git checkout develop;
 
           if [[ "$RELEASE_VERSION" == *"-SNAPSHOT" ]]; then
+            # -SNAPSHOT qualifier maybe used to test release-candidates
             ./gradlew release -Prelease.useAutomaticVersion=true \
             -Prelease.releaseVersion="${RELEASE_VERSION}" \
             -Prelease.newVersion="${NEXT_VERSION}" \
@@ -81,4 +89,4 @@ jobs:
             -Prelease.releaseVersion="${RELEASE_VERSION}" \
             -Prelease.newVersion="${NEXT_VERSION}" \
             -Prelease.pushReleaseVersionBranch="${PUSH_RELEASE_BRANCH}"
-          fi
+          fi

.github/workflows/main-build.yml

@@ -1,86 +0,0 @@
-name: Main Workflow
-
-on:
-  push:
-    branches:
-      - releases/*
-      - develop
-
-  workflow_dispatch:
-    inputs:
-      skip-test:
-        description: 'Skip test'
-        type: choice
-        required: true
-        default: 'false'
-        options:
-          - "true"
-          - "false"
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}-main
-  cancel-in-progress: true
-
-jobs:
-  backend-tests:
-    name: Backend tests
-    if: ${{ github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '' }}
-    uses: kestra-io/actions/.github/workflows/kestra-oss-backend-tests.yml@main
-    secrets:
-      GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-      GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
-
-  frontend-tests:
-    name: Frontend tests
-    if: ${{ github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '' }}
-    uses: kestra-io/actions/.github/workflows/kestra-oss-frontend-tests.yml@main
-    secrets:
-      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-      GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  publish-develop-docker:
-    name: Publish Docker
-    needs: [backend-tests, frontend-tests]
-    if: "!failure() && !cancelled() && github.ref == 'refs/heads/develop'"
-    uses: kestra-io/actions/.github/workflows/kestra-oss-publish-docker.yml@main
-    with:
-      plugin-version: 'LATEST-SNAPSHOT'
-    secrets:
-      DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-      DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
-      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
-
-
-  publish-develop-maven:
-    name: Publish develop Maven
-    needs: [ backend-tests, frontend-tests ]
-    if: "!failure() && !cancelled() && github.ref == 'refs/heads/develop'"
-    uses: kestra-io/actions/.github/workflows/kestra-oss-publish-maven.yml@main
-    secrets:
-      SONATYPE_USER: ${{ secrets.SONATYPE_USER }}
-      SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
-      SONATYPE_GPG_KEYID: ${{ secrets.SONATYPE_GPG_KEYID }}
-      SONATYPE_GPG_PASSWORD: ${{ secrets.SONATYPE_GPG_PASSWORD }}
-      SONATYPE_GPG_FILE: ${{ secrets.SONATYPE_GPG_FILE }}
-
-  end:
-    runs-on: ubuntu-latest
-    needs: [publish-develop-docker, publish-develop-maven]
-    if: always()
-    steps:
-      - name: Trigger EE Workflow
-        uses: peter-evans/repository-dispatch@v3
-        if: github.ref == 'refs/heads/develop' && needs.release.result == 'success'
-        with:
-          token: ${{ secrets.GH_PERSONAL_TOKEN }}
-          repository: kestra-io/kestra-ee
-          event-type: "oss-updated"
-
-      # Slack
-      - name: Slack - Notification
-        if: ${{ failure() && env.SLACK_WEBHOOK_URL != 0 && (github.ref == 'refs/heads/master' || github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop') }}
-        uses: kestra-io/actions/composite/slack-status@main
-        with:
-          webhook-url: ${{ secrets.SLACK_WEBHOOK_URL }}

.github/workflows/main.yml

@@ -0,0 +1,73 @@
+name: Main Workflow
+
+on:
+  workflow_dispatch:
+    inputs:
+      plugin-version:
+          description: "plugins version"
+          required: false
+          type: string
+  push:
+    branches:
+      - master
+      - main
+      - releases/*
+      - develop
+    tags:
+      - v*
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-main
+  cancel-in-progress: true
+
+jobs:
+  tests:
+    name: Execute tests
+    uses: ./.github/workflows/workflow-test.yml
+    with:
+      report-status: false
+
+  release:
+    name: Release
+    needs: [tests]
+    if: "!startsWith(github.ref, 'refs/heads/releases')"
+    uses: ./.github/workflows/workflow-release.yml
+    with:
+        plugin-version: ${{ inputs.plugin-version != '' && inputs.plugin-version || (github.ref == 'refs/heads/develop' && 'LATEST-SNAPSHOT' || 'LATEST') }}
+    secrets:
+      DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+      DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
+      SONATYPE_USER: ${{ secrets.SONATYPE_USER }}
+      SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
+      SONATYPE_GPG_KEYID: ${{ secrets.SONATYPE_GPG_KEYID }}
+      SONATYPE_GPG_PASSWORD: ${{ secrets.SONATYPE_GPG_PASSWORD }}
+      SONATYPE_GPG_FILE: ${{ secrets.SONATYPE_GPG_FILE }}
+      GH_PERSONAL_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}
+      SLACK_RELEASES_WEBHOOK_URL: ${{ secrets.SLACK_RELEASES_WEBHOOK_URL }}
+  end:
+    runs-on: ubuntu-latest
+    needs:
+      - release
+    if: always()
+    env:
+      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+    steps:
+      - name: Trigger EE Workflow
+        uses: peter-evans/repository-dispatch@v3
+        if: github.ref == 'refs/heads/develop' && needs.release.result == 'success'
+        with:
+          token: ${{ secrets.GH_PERSONAL_TOKEN }}
+          repository: kestra-io/kestra-ee
+          event-type: "oss-updated"
+
+
+      # Slack
+      - name: Slack - Notification
+        uses: Gamesight/slack-workflow-status@master
+        if: ${{ always() && env.SLACK_WEBHOOK_URL != 0 }}
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          slack_webhook_url: ${{ secrets.SLACK_WEBHOOK_URL }}
+          name: GitHub Actions
+          icon_emoji: ":github-actions:"
+          channel: "C02DQ1A7JLR" # _int_git channel

.github/workflows/pre-release.yml

@@ -1,49 +0,0 @@
-name: Pre Release
-
-on:
-  push:
-    tags:
-      - 'v*'
-  workflow_dispatch:
-
-jobs:
-  build-artifacts:
-    name: Build Artifacts
-    uses: kestra-io/actions/.github/workflows/kestra-oss-build-artifacts.yml@main
-
-  backend-tests:
-    name: Backend tests
-    uses: kestra-io/actions/.github/workflows/kestra-oss-backend-tests.yml@main
-    secrets:
-      GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-      GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
-
-  frontend-tests:
-    name: Frontend tests
-    uses: kestra-io/actions/.github/workflows/kestra-oss-frontend-tests.yml@main
-    secrets:
-      GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-
-  publish-maven:
-    name: Publish Maven
-    needs: [ backend-tests, frontend-tests ]
-    if: "!failure() && !cancelled()"
-    uses: kestra-io/actions/.github/workflows/kestra-oss-publish-maven.yml@main
-    secrets:
-      SONATYPE_USER: ${{ secrets.SONATYPE_USER }}
-      SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
-      SONATYPE_GPG_KEYID: ${{ secrets.SONATYPE_GPG_KEYID }}
-      SONATYPE_GPG_PASSWORD: ${{ secrets.SONATYPE_GPG_PASSWORD }}
-      SONATYPE_GPG_FILE: ${{ secrets.SONATYPE_GPG_FILE }}
-
-  publish-github:
-    name: Github Release
-    needs: [build-artifacts, backend-tests, frontend-tests]
-    if: "!failure() && !cancelled()"
-    uses: kestra-io/actions/.github/workflows/kestra-oss-publish-github.yml@main
-    secrets:
-      GH_PERSONAL_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}
-      SLACK_RELEASES_WEBHOOK_URL: ${{ secrets.SLACK_RELEASES_WEBHOOK_URL }}

.github/workflows/pull-request.yml

@@ -2,12 +2,17 @@ name: Pull Request Workflow
 
 on:
   pull_request:
+    branches:
+      - develop
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref_name }}-pr
   cancel-in-progress: true
 
 jobs:
+  # ********************************************************************************************************************
+  # File changes detection
+  # ********************************************************************************************************************
   file-changes:
     if: ${{ github.event.pull_request.draft == false }}
     name: File changes detection
@@ -28,11 +33,14 @@ jobs:
               - '!{ui,.github}/**'
           token: ${{ secrets.GITHUB_TOKEN }}
 
+  # ********************************************************************************************************************
+  # Tests
+  # ********************************************************************************************************************
   frontend:
     name: Frontend - Tests
     needs: [file-changes]
     if: "needs.file-changes.outputs.ui == 'true'"
-    uses: kestra-io/actions/.github/workflows/kestra-oss-frontend-tests.yml@main
+    uses: ./.github/workflows/workflow-frontend-test.yml
     secrets:
       GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
@@ -41,7 +49,7 @@ jobs:
     name: Backend - Tests
     needs: file-changes
     if: "needs.file-changes.outputs.backend == 'true'"
-    uses: kestra-io/actions/.github/workflows/kestra-oss-backend-tests.yml@main
+    uses: ./.github/workflows/workflow-backend-test.yml
     secrets:
       GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
@@ -50,8 +58,21 @@ jobs:
 
   e2e-tests:
     name: E2E - Tests
-    uses: kestra-io/actions/.github/workflows/kestra-oss-e2e-tests.yml@main
+    uses: ./.github/workflows/e2e.yml
 
-  generate-pull-request-docker-image:
-    name: Generate PR docker image
-    uses: kestra-io/actions/.github/workflows/kestra-oss-pullrequest-publish-docker.yml@main
+  end:
+    name: End
+    runs-on: ubuntu-latest
+    if: always()
+    needs: [frontend, backend]
+    steps:
+      # Slack
+      - name: Slack notification
+        uses: Gamesight/slack-workflow-status@master
+        if: ${{ always() && env.SLACK_WEBHOOK_URL != 0 }}
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          slack_webhook_url: ${{ secrets.SLACK_WEBHOOK_URL }}
+          name: GitHub Actions
+          icon_emoji: ":github-actions:"
+          channel: "C02DQ1A7JLR"

.github/workflows/release-docker.yml

@@ -1,34 +0,0 @@
-name: Publish docker
-
-on:
-  workflow_dispatch:
-    inputs:
-      retag-latest:
-        description: 'Retag latest Docker images'
-        required: true
-        type: boolean
-        default: false
-      retag-lts:
-        description: 'Retag LTS Docker images'
-        required: true
-        type: boolean
-        default: false
-      plugin-version:
-        description: 'Plugin version'
-        required: false
-        type: string
-        default: "LATEST"
-
-jobs:
-  publish-docker:
-    name: Publish Docker
-    if: startsWith(github.ref, 'refs/tags/v')
-    uses: kestra-io/actions/.github/workflows/kestra-oss-publish-docker.yml@main
-    with:
-      plugin-version: ${{ inputs.plugin-version }}
-      retag-latest: ${{ inputs.retag-latest }}
-      retag-lts: ${{ inputs.retag-lts }}
-    secrets:
-      DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-      DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
-      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}

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

@@ -23,7 +23,7 @@ jobs:
 
       # Get Plugins List
       - name: Get Plugins List
-        uses: kestra-io/actions/composite/kestra-oss/kestra-oss-plugins-list@main
+        uses: ./.github/actions/plugins-list
         id: plugins-list
         with:
           plugin-version: 'LATEST'
@@ -40,7 +40,7 @@ jobs:
           GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
         run: |
           chmod +x ./dev-tools/setversion-tag-plugins.sh;
-
+          
           ./dev-tools/setversion-tag-plugins.sh \
           --release-version=${{github.event.inputs.releaseVersion}} \
           --yes \
@@ -52,7 +52,7 @@ jobs:
           GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
         run: |
           chmod +x ./dev-tools/setversion-tag-plugins.sh;
-
+          
           ./dev-tools/setversion-tag-plugins.sh \
           --release-version=${{github.event.inputs.releaseVersion}} \
           --dry-run \

.github/workflows/setversion-tag.yml

@@ -1,5 +1,5 @@
-name: Start release
-run-name: "Start release of Kestra ${{ github.event.inputs.releaseVersion }} 🚀"
+name: Set Version and Tag
+run-name: "Set version and Tag Kestra to ${{ github.event.inputs.releaseVersion }} 🚀"
 on:
   workflow_dispatch:
     inputs:
@@ -7,26 +7,17 @@ on:
         description: 'The release version (e.g., 0.21.1)'
         required: true
         type: string
-
-permissions:
-  contents: write
-
 env:
   RELEASE_VERSION: "${{ github.event.inputs.releaseVersion }}"
 jobs:
   release:
     name: Release Kestra
     runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/heads/releases/v')
     steps:
-      - name: Parse and Check Inputs
-        id: parse-and-check-inputs
+      # Checks
+      - name: Check Inputs
         run: |
-          CURRENT_BRANCH="${{ github.ref_name }}"
-          if ! [[ "$CURRENT_BRANCH" == "develop" ]]; then
-            echo "You can only run this workflow on develop, but you ran it on $CURRENT_BRANCH"
-            exit 1
-          fi
-
           if ! [[ "$RELEASE_VERSION" =~ ^[0-9]+(\.[0-9]+)(\.[0-9]+)(-rc[0-9])?(-SNAPSHOT)?$ ]]; then
             echo "Invalid release version. Must match regex: ^[0-9]+(\.[0-9]+)(\.[0-9]+)-(rc[0-9])?(-SNAPSHOT)?$"
             exit 1
@@ -34,25 +25,26 @@ jobs:
 
           # Extract the major and minor versions
           BASE_VERSION=$(echo "$RELEASE_VERSION" | sed -E 's/^([0-9]+\.[0-9]+)\..*/\1/')
-          RELEASE_BRANCH="releases/v${BASE_VERSION}.x"
-          echo "release_branch=${RELEASE_BRANCH}" >> $GITHUB_OUTPUT
+          RELEASE_BRANCH="refs/heads/releases/v${BASE_VERSION}.x"
+
+          CURRENT_BRANCH="$GITHUB_REF"
+          if ! [[ "$CURRENT_BRANCH" == "$RELEASE_BRANCH" ]]; then
+            echo "Invalid release branch. Expected $RELEASE_BRANCH, was $CURRENT_BRANCH"
+            exit 1
+          fi
 
       # Checkout
-      - name: Checkout
-        uses: actions/checkout@v5
+      - uses: actions/checkout@v5
         with:
           fetch-depth: 0
-          token: ${{ secrets.GH_PERSONAL_TOKEN }}
-          ref: ${{ steps.parse-and-check-inputs.outputs.release_branch }}
 
-      # Configure
-      - name: Git - Configure
+      - name: Configure Git
         run: |
           git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
           git config --global user.name "github-actions[bot]"
 
       # Execute
-      - name: Start release by updating version and pushing a new tag
+      - name: Run Gradle Release
         env:
           GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
         run: |
@@ -62,4 +54,4 @@ jobs:
           git commit -m"chore(version): update to version '$RELEASE_VERSION'"
           git push
           git tag -a "v$RELEASE_VERSION" -m"v$RELEASE_VERSION"
-          git push --tags
+          git push --tags

.github/workflows/vulnerabilities-check.yml

@@ -21,6 +21,13 @@ jobs:
         with:
           fetch-depth: 0
 
+      # Checkout GitHub Actions
+      - uses: actions/checkout@v5
+        with:
+          repository: kestra-io/actions
+          path: actions
+          ref: main
+
       # Setup build
       - uses: ./actions/.github/actions/setup-build
         id: build
@@ -63,8 +70,15 @@ jobs:
         with:
           fetch-depth: 0
 
+      # Checkout GitHub Actions
+      - uses: actions/checkout@v5
+        with:
+          repository: kestra-io/actions
+          path: actions
+          ref: main
+
       # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
+      - uses: ./actions/.github/actions/setup-build
         id: build
         with:
           java-enabled: false
@@ -73,7 +87,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.33.1
+        uses: aquasecurity/trivy-action@0.32.0
         with:
           image-ref: kestra/kestra:develop
           format: 'template'
@@ -101,16 +115,24 @@ jobs:
         with:
           fetch-depth: 0
 
+      # Checkout GitHub Actions
+      - uses: actions/checkout@v5
+        with:
+          repository: kestra-io/actions
+          path: actions
+          ref: main
+
       # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
+      - uses: ./actions/.github/actions/setup-build
         id: build
         with:
           java-enabled: false
           node-enabled: false
+          caches-enabled: true
 
       # Run Trivy image scan for Docker vulnerabilities, see https://github.com/aquasecurity/trivy-action
       - name: Docker Vulnerabilities Check
-        uses: aquasecurity/trivy-action@0.33.1
+        uses: aquasecurity/trivy-action@0.32.0
         with:
           image-ref: kestra/kestra:latest
           format: table

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

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

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

@@ -0,0 +1,80 @@
+name: Build Artifacts
+
+on:
+  workflow_call: {}
+
+jobs:
+  build:
+    name: Build - Artifacts
+    runs-on: ubuntu-latest
+    outputs:
+        docker-tag: ${{ steps.vars.outputs.tag }}
+        docker-artifact-name: ${{ steps.vars.outputs.artifact }}
+        plugins: ${{ steps.plugins.outputs.plugins }}
+    env:
+      PLUGIN_VERSION: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
+    steps:
+      - name: Checkout - Current ref
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      # Npm
+      - name: Setup - Npm install
+        shell: bash
+        working-directory: ui
+        run: npm ci
+
+      # Setup build
+      - uses: kestra-io/actions/.github/actions/setup-build@main
+        name: Setup - Build
+        id: build
+        with:
+          java-enabled: true
+          node-enabled: true
+
+      # Get Plugins List
+      - name: Plugins - Get List
+        uses: ./.github/actions/plugins-list
+        if: "!startsWith(github.ref, 'refs/tags/v')"
+        id: plugins-list
+        with:
+          plugin-version: ${{ env.PLUGIN_VERSION }}
+
+      # Set Plugins List
+      - name: Plugins - Set List
+        id: plugins
+        if: "!startsWith(github.ref, 'refs/tags/v')"
+        shell: bash
+        run: |
+          PLUGINS="${{ steps.plugins-list.outputs.plugins }}"
+          TAG=${GITHUB_REF#refs/*/}
+          if [[ $TAG = "master" || $TAG == v* ]]; then
+            echo "plugins=$PLUGINS" >> $GITHUB_OUTPUT
+          else
+            echo "plugins=--repositories=https://central.sonatype.com/repository/maven-snapshots/ $PLUGINS" >> $GITHUB_OUTPUT
+          fi
+
+      # Build
+      - name: Gradle - Build
+        shell: bash
+        run: |
+          ./gradlew executableJar
+
+      - name: Artifacts - Copy exe to image
+        shell: bash
+        run: |
+          cp build/executable/* docker/app/kestra && chmod +x docker/app/kestra
+
+      # Upload artifacts
+      - name: Artifacts - Upload JAR
+        uses: actions/upload-artifact@v4
+        with:
+          name: jar
+          path: build/libs/
+
+      - name: Artifacts - Upload Executable
+        uses: actions/upload-artifact@v4
+        with:
+          name: exe
+          path: build/executable/

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

@@ -0,0 +1,70 @@
+name: Frontend - Tests
+
+on:
+  workflow_call:
+    secrets:
+      GITHUB_AUTH_TOKEN:
+        description: "The GitHub Token."
+        required: true
+      CODECOV_TOKEN:
+        description: 'Codecov Token'
+        required: true
+
+env:
+  # to save corepack from itself
+  COREPACK_INTEGRITY_KEYS: 0
+
+jobs:
+  test:
+    name: Frontend - Tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Cache Node Modules
+        id: cache-node-modules
+        uses: actions/cache@v4
+        with:
+          path: |
+            ui/node_modules
+          key: modules-${{ hashFiles('ui/package-lock.json') }}
+
+      - name: Cache Playwright Binaries
+        id: cache-playwright
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/ms-playwright
+          key: playwright-${{ hashFiles('ui/package-lock.json') }}
+
+      - name: Npm - install
+        if: steps.cache-node-modules.outputs.cache-hit != 'true'
+        working-directory: ui
+        run: npm ci
+
+      - name: Npm - lint
+        uses: reviewdog/action-eslint@v1
+        with:
+          github_token: ${{ secrets.GITHUB_AUTH_TOKEN }}
+          reporter: github-pr-review
+          workdir: ui
+
+      - name: Npm - Run build
+        working-directory: ui
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+        run: npm run build
+
+      - name: Run front-end unit tests
+        working-directory: ui
+        run: npm run test:unit -- --coverage
+
+      - name: Storybook - Install Playwright
+        working-directory: ui
+        if: steps.cache-playwright.outputs.cache-hit != 'true'
+        run: npx playwright install --with-deps
+
+      - name: Run storybook component tests
+        working-directory: ui
+        run: npm run test:storybook -- --coverage

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

@@ -0,0 +1,81 @@
+name: Github - Release
+
+on:
+  workflow_dispatch:
+  workflow_call:
+    secrets:
+      GH_PERSONAL_TOKEN:
+        description: "The Github personal token."
+        required: true
+      SLACK_RELEASES_WEBHOOK_URL:
+        description: "The Slack webhook URL."
+        required: true
+
+
+
+jobs:
+  publish:
+    name: Github - Release
+    runs-on: ubuntu-latest
+    steps:
+      # Check out
+      - name: Checkout - Repository
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      # Checkout GitHub Actions
+      - name: Checkout - Actions
+        uses: actions/checkout@v5
+        with:
+          repository: kestra-io/actions
+          sparse-checkout-cone-mode: true
+          path: actions
+          sparse-checkout: |
+            .github/actions
+
+      # Download Exec
+      # Must be done after checkout actions
+      - name: Artifacts - Download executable
+        uses: actions/download-artifact@v5
+        if: startsWith(github.ref, 'refs/tags/v')
+        with:
+          name: exe
+          path: build/executable
+
+      - name: Check if current tag is latest
+        id: is_latest
+        run: |
+          latest_tag=$(git tag | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' | sed 's/^v//' | sort -V | tail -n1)
+          current_tag="${GITHUB_REF_NAME#v}"
+          if [ "$current_tag" = "$latest_tag" ]; then
+          echo "latest=true" >> $GITHUB_OUTPUT
+          else
+          echo "latest=false" >> $GITHUB_OUTPUT
+          fi
+        env:
+          GITHUB_REF_NAME: ${{ github.ref_name }}
+
+      # GitHub Release
+      - name: Create GitHub release
+        uses: ./actions/.github/actions/github-release
+        if: ${{ startsWith(github.ref, 'refs/tags/v') }}
+        env:
+          MAKE_LATEST: ${{ steps.is_latest.outputs.latest }}
+          GITHUB_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}
+          SLACK_RELEASES_WEBHOOK_URL: ${{ secrets.SLACK_RELEASES_WEBHOOK_URL }}
+
+      # Trigger gha workflow to bump helm chart version
+      - name: GitHub - Trigger the Helm chart version bump
+        uses: peter-evans/repository-dispatch@v3
+        with:
+          token: ${{ secrets.GH_PERSONAL_TOKEN }}
+          repository: kestra-io/helm-charts
+          event-type: update-helm-chart-version
+          client-payload: |-
+            {
+              "new_version": "${{ github.ref_name }}",
+              "github_repository": "${{ github.repository }}",
+              "github_actor": "${{ github.actor }}"
+            }

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

@@ -0,0 +1,200 @@
+name: Create Docker images on Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      retag-latest:
+        description: 'Retag latest Docker images'
+        required: true
+        type: choice
+        default: "false"
+        options:
+          - "true"
+          - "false"
+      release-tag:
+        description: 'Kestra Release Tag (by default, deduced with the ref)'
+        required: false
+        type: string
+      plugin-version:
+        description: 'Plugin version'
+        required: false
+        type: string
+        default: "LATEST"
+      force-download-artifact:
+        description: 'Force download artifact'
+        required: false
+        type: choice
+        default: "true"
+        options:
+          - "true"
+          - "false"
+  workflow_call:
+    inputs:
+      plugin-version:
+        description: "Plugin version"
+        default: 'LATEST'
+        required: false
+        type: string
+      force-download-artifact:
+        description: 'Force download artifact'
+        required: false
+        type: string
+        default: "true"
+    secrets:
+      DOCKERHUB_USERNAME:
+        description: "The Dockerhub username."
+        required: true
+      DOCKERHUB_PASSWORD:
+        description: "The Dockerhub password."
+        required: true
+
+env:
+  PLUGIN_VERSION: ${{ inputs.plugin-version != null && inputs.plugin-version || 'LATEST' }}
+jobs:
+  plugins:
+    name: List Plugins
+    runs-on: ubuntu-latest
+    outputs:
+      plugins: ${{ steps.plugins.outputs.plugins }}
+    steps:
+      # Checkout
+      - uses: actions/checkout@v5
+
+      # Get Plugins List
+      - name: Get Plugins List
+        uses: ./.github/actions/plugins-list
+        id: plugins
+        with: # remap LATEST-SNAPSHOT to LATEST
+          plugin-version: ${{ env.PLUGIN_VERSION == 'LATEST-SNAPSHOT' && 'LATEST' || env.PLUGIN_VERSION }}
+
+  # ********************************************************************************************************************
+  # Build
+  # ********************************************************************************************************************
+  build-artifacts:
+    name: Build Artifacts
+    if: ${{ inputs.force-download-artifact == 'true' }}
+    uses: ./.github/workflows/workflow-build-artifacts.yml
+
+  docker:
+    name: Publish Docker
+    needs: [ plugins, build-artifacts ]
+    if: always()
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        image:
+          - name: "-no-plugins"
+            plugins: ""
+            packages: jattach
+            python-libs: ""
+          - name: ""
+            plugins: ${{needs.plugins.outputs.plugins}}
+            packages: python3 python-is-python3 python3-pip curl jattach
+            python-libs: kestra
+    steps:
+      - uses: actions/checkout@v5
+
+      # Vars
+      - name: Set image name
+        id: vars
+        run: |
+          if [[ "${{ inputs.release-tag }}" == "" ]]; then
+            TAG=${GITHUB_REF#refs/*/}
+            echo "tag=${TAG}" >> $GITHUB_OUTPUT
+          else
+            TAG="${{ inputs.release-tag }}"
+            echo "tag=${TAG}" >> $GITHUB_OUTPUT
+          fi
+
+          if [[ $GITHUB_REF == refs/tags/* ]]; then
+            if [[ $TAG =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+              # this will remove the patch version number
+              MINOR_SEMVER=${TAG%.*}
+              echo "minor_semver=${MINOR_SEMVER}" >> $GITHUB_OUTPUT
+            else
+              echo "Tag '$TAG' is not a valid semver (vMAJOR.MINOR.PATCH), skipping minor_semver"
+            fi
+          fi
+
+          if [[ "${{ env.PLUGIN_VERSION }}" == *"-SNAPSHOT" ]]; then
+            echo "plugins=--repositories=https://central.sonatype.com/repository/maven-snapshots/ ${{ matrix.image.plugins }}" >> $GITHUB_OUTPUT;
+          else
+            echo "plugins=${{ matrix.image.plugins }}" >> $GITHUB_OUTPUT
+          fi
+
+      # Download executable from artifact
+      - name: Artifacts - Download executable
+        uses: actions/download-artifact@v5
+        with:
+          name: exe
+          path: build/executable
+
+      - name: Copy exe to image
+        run: |
+          cp build/executable/* docker/app/kestra && chmod +x docker/app/kestra
+
+      # Docker setup
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Docker - Fix Qemu
+        shell: bash
+        run: |
+          docker run --rm --privileged multiarch/qemu-user-static --reset -p yes -c yes
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      # Docker Login
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_PASSWORD }}
+
+      # Docker Build and push
+      - name: Push to Docker Hub
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          tags: ${{ format('kestra/kestra:{0}{1}', steps.vars.outputs.tag, matrix.image.name) }}
+          platforms: linux/amd64,linux/arm64
+          build-args: |
+            KESTRA_PLUGINS=${{ steps.vars.outputs.plugins }}
+            APT_PACKAGES=${{ matrix.image.packages }}
+            PYTHON_LIBRARIES=${{ matrix.image.python-libs }}
+
+      - name: Install regctl
+        if: startsWith(github.ref, 'refs/tags/v')
+        uses: regclient/actions/regctl-installer@main
+
+      - name: Retag to minor semver version
+        if: startsWith(github.ref, 'refs/tags/v') && steps.vars.outputs.minor_semver != ''
+        run: |
+          regctl image copy ${{ format('kestra/kestra:{0}{1}', steps.vars.outputs.tag, matrix.image.name) }} ${{ format('kestra/kestra:{0}{1}', steps.vars.outputs.minor_semver, matrix.image.name) }}
+
+      - name: Retag to latest
+        if: startsWith(github.ref, 'refs/tags/v') && inputs.retag-latest == 'true'
+        run: |
+          regctl image copy ${{ format('kestra/kestra:{0}{1}', steps.vars.outputs.tag, matrix.image.name) }} ${{ format('kestra/kestra:latest{0}', matrix.image.name) }}
+
+  end:
+    runs-on: ubuntu-latest
+    needs:
+      - docker
+    if: always()
+    env:
+      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+    steps:
+
+      # Slack
+      - name: Slack notification
+        uses: Gamesight/slack-workflow-status@master
+        if: ${{ always() && env.SLACK_WEBHOOK_URL != 0 }}
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          slack_webhook_url: ${{ secrets.SLACK_WEBHOOK_URL }}
+          name: GitHub Actions
+          icon_emoji: ':github-actions:'
+          channel: 'C02DQ1A7JLR' # _int_git channel

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

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

.github/workflows/workflow-pullrequest-delete-docker.yml

@@ -3,11 +3,11 @@ name: Pull Request - Delete Docker
 on:
   pull_request:
     types: [closed]
-# TODO import a reusable one
+
 jobs:
   publish:
     name: Pull Request - Delete Docker
-    if: github.repository == 'kestra-io/kestra' # prevent running on forks
+    if: github.repository == github.event.pull_request.head.repo.full_name # prevent running on forks
     runs-on: ubuntu-latest
     steps:
       - uses: dataaxiom/ghcr-cleanup-action@v1

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

@@ -0,0 +1,78 @@
+name: Pull Request - Publish Docker
+
+on:
+  pull_request:
+    branches:
+      - develop
+
+jobs:
+  build-artifacts:
+    name: Build Artifacts
+    if: github.repository == github.event.pull_request.head.repo.full_name # prevent running on forks
+    uses: ./.github/workflows/workflow-build-artifacts.yml
+
+  publish:
+    name: Publish Docker
+    if: github.repository == github.event.pull_request.head.repo.full_name # prevent running on forks
+    runs-on: ubuntu-latest
+    needs: build-artifacts
+    env:
+      GITHUB_IMAGE_PATH: "ghcr.io/kestra-io/kestra-pr"
+    steps:
+      - name: Checkout - Current ref
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      # Docker setup
+      - name: Docker - Setup QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Docker - Setup Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      # Docker Login
+      - name: Login to GHCR
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      # Build Docker Image
+      - name: Artifacts - Download executable
+        uses: actions/download-artifact@v5
+        with:
+          name: exe
+          path: build/executable
+
+      - name: Docker - Copy exe to image
+        shell: bash
+        run: |
+          cp build/executable/* docker/app/kestra && chmod +x docker/app/kestra
+
+      - name: Docker - Build image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./Dockerfile.pr
+          push: true
+          tags: ${{ env.GITHUB_IMAGE_PATH }}:${{ github.event.pull_request.number }}
+          platforms: linux/amd64,linux/arm64
+
+      # Add comment on pull request
+      - name: Add comment to PR
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            await github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: `**🐋 Docker image**: \`${{ env.GITHUB_IMAGE_PATH }}:${{ github.event.pull_request.number }}\`\n` +
+                `\n` +
+                `\`\`\`bash\n` +
+                `docker run --pull=always --rm -it -p 8080:8080 --user=root -v /var/run/docker.sock:/var/run/docker.sock -v /tmp:/tmp ${{ env.GITHUB_IMAGE_PATH }}:${{ github.event.pull_request.number }} server local\n` +
+                `\`\`\``
+            })

.github/workflows/workflow-release.yml

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

.github/workflows/workflow-test.yml

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

.plugins

@@ -36,7 +36,6 @@
 #plugin-gemini:io.kestra.plugin:plugin-gemini:LATEST
 #plugin-git:io.kestra.plugin:plugin-git:LATEST
 #plugin-github:io.kestra.plugin:plugin-github:LATEST
-#plugin-gitlab:io.kestra.plugin:plugin-gitlab:LATEST
 #plugin-googleworkspace:io.kestra.plugin:plugin-googleworkspace:LATEST
 #plugin-graalvm:io.kestra.plugin:plugin-graalvm:LATEST
 #plugin-graphql:io.kestra.plugin:plugin-graphql:LATEST
@@ -109,17 +108,16 @@
 #plugin-serdes:io.kestra.plugin:plugin-serdes:LATEST
 #plugin-servicenow:io.kestra.plugin:plugin-servicenow:LATEST
 #plugin-sifflet:io.kestra.plugin:plugin-sifflet: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-supabase:io.kestra.plugin:plugin-supabase: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-trivy:io.kestra.plugin:plugin-trivy: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

AGENTS.md

@@ -1,305 +0,0 @@
-# Kestra AGENTS.md
-
-This file provides guidance for AI coding agents working on the Kestra project. Kestra is an open-source data orchestration and scheduling platform built with Java (Micronaut) and Vue.js.
-
-## Repository Layout
-
-- **`core/`**: Core Kestra framework and task definitions
-- **`cli/`**: Command-line interface and server implementation
-- **`webserver/`**: REST API server implementation
-- **`ui/`**: Vue.js frontend application
-- **`jdbc-*`**: Database connector modules (H2, MySQL, PostgreSQL)
-- **`script/`**: Script execution engine
-- **`storage-local/`**: Local file storage implementation
-- **`repository-memory/`**: In-memory repository implementation
-- **`runner-memory/`**: In-memory execution runner
-- **`processor/`**: Task processing engine
-- **`model/`**: Data models and Data Transfer Objects
-- **`platform/`**: Platform-specific implementations
-- **`tests/`**: Integration test framework
-- **`e2e-tests/`**: End-to-end testing suite
-
-## Development Environment
-
-### Prerequisites
-
-- Java 21+
-- Node.js 22+ and npm
-- Python 3, pip, and python venv
-- Docker & Docker Compose
-- Gradle (wrapper included)
-
-### Quick Setup with Devcontainer
-
-The easiest way to get started is using the provided devcontainer:
-
-1. Install VSCode Remote Development extension
-2. Run `Dev Containers: Open Folder in Container...` from command palette
-3. Select the Kestra root folder
-4. Wait for Gradle build to complete
-
-### Manual Setup
-
-1. Clone the repository
-2. Run `./gradlew build` to build the backend
-3. Navigate to `ui/` and run `npm install`
-4. Create configuration files as described below
-
-## Configuration Files
-
-### Backend Configuration
-
-Create `cli/src/main/resources/application-override.yml`:
-
-**Local Mode (H2 database):**
-
-```yaml
-micronaut:
-  server:
-    cors:
-      enabled: true
-      configurations:
-        all:
-          allowedOrigins:
-            - http://localhost:5173
-```
-
-**Standalone Mode (PostgreSQL):**
-
-```yaml
-kestra:
-  repository:
-    type: postgres
-  storage:
-    type: local
-    local:
-      base-path: "/app/storage"
-  queue:
-    type: postgres
-  tasks:
-    tmp-dir:
-      path: /tmp/kestra-wd/tmp
-  anonymous-usage-report:
-    enabled: false
-
-datasources:
-  postgres:
-    url: jdbc:postgresql://host.docker.internal:5432/kestra
-    driverClassName: org.postgresql.Driver
-    username: kestra
-    password: k3str4
-
-flyway:
-  datasources:
-    postgres:
-      enabled: true
-      locations:
-        - classpath:migrations/postgres
-      ignore-migration-patterns: "*:missing,*:future"
-      out-of-order: true
-
-micronaut:
-  server:
-    cors:
-      enabled: true
-      configurations:
-        all:
-          allowedOrigins:
-            - http://localhost:5173
-```
-
-### Frontend Configuration
-
-Create `ui/.env.development.local` for environment variables.
-
-## Running the Application
-
-### Backend
-
-- **Local mode**: `./gradlew runLocal` (uses H2 database)
-- **Standalone mode**: Use VSCode Run and Debug with main class `io.kestra.cli.App` and args `server standalone`
-
-### Frontend
-
-- Navigate to `ui/` directory
-- Run `npm run dev` for development server (port 5173)
-- Run `npm run build` for production build
-
-## Building and Testing
-
-### Backend
-
-```bash
-# Build the project
-./gradlew build
-
-# Run tests
-./gradlew test
-
-# Run specific module tests
-./gradlew :core:test
-
-# Clean build
-./gradlew clean build
-```
-
-### Frontend
-
-```bash
-cd ui
-npm install
-npm run test
-npm run lint
-npm run build
-```
-
-### End-to-End Tests
-
-```bash
-# Build and start E2E tests
-./build-and-start-e2e-tests.sh
-
-# Or use the Makefile
-make install
-make install-plugins
-make start-standalone-postgres
-```
-
-## Development Guidelines
-
-### Java Backend
-
-- Use Java 21 features
-- Follow Micronaut framework patterns
-- Add Swagger annotations for API documentation
-- Use annotation processors (enable in IDE)
-- Set `MICRONAUT_ENVIRONMENTS=local,override` for custom config
-- Set `KESTRA_PLUGINS_PATH` for custom plugin loading
-
-### Vue.js Frontend
-
-- Vue 3 with Composition API
-- TypeScript for type safety
-- Vite for build tooling
-- ESLint and Prettier for code quality
-- Component-based architecture in `src/components/`
-
-### Code Style
-
-- Follow `.editorconfig` settings
-- Use 4 spaces for Java, 2 spaces for YAML/JSON/CSS
-- Enable format on save in VSCode
-- Use Prettier for frontend code formatting
-
-## Testing Strategy
-
-### Backend Testing
-
-- Unit tests in `src/test/java/`
-- Integration tests in `tests/` module
-- Use Micronaut test framework
-- Test both local and standalone modes
-
-### Frontend Testing
-- Unit tests with Jest
-- E2E tests with Playwright
-- Component testing with Storybook
-- Run `npm run test:unit` and `npm run test:e2e`
-
-## Plugin Development
-
-### Creating Plugins
-
-- Follow the [Plugin Developer Guide](https://kestra.io/docs/plugin-developer-guide/)
-- Place JAR files in `KESTRA_PLUGINS_PATH`
-- Use the plugin template structure
-- Test with both local and standalone modes
-
-### Plugin Loading
-
-- Set `KESTRA_PLUGINS_PATH` environment variable
-- Use devcontainer mounts for local development
-- Plugins are loaded at startup
-
-## Common Issues and Solutions
-
-### JavaScript Heap Out of Memory
-
-Set `NODE_OPTIONS=--max-old-space-size=4096` environment variable.
-
-### CORS Issues
-
-Ensure backend CORS is configured for `http://localhost:5173` when using frontend dev server.
-
-### Database Connection Issues
-
-- Use `host.docker.internal` instead of `localhost` when connecting from devcontainer
-- Verify PostgreSQL is running and accessible
-- Check database credentials and permissions
-
-### Gradle Build Issues
-
-- Clear Gradle cache: `./gradlew clean`
-- Check Java version compatibility
-- Verify all dependencies are available
-
-## Pull Request Guidelines
-
-### Before Submitting
-
-1. Run all tests: `./gradlew test` and `npm test`
-2. Check code formatting: `./gradlew spotlessCheck`
-3. Verify CORS configuration if changing API
-4. Test both local and standalone modes
-5. Update documentation for user-facing changes
-
-### Commit Messages
-
-- Follow conventional commit format
-- Use present tense ("Add feature" not "Added feature")
-- Reference issue numbers when applicable
-- Keep commits focused and atomic
-
-### Review Checklist
-
-- [ ] All tests pass
-- [ ] Code follows project style guidelines
-- [ ] Documentation is updated
-- [ ] No breaking changes without migration guide
-- [ ] CORS properly configured if API changes
-- [ ] Both local and standalone modes tested
-
-## Useful Commands
-
-```bash
-# Quick development commands
-./gradlew runLocal                    # Start local backend
-./gradlew :ui:build                   # Build frontend
-./gradlew clean build                 # Clean rebuild
-npm run dev                           # Start frontend dev server
-make install                          # Install Kestra locally
-make start-standalone-postgres        # Start with PostgreSQL
-
-# Testing commands
-./gradlew test                        # Run all backend tests
-./gradlew :core:test                  # Run specific module tests
-npm run test                          # Run frontend tests
-npm run lint                          # Lint frontend code
-```
-
-## Getting Help
-
-- Open a [GitHub issue](https://github.com/kestra-io/kestra/issues)
-- Join the [Kestra Slack community](https://kestra.io/slack)
-- Check the [main documentation](https://kestra.io/docs)
-
-## Environment Variables
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `MICRONAUT_ENVIRONMENTS` | Custom config environments | `local,override` |
-| `KESTRA_PLUGINS_PATH` | Path to custom plugins | `/workspaces/kestra/local/plugins` |
-| `NODE_OPTIONS` | Node.js options | `--max-old-space-size=4096` |
-| `JAVA_HOME` | Java installation path | `/usr/java/jdk-21` |
-
-Remember: Always test your changes in both local and standalone modes, and ensure CORS is properly configured for frontend development.

Makefile

@@ -89,7 +89,7 @@ build-docker: build-exec
 		--compress \
 		--rm \
 		-f ./Dockerfile \
-		--build-arg="APT_PACKAGES=python3 python-is-python3 python3-pip curl jattach" \
+		--build-arg="APT_PACKAGES=python3 python3-venv python-is-python3 python3-pip nodejs npm curl zip unzip jattach" \
 		--build-arg="PYTHON_LIBRARIES=kestra" \
 		-t ${DOCKER_IMAGE}:${VERSION} ${DOCKER_PATH} || exit 1 ;
 

README.md

@@ -19,12 +19,9 @@
 <br />
 
 <p align="center">
-  <a href="https://twitter.com/kestra_io" style="margin: 0 10px;">
-        <img height="25" src="https://kestra.io/twitter.svg" alt="twitter" width="35" height="25" /></a>
-  <a href="https://www.linkedin.com/company/kestra/" style="margin: 0 10px;">
-        <img height="25" src="https://kestra.io/linkedin.svg" alt="linkedin" width="35" height="25" /></a> 
-  <a href="https://www.youtube.com/@kestra-io" style="margin: 0 10px;">
-        <img height="25" src="https://kestra.io/youtube.svg" alt="youtube" width="35" height="25" /></a>
+    <a href="https://x.com/kestra_io"><img height="25" src="https://kestra.io/twitter.svg" alt="X(formerly Twitter)" /></a> &nbsp;
+    <a href="https://www.linkedin.com/company/kestra/"><img height="25" src="https://kestra.io/linkedin.svg" alt="linkedin" /></a> &nbsp;
+<a href="https://www.youtube.com/@kestra-io"><img height="25" src="https://kestra.io/youtube.svg" alt="youtube" /></a> &nbsp;
 </p>
 
 <p align="center">
@@ -36,10 +33,10 @@
 
 <p align="center">
     <a href="https://go.kestra.io/video/product-overview" target="_blank">
-        <img src="https://kestra.io/startvideo.png" alt="Get started in 3 minutes with Kestra" width="640px" />
+        <img src="https://kestra.io/startvideo.png" alt="Get started in 4 minutes with Kestra" width="640px" />
     </a>
 </p>
-<p align="center" style="color:grey;"><i>Click on the image to learn how to get started with Kestra in 3 minutes.</i></p>
+<p align="center" style="color:grey;"><i>Click on the image to learn how to get started with Kestra in 4 minutes.</i></p>
 
 
 ## 🌟 What is Kestra?

build.gradle

@@ -21,23 +21,23 @@ plugins {
 
     // test
     id "com.adarshr.test-logger" version "4.0.0"
-    id "org.sonarqube" version "6.3.1.5724"
+    id "org.sonarqube" version "6.2.0.5505"
     id 'jacoco-report-aggregation'
 
     // helper
-    id "com.github.ben-manes.versions" version "0.53.0"
+    id "com.github.ben-manes.versions" version "0.52.0"
 
     // front
     id 'com.github.node-gradle.node' version '7.1.0'
 
     // release
     id 'net.researchgate.release' version '3.1.0'
-    id "com.gorylenko.gradle-git-properties" version "2.5.3"
+    id "com.gorylenko.gradle-git-properties" version "2.5.2"
     id 'signing'
     id "com.vanniktech.maven.publish" version "0.34.0"
 
     // OWASP dependency check
-    id "org.owasp.dependencycheck" version "12.1.5" apply false
+    id "org.owasp.dependencycheck" version "12.1.3" apply false
 }
 
 idea {
@@ -168,9 +168,8 @@ allprojects {
 /**********************************************************************************************************************\
  * Test
  **********************************************************************************************************************/
-subprojects {subProj ->
-
-    if (subProj.name != 'platform' && subProj.name != 'jmh-benchmarks') {
+subprojects {
+    if (it.name != 'platform' && it.name != 'jmh-benchmarks') {
         apply plugin: "com.adarshr.test-logger"
 
         java {
@@ -208,13 +207,6 @@ subprojects {subProj ->
 
         test {
             useJUnitPlatform()
-            reports {
-                junitXml.required = true
-                junitXml.outputPerTestCase = true
-                junitXml.mergeReruns = true
-                junitXml.includeSystemErrLog = true;
-                junitXml.outputLocation = layout.buildDirectory.dir("test-results/test")
-            }
 
             // set Xmx for test workers
             maxHeapSize = '4g'
@@ -230,15 +222,6 @@ subprojects {subProj ->
             environment 'SECRET_PASSWORD', "cGFzc3dvcmQ="
             environment 'ENV_TEST1', "true"
             environment 'ENV_TEST2', "Pass by env"
-
-
-            if (subProj.name == 'core' || subProj.name == 'jdbc-h2' || subProj.name == 'jdbc-mysql' || subProj.name == 'jdbc-postgres') {
-                // JUnit 5 parallel settings
-                systemProperty 'junit.jupiter.execution.parallel.enabled', 'true'
-                systemProperty 'junit.jupiter.execution.parallel.mode.default', 'concurrent'
-                systemProperty 'junit.jupiter.execution.parallel.mode.classes.default', 'same_thread'
-                systemProperty 'junit.jupiter.execution.parallel.config.strategy', 'dynamic'
-            }
         }
 
         testlogger {

cli/build.gradle

@@ -33,13 +33,9 @@ dependencies {
 
     implementation project(":storage-local")
 
-    // Kestra server components
-    implementation project(":executor")
-    implementation project(":scheduler")
     implementation project(":webserver")
     implementation project(":worker")
 
     //test
-    testImplementation project(':tests')
     testImplementation "org.wiremock:wiremock-jetty12"
 }

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

@@ -49,7 +49,7 @@ import java.util.concurrent.Callable;
 @Introspected
 public class App implements Callable<Integer> {
     public static void main(String[] args) {
-        execute(App.class, new String [] { Environment.CLI }, args);
+        execute(App.class, args);
     }
 
     @Override
@@ -57,13 +57,13 @@ public class App implements Callable<Integer> {
         return PicocliRunner.call(App.class, "--help");
     }
 
-    protected static void execute(Class<?> cls, String[] environments, String... args) {
+    protected static void execute(Class<?> cls, String... args) {
         // Log Bridge
         SLF4JBridgeHandler.removeHandlersForRootLogger();
         SLF4JBridgeHandler.install();
 
         // Init ApplicationContext
-        ApplicationContext applicationContext = App.applicationContext(cls, environments, args);
+        ApplicationContext applicationContext = App.applicationContext(cls, args);
 
         // Call Picocli command
         int exitCode = 0;
@@ -80,7 +80,6 @@ public class App implements Callable<Integer> {
         System.exit(Objects.requireNonNullElse(exitCode, 0));
     }
 
-
     /**
      * Create an {@link ApplicationContext} with additional properties based on configuration files (--config) and
      * forced Properties from current command.
@@ -89,13 +88,12 @@ public class App implements Callable<Integer> {
      * @return the application context created
      */
     protected static ApplicationContext applicationContext(Class<?> mainClass,
-                                                           String[] environments,
                                                            String[] args) {
 
         ApplicationContextBuilder builder = ApplicationContext
             .builder()
             .mainClass(mainClass)
-            .environments(environments);
+            .environments(Environment.CLI);
 
         CommandLine cmd = new CommandLine(mainClass, CommandLine.defaultFactory());
         continueOnParsingErrors(cmd);

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

@@ -8,7 +8,7 @@ import io.kestra.core.repositories.FlowRepositoryInterface;
 import io.kestra.core.repositories.LocalFlowRepositoryLoader;
 import io.kestra.core.runners.FlowInputOutput;
 import io.kestra.core.runners.RunnerUtils;
-import io.kestra.cli.StandAloneRunner;
+import io.kestra.core.runners.StandAloneRunner;
 import io.micronaut.context.ApplicationContext;
 import jakarta.inject.Inject;
 import jakarta.validation.ConstraintViolationException;
@@ -72,6 +72,7 @@ public class FlowTestCommand extends AbstractApiCommand {
     public Integer call() throws Exception {
         super.call();
 
+        StandAloneRunner runner = applicationContext.getBean(StandAloneRunner.class);
         LocalFlowRepositoryLoader repositoryLoader = applicationContext.getBean(LocalFlowRepositoryLoader.class);
         FlowRepositoryInterface flowRepository = applicationContext.getBean(FlowRepositoryInterface.class);
         FlowInputOutput flowInputOutput = applicationContext.getBean(FlowInputOutput.class);
@@ -88,7 +89,7 @@ public class FlowTestCommand extends AbstractApiCommand {
             inputs.put(this.inputs.get(i), this.inputs.get(i+1));
         }
 
-        try (StandAloneRunner runner = applicationContext.createBean(StandAloneRunner.class);){
+        try {
             runner.run();
             repositoryLoader.load(tenantService.getTenantId(tenantId), file.toFile());
 
@@ -102,6 +103,8 @@ public class FlowTestCommand extends AbstractApiCommand {
                 (flow, execution) -> flowInputOutput.readExecutionInputs(flow, execution, inputs),
                 Duration.ofHours(1)
             );
+
+            runner.close();
         } catch (ConstraintViolationException e) {
             throw new CommandLine.ParameterException(this.spec.commandLine(), e.getMessage());
         } catch (IOException | TimeoutException e) {

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

@@ -2,27 +2,19 @@ package io.kestra.cli.commands.servers;
 
 import io.kestra.cli.AbstractCommand;
 import io.kestra.core.contexts.KestraContext;
-import lombok.extern.slf4j.Slf4j;
+import jakarta.annotation.PostConstruct;
 import picocli.CommandLine;
 
-@Slf4j
-public abstract class AbstractServerCommand extends AbstractCommand implements ServerCommandInterface {
+abstract public class AbstractServerCommand extends AbstractCommand implements ServerCommandInterface {
     @CommandLine.Option(names = {"--port"}, description = "The port to bind")
     Integer serverPort;
 
     @Override
     public Integer call()  throws Exception {
-        log.info("Machine information: {} available cpu(s), {}MB max memory, Java version {}", Runtime.getRuntime().availableProcessors(), maxMemoryInMB(), Runtime.version());
-
         this.shutdownHook(true, () -> KestraContext.getContext().shutdown());
-
         return super.call();
     }
 
-    private long maxMemoryInMB() {
-        return Runtime.getRuntime().maxMemory() / 1024 / 1024;
-    }
-
     protected static int defaultWorkerThread() {
         return Runtime.getRuntime().availableProcessors() * 8;
     }

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

@@ -2,15 +2,12 @@ package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
 import io.kestra.core.models.ServerType;
-import io.kestra.core.runners.Indexer;
+import io.kestra.core.runners.IndexerInterface;
 import io.kestra.core.utils.Await;
-import io.kestra.core.services.SkipExecutionService;
 import io.micronaut.context.ApplicationContext;
 import jakarta.inject.Inject;
 import picocli.CommandLine;
 
-import java.util.Collections;
-import java.util.List;
 import java.util.Map;
 
 @CommandLine.Command(
@@ -20,11 +17,6 @@ import java.util.Map;
 public class IndexerCommand extends AbstractServerCommand {
     @Inject
     private ApplicationContext applicationContext;
-    @Inject
-    private SkipExecutionService skipExecutionService;
-
-    @CommandLine.Option(names = {"--skip-indexer-records"}, split=",", description = "a list of indexer record keys, separated by a coma; for troubleshooting purpose only")
-    private List<String> skipIndexerRecords = Collections.emptyList();
 
     @SuppressWarnings("unused")
     public static Map<String, Object> propertiesOverrides() {
@@ -35,11 +27,9 @@ public class IndexerCommand extends AbstractServerCommand {
 
     @Override
     public Integer call() throws Exception {
-        this.skipExecutionService.setSkipIndexerRecords(skipIndexerRecords);
-
         super.call();
 
-        Indexer indexer = applicationContext.getBean(Indexer.class);
+        IndexerInterface indexer = applicationContext.getBean(IndexerInterface.class);
         indexer.run();
 
         Await.until(() -> !this.applicationContext.isRunning());

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

@@ -2,7 +2,7 @@ package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
 import io.kestra.core.models.ServerType;
-import io.kestra.scheduler.AbstractScheduler;
+import io.kestra.core.schedulers.AbstractScheduler;
 import io.kestra.core.utils.Await;
 import io.micronaut.context.ApplicationContext;
 import jakarta.inject.Inject;

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

@@ -19,6 +19,7 @@ import picocli.CommandLine;
         WebServerCommand.class,
         WorkerCommand.class,
         LocalCommand.class,
+        WorkerAgentCommand.class,
     }
 )
 @Slf4j

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

@@ -6,10 +6,11 @@ import io.kestra.cli.services.TenantIdSelectorService;
 import io.kestra.core.contexts.KestraContext;
 import io.kestra.core.models.ServerType;
 import io.kestra.core.repositories.LocalFlowRepositoryLoader;
-import io.kestra.cli.StandAloneRunner;
+import io.kestra.core.runners.StandAloneRunner;
 import io.kestra.core.services.SkipExecutionService;
 import io.kestra.core.services.StartExecutorService;
 import io.kestra.core.utils.Await;
+import io.kestra.controller.Controller;
 import io.micronaut.context.ApplicationContext;
 import jakarta.annotation.Nullable;
 import jakarta.inject.Inject;
@@ -63,9 +64,6 @@ public class StandAloneCommand extends AbstractServerCommand {
     @CommandLine.Option(names = {"--skip-tenants"}, split=",", description = "a list of tenants to skip, separated by a coma; for troubleshooting purpose only")
     private List<String> skipTenants = Collections.emptyList();
 
-    @CommandLine.Option(names = {"--skip-indexer-records"}, split=",", description = "a list of indexer record keys, separated by a coma; for troubleshooting purpose only")
-    private List<String> skipIndexerRecords = Collections.emptyList();
-
     @CommandLine.Option(names = {"--no-tutorials"}, description = "Flag to disable auto-loading of tutorial flows.")
     boolean tutorialsDisabled = false;
 
@@ -96,7 +94,6 @@ public class StandAloneCommand extends AbstractServerCommand {
         this.skipExecutionService.setSkipFlows(skipFlows);
         this.skipExecutionService.setSkipNamespaces(skipNamespaces);
         this.skipExecutionService.setSkipTenants(skipTenants);
-        this.skipExecutionService.setSkipIndexerRecords(skipIndexerRecords);
         this.startExecutorService.applyOptions(startExecutors, notStartExecutors);
 
         KestraContext.getContext().injectWorkerConfigs(workerThread, null);
@@ -113,27 +110,28 @@ public class StandAloneCommand extends AbstractServerCommand {
             }
         }
 
-        try (StandAloneRunner standAloneRunner = applicationContext.getBean(StandAloneRunner.class)) {
+        StandAloneRunner standAloneRunner = applicationContext.getBean(StandAloneRunner.class);
+        
+        Controller controller = applicationContext.getBean(Controller.class);
 
-            if (this.workerThread == 0) {
-                standAloneRunner.setWorkerEnabled(false);
-            } else {
-                standAloneRunner.setWorkerThread(this.workerThread);
-            }
-
-            if (this.indexerDisabled) {
-                standAloneRunner.setIndexerEnabled(false);
-            }
-
-            standAloneRunner.run();
-
-            if (fileWatcher != null) {
-                fileWatcher.startListeningFromConfig();
-            }
-
-            Await.until(() -> !this.applicationContext.isRunning());
+        if (this.workerThread == 0) {
+            standAloneRunner.setWorkerEnabled(false);
+        } else {
+            standAloneRunner.setWorkerThread(this.workerThread);
         }
 
+        if (this.indexerDisabled) {
+            standAloneRunner.setIndexerEnabled(false);
+        }
+
+        standAloneRunner.run();
+
+        if (fileWatcher != null) {
+            fileWatcher.startListeningFromConfig();
+        }
+
+        Await.until(() -> !this.applicationContext.isRunning());
+
         return 0;
     }
 }

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

@@ -2,18 +2,15 @@ package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
 import io.kestra.core.models.ServerType;
-import io.kestra.core.runners.Indexer;
+import io.kestra.core.runners.IndexerInterface;
 import io.kestra.core.utils.Await;
 import io.kestra.core.utils.ExecutorsUtils;
-import io.kestra.core.services.SkipExecutionService;
 import io.micronaut.context.ApplicationContext;
 import jakarta.inject.Inject;
 import lombok.extern.slf4j.Slf4j;
 import picocli.CommandLine;
 import picocli.CommandLine.Option;
 
-import java.util.Collections;
-import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
 
@@ -31,17 +28,11 @@ public class WebServerCommand extends AbstractServerCommand {
     @Inject
     private ExecutorsUtils executorsUtils;
 
-    @Inject
-    private SkipExecutionService skipExecutionService;
-
     @Option(names = {"--no-tutorials"}, description = "Flag to disable auto-loading of tutorial flows.")
-    private boolean tutorialsDisabled = false;
+    boolean tutorialsDisabled = false;
 
     @Option(names = {"--no-indexer"}, description = "Flag to disable starting an embedded indexer.")
-    private boolean indexerDisabled = false;
-
-    @CommandLine.Option(names = {"--skip-indexer-records"}, split=",", description = "a list of indexer record keys, separated by a coma; for troubleshooting purpose only")
-    private List<String> skipIndexerRecords = Collections.emptyList();
+    boolean indexerDisabled = false;
 
     @Override
     public boolean isFlowAutoLoadEnabled() {
@@ -57,15 +48,13 @@ public class WebServerCommand extends AbstractServerCommand {
 
     @Override
     public Integer call() throws Exception {
-        this.skipExecutionService.setSkipIndexerRecords(skipIndexerRecords);
-
         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(Indexer.class));
+            poolExecutor.execute(applicationContext.getBean(IndexerInterface.class));
             shutdownHook(false, () -> poolExecutor.shutdown());
         }
 

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

@@ -0,0 +1,59 @@
+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.utils.Await;
+import io.kestra.worker.Worker;
+import io.micronaut.context.ApplicationContext;
+import jakarta.inject.Inject;
+import picocli.CommandLine;
+import picocli.CommandLine.Option;
+
+import java.util.Map;
+
+@CommandLine.Command(
+    name = "worker-agent",
+    description = "Start the Kestra worker"
+)
+public class WorkerAgentCommand extends AbstractServerCommand {
+
+    @Inject
+    private ApplicationContext applicationContext;
+
+    @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)")
+    private String workerGroupKey = null;
+
+    @SuppressWarnings("unused")
+    public static Map<String, Object> propertiesOverrides() {
+        return ImmutableMap.of(
+            "kestra.server-type", ServerType.WORKER_AGENT
+        );
+    }
+
+    @Override
+    public Integer call() throws Exception {
+
+        KestraContext.getContext().injectWorkerConfigs(thread, workerGroupKey);
+
+        super.call();
+
+        if (this.workerGroupKey != null && !this.workerGroupKey.matches("[a-zA-Z0-9_-]+")) {
+            throw new IllegalArgumentException("The --worker-group option must match the [a-zA-Z0-9_-]+ pattern");
+        }
+        
+        Worker worker = applicationContext.getBean(Worker.class);
+        worker.start(thread, workerGroupKey);
+
+        Await.until(() -> !this.applicationContext.isRunning());
+
+        return 0;
+    }
+
+    public String workerGroupKey() {
+        return workerGroupKey;
+    }
+}

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

@@ -262,8 +262,6 @@ public class FileChangedEventListener {
     }
 
     private String getTenantIdFromPath(Path path) {
-        // FIXME there is probably a bug here when a tenant has '_' in its name,
-        //  a valid tenant name is defined with following regex: "^[a-z0-9][a-z0-9_-]*"
         return path.getFileName().toString().split("_")[0];
     }
 }

cli/src/main/resources/application.yml

@@ -18,10 +18,6 @@ micronaut:
       root:
         paths: classpath:root
         mapping: /**
-  codec:
-    json:
-      additional-types:
-        - application/scim+json
   server:
     max-request-size: 10GB
     multipart:
@@ -54,7 +50,6 @@ micronaut:
   caches:
     default:
       maximum-weight: 10485760
-
   http:
     client:
       read-idle-timeout: 60s
@@ -82,19 +77,8 @@ micronaut:
       type: scheduled
       core-pool-size: 1
 
+  # Disable OpenTelemetry metrics by default, users that need it must enable it and configure the collector URL.
   metrics:
-    binders:
-      retry:
-        enabled: true
-      netty:
-        queues:
-          enabled: true
-        bytebuf-allocators:
-          enabled: true
-        channels:
-          enabled: true
-
-    # Disable OpenTelemetry metrics by default, users that need it must enable it and configure the collector URL.
     export:
       otlp:
         enabled: false
@@ -107,20 +91,20 @@ jackson:
   serialization-inclusion: non_null
   deserialization:
     FAIL_ON_UNKNOWN_PROPERTIES: false
-  mapper:
-    ACCEPT_CASE_INSENSITIVE_ENUMS: true
 
-endpoints:
+# Disable Micronaut GRPC
+grpc:
+  server:
+    enabled: false
+    health:
+      enabled: false
+endpoints: 
   all:
     port: 8081
     enabled: true
     sensitive: false
   health:
     details-visible: ANONYMOUS
-    disk-space:
-      enabled: false
-    discovery-client:
-      enabled: false
   loggers:
     write-sensitive: false
   env:
@@ -154,47 +138,12 @@ kestra:
   tutorial-flows:
     # Automatically loads all tutorial flows at startup.
     enabled: true
-
   retries:
     attempts: 5
     multiplier: 2.0
     delay: 1s
     maxDelay: ""
 
-  server:
-    basic-auth:
-      # These URLs will not be authenticated, by default we open some of the Micronaut default endpoints but not all for security reasons
-      open-urls:
-        - "/ping"
-        - "/api/v1/executions/webhook/"
-        - "/api/v1/main/executions/webhook/"
-        - "/api/v1/*/executions/webhook/"
-        - "/api/v1/basicAuthValidationErrors"
-
-    preview:
-      initial-rows: 100
-      max-rows: 5000
-
-    # The expected time for this server to complete all its tasks before initiating a graceful shutdown.
-    terminationGracePeriod: 5m
-    workerTaskRestartStrategy: AFTER_TERMINATION_GRACE_PERIOD
-    # Configuration for Liveness and Heartbeat mechanism between servers.
-    liveness:
-      enabled: true
-      # The expected time between liveness probe.
-      interval: 10s
-      # The timeout used to detect service failures.
-      timeout: 1m
-      # The time to wait before executing a liveness probe.
-      initialDelay: 1m
-      # The expected time between service heartbeats.
-      heartbeatInterval: 3s
-    service:
-      purge:
-        initial-delay: 1h
-        fixed-delay: 1d
-        retention: 30d
-
   jdbc:
     queues:
       min-poll-interval: 25ms
@@ -206,7 +155,7 @@ kestra:
       fixed-delay: 1h
       retention: 7d
       types:
-        - type: io.kestra.core.models.executions.LogEntry
+        - type : io.kestra.core.models.executions.LogEntry
           retention: 1h
         - type: io.kestra.core.models.executions.MetricEntry
           retention: 1h
@@ -238,12 +187,37 @@ kestra:
   traces:
     root: DISABLED
 
-  ui-anonymous-usage-report:
-    enabled: true
-
+  server:
+    basic-auth:
+      # These URLs will not be authenticated, by default we open some of the Micronaut default endpoints but not all for security reasons
+      open-urls:
+        - "/ping"
+        - "/api/v1/executions/webhook/"
+    preview:
+      initial-rows: 100
+      max-rows: 5000
+    # The expected time for this server to complete all its tasks before initiating a graceful shutdown.
+    terminationGracePeriod: 5m
+    workerTaskRestartStrategy: AFTER_TERMINATION_GRACE_PERIOD
+    # Configuration for Liveness and Heartbeat mechanism between servers.
+    liveness:
+      enabled: true
+      # The expected time between liveness probe.
+      interval: 10s
+      # The timeout used to detect service failures.
+      timeout: 1m
+      # The time to wait before executing a liveness probe.
+      initialDelay: 1m
+      # The expected time between service heartbeats.
+      heartbeatInterval: 3s
+    service:
+      purge:
+        initial-delay: 1h
+        fixed-delay: 1d
+        retention: 30d
   anonymous-usage-report:
     enabled: true
-    uri: https://api.kestra.io/v1/reports/server-events
+    uri: https://api.kestra.io/v1/server-events/
     initial-delay: 5m
     fixed-delay: 1h
 

cli/src/test/java/io/kestra/cli/AppTest.java

@@ -37,7 +37,7 @@ class AppTest {
 
         final String[] args = new String[]{"server", serverType, "--help"};
 
-        try (ApplicationContext ctx = App.applicationContext(App.class, new String [] { Environment.CLI }, args)) {
+        try (ApplicationContext ctx = App.applicationContext(App.class, args)) {
             new CommandLine(App.class, new MicronautFactory(ctx)).execute(args);
 
             assertTrue(ctx.getProperty("kestra.server-type", ServerType.class).isEmpty());
@@ -52,7 +52,7 @@ class AppTest {
 
         final String[] argsWithMissingParams = new String[]{"flow", "namespace", "update"};
 
-        try (ApplicationContext ctx = App.applicationContext(App.class, new String [] { Environment.CLI }, argsWithMissingParams)) {
+        try (ApplicationContext ctx = App.applicationContext(App.class, argsWithMissingParams)) {
             new CommandLine(App.class, new MicronautFactory(ctx)).execute(argsWithMissingParams);
 
             assertThat(out.toString()).startsWith("Missing required parameters: ");

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

@@ -1,15 +1,14 @@
 package io.kestra.cli.services;
 
-import io.kestra.core.junit.annotations.FlakyTest;
 import io.kestra.core.models.flows.Flow;
 import io.kestra.core.models.flows.GenericFlow;
 import io.kestra.core.repositories.FlowRepositoryInterface;
 import io.kestra.core.utils.Await;
-import io.kestra.core.utils.TestsUtils;
 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;
@@ -19,8 +18,8 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
-import org.junitpioneer.jupiter.RetryingTest;
 
+import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static io.kestra.core.utils.Rethrow.throwRunnable;
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -58,12 +57,10 @@ class FileChangedEventListenerTest {
         }
     }
 
-    @FlakyTest
-    @RetryingTest(2)
+    @RetryingTest(5) // Flaky on CI but always pass locally
     void test() throws IOException, TimeoutException {
-        var tenant = TestsUtils.randomTenant(FileChangedEventListenerTest.class.getSimpleName(), "test");
         // remove the flow if it already exists
-        flowRepository.findByIdWithSource(tenant, "io.kestra.tests.watch", "myflow").ifPresent(flow -> flowRepository.delete(flow));
+        flowRepository.findByIdWithSource(MAIN_TENANT, "io.kestra.tests.watch", "myflow").ifPresent(flow -> flowRepository.delete(flow));
 
         // create a basic flow
         String flow = """
@@ -76,14 +73,14 @@ class FileChangedEventListenerTest {
                 message: Hello World! 🚀
             """;
 
-        GenericFlow genericFlow = GenericFlow.fromYaml(tenant, flow);
+        GenericFlow genericFlow = GenericFlow.fromYaml(MAIN_TENANT, flow);
         Files.write(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"), flow.getBytes());
         Await.until(
-            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "myflow").isPresent(),
+            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "myflow").isPresent(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );
-        Flow myflow = flowRepository.findById(tenant, "io.kestra.tests.watch", "myflow").orElseThrow();
+        Flow myflow = flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "myflow").orElseThrow();
         assertThat(myflow.getTasks()).hasSize(1);
         assertThat(myflow.getTasks().getFirst().getId()).isEqualTo("hello");
         assertThat(myflow.getTasks().getFirst().getType()).isEqualTo("io.kestra.plugin.core.log.Log");
@@ -91,18 +88,16 @@ class FileChangedEventListenerTest {
         // delete the flow
         Files.delete(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"));
         Await.until(
-            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "myflow").isEmpty(),
+            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "myflow").isEmpty(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );
     }
 
-    @FlakyTest
-    @RetryingTest(2)
+    @RetryingTest(5) // Flaky on CI but always pass locally
     void testWithPluginDefault() throws IOException, TimeoutException {
-        var tenant = TestsUtils.randomTenant(FileChangedEventListenerTest.class.getName(), "testWithPluginDefault");
         // remove the flow if it already exists
-        flowRepository.findByIdWithSource(tenant, "io.kestra.tests.watch", "pluginDefault").ifPresent(flow -> flowRepository.delete(flow));
+        flowRepository.findByIdWithSource(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").ifPresent(flow -> flowRepository.delete(flow));
 
         // create a flow with plugin default
         String pluginDefault = """
@@ -118,14 +113,14 @@ class FileChangedEventListenerTest {
                 values:
                   message: Hello World!
             """;
-        GenericFlow genericFlow = GenericFlow.fromYaml(tenant, pluginDefault);
+        GenericFlow genericFlow = GenericFlow.fromYaml(MAIN_TENANT, pluginDefault);
         Files.write(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"), pluginDefault.getBytes());
         Await.until(
-            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "pluginDefault").isPresent(),
+            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").isPresent(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );
-        Flow pluginDefaultFlow = flowRepository.findById(tenant, "io.kestra.tests.watch", "pluginDefault").orElseThrow();
+        Flow pluginDefaultFlow = flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").orElseThrow();
         assertThat(pluginDefaultFlow.getTasks()).hasSize(1);
         assertThat(pluginDefaultFlow.getTasks().getFirst().getId()).isEqualTo("helloWithDefault");
         assertThat(pluginDefaultFlow.getTasks().getFirst().getType()).isEqualTo("io.kestra.plugin.core.log.Log");
@@ -133,7 +128,7 @@ class FileChangedEventListenerTest {
         // delete both files
         Files.delete(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"));
         Await.until(
-            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "pluginDefault").isEmpty(),
+            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").isEmpty(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );

core/build.gradle

@@ -37,15 +37,15 @@ dependencies {
     implementation 'nl.basjes.gitignore:gitignore-reader'
     implementation group: 'dev.failsafe', name: 'failsafe'
     implementation 'com.github.ben-manes.caffeine:caffeine'
-    implementation 'com.github.ksuid:ksuid:1.1.4'
+    implementation 'com.github.ksuid:ksuid:1.1.3'
     api 'org.apache.httpcomponents.client5:httpclient5'
 
     // plugins
     implementation 'org.apache.maven.resolver:maven-resolver-impl'
-    implementation 'org.apache.maven.resolver:maven-resolver-supplier-mvn3'
+    implementation 'org.apache.maven.resolver:maven-resolver-supplier'
     implementation 'org.apache.maven.resolver:maven-resolver-connector-basic'
     implementation 'org.apache.maven.resolver:maven-resolver-transport-file'
-    implementation 'org.apache.maven.resolver:maven-resolver-transport-apache'
+    implementation 'org.apache.maven.resolver:maven-resolver-transport-http'
 
     // scheduler
     implementation group: 'com.cronutils', name: 'cron-utils'
@@ -63,10 +63,6 @@ dependencies {
         exclude group: 'com.fasterxml.jackson.core'
     }
 
-    // micrometer
-    implementation "io.micronaut.micrometer:micronaut-micrometer-observation"
-    implementation 'io.micrometer:micrometer-java21'
-
     // test
     testAnnotationProcessor project(':processor')
     testImplementation project(':tests')
@@ -74,9 +70,6 @@ dependencies {
     testImplementation project(':repository-memory')
     testImplementation project(':runner-memory')
     testImplementation project(':storage-local')
-    testImplementation project(':worker')
-    testImplementation project(':scheduler')
-    testImplementation project(':executor')
 
     testImplementation "io.micronaut:micronaut-http-client"
     testImplementation "io.micronaut:micronaut-http-server-netty"
@@ -84,7 +77,7 @@ dependencies {
 
     testImplementation "org.testcontainers:testcontainers:1.21.3"
     testImplementation "org.testcontainers:junit-jupiter:1.21.3"
-    testImplementation "org.bouncycastle:bcpkix-jdk18on"
+    testImplementation "org.bouncycastle:bcpkix-jdk18on:1.81"
 
     testImplementation "org.wiremock:wiremock-jetty12"
 }

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

@@ -118,7 +118,7 @@ public class JsonSchemaGenerator {
             removeRequiredOnPropsWithDefaults(objectNode);
 
             return MAPPER.convertValue(objectNode, MAP_TYPE_REFERENCE);
-        } catch (Exception e) {
+        } catch (IllegalArgumentException e) {
             throw new IllegalArgumentException("Unable to generate jsonschema for '" + cls.getName() + "'", e);
         }
     }

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

@@ -36,7 +36,6 @@ public class Plugin {
     private List<PluginElementMetadata> appBlocks;
     private List<PluginElementMetadata> charts;
     private List<PluginElementMetadata> dataFilters;
-    private List<PluginElementMetadata> dataFiltersKPI;
     private List<PluginElementMetadata> logExporters;
     private List<PluginElementMetadata> additionalPlugins;
     private List<PluginSubGroup.PluginCategory> categories;
@@ -97,7 +96,6 @@ public class Plugin {
         plugin.appBlocks = filterAndGetTypeWithMetadata(registeredPlugin.getAppBlocks(), packagePredicate);
         plugin.charts = filterAndGetTypeWithMetadata(registeredPlugin.getCharts(), packagePredicate);
         plugin.dataFilters = filterAndGetTypeWithMetadata(registeredPlugin.getDataFilters(), packagePredicate);
-        plugin.dataFiltersKPI = filterAndGetTypeWithMetadata(registeredPlugin.getDataFiltersKPI(), packagePredicate);
         plugin.logExporters = filterAndGetTypeWithMetadata(registeredPlugin.getLogExporters(), packagePredicate);
         plugin.additionalPlugins = filterAndGetTypeWithMetadata(registeredPlugin.getAdditionalPlugins(), packagePredicate);
 

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

@@ -1,9 +1,9 @@
-package io.kestra.scheduler.endpoint;
+package io.kestra.core.endpoints;
 
 import io.kestra.core.models.flows.FlowWithException;
 import io.kestra.core.models.triggers.AbstractTrigger;
 import io.kestra.core.models.triggers.Trigger;
-import io.kestra.scheduler.AbstractScheduler;
+import io.kestra.core.schedulers.AbstractScheduler;
 import io.micronaut.context.annotation.Requires;
 import io.micronaut.management.endpoint.annotation.Endpoint;
 import io.micronaut.management.endpoint.annotation.Read;

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

@@ -1,4 +1,4 @@
-package io.kestra.worker.endpoint;
+package io.kestra.core.endpoints;
 
 import io.kestra.core.models.triggers.AbstractTrigger;
 import io.kestra.core.runners.WorkerTask;
@@ -11,18 +11,18 @@ import lombok.Builder;
 import lombok.Getter;
 import io.kestra.core.models.executions.TaskRun;
 import io.kestra.core.models.tasks.Task;
-import io.kestra.worker.DefaultWorker;
+import io.kestra.core.runners.Worker;
 
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
-
+import java.util.stream.Collectors;
 import jakarta.inject.Inject;
 
 @Endpoint(id = "worker", defaultSensitive = false)
 @Requires(property = "kestra.server-type", pattern = "(WORKER|STANDALONE)")
 public class WorkerEndpoint {
     @Inject
-    DefaultWorker worker;
+    Worker worker;
 
     @Read
     public WorkerEndpointResult running() throws Exception {

core/src/main/java/io/kestra/core/events/CrudEvent.java

@@ -3,88 +3,30 @@ package io.kestra.core.events;
 import io.micronaut.core.annotation.Nullable;
 import io.micronaut.http.HttpRequest;
 import io.micronaut.http.context.ServerRequestContext;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
 
-import java.util.Objects;
-
+@AllArgsConstructor
 @Getter
 public class CrudEvent<T> {
-    private final T model;
+    T model;
     @Nullable
-    private final T previousModel;
-    private final CrudEventType type;
-    private final HttpRequest<?> request;
-    
-    /**
-     * Static helper method for creating a new {@link CrudEventType#UPDATE} CrudEvent.
-     *
-     * @param model the new created model.
-     * @param <T>   type of the model.
-     * @return the new {@link CrudEvent}.
-     */
-    public static <T> CrudEvent<T> create(T model) {
-        Objects.requireNonNull(model, "Can't create CREATE event with a null model");
-        return new CrudEvent<>(model, null, CrudEventType.CREATE);
-    }
-    
-    /**
-     * Static helper method for creating a new {@link CrudEventType#DELETE} CrudEvent.
-     *
-     * @param model the deleted model.
-     * @param <T>   type of the model.
-     * @return the new {@link CrudEvent}.
-     */
-    public static <T> CrudEvent<T> delete(T model) {
-        Objects.requireNonNull(model, "Can't create DELETE event with a null model");
-        return new CrudEvent<>(null, model, CrudEventType.DELETE);
-    }
-    
-    /**
-     * Static helper method for creating a new CrudEvent.
-     *
-     * @param before the model before the update.
-     * @param after  the model after the update.
-     * @param <T>   type of the model.
-     * @return the new {@link CrudEvent}.
-     */
-    public static <T> CrudEvent<T> of(T before, T after) {
-        
-        if (before == null && after == null) {
-            throw new IllegalArgumentException("Both before and after cannot be null");
-        }
-        
-        if (before == null) {
-            return create(after);
-        }
-        
-        if (after == null) {
-            return delete(before);
-        }
-        
-        return new CrudEvent<>(after, before, CrudEventType.UPDATE);
-    }
-    
-    /**
-     * @deprecated use the static factory methods.
-     */
-    @Deprecated
+    T previousModel;
+    CrudEventType type;
+    HttpRequest<?> request;
+
     public CrudEvent(T model, CrudEventType type) {
-        this(
-            CrudEventType.DELETE.equals(type) ? null : model,
-            CrudEventType.DELETE.equals(type) ? model : null, 
-            type, 
-            ServerRequestContext.currentRequest().orElse(null)
-        );
+        this.model = model;
+        this.type = type;
+        this.previousModel = null;
+        this.request = ServerRequestContext.currentRequest().orElse(null);
     }
 
     public CrudEvent(T model, T previousModel, CrudEventType type) {
-        this(model, previousModel, type, ServerRequestContext.currentRequest().orElse(null));
-    }
-    
-    public CrudEvent(T model, T previousModel, CrudEventType type, HttpRequest<?> request) {
         this.model = model;
         this.previousModel = previousModel;
         this.type = type;
-        this.request = request;
+        this.request = ServerRequestContext.currentRequest().orElse(null);
     }
+
 }

core/src/main/java/io/kestra/core/http/client/HttpClient.java

@@ -6,24 +6,16 @@ import io.kestra.core.http.HttpRequest;
 import io.kestra.core.http.HttpResponse;
 import io.kestra.core.http.client.apache.*;
 import io.kestra.core.http.client.configurations.HttpConfiguration;
-import io.kestra.core.runners.DefaultRunContext;
 import io.kestra.core.runners.RunContext;
 import io.kestra.core.serializers.JacksonMapper;
-import io.micrometer.common.KeyValues;
-import io.micrometer.core.instrument.binder.httpcomponents.hc5.ApacheHttpClientContext;
-import io.micrometer.core.instrument.binder.httpcomponents.hc5.DefaultApacheHttpClientObservationConvention;
-import io.micrometer.core.instrument.binder.httpcomponents.hc5.ObservationExecChainHandler;
-import io.micrometer.observation.ObservationRegistry;
 import io.micronaut.http.MediaType;
 import jakarta.annotation.Nullable;
 import lombok.Builder;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.ArrayUtils;
-import org.apache.commons.lang3.StringUtils;
 import org.apache.hc.client5.http.ContextBuilder;
 import org.apache.hc.client5.http.auth.*;
 import org.apache.hc.client5.http.config.ConnectionConfig;
-import org.apache.hc.client5.http.impl.ChainElement;
 import org.apache.hc.client5.http.impl.DefaultAuthenticationStrategy;
 import org.apache.hc.client5.http.impl.auth.BasicCredentialsProvider;
 import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
@@ -38,6 +30,7 @@ import org.apache.hc.core5.http.io.HttpClientResponseHandler;
 import org.apache.hc.core5.http.io.entity.EntityUtils;
 import org.apache.hc.core5.ssl.SSLContexts;
 import org.apache.hc.core5.util.Timeout;
+import org.codehaus.plexus.util.StringUtils;
 
 import java.io.Closeable;
 import java.io.IOException;
@@ -57,16 +50,11 @@ public class HttpClient implements Closeable {
     private transient CloseableHttpClient client;
     private final RunContext runContext;
     private final HttpConfiguration configuration;
-    private ObservationRegistry observationRegistry;
 
     @Builder
     public HttpClient(RunContext runContext, @Nullable HttpConfiguration configuration) throws IllegalVariableEvaluationException {
         this.runContext = runContext;
         this.configuration = configuration == null ? HttpConfiguration.builder().build() : configuration;
-        if (runContext instanceof DefaultRunContext defaultRunContext) {
-            this.observationRegistry = defaultRunContext.getApplicationContext().findBean(ObservationRegistry.class).orElse(null);
-        }
-
         this.client = this.createClient();
     }
 
@@ -79,13 +67,6 @@ public class HttpClient implements Closeable {
             .disableDefaultUserAgent()
             .setUserAgent("Kestra");
 
-        if (observationRegistry != null) {
-            // micrometer, must be placed before the retry strategy (see https://docs.micrometer.io/micrometer/reference/reference/httpcomponents.html#_retry_strategy_considerations)
-            builder.addExecInterceptorAfter(ChainElement.RETRY.name(), "micrometer",
-                new ObservationExecChainHandler(observationRegistry, new CustomApacheHttpClientObservationConvention())
-            );
-        }
-
         // logger
         if (this.configuration.getLogs() != null && this.configuration.getLogs().length > 0) {
             if (ArrayUtils.contains(this.configuration.getLogs(), HttpConfiguration.LoggingType.REQUEST_HEADERS) ||
@@ -316,14 +297,4 @@ public class HttpClient implements Closeable {
             this.client.close();
         }
     }
-
-    public static class CustomApacheHttpClientObservationConvention extends DefaultApacheHttpClientObservationConvention {
-        @Override
-        public KeyValues getLowCardinalityKeyValues(ApacheHttpClientContext context) {
-            return KeyValues.concat(
-                super.getLowCardinalityKeyValues(context),
-                KeyValues.of("type", "core-client")
-            );
-        }
-    }
 }

core/src/main/java/io/kestra/core/metrics/MeterRegistryBinderFactory.java

@@ -1,34 +0,0 @@
-package io.kestra.core.metrics;
-
-import io.micrometer.core.instrument.binder.jvm.JvmThreadDeadlockMetrics;
-import io.micrometer.java21.instrument.binder.jdk.VirtualThreadMetrics;
-import io.micronaut.configuration.metrics.annotation.RequiresMetrics;
-import io.micronaut.context.annotation.Bean;
-import io.micronaut.context.annotation.Factory;
-import io.micronaut.context.annotation.Primary;
-import io.micronaut.context.annotation.Requires;
-import jakarta.inject.Singleton;
-
-import static io.micronaut.configuration.metrics.micrometer.MeterRegistryFactory.MICRONAUT_METRICS_BINDERS;
-import static io.micronaut.core.util.StringUtils.FALSE;
-
-@Factory
-@RequiresMetrics
-
-public class MeterRegistryBinderFactory {
-    @Bean
-    @Primary
-    @Singleton
-    @Requires(property = MICRONAUT_METRICS_BINDERS + ".jvm.enabled", notEquals = FALSE)
-    public VirtualThreadMetrics virtualThreadMetrics() {
-        return new VirtualThreadMetrics();
-    }
-
-    @Bean
-    @Primary
-    @Singleton
-    @Requires(property = MICRONAUT_METRICS_BINDERS + ".jvm.enabled", notEquals = FALSE)
-    public JvmThreadDeadlockMetrics threadDeadlockMetricsMetrics() {
-        return new JvmThreadDeadlockMetrics();
-    }
-}

core/src/main/java/io/kestra/core/metrics/MetricRegistry.java

@@ -6,6 +6,7 @@ import io.kestra.core.models.tasks.Task;
 import io.kestra.core.models.triggers.AbstractTrigger;
 import io.kestra.core.models.triggers.TriggerContext;
 import io.kestra.core.runners.*;
+import io.kestra.core.schedulers.SchedulerExecutionWithTrigger;
 import io.micrometer.core.instrument.*;
 import io.micrometer.core.instrument.binder.MeterBinder;
 import io.micrometer.core.instrument.search.Search;
@@ -14,6 +15,8 @@ import jakarta.inject.Singleton;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.ArrayUtils;
 
+import java.util.function.Supplier;
+
 @Singleton
 @Slf4j
 public class MetricRegistry {
@@ -179,11 +182,26 @@ public class MetricRegistry {
      * statement.
      */
     public <T extends Number> T gauge(String name, String description, T number, String... tags) {
-        Gauge.builder(metricName(name), () -> number)
+        registerGauge(name, description, () -> number, tags);
+        return number;
+    }
+    
+    /**
+     * Register a gauge that reports the value of the {@link Number}.
+     *
+     * @param name   Name of the gauge being registered.
+     * @param description The metric description
+     * @param supplier A function that yields a double value for the gauge.
+     * @param tags   Sequence of dimensions for breaking down the name.
+     * @param <T>    The type of the number from which the gauge value is extracted.
+     * @return The number that was passed in so the registration can be done as part of an assignment
+     * statement.
+     */
+    public <T extends Number> Gauge registerGauge(String name, String description, Supplier<T> supplier, String... tags) {
+        return Gauge.builder(metricName(name),supplier)
             .description(description)
             .tags(tags)
             .register(this.meterRegistry);
-        return number;
     }
 
     /**
@@ -394,6 +412,19 @@ public class MetricRegistry {
         return triggerContext.getTenantId() == null ? baseTags : ArrayUtils.addAll(baseTags, TAG_TENANT_ID, triggerContext.getTenantId());
     }
 
+    /**
+     * Return tags for current {@link SchedulerExecutionWithTrigger}.
+     *
+     * @param schedulerExecutionWithTrigger the current SchedulerExecutionWithTrigger
+     * @return tags to apply to metrics
+     */
+    public String[] tags(SchedulerExecutionWithTrigger schedulerExecutionWithTrigger, String... tags) {
+        return ArrayUtils.addAll(
+            this.tags(schedulerExecutionWithTrigger.getExecution()),
+            tags
+        );
+    }
+
     /**
      * Return tags for current {@link ExecutionKilled}
      *

core/src/main/java/io/kestra/core/models/Label.java

@@ -1,16 +1,13 @@
 package io.kestra.core.models;
 
 import io.kestra.core.utils.MapUtils;
-import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.annotation.Nullable;
-import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
 
 import java.util.*;
-import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
-@Schema(description = "A key/value pair that can be attached to a Flow or Execution. Labels are often used to organize and categorize objects.")
-public record Label(@NotEmpty String key, @NotEmpty String value) {
+public record Label(@NotNull String key, @NotNull String value) {
     public static final String SYSTEM_PREFIX = "system.";
 
     // system labels
@@ -44,7 +41,7 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
     public static Map<String, String> toMap(@Nullable List<Label> labels) {
         if (labels == null || labels.isEmpty()) return Collections.emptyMap();
         return labels.stream()
-            .filter(label -> label.value() != null && !label.value().isEmpty() && label.key() != null && !label.key().isEmpty())
+            .filter(label -> label.value() != null && label.key() != null)
             // using an accumulator in case labels with the same key exists: the second is kept
             .collect(Collectors.toMap(Label::key, Label::value, (first, second) -> second, LinkedHashMap::new));
     }
@@ -59,7 +56,6 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
     public static List<Label> deduplicate(@Nullable List<Label> labels) {
         if (labels == null || labels.isEmpty()) return Collections.emptyList();
         return toMap(labels).entrySet().stream()
-            .filter(getEntryNotEmptyPredicate())
             .map(entry -> new Label(entry.getKey(), entry.getValue()))
             .collect(Collectors.toCollection(ArrayList::new));
     }
@@ -74,7 +70,6 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
         if (map == null || map.isEmpty()) return List.of();
         return map.entrySet()
             .stream()
-            .filter(getEntryNotEmptyPredicate())
             .map(entry -> new Label(entry.getKey(), entry.getValue()))
             .toList();
     }
@@ -93,14 +88,4 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
         }
         return map;
     }
-
-    /**
-     * Provides predicate for not empty entries.
-     *
-     * @return The non-empty filter
-     */
-    public static Predicate<Map.Entry<String, String>> getEntryNotEmptyPredicate() {
-        return entry -> entry.getKey() != null && !entry.getKey().isEmpty() &&
-            entry.getValue() != null && !entry.getValue().isEmpty();
-    }
 }

core/src/main/java/io/kestra/core/models/PluginVersioning.java

@@ -1,33 +1,16 @@
 package io.kestra.core.models;
 
 import io.swagger.v3.oas.annotations.media.Schema;
-import jakarta.validation.Valid;
 import jakarta.validation.constraints.Pattern;
 
-import java.util.List;
-import java.util.Map;
-
 /**
  * Interface that can be implemented by classes supporting plugin versioning.
  *
  * @see Plugin
  */
 public interface PluginVersioning {
-    
-    String TITLE = "Plugin Version";
-    String DESCRIPTION = """
-    Defines the version of the plugin to use.
 
-    The version must follow the Semantic Versioning (SemVer) specification:
-      - A single-digit MAJOR version (e.g., `1`).
-      - A MAJOR.MINOR version (e.g., `1.1`).
-      - A MAJOR.MINOR.PATCH version, optionally with any qualifier
-        (e.g., `1.1.2`, `1.1.0-SNAPSHOT`).
-    """;
-    
-    @Schema(
-        title = TITLE,
-        description = DESCRIPTION
-    )
+    @Pattern(regexp="\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9-]+)?|([a-zA-Z0-9]+)")
+    @Schema(title = "The version of the plugin to use.")
     String getVersion();
 }

core/src/main/java/io/kestra/core/models/QueryFilter.java

@@ -254,7 +254,19 @@ public record QueryFilter(
          *
          * @return List of {@code ResourceField} with resource names, fields, and operations.
          */
-        
+        public static List<ResourceField> asResourceList() {
+            return Arrays.stream(values())
+                .map(Resource::toResourceField)
+                .toList();
+        }
+
+        private static ResourceField toResourceField(Resource resource) {
+            List<FieldOp> fieldOps = resource.supportedField().stream()
+                .map(Resource::toFieldInfo)
+                .toList();
+            return new ResourceField(resource.name().toLowerCase(), fieldOps);
+        }
+
         private static FieldOp toFieldInfo(Field field) {
             List<Operation> operations = field.supportedOp().stream()
                 .map(Resource::toOperation)
@@ -267,6 +279,9 @@ public record QueryFilter(
         }
     }
 
+    public record ResourceField(String name, List<FieldOp> fields) {
+    }
+
     public record FieldOp(String name, String value, List<Operation> operations) {
     }
 

core/src/main/java/io/kestra/core/models/ServerType.java

@@ -1,10 +1,11 @@
 package io.kestra.core.models;
 
-public enum  ServerType {
+public enum ServerType {
     EXECUTOR,
     INDEXER,
     SCHEDULER,
     STANDALONE,
     WEBSERVER,
     WORKER,
+    WORKER_AGENT,
 }

core/src/main/java/io/kestra/core/models/collectors/ExecutionUsage.java

@@ -17,12 +17,31 @@ import java.util.List;
 @Introspected
 public class ExecutionUsage {
     private final List<DailyExecutionStatistics> dailyExecutionsCount;
+    private final List<DailyExecutionStatistics> dailyTaskRunsCount;
 
     public static ExecutionUsage of(final String tenantId,
                                     final ExecutionRepositoryInterface executionRepository,
                                     final ZonedDateTime from,
                                     final ZonedDateTime to) {
 
+        List<DailyExecutionStatistics> dailyTaskRunsCount = null;
+
+        try {
+            dailyTaskRunsCount = executionRepository.dailyStatistics(
+                null,
+                tenantId,
+                null,
+                null,
+                null,
+                from,
+                to,
+                DateUtils.GroupType.DAY,
+                null,
+                true);
+        } catch (UnsupportedOperationException ignored) {
+
+        }
+
         return ExecutionUsage.builder()
             .dailyExecutionsCount(executionRepository.dailyStatistics(
                 null,
@@ -33,13 +52,28 @@ public class ExecutionUsage {
                 from,
                 to,
                 DateUtils.GroupType.DAY,
-                null))
+                null,
+                false))
+            .dailyTaskRunsCount(dailyTaskRunsCount)
             .build();
     }
 
     public static ExecutionUsage of(final ExecutionRepositoryInterface repository,
                                     final ZonedDateTime from,
                                     final ZonedDateTime to) {
+        List<DailyExecutionStatistics> dailyTaskRunsCount = null;
+        try {
+            dailyTaskRunsCount = repository.dailyStatisticsForAllTenants(
+                null,
+                null,
+                null,
+                from,
+                to,
+                DateUtils.GroupType.DAY,
+                true
+            );
+        } catch (UnsupportedOperationException ignored) {}
+
         return ExecutionUsage.builder()
             .dailyExecutionsCount(repository.dailyStatisticsForAllTenants(
                 null,
@@ -47,8 +81,10 @@ public class ExecutionUsage {
                 null,
                 from,
                 to,
-                DateUtils.GroupType.DAY
+                DateUtils.GroupType.DAY,
+                false
             ))
+            .dailyTaskRunsCount(dailyTaskRunsCount)
             .build();
     }
 }

core/src/main/java/io/kestra/core/models/executions/Execution.java

@@ -272,7 +272,7 @@ public class Execution implements DeletedInterface, TenantInterface {
     }
 
     public Execution withTaskRun(TaskRun taskRun) throws InternalException {
-        ArrayList<TaskRun> newTaskRunList = this.taskRunList == null ? new ArrayList<>() : new ArrayList<>(this.taskRunList);
+        ArrayList<TaskRun> newTaskRunList = new ArrayList<>(this.taskRunList);
 
         boolean b = Collections.replaceAll(
             newTaskRunList,
@@ -441,28 +441,6 @@ public class Execution implements DeletedInterface, TenantInterface {
         @Nullable List<ResolvedTask> resolvedErrors,
         @Nullable List<ResolvedTask> resolvedFinally,
         TaskRun parentTaskRun
-    ) {
-        return findTaskDependingFlowState(resolvedTasks, resolvedErrors, resolvedFinally, parentTaskRun, null);
-    }
-
-    /**
-     * Determine if the current execution is on error &amp; normal tasks
-     * <p>
-     * if the current have errors, return tasks from errors if not, return the normal tasks
-     *
-     * @param resolvedTasks normal tasks
-     * @param resolvedErrors errors tasks
-     * @param resolvedFinally finally tasks
-     * @param parentTaskRun the parent task
-     * @param terminalState the parent task terminal state
-     * @return the flow we need to follow
-     */
-    public List<ResolvedTask> findTaskDependingFlowState(
-        List<ResolvedTask> resolvedTasks,
-        @Nullable List<ResolvedTask> resolvedErrors,
-        @Nullable List<ResolvedTask> resolvedFinally,
-        TaskRun parentTaskRun,
-        @Nullable State.Type terminalState
     ) {
         resolvedTasks = removeDisabled(resolvedTasks);
         resolvedErrors = removeDisabled(resolvedErrors);
@@ -476,15 +454,10 @@ public class Execution implements DeletedInterface, TenantInterface {
             return resolvedFinally == null ? Collections.emptyList() : resolvedFinally;
         }
 
-        // check if the parent task should fail, and there is error tasks so we start them
-        if (errorsFlow.isEmpty() && terminalState == State.Type.FAILED) {
-            return resolvedErrors == null ? resolvedFinally == null ? Collections.emptyList() : resolvedFinally : resolvedErrors;
-        }
-
-        // Check if flow has failed tasks
+        // Check if flow has failed task
         if (!errorsFlow.isEmpty() || this.hasFailed(resolvedTasks, parentTaskRun)) {
             // Check if among the failed task, they will be retried
-            if (!this.hasFailedNoRetry(resolvedTasks, parentTaskRun) && terminalState != State.Type.FAILED) {
+            if (!this.hasFailedNoRetry(resolvedTasks, parentTaskRun)) {
                 return Collections.emptyList();
             }
 
@@ -693,11 +666,6 @@ public class Execution implements DeletedInterface, TenantInterface {
 
     public State.Type guessFinalState(List<ResolvedTask> currentTasks, TaskRun parentTaskRun,
         boolean allowFailure, boolean allowWarning) {
-        return guessFinalState(currentTasks, parentTaskRun, allowFailure, allowWarning, State.Type.SUCCESS);
-    }
-
-    public State.Type guessFinalState(List<ResolvedTask> currentTasks, TaskRun parentTaskRun,
-                                      boolean allowFailure, boolean allowWarning, State.Type terminalState) {
         List<TaskRun> taskRuns = this.findTaskRunByTasks(currentTasks, parentTaskRun);
         var state = this
             .findLastByState(taskRuns, State.Type.KILLED)
@@ -714,7 +682,7 @@ public class Execution implements DeletedInterface, TenantInterface {
                 .findLastByState(taskRuns, State.Type.PAUSED)
                 .map(taskRun -> taskRun.getState().getCurrent())
             )
-            .orElse(terminalState);
+            .orElse(State.Type.SUCCESS);
 
         if (state == State.Type.FAILED && allowFailure) {
             if (allowWarning) {
@@ -865,18 +833,20 @@ public class Execution implements DeletedInterface, TenantInterface {
      * @param e the exception raise
      * @return new taskRun with updated attempt with logs
      */
-    private FailedTaskRunWithLog lastAttemptsTaskRunForFailedExecution(TaskRun taskRun, TaskRunAttempt lastAttempt, Exception e) {
-        TaskRun failed = taskRun
-            .withAttempts(
-                Stream
-                    .concat(
-                        taskRun.getAttempts().stream().limit(taskRun.getAttempts().size() - 1),
-                        Stream.of(lastAttempt.getState().isFailed() ? lastAttempt : lastAttempt.withState(State.Type.FAILED))
-                    )
-                    .toList()
-            );
+    private FailedTaskRunWithLog lastAttemptsTaskRunForFailedExecution(TaskRun taskRun,
+        TaskRunAttempt lastAttempt, Exception e) {
         return new FailedTaskRunWithLog(
-            failed.getState().isFailed() ? failed : failed.withState(State.Type.FAILED),
+            taskRun
+                .withAttempts(
+                    Stream
+                        .concat(
+                            taskRun.getAttempts().stream().limit(taskRun.getAttempts().size() - 1),
+                            Stream.of(lastAttempt
+                                .withState(State.Type.FAILED))
+                        )
+                        .toList()
+                )
+                .withState(State.Type.FAILED),
             RunContextLogger.logEntries(loggingEventFromException(e), LogEntry.of(taskRun, kind))
         );
     }

core/src/main/java/io/kestra/core/models/executions/TaskRun.java

@@ -296,7 +296,7 @@ public class TaskRun implements TenantInterface {
     }
 
     public TaskRun incrementIteration() {
-        int iteration = this.iteration == null ? 0 : this.iteration;
+        int iteration = this.iteration == null ? 1 : this.iteration;
         return this.toBuilder()
             .iteration(iteration + 1)
             .build();

core/src/main/java/io/kestra/core/models/flows/AbstractFlow.java

@@ -3,6 +3,7 @@ package io.kestra.core.models.flows;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import io.kestra.core.models.Label;
+import io.kestra.core.models.annotations.PluginProperty;
 import io.kestra.core.models.tasks.WorkerGroup;
 import io.kestra.core.serializers.ListOrMapOfLabelDeserializer;
 import io.kestra.core.serializers.ListOrMapOfLabelSerializer;
@@ -60,14 +61,7 @@ public abstract class AbstractFlow implements FlowInterface {
 
     @JsonSerialize(using = ListOrMapOfLabelSerializer.class)
     @JsonDeserialize(using = ListOrMapOfLabelDeserializer.class)
-    @Schema(
-            description = "Labels as a list of Label (key/value pairs) or as a map of string to string.",
-            oneOf = {
-                    Label[].class,
-                    Map.class
-            }
-    )
-    @Valid
+    @Schema(implementation = Object.class, oneOf = {List.class, Map.class})
     List<Label> labels;
 
     @Schema(additionalProperties = Schema.AdditionalPropertiesValue.TRUE)
@@ -75,5 +69,4 @@ public abstract class AbstractFlow implements FlowInterface {
 
     @Valid
     private WorkerGroup workerGroup;
-
 }

core/src/main/java/io/kestra/core/models/flows/State.java

@@ -86,11 +86,10 @@ public class State {
 
     @JsonProperty(access = JsonProperty.Access.READ_ONLY)
     public Duration getDuration() {
-        if(this.getEndDate().isPresent()){
-            return Duration.between(this.getStartDate(), this.getEndDate().get());
-        } else {
-            return Duration.between(this.getStartDate(), Instant.now());
-        }
+        return Duration.between(
+            this.histories.getFirst().getDate(),
+            this.histories.size() > 1 ? this.histories.get(this.histories.size() - 1).getDate() : Instant.now()
+        );
     }
 
     @JsonProperty(access = JsonProperty.Access.READ_ONLY)

core/src/main/java/io/kestra/core/models/flows/input/MultiselectInput.java

@@ -3,7 +3,6 @@ package io.kestra.core.models.flows.input;
 import io.kestra.core.models.flows.Input;
 import io.kestra.core.models.flows.RenderableInput;
 import io.kestra.core.models.flows.Type;
-import io.kestra.core.models.property.Property;
 import io.kestra.core.models.validations.ManualConstraintViolation;
 import io.kestra.core.validations.Regex;
 import io.swagger.v3.oas.annotations.media.Schema;
@@ -14,7 +13,6 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 
-import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
@@ -58,23 +56,6 @@ public class MultiselectInput extends Input<List<String>> implements ItemTypeInt
     @Builder.Default
     Boolean allowCustomValue = false;
 
-    @Schema(
-        title = "Whether the first value of the multi-select should be selected by default."
-    )
-    @NotNull
-    @Builder.Default
-    Boolean autoSelectFirst = false;
-
-    @Override
-    public Property<List<String>> getDefaults() {
-        Property<List<String>> baseDefaults = super.getDefaults();
-        if (baseDefaults == null && autoSelectFirst && !Optional.ofNullable(values).map(Collection::isEmpty).orElse(true)) {
-            return Property.ofValue(List.of(values.getFirst()));
-        }
-
-        return baseDefaults;
-    }
-
     @Override
     public void validate(List<String> inputs) throws ConstraintViolationException {
         if (values != null && options != null) {
@@ -119,7 +100,6 @@ public class MultiselectInput extends Input<List<String>> implements ItemTypeInt
                 .dependsOn(getDependsOn())
                 .itemType(getItemType())
                 .displayName(getDisplayName())
-                .autoSelectFirst(getAutoSelectFirst())
                 .build();
         }
         return this;

core/src/main/java/io/kestra/core/models/flows/input/SelectInput.java

@@ -2,7 +2,6 @@ package io.kestra.core.models.flows.input;
 
 import io.kestra.core.models.flows.Input;
 import io.kestra.core.models.flows.RenderableInput;
-import io.kestra.core.models.property.Property;
 import io.kestra.core.models.validations.ManualConstraintViolation;
 import io.kestra.core.validations.Regex;
 import io.swagger.v3.oas.annotations.media.Schema;
@@ -13,7 +12,6 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 
-import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
@@ -48,23 +46,6 @@ public class SelectInput extends Input<String> implements RenderableInput {
     @Builder.Default
     Boolean isRadio = false;
 
-    @Schema(
-        title = "Whether the first value of the select should be selected by default."
-    )
-    @NotNull
-    @Builder.Default
-    Boolean autoSelectFirst = false;
-
-    @Override
-    public Property<String> getDefaults() {
-        Property<String> baseDefaults = super.getDefaults();
-        if (baseDefaults == null && autoSelectFirst && !Optional.ofNullable(values).map(Collection::isEmpty).orElse(true)) {
-            return Property.ofValue(values.getFirst());
-        }
-
-        return baseDefaults;
-    }
-
     @Override
     public void validate(String input) throws ConstraintViolationException {
         if (!values.contains(input) && this.getRequired()) {
@@ -97,7 +78,6 @@ public class SelectInput extends Input<String> implements RenderableInput {
                 .dependsOn(getDependsOn())
                 .displayName(getDisplayName())
                 .isRadio(getIsRadio())
-                .autoSelectFirst(getAutoSelectFirst())
                 .build();
         }
         return this;

core/src/main/java/io/kestra/core/models/tasks/ResolvedTask.java

@@ -30,7 +30,7 @@ public class ResolvedTask {
 
     public NextTaskRun toNextTaskRunIncrementIteration(Execution execution, Integer iteration) {
         return new NextTaskRun(
-            TaskRun.of(execution, this).withIteration(iteration != null ? iteration : 0),
+            TaskRun.of(execution, this).withIteration(iteration != null ? iteration : 1),
             this.getTask()
         );
     }

core/src/main/java/io/kestra/core/models/triggers/Trigger.java

@@ -185,6 +185,34 @@ public class Trigger extends TriggerContext implements HasUID {
             .build();
     }
 
+    public static Trigger update(Trigger currentTrigger, Trigger newTrigger, ZonedDateTime nextExecutionDate) throws Exception {
+        Trigger updated = currentTrigger;
+
+        // If a backfill is created, we update the currentTrigger
+        // and set the nextExecutionDate() as the previous one
+        if (newTrigger.getBackfill() != null) {
+            updated = currentTrigger.toBuilder()
+                .backfill(
+                    newTrigger
+                        .getBackfill()
+                        .toBuilder()
+                        .end(newTrigger.getBackfill().getEnd() != null ? newTrigger.getBackfill().getEnd() : ZonedDateTime.now())
+                        .currentDate(
+                            newTrigger.getBackfill().getStart()
+                        )
+                        .previousNextExecutionDate(
+                            currentTrigger.getNextExecutionDate())
+                        .build())
+                .build();
+        }
+
+        return updated.toBuilder()
+            .nextExecutionDate(newTrigger.getDisabled() ?
+                null : nextExecutionDate)
+            .disabled(newTrigger.getDisabled())
+            .build();
+    }
+
     public Trigger resetExecution(Flow flow, Execution execution, ConditionContext conditionContext) {
         boolean disabled = this.getStopAfter() != null ? this.getStopAfter().contains(execution.getState().getCurrent()) : this.getDisabled();
         if (!disabled) {
@@ -248,22 +276,27 @@ public class Trigger extends TriggerContext implements HasUID {
             .build();
     }
 
-    public Trigger withBackfill(final Backfill backfill) {
-        Trigger updated = this;
-        // If a backfill is created, we update the trigger
+    public Trigger initBackfill(Trigger newTrigger) {
+        // If a backfill is created, we update the currentTrigger
         // and set the nextExecutionDate() as the previous one
-        if (backfill != null) {
-            updated = this.toBuilder()
+        if (newTrigger.getBackfill() != null) {
+
+            return this.toBuilder()
                 .backfill(
-                    backfill
+                    newTrigger
+                        .getBackfill()
                         .toBuilder()
-                        .end(backfill.getEnd() != null ? backfill.getEnd() : ZonedDateTime.now())
-                        .currentDate(backfill.getStart())
-                        .previousNextExecutionDate(this.getNextExecutionDate())
+                        .end(newTrigger.getBackfill().getEnd() != null ? newTrigger.getBackfill().getEnd() : ZonedDateTime.now())
+                        .currentDate(
+                            newTrigger.getBackfill().getStart()
+                        )
+                        .previousNextExecutionDate(
+                            this.getNextExecutionDate())
                         .build())
                 .build();
         }
-        return updated;
+
+        return this;
     }
 
     // if the next date is after the backfill end, we remove the backfill

core/src/main/java/io/kestra/core/models/triggers/multipleflows/MultipleCondition.java

@@ -3,6 +3,7 @@ package io.kestra.core.models.triggers.multipleflows;
 import io.kestra.core.exceptions.InternalException;
 import io.kestra.core.models.conditions.Condition;
 import io.kestra.core.models.conditions.ConditionContext;
+import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.triggers.TimeWindow;
 import io.kestra.core.utils.Rethrow;
 import org.slf4j.Logger;
@@ -23,7 +24,7 @@ public interface MultipleCondition extends Rethrow.PredicateChecked<ConditionCon
 
     /**
      * This conditions will only validate previously calculated value on
-     * io.kestra.executor.FlowTriggerService#computeExecutionsFromFlowTriggers(Execution, List, Optional) and {@link MultipleConditionStorageInterface#save(List)} by the executor.
+     * {@link io.kestra.core.services.FlowTriggerService#computeExecutionsFromFlowTriggers(Execution, List, Optional)}} and {@link MultipleConditionStorageInterface#save(List)} by the executor.
      * The real validation is done here.
      */
     @Override

core/src/main/java/io/kestra/core/plugins/DefaultPluginRegistry.java

@@ -43,7 +43,7 @@ public class DefaultPluginRegistry implements PluginRegistry {
         static final DefaultPluginRegistry INSTANCE = new DefaultPluginRegistry();
     }
 
-    protected final Map<PluginIdentifier, PluginClassAndMetadata<? extends Plugin>> pluginClassByIdentifier = new ConcurrentHashMap<>();
+    private final Map<PluginIdentifier, PluginClassAndMetadata<? extends Plugin>> pluginClassByIdentifier = new ConcurrentHashMap<>();
     private final Map<PluginBundleIdentifier, RegisteredPlugin> plugins = new ConcurrentHashMap<>();
     private final PluginScanner scanner = new PluginScanner(DefaultPluginRegistry.class.getClassLoader());
     private final AtomicBoolean initialized = new AtomicBoolean(false);
@@ -56,7 +56,7 @@ public class DefaultPluginRegistry implements PluginRegistry {
      *
      * @return the {@link DefaultPluginRegistry}.
      */
-    public synchronized static DefaultPluginRegistry getOrCreate() {
+    public static DefaultPluginRegistry getOrCreate() {
         DefaultPluginRegistry instance = LazyHolder.INSTANCE;
         if (!instance.isInitialized()) {
             instance.init();
@@ -74,7 +74,7 @@ public class DefaultPluginRegistry implements PluginRegistry {
     /**
      * Initializes the registry by loading all core plugins.
      */
-    protected synchronized void init() {
+    protected void init() {
         if (initialized.compareAndSet(false, true)) {
             register(scanner.scan());
         }
@@ -103,13 +103,11 @@ public class DefaultPluginRegistry implements PluginRegistry {
      */
     @Override
     public void registerIfAbsent(final Path pluginPath) {
-        long start = System.currentTimeMillis();
         if (isPluginPathValid(pluginPath) && !isPluginPathScanned(pluginPath)) {
             List<RegisteredPlugin> scanned = scanner.scan(pluginPath);
             scanned.forEach(this::register);
             scannedPluginPaths.add(pluginPath);
         }
-        log.debug("Registered if absent plugins from path {} in {} ms", pluginPath, System.currentTimeMillis() - start);
     }
 
     private boolean isPluginPathScanned(final Path pluginPath) {
@@ -121,12 +119,10 @@ public class DefaultPluginRegistry implements PluginRegistry {
      */
     @Override
     public void register(final Path pluginPath) {
-        long start = System.currentTimeMillis();
         if (isPluginPathValid(pluginPath)) {
             List<RegisteredPlugin> scanned = scanner.scan(pluginPath);
             scanned.forEach(this::register);
         }
-        log.debug("Registered plugins from path {} in {} ms", pluginPath, System.currentTimeMillis() - start);
     }
 
     /**
@@ -195,28 +191,21 @@ public class DefaultPluginRegistry implements PluginRegistry {
      */
     public void register(final RegisteredPlugin plugin) {
         final PluginBundleIdentifier identifier = PluginBundleIdentifier.of(plugin);
-        // Skip registration if the same plugin already exists in the registry.
-        final RegisteredPlugin existing = plugins.get(identifier);
-        if (existing != null && existing.crc32() == plugin.crc32()) {
-            return; // same plugin already registered
+
+        // Skip registration if plugin-bundle already exists in the registry.
+        if (containsPluginBundle(identifier)) {
+            return;
         }
 
         lock.lock();
         try {
-            if (existing != null) {
-                unregister(List.of(existing));
-            }
             plugins.put(PluginBundleIdentifier.of(plugin), plugin);
-            registerAll(getPluginClassesByIdentifier(plugin));
+            pluginClassByIdentifier.putAll(getPluginClassesByIdentifier(plugin));
         } finally {
             lock.unlock();
         }
     }
 
-    protected void registerAll(Map<PluginIdentifier, PluginClassAndMetadata<? extends Plugin>> plugins) {
-        pluginClassByIdentifier.putAll(plugins);
-    }
-
     @SuppressWarnings("unchecked")
     protected Map<PluginIdentifier, PluginClassAndMetadata<? extends Plugin>> getPluginClassesByIdentifier(final RegisteredPlugin plugin) {
         Map<PluginIdentifier, PluginClassAndMetadata<? extends Plugin>> classes = new HashMap<>();

core/src/main/java/io/kestra/core/plugins/ExternalPlugin.java

@@ -6,12 +6,6 @@ import lombok.Getter;
 import lombok.ToString;
 
 import java.net.URL;
-import java.nio.ByteBuffer;
-import java.nio.charset.StandardCharsets;
-import java.util.Enumeration;
-import java.util.jar.JarEntry;
-import java.util.jar.JarFile;
-import java.util.zip.CRC32;
 
 @AllArgsConstructor
 @Getter
@@ -20,59 +14,4 @@ import java.util.zip.CRC32;
 public class ExternalPlugin {
     private final URL location;
     private final URL[] resources;
-    private volatile Long crc32; // lazy-val
-    
-    public ExternalPlugin(URL location, URL[] resources) {
-        this.location = location;
-        this.resources = resources;
-    }
-    
-    public Long getCrc32() {
-        if (this.crc32 == null) {
-            synchronized (this) {
-                if (this.crc32 == null) {
-                    this.crc32 = computeJarCrc32(location);
-                }
-            }
-        }
-        return crc32;
-    }
-    
-    /**
-     * Compute a CRC32 of the JAR File without reading the whole file
-     *
-     * @param location of the JAR File.
-     * @return the CRC32 of {@code -1} if the checksum can't be computed.
-     */
-    private static long computeJarCrc32(final URL location) {
-        CRC32 crc = new CRC32();
-        try (JarFile jar = new JarFile(location.toURI().getPath(), false)) {
-            Enumeration<JarEntry> entries = jar.entries();
-            byte[] buffer = new byte[Long.BYTES]; // reusable buffer to avoid re-allocation
-            
-            while (entries.hasMoreElements()) {
-                JarEntry entry = entries.nextElement();
-                crc.update(entry.getName().getBytes(StandardCharsets.UTF_8));
-                updateCrc32WithLong(crc, buffer, entry.getSize());
-                updateCrc32WithLong(crc, buffer, entry.getCrc());
-            }
-            
-            return crc.getValue();
-        } catch (Exception e) {
-            return -1;
-        }
-    }
-    
-    private static void updateCrc32WithLong(CRC32 crc32, byte[] reusable, long val) {
-        // fast long -> byte conversion
-        reusable[0] = (byte) (val >>> 56);
-        reusable[1] = (byte) (val >>> 48);
-        reusable[2] = (byte) (val >>> 40);
-        reusable[3] = (byte) (val >>> 32);
-        reusable[4] = (byte) (val >>> 24);
-        reusable[5] = (byte) (val >>> 16);
-        reusable[6] = (byte) (val >>> 8);
-        reusable[7] = (byte) val;
-        crc32.update(reusable);;
-    }
 }

core/src/main/java/io/kestra/core/plugins/PluginClassLoader.java

@@ -46,7 +46,6 @@ public class PluginClassLoader extends URLClassLoader {
         + "|dev.failsafe"
         + "|reactor"
         + "|io.opentelemetry"
-        + "|io.netty"
         + ")\\..*$");
 
     private final ClassLoader parent;

core/src/main/java/io/kestra/core/plugins/PluginRegistry.java

@@ -2,14 +2,10 @@ package io.kestra.core.plugins;
 
 import io.kestra.core.models.Plugin;
 
-import java.net.URL;
-import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Predicate;
-import java.util.zip.CRC32;
-import java.util.zip.Checksum;
 
 /**
  * Registry for managing all Kestra's {@link Plugin}.
@@ -127,24 +123,4 @@ public interface PluginRegistry {
      * @return {@code true} if supported. Otherwise {@code false}.
      */
     boolean isVersioningSupported();
-    
-    /**
-     * Computes a CRC32 hash value representing the current content of the plugin registry.
-     *
-     * @return a {@code long} containing the CRC32 checksum value, serving as a compact
-     *         representation of the registry's content
-     */
-    default long hash() {
-        Checksum crc32 = new CRC32();
-        
-        for (RegisteredPlugin plugin : plugins()) {
-            Optional.ofNullable(plugin.getExternalPlugin())
-                .map(ExternalPlugin::getCrc32)
-                .ifPresent(checksum -> {
-                    byte[] bytes = ByteBuffer.allocate(Long.BYTES).putLong(checksum).array();
-                    crc32.update(bytes, 0, bytes.length);
-                });
-        }
-        return crc32.getValue();
-    }
 }

core/src/main/java/io/kestra/core/plugins/PluginResolver.java

@@ -5,15 +5,11 @@ import lombok.extern.slf4j.Slf4j;
 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
-import java.nio.ByteBuffer;
 import java.nio.file.DirectoryStream;
 import java.nio.file.Files;
 import java.nio.file.InvalidPathException;
 import java.nio.file.Path;
 import java.util.*;
-import java.util.jar.JarEntry;
-import java.util.jar.JarFile;
-import java.util.zip.CRC32;
 
 @Slf4j
 public class PluginResolver {
@@ -123,5 +119,4 @@ public class PluginResolver {
 
         return urls;
     }
-
 }

core/src/main/java/io/kestra/core/plugins/RegisteredPlugin.java

@@ -308,10 +308,6 @@ public class RegisteredPlugin {
         }
         return null;
     }
-    
-    public long crc32() {
-        return Optional.ofNullable(externalPlugin).map(ExternalPlugin::getCrc32).orElse(-1L);
-    }
 
     @Override
     public String toString() {

core/src/main/java/io/kestra/core/plugins/serdes/PluginDeserializer.java

@@ -144,7 +144,7 @@ public final class PluginDeserializer<T extends Plugin> extends JsonDeserializer
 
     static String extractPluginRawIdentifier(final JsonNode node, final boolean isVersioningSupported) {
         String type = Optional.ofNullable(node.get(TYPE)).map(JsonNode::textValue).orElse(null);
-        String version = Optional.ofNullable(node.get(VERSION)).map(JsonNode::asText).orElse(null);
+        String version = Optional.ofNullable(node.get(VERSION)).map(JsonNode::textValue).orElse(null);
 
         if (type == null || type.isEmpty()) {
             return null;

core/src/main/java/io/kestra/core/queues/QueueFactoryInterface.java

@@ -27,7 +27,6 @@ public interface QueueFactoryInterface {
     String CLUSTER_EVENT_NAMED = "clusterEventQueue";
     String SUBFLOWEXECUTIONEND_NAMED = "subflowExecutionEndQueue";
     String EXECUTION_RUNNING_NAMED = "executionRunningQueue";
-    String MULTIPLE_CONDITION_EVENT_NAMED = "multipleConditionEventQueue";
 
     QueueInterface<Execution> execution();
 
@@ -60,6 +59,4 @@ public interface QueueFactoryInterface {
     QueueInterface<SubflowExecutionEnd> subflowExecutionEnd();
 
     QueueInterface<ExecutionRunning> executionRunning();
-
-    QueueInterface<MultipleConditionEvent> multipleConditionEvent();
 }

core/src/main/java/io/kestra/core/queues/QueueInterface.java

@@ -5,7 +5,6 @@ import io.kestra.core.models.Pauseable;
 import io.kestra.core.utils.Either;
 
 import java.io.Closeable;
-import java.util.List;
 import java.util.function.Consumer;
 
 public interface QueueInterface<T> extends Closeable, Pauseable {
@@ -19,15 +18,7 @@ public interface QueueInterface<T> extends Closeable, Pauseable {
         emitAsync(null, message);
     }
 
-    default void emitAsync(String consumerGroup, T message) throws QueueException {
-        emitAsync(consumerGroup, List.of(message));
-    }
-
-    default void emitAsync(List<T> messages) throws QueueException {
-        emitAsync(null, messages);
-    }
-
-    void emitAsync(String consumerGroup, List<T> messages) throws QueueException;
+    void emitAsync(String consumerGroup, T message) throws QueueException;
 
     default void delete(T message) throws QueueException {
         delete(null, message);

core/src/main/java/io/kestra/core/queues/WorkerJobQueueInterface.java

@@ -9,4 +9,5 @@ import java.util.function.Consumer;
 public interface WorkerJobQueueInterface extends QueueInterface<WorkerJob> {
     
     Runnable subscribe(String workerId, String workerGroup, Consumer<Either<WorkerJob, DeserializationException>> consumer);
+
 }

core/src/main/java/io/kestra/core/repositories/ExecutionRepositoryInterface.java

@@ -25,6 +25,8 @@ import java.util.Optional;
 import java.util.function.Function;
 
 public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Execution>, QueryBuilderInterface<Executions.Fields> {
+    Boolean isTaskRunEnabled();
+
     default Optional<Execution> findById(String tenantId, String id) {
         return findById(tenantId, id, false);
     }
@@ -94,19 +96,24 @@ public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Ex
 
     Flux<Execution> findAllAsync(@Nullable String tenantId);
 
+    ArrayListTotal<TaskRun> findTaskRun(
+        Pageable pageable,
+        @Nullable String tenantId,
+        List<QueryFilter> filters
+    );
+
     Execution delete(Execution execution);
 
     Integer purge(Execution execution);
 
-    Integer purge(List<Execution> executions);
-
     List<DailyExecutionStatistics> dailyStatisticsForAllTenants(
         @Nullable String query,
         @Nullable String namespace,
         @Nullable String flowId,
         @Nullable ZonedDateTime startDate,
         @Nullable ZonedDateTime endDate,
-        @Nullable DateUtils.GroupType groupBy
+        @Nullable DateUtils.GroupType groupBy,
+        boolean isTaskRun
     );
 
     List<DailyExecutionStatistics> dailyStatistics(
@@ -118,7 +125,8 @@ public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Ex
         @Nullable ZonedDateTime startDate,
         @Nullable ZonedDateTime endDate,
         @Nullable DateUtils.GroupType groupBy,
-        List<State.Type> state
+        List<State.Type> state,
+        boolean isTaskRun
     );
 
     @Getter

core/src/main/java/io/kestra/core/repositories/FlowRepositoryInterface.java

@@ -4,7 +4,6 @@ import io.kestra.core.models.QueryFilter;
 import io.kestra.core.models.SearchResult;
 import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.flows.*;
-import io.kestra.plugin.core.dashboard.data.Flows;
 import io.micronaut.data.model.Pageable;
 import jakarta.annotation.Nullable;
 import jakarta.validation.ConstraintViolationException;
@@ -12,7 +11,7 @@ import jakarta.validation.ConstraintViolationException;
 import java.util.List;
 import java.util.Optional;
 
-public interface FlowRepositoryInterface extends QueryBuilderInterface<Flows.Fields> {
+public interface FlowRepositoryInterface {
 
     Optional<Flow> findById(String tenantId, String namespace, String id, Optional<Integer> revision, Boolean allowDeleted);
 
@@ -163,6 +162,4 @@ public interface FlowRepositoryInterface extends QueryBuilderInterface<Flows.Fie
     FlowWithSource update(GenericFlow flow, FlowInterface previous) throws ConstraintViolationException;
 
     FlowWithSource delete(FlowInterface flow);
-
-    Boolean existAnyNoAcl(String tenantId);
 }

core/src/main/java/io/kestra/core/repositories/LocalFlowRepositoryLoader.java

@@ -83,9 +83,7 @@ public class LocalFlowRepositoryLoader {
     }
 
     public void load(String tenantId, File basePath) throws IOException {
-        Map<String, FlowInterface> flowByUidInRepository = flowRepository.findAllForAllTenants()
-            .stream()
-            .filter(flow -> tenantId.equals(flow.getTenantId()))
+        Map<String, FlowInterface> flowByUidInRepository = flowRepository.findAllForAllTenants().stream()
             .collect(Collectors.toMap(FlowId::uidWithoutRevision, Function.identity()));
 
         try (Stream<Path> pathStream = Files.walk(basePath.toPath())) {

core/src/main/java/io/kestra/core/repositories/LogRepositoryInterface.java

@@ -90,8 +90,6 @@ public interface LogRepositoryInterface extends SaveRepositoryInterface<LogEntry
 
     Integer purge(Execution execution);
 
-    Integer purge(List<Execution> executions);
-
     void deleteByQuery(String tenantId, String executionId, String taskId, String taskRunId, Level minLevel, Integer attempt);
 
     void deleteByQuery(String tenantId, String namespace, String flowId, String triggerId);

core/src/main/java/io/kestra/core/repositories/MetricRepositoryInterface.java

@@ -29,8 +29,6 @@ public interface MetricRepositoryInterface extends SaveRepositoryInterface<Metri
 
     Integer purge(Execution execution);
 
-    Integer purge(List<Execution> executions);
-
     Flux<MetricEntry> findAllAsync(@Nullable String tenantId);
 
     default Function<String, String> sortMapping() throws IllegalArgumentException {

core/src/main/java/io/kestra/core/runners/AbstractWorkerCallable.java

@@ -1,12 +1,12 @@
-package io.kestra.worker;
+package io.kestra.core.runners;
 
 import io.kestra.core.models.WorkerJobLifecycle;
 import io.kestra.core.models.flows.State;
-import io.kestra.core.runners.RunContext;
 import io.kestra.core.utils.Exceptions;
 import io.opentelemetry.api.trace.Span;
 import io.opentelemetry.api.trace.StatusCode;
 import lombok.Getter;
+import lombok.Setter;
 import lombok.Synchronized;
 import org.slf4j.Logger;
 
@@ -33,6 +33,7 @@ public abstract class AbstractWorkerCallable implements Callable<State.Type> {
     String uid;
 
     @Getter
+    @Setter
     Throwable exception;
 
     private final CountDownLatch shutdownLatch = new CountDownLatch(1);
@@ -81,7 +82,7 @@ public abstract class AbstractWorkerCallable implements Callable<State.Type> {
      *
      * @see WorkerJobLifecycle#stop()
      */
-    protected abstract void signalStop();
+    public abstract void signalStop();
 
     /**
      * Wait for this worker task to complete stopping.

core/src/main/java/io/kestra/core/runners/AbstractWorkerTriggerCallable.java

@@ -1,8 +1,6 @@
-package io.kestra.worker;
+package io.kestra.core.runners;
 
 import io.kestra.core.models.triggers.WorkerTriggerInterface;
-import io.kestra.core.runners.RunContext;
-import io.kestra.core.runners.WorkerTrigger;
 import lombok.Getter;
 
 import java.time.Duration;

core/src/main/java/io/kestra/core/runners/ExecutableUtils.java

@@ -5,7 +5,10 @@ import io.kestra.core.exceptions.IllegalVariableEvaluationException;
 import io.kestra.core.exceptions.InternalException;
 import io.kestra.core.models.Label;
 import io.kestra.core.models.executions.*;
-import io.kestra.core.models.flows.*;
+import io.kestra.core.models.flows.Flow;
+import io.kestra.core.models.flows.FlowInterface;
+import io.kestra.core.models.flows.FlowWithException;
+import io.kestra.core.models.flows.State;
 import io.kestra.core.models.property.Property;
 import io.kestra.core.models.tasks.ExecutableTask;
 import io.kestra.core.models.tasks.Task;
@@ -26,7 +29,6 @@ import org.apache.commons.lang3.stream.Streams;
 import java.time.Instant;
 import java.time.ZonedDateTime;
 import java.util.*;
-import java.util.stream.Collectors;
 
 import static io.kestra.core.trace.Tracer.throwCallable;
 import static io.kestra.core.utils.Rethrow.throwConsumer;
@@ -151,22 +153,14 @@ public final class ExecutableUtils {
                     currentFlow.getNamespace(),
                     currentFlow.getId()
                 )
-                .orElseThrow(() -> {
-                    String msg = "Unable to find flow '" + subflowNamespace + "'.'" + subflowId + "' with revision '" + subflowRevision.orElse(0) + "'";
-                    runContext.logger().error(msg);
-                    return new IllegalStateException(msg);
-                });
+                .orElseThrow(() -> new IllegalStateException("Unable to find flow '" + subflowNamespace + "'.'" + subflowId + "' with revision '" + subflowRevision.orElse(0) + "'"));
 
             if (flow.isDisabled()) {
-                String msg = "Cannot execute a flow which is disabled";
-                runContext.logger().error(msg);
-                throw new IllegalStateException(msg);
+                throw new IllegalStateException("Cannot execute a flow which is disabled");
             }
 
             if (flow instanceof FlowWithException fwe) {
-                String msg = "Cannot execute an invalid flow: " + fwe.getException();
-                runContext.logger().error(msg);
-                throw new IllegalStateException(msg);
+                throw new IllegalStateException("Cannot execute an invalid flow: " + fwe.getException());
             }
 
             List<Label> newLabels = inheritLabels ? new ArrayList<>(filterLabels(currentExecution.getLabels(), flow)) : new ArrayList<>(systemLabels(currentExecution));
@@ -207,20 +201,7 @@ public final class ExecutableUtils {
                     .build()
                 )
                 .withScheduleDate(scheduleOnDate);
-                if(execution.getInputs().size()<inputs.size()) {
-                    Map<String,Object>resolvedInputs=execution.getInputs();
-                    for (var inputKey : inputs.keySet()) {
-                        if (!resolvedInputs.containsKey(inputKey)) {
-                            runContext.logger().warn(
-                                "Input {} was provided by parent execution {} for subflow {}.{} but isn't declared at the subflow inputs",
-                                inputKey,
-                                currentExecution.getId(),
-                                currentTask.subflowId().namespace(),
-                                currentTask.subflowId().flowId()
-                            );
-                        }
-                    }
-                }
+
             // inject the traceparent into the new execution
             propagator.ifPresent(pg -> pg.inject(Context.current(), execution, ExecutionTextMapSetter.INSTANCE));
 

core/src/main/java/io/kestra/core/runners/ExecutionRunning.java

@@ -32,7 +32,5 @@ public class ExecutionRunning implements HasUID {
         return IdUtils.fromPartsAndSeparator('|', this.tenantId, this.namespace, this.flowId, this.execution.getId());
     }
 
-    // Note: the KILLED state is only used in the Kafka implementation to difference between purging terminated running execution (null)
-    // and purging killed execution which need special treatment
-    public enum ConcurrencyState { CREATED, RUNNING, QUEUED, CANCELLED, FAILED, KILLED }
+    public enum ConcurrencyState { CREATED, RUNNING, QUEUED, CANCELLED, FAILED }
 }

core/src/main/java/io/kestra/core/runners/Executor.java

@@ -11,10 +11,6 @@ import lombok.Getter;
 import java.util.ArrayList;
 import java.util.List;
 
-// TODO for 2.0: this class is used as a queue consumer (which should have been the ExecutorInterface instead),
-//  a queue message (only in Kafka) and an execution context.
-//  At some point, we should rename it to ExecutorContext and move it to the executor module,
-//  then rename the ExecutorInterface to just Executor (to be used as a queue consumer)
 @Getter
 @AllArgsConstructor
 public class Executor {

core/src/main/java/io/kestra/core/runners/ExecutorInterface.java

@@ -1,7 +1,7 @@
 package io.kestra.core.runners;
 
-import io.kestra.core.server.Service;
+import java.io.Closeable;
 
-public interface ExecutorInterface extends Service, Runnable {
+public interface ExecutorInterface extends Closeable, Runnable {
 
 }

core/src/main/java/io/kestra/core/runners/ExecutorService.java

@@ -1,4 +1,4 @@
-package io.kestra.executor;
+package io.kestra.core.runners;
 
 import io.kestra.core.debug.Breakpoint;
 import io.kestra.core.exceptions.InternalException;
@@ -14,7 +14,6 @@ import io.kestra.core.models.tasks.retrys.AbstractRetry;
 import io.kestra.core.queues.QueueException;
 import io.kestra.core.queues.QueueFactoryInterface;
 import io.kestra.core.queues.QueueInterface;
-import io.kestra.core.runners.*;
 import io.kestra.core.services.*;
 import io.kestra.core.storages.StorageContext;
 import io.kestra.core.test.flow.TaskFixture;
@@ -94,10 +93,6 @@ public class ExecutorService {
     @Named(QueueFactoryInterface.KILL_NAMED)
     protected QueueInterface<ExecutionKilled> killQueue;
 
-    @Inject
-    @Named(QueueFactoryInterface.WORKERTASKLOG_NAMED)
-    private QueueInterface<LogEntry> logQueue;
-
     protected FlowMetaStoreInterface flowExecutorInterface() {
         // bean is injected late, so we need to wait
         if (this.flowExecutorInterface == null) {
@@ -128,17 +123,10 @@ public class ExecutorService {
                     executionRunning
                         .withExecution(executionRunning.getExecution().withState(State.Type.CANCELLED))
                         .withConcurrencyState(ExecutionRunning.ConcurrencyState.RUNNING);
-                case FAIL -> {
-                    var failedExecution = executionRunning.getExecution().failedExecutionFromExecutor(new IllegalStateException("Execution is FAILED due to concurrency limit exceeded"));
-                    try {
-                        logQueue.emitAsync(failedExecution.getLogs());
-                    } catch (QueueException ex) {
-                        // fail silently
-                    }
-                    yield executionRunning
-                        .withExecution(failedExecution.getExecution())
+                case FAIL ->
+                    executionRunning
+                        .withExecution(executionRunning.getExecution().failedExecutionFromExecutor(new IllegalStateException("Execution is FAILED due to concurrency limit exceeded")).getExecution())
                         .withConcurrencyState(ExecutionRunning.ConcurrencyState.RUNNING);
-                }
 
             };
         }
@@ -392,7 +380,7 @@ public class ExecutorService {
 
         if (flow.getOutputs() != null) {
             RunContext runContext = runContextFactory.of(executor.getFlow(), executor.getExecution());
-
+            
             try {
                 Map<String, Object> outputs = FlowInputOutput.renderFlowOutputs(flow.getOutputs(), runContext);
                 outputs = flowInputOutput.typedOutputs(flow, executor.getExecution(), outputs);
@@ -1072,17 +1060,6 @@ public class ExecutorService {
                 var executionUpdatingTask = (ExecutionUpdatableTask) workerTask.getTask();
 
                 try {
-                    // handle runIf
-                    if (!TruthUtils.isTruthy(workerTask.getRunContext().render(workerTask.getTask().getRunIf()))) {
-                        executor.withExecution(
-                            executor
-                                .getExecution()
-                                .withTaskRun(workerTask.getTaskRun().withState(State.Type.SKIPPED)),
-                            "handleExecutionUpdatingTaskSkipped"
-                        );
-                        return false;
-                    }
-
                     executor.withExecution(
                         executionUpdatingTask.update(executor.getExecution(), workerTask.getRunContext())
                             .withTaskRun(workerTask.getTaskRun().withState(State.Type.RUNNING)),
@@ -1182,7 +1159,7 @@ public class ExecutorService {
             }
         }
 
-        return taskRuns.size() > ListUtils.emptyOnNull(execution.getTaskRunList()).size() ? execution.withTaskRunList(taskRuns) : null;
+        return taskRuns.size() > execution.getTaskRunList().size() ? execution.withTaskRunList(taskRuns) : null;
     }
 
     public boolean canBePurged(final Executor executor) {

core/src/main/java/io/kestra/core/runners/FlowInputOutput.java

@@ -49,7 +49,15 @@ import java.time.Duration;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalTime;
-import java.util.*;
+import java.util.AbstractMap;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.regex.Matcher;
@@ -223,19 +231,6 @@ public class FlowInputOutput {
                 return new AbstractMap.SimpleEntry<>(it.input().getId(), it.value());
             })
             .collect(HashMap::new, (m,v)-> m.put(v.getKey(), v.getValue()), HashMap::putAll);
-        if (resolved.size() < data.size()) {
-            RunContext runContext = runContextFactory.of(flow, execution);
-            for (var inputKey : data.keySet()) {
-                if (!resolved.containsKey(inputKey)) {
-                    runContext.logger().warn(
-                        "Input {} was provided for workflow {}.{} but isn't declared in the workflow inputs",
-                        inputKey,
-                        flow.getNamespace(),
-                        flow.getId()
-                    );
-                }
-            }
-        }
         return MapUtils.flattenToNestedMap(resolved);
     }
 
@@ -318,15 +313,15 @@ public class FlowInputOutput {
             });
             resolvable.setInput(input);
 
-
+            
             Object value = resolvable.get().value();
-
+            
             // resolve default if needed
             if (value == null && input.getDefaults() != null) {
                 value = resolveDefaultValue(input, runContext);
                 resolvable.isDefault(true);
             }
-
+            
             // validate and parse input value
             if (value == null) {
                 if (input.getRequired()) {
@@ -355,7 +350,7 @@ public class FlowInputOutput {
 
         return resolvable.get();
     }
-
+    
     public static Object resolveDefaultValue(Input<?> input, PropertyContext renderer) throws IllegalVariableEvaluationException {
         return switch (input.getType()) {
             case STRING, ENUM, SELECT, SECRET, EMAIL -> resolveDefaultPropertyAs(input, renderer, String.class);
@@ -372,7 +367,7 @@ public class FlowInputOutput {
             case MULTISELECT -> resolveDefaultPropertyAsList(input, renderer, String.class);
         };
     }
-
+    
     @SuppressWarnings("unchecked")
     private static <T> Object resolveDefaultPropertyAs(Input<?> input, PropertyContext renderer, Class<T> clazz) throws IllegalVariableEvaluationException {
         return Property.as((Property<T>) input.getDefaults(), renderer, clazz);
@@ -381,21 +376,12 @@ public class FlowInputOutput {
     private static <T> Object resolveDefaultPropertyAsList(Input<?> input, PropertyContext renderer, Class<T> clazz) throws IllegalVariableEvaluationException {
         return Property.asList((Property<List<T>>) input.getDefaults(), renderer, clazz);
     }
-
+    
     private RunContext buildRunContextForExecutionAndInputs(final FlowInterface flow, final Execution execution, Map<String, InputAndValue> dependencies) {
         Map<String, Object> flattenInputs = MapUtils.flattenToNestedMap(dependencies.entrySet()
             .stream()
             .collect(HashMap::new, (m, v) -> m.put(v.getKey(), v.getValue().value()), HashMap::putAll)
         );
-        // Hack: Pre-inject all inputs that have a default value with 'null' to prevent
-        // RunContextFactory from attempting to render them when absent, which could
-        // otherwise cause an exception if a Pebble expression is involved.
-        List<Input<?>> inputs = Optional.ofNullable(flow).map(FlowInterface::getInputs).orElse(List.of());
-        for (Input<?> input : inputs) {
-            if (input.getDefaults() != null && !flattenInputs.containsKey(input.getId())) {
-                flattenInputs.put(input.getId(), null);
-            }
-        }
         return runContextFactory.of(flow, execution, vars -> vars.withInputs(flattenInputs));
     }
 
@@ -458,7 +444,7 @@ public class FlowInputOutput {
         if (data.getType() == null) {
             return Optional.of(new AbstractMap.SimpleEntry<>(data.getId(), current));
         }
-
+        
         final Type elementType = data instanceof ItemTypeInterface itemTypeInterface ? itemTypeInterface.getItemType() : null;
 
         return Optional.of(new AbstractMap.SimpleEntry<>(
@@ -500,7 +486,7 @@ public class FlowInputOutput {
                 case URI -> {
                     Matcher matcher = URI_PATTERN.matcher(current.toString());
                     if (matcher.matches()) {
-                        yield current.toString();
+                        yield current;
                     } else {
                         throw new IllegalArgumentException("Expected `URI` but received `" + current + "`");
                     }
@@ -535,17 +521,17 @@ public class FlowInputOutput {
             throw new Exception("Expected `" + type + "` but received `" + current + "` with errors:\n```\n" + e.getMessage() + "\n```");
         }
     }
-
+    
     public static Map<String, Object> renderFlowOutputs(List<Output> outputs, RunContext runContext) throws IllegalVariableEvaluationException {
         if (outputs == null) return Map.of();
-
+        
         // render required outputs
         Map<String, Object> outputsById = outputs
             .stream()
             .filter(output -> output.getRequired() == null || output.getRequired())
             .collect(HashMap::new, (map, entry) -> map.put(entry.getId(), entry.getValue()), Map::putAll);
         outputsById = runContext.render(outputsById);
-
+        
         // render optional outputs one by one to catch, log, and skip any error.
         for (io.kestra.core.models.flows.Output output : outputs) {
             if (Boolean.FALSE.equals(output.getRequired())) {
@@ -588,9 +574,9 @@ public class FlowInputOutput {
         }
 
         public void isDefault(boolean isDefault) {
-            this.input = new InputAndValue(this.input.input(), this.input.value(), this.input.enabled(), isDefault, this.input.exception());
+            this.input = new InputAndValue(this.input.input(), this.input.value(), this.input.enabled(), isDefault, this.input.exception());  
         }
-
+        
         public void setInput(final Input<?> input) {
             this.input = new InputAndValue(input, this.input.value(), this.input.enabled(), this.input.isDefault(), this.input.exception());
         }

core/src/main/java/io/kestra/core/runners/FlowableUtils.java

@@ -49,19 +49,6 @@ public class FlowableUtils {
         return FlowableUtils.innerResolveSequentialNexts(execution, currentTasks, parentTaskRun);
     }
 
-    public static List<NextTaskRun> resolveSequentialNexts(
-        Execution execution,
-        List<ResolvedTask> tasks,
-        List<ResolvedTask> errors,
-        List<ResolvedTask> _finally,
-        TaskRun parentTaskRun,
-        State.Type terminalState
-    ) {
-        List<ResolvedTask> currentTasks = execution.findTaskDependingFlowState(tasks, errors, _finally, parentTaskRun, terminalState);
-
-        return FlowableUtils.innerResolveSequentialNexts(execution, currentTasks, parentTaskRun);
-    }
-
     private static List<NextTaskRun> innerResolveSequentialNexts(
         Execution execution,
         List<ResolvedTask> currentTasks,
@@ -162,31 +149,7 @@ public class FlowableUtils {
         boolean allowFailure,
         boolean allowWarning
     ) {
-        return resolveState(
-            execution,
-            tasks,
-            errors,
-            _finally,
-            parentTaskRun,
-            runContext,
-            allowFailure,
-            allowWarning,
-            State.Type.SUCCESS
-        );
-    }
-
-    public static Optional<State.Type> resolveState(
-        Execution execution,
-        List<ResolvedTask> tasks,
-        List<ResolvedTask> errors,
-        List<ResolvedTask> _finally,
-        TaskRun parentTaskRun,
-        RunContext runContext,
-        boolean allowFailure,
-        boolean allowWarning,
-        State.Type terminalState
-    ) {
-        List<ResolvedTask> currentTasks = execution.findTaskDependingFlowState(tasks, errors, _finally, parentTaskRun, terminalState);
+        List<ResolvedTask> currentTasks = execution.findTaskDependingFlowState(tasks, errors, _finally, parentTaskRun);
 
         if (currentTasks == null) {
             runContext.logger().warn(
@@ -198,17 +161,17 @@ public class FlowableUtils {
 
             return Optional.of(allowFailure ? allowWarning ? State.Type.SUCCESS : State.Type.WARNING : State.Type.FAILED);
         } else if (currentTasks.stream().allMatch(t -> t.getTask().getDisabled()) && !currentTasks.isEmpty()) {
-            // if all child tasks are disabled, we end in the terminal state
-            return Optional.of(terminalState);
+            // if all child tasks are disabled, we end in SUCCESS
+            return Optional.of(State.Type.SUCCESS);
         } else if (!currentTasks.isEmpty()) {
-            // handle nominal case, tasks or errors flow are ready to be analyzed
+            // handle nominal case, tasks or errors flow are ready to be analysed
             if (execution.isTerminated(currentTasks, parentTaskRun)) {
-                return Optional.of(execution.guessFinalState(tasks, parentTaskRun, allowFailure, allowWarning, terminalState));
+                return Optional.of(execution.guessFinalState(tasks, parentTaskRun, allowFailure, allowWarning));
             }
         } else {
             // first call, the error flow is not ready, we need to notify the parent task that can be failed to init error flows
-            if (execution.hasFailed(tasks, parentTaskRun) || terminalState == State.Type.FAILED) {
-                return Optional.of(execution.guessFinalState(tasks, parentTaskRun, allowFailure, allowWarning, terminalState));
+            if (execution.hasFailed(tasks, parentTaskRun)) {
+                return Optional.of(execution.guessFinalState(tasks, parentTaskRun, allowFailure, allowWarning));
             }
         }
 
@@ -500,7 +463,7 @@ public class FlowableUtils {
 
         ArrayList<ResolvedTask> result = new ArrayList<>();
 
-        int iteration = 0;
+        int index = 0;
         for (Object current : distinctValue) {
             try {
                 String resolvedValue = current instanceof String stringValue ? stringValue : MAPPER.writeValueAsString(current);
@@ -508,7 +471,7 @@ public class FlowableUtils {
                     result.add(ResolvedTask.builder()
                         .task(task)
                         .value(resolvedValue)
-                        .iteration(iteration)
+                        .iteration(index++)
                         .parentId(parentTaskRun.getId())
                         .build()
                     );
@@ -516,7 +479,6 @@ public class FlowableUtils {
             } catch (JsonProcessingException e) {
                 throw new IllegalVariableEvaluationException(e);
             }
-            iteration++;
         }
 
         return result;

core/src/main/java/io/kestra/core/runners/Indexer.java

@@ -1,7 +1,4 @@
 package io.kestra.core.runners;
-
-import io.kestra.core.server.Service;
-
-public interface Indexer extends Service, Runnable {
-
+// NOTE: this class is not used anymore but must be kept as it is used in as queue consumer both in JDBC and Kafka
+public class Indexer {
 }

core/src/main/java/io/kestra/core/runners/IndexerInterface.java

@@ -2,5 +2,6 @@ package io.kestra.core.runners;
 
 import io.kestra.core.server.Service;
 
-public interface Scheduler extends Service, Runnable {
+public interface IndexerInterface extends Service, Runnable {
+
 }

core/src/main/java/io/kestra/core/runners/MultipleConditionEvent.java

@@ -1,13 +0,0 @@
-package io.kestra.core.runners;
-
-import io.kestra.core.models.HasUID;
-import io.kestra.core.models.executions.Execution;
-import io.kestra.core.models.flows.Flow;
-import io.kestra.core.utils.IdUtils;
-
-public record MultipleConditionEvent(Flow flow, Execution execution) implements HasUID {
-    @Override
-    public String uid() {
-        return IdUtils.fromParts(flow.uidWithoutRevision(), execution.getId());
-    }
-}

core/src/main/java/io/kestra/core/runners/RunContextLogger.java

@@ -20,18 +20,16 @@ import io.kestra.core.queues.QueueInterface;
 import jakarta.annotation.Nullable;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.io.IOUtils;
 import org.slf4j.LoggerFactory;
 
 import java.io.*;
-import java.nio.charset.StandardCharsets;
 import java.time.Instant;
 import java.util.*;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
 public class RunContextLogger implements Supplier<org.slf4j.Logger> {
-    private static final int MAX_MESSAGE_LENGTH = 1024 * 15;
+    private static final int MAX_MESSAGE_LENGTH = 1024 * 10;
     public static final String ORIGINAL_TIMESTAMP_KEY = "originalTimestamp";
 
     private final String loggerName;
@@ -82,6 +80,7 @@ public class RunContextLogger implements Supplier<org.slf4j.Logger> {
         }
 
         List<LogEntry> result = new ArrayList<>();
+        long i = 0;
         for (String s : split) {
             result.add(LogEntry.builder()
                 .namespace(logEntry.getNamespace())
@@ -99,6 +98,7 @@ public class RunContextLogger implements Supplier<org.slf4j.Logger> {
                 .thread(event.getThreadName())
                 .build()
             );
+            i++;
         }
 
         return result;
@@ -144,9 +144,8 @@ public class RunContextLogger implements Supplier<org.slf4j.Logger> {
     }
 
     public void usedSecret(String secret) {
-        if (secret != null && !secret.isEmpty()) {
+        if (secret != null) {
             this.useSecrets.add(secret);
-            this.useSecrets.add(Base64.getEncoder().encodeToString(secret.getBytes(StandardCharsets.UTF_8)));
         }
     }
 
@@ -332,11 +331,14 @@ public class RunContextLogger implements Supplier<org.slf4j.Logger> {
         protected void append(ILoggingEvent e) {
             e = this.transform(e);
 
-            try {
-                logQueue.emitAsync(logEntries(e, logEntry));
-            } catch (QueueException ex) {
-                log.warn("Unable to emit logQueue", ex);
-            }
+            logEntries(e, logEntry)
+                .forEach(l -> {
+                    try {
+                        logQueue.emitAsync(l);
+                    } catch (QueueException ex) {
+                        log.warn("Unable to emit logQueue", ex);
+                    }
+                });
         }
     }
 

core/src/main/java/io/kestra/core/runners/RunVariables.java

@@ -10,7 +10,6 @@ import io.kestra.core.models.flows.FlowInterface;
 import io.kestra.core.models.flows.Input;
 import io.kestra.core.models.flows.State;
 import io.kestra.core.models.flows.input.SecretInput;
-import io.kestra.core.models.property.Property;
 import io.kestra.core.models.property.PropertyContext;
 import io.kestra.core.models.tasks.Task;
 import io.kestra.core.models.triggers.AbstractTrigger;
@@ -283,15 +282,15 @@ public final class RunVariables {
 
                 if (flow != null && flow.getInputs() != null) {
                     // we add default inputs value from the flow if not already set, this will be useful for triggers
-                    flow.getInputs().stream()
-                        .filter(input -> input.getDefaults() != null && !inputs.containsKey(input.getId()))
-                        .forEach(input -> {
-                            try {
-                                inputs.put(input.getId(), FlowInputOutput.resolveDefaultValue(input, propertyContext));
-                            } catch (IllegalVariableEvaluationException e) {
-                                // Silent catch, if an input depends on another input, or a variable that is populated at runtime / input filling time, we can't resolve it here.
-                            }
-                        });
+                        flow.getInputs().stream()
+                            .filter(input -> input.getDefaults() != null && !inputs.containsKey(input.getId()))
+                            .forEach(input -> {
+                                try {
+                                    inputs.put(input.getId(), FlowInputOutput.resolveDefaultValue(input, propertyContext));
+                                } catch (IllegalVariableEvaluationException e) {
+                                    throw new RuntimeException("Unable to inject default value for input '" + input.getId() + "'", e);
+                                }
+                            });
                 }
 
                 if (!inputs.isEmpty()) {

core/src/main/java/io/kestra/core/runners/RunnerInterface.java

@@ -0,0 +1,5 @@
+package io.kestra.core.runners;
+
+public interface RunnerInterface {
+    void run();
+}

core/src/main/java/io/kestra/core/runners/Secret.java

@@ -45,7 +45,7 @@ final class Secret {
         for (var entry: data.entrySet()) {
             if (entry.getValue() instanceof Map map) {
                 // if some value are of type EncryptedString we decode them and replace the object
-                if (map.get("type") instanceof String typeStr && EncryptedString.TYPE.equalsIgnoreCase(typeStr)) {
+                if (EncryptedString.TYPE.equalsIgnoreCase((String)map.get("type"))) {
                     try {
                         String decoded = decrypt((String) map.get("value"));
                         decryptedMap.put(entry.getKey(), decoded);