@kalisio/kdk 2.5.2 → 2.6.0

package/scripts/kash/kash.sh

@@ -18,7 +18,20 @@
 . /etc/os-release
 
 OS_ID=$ID
-OS_VERSION=$VERSION_ID
+OS_VERSION=${VERSION_ID:-}
+
+# VERSION_ID is an optional field, do what we can to deduce when missing
+if [[ "$OS_VERSION" = "" ]]; then
+    case "$OS_ID" in
+        debian)
+            OS_VERSION=$(cat /etc/debian_version)
+            OS_VERSION=${OS_VERSION%%.*}
+            ;;
+        *)
+            OS_VERSION=unknown
+            ;;
+    esac
+fi
 
 echo "Running on ${OS_ID}-${OS_VERSION}"
 
@@ -43,11 +56,11 @@ fi
 
 if [ -n "$CI_ID" ]; then
     CI=true
-    echo "Running in CI mode ($CI_ID)..."
+    echo "Running in CI mode ($CI_ID) ..."
 
     # Make sure we have the requirements to run kash functions
     set +e
-    command -v curl >/dev/null 2>&1 && command -v git >/dev/null 2>&1 && command -v sha256sum >/dev/null 2>&1
+    command -v curl >/dev/null 2>&1 && command -v git >/dev/null 2>&1 && command -v sha256sum >/dev/null 2>&1 && command -v unzip >/dev/null 2>&1
     RC=$?
     set -e
 
@@ -55,13 +68,13 @@ if [ -n "$CI_ID" ]; then
         case "$OS_ID" in
             debian | ubuntu)
                 if [ "$(id -u)" -eq 0 ]; then
-                    apt-get update && apt-get --no-install-recommends --yes install sudo curl ca-certificates coreutils git
+                    apt-get update && apt-get --no-install-recommends --yes install sudo curl ca-certificates coreutils git unzip
                 else
-                    sudo apt-get update && sudo apt-get --no-install-recommends --yes install curl ca-certificates coreutils git
+                    sudo apt-get update && sudo apt-get --no-install-recommends --yes install curl ca-certificates coreutils git unzip
                 fi
                 ;;
             alpine)
-                apk update && apk add curl ca-certificates coreutils git
+                apk update && apk add curl ca-certificates coreutils git unzip
                 ;;
             *)
                 ;;
@@ -92,6 +105,12 @@ if [ -d "$HOME/.nvm" ]; then
     . "$HOME/.nvm/nvm.sh"
 fi
 
+# If sonar-scanner-cli is present, add it to PATH
+# See install_sonar_scanner_cli
+if [ -d "$HOME/.local/sonar-scanner" ]; then
+    export PATH=$PATH:$HOME/.local/sonar-scanner/bin
+fi
+
 # Define a TMP_DIR to operate with temp files
 if [ -n "${RUNNER_TEMP:-}" ]; then # RUNNER_TEMP is Github Action specific
     TMP_DIR="$RUNNER_TEMP"
@@ -110,27 +129,24 @@ AGE_VERSION=1.1.1
 SOPS_VERSION=3.8.1
 
 # https://github.com/kubernetes/kubernetes/tree/master/CHANGELOG
-KUBECTL_VERSION=1.25.16
+KUBECTL_VERSION=1.28.13
 # https://github.com/helm/helm/releases
-HELM_VERSION=3.11.3
+HELM_VERSION=3.14.4
 # https://github.com/helmfile/helmfile/releases
-HELMFILE_VERSION=0.153.0
-# https://github.com/derailed/k9s/releases
-K9S_VERSION=0.32.4
+HELMFILE_VERSION=0.167.1
 
 # https://github.com/nvm-sh/nvm/releases
-NVM_VERSION=0.39.7
+NVM_VERSION=0.40.3
 # https://nodejs.org/en/about/previous-releases#looking-for-latest-release-of-a-version-branch
-NODE16_VERSION=16.20.2
-NODE18_VERSION=18.19.1
-NODE20_VERSION=20.11.1
-NODE22_VERSION=22.3.0
+NODE20_VERSION=20.19
+NODE22_VERSION=22.16
 
 # https://www.mongodb.com/try/download/community
-MONGODB4_VERSION=4.4.28
-MONGODB5_VERSION=5.0.24
-MONGODB6_VERSION=6.0.13
-MONGODB7_VERSION=7.0.5
+MONGODB7_VERSION=7.0.21
+MONGODB8_VERSION=8.0.10
+
+# https://docs.sonarsource.com/sonarqube-server/latest/analyzing-source-code/scanners/sonarscanner/
+SONAR_SCANNER_CLI_VERSION=6.2.1.4610
 
 # Install yq in ~/.local/bin
 # Arg1: a writable folder where to write downloaded files
@@ -250,9 +266,11 @@ install_cc_test_reporter() {
 
 # Sends test coverage to code climate
 # Arg1: code climate identifier for authentication
+# Arg2: prefix to use when using format-coverage (can be empty)
 send_coverage_to_cc() {
     local CC_TEST_REPORTER_ID=$1
-    ~/.local/bin/cc-test-reporter format-coverage -t lcov coverage/lcov.info
+    local CC_PREFIX=${2:-}
+    ~/.local/bin/cc-test-reporter format-coverage -t lcov --add-prefix "$CC_PREFIX" coverage/lcov.info
     ~/.local/bin/cc-test-reporter upload-coverage -r "$CC_TEST_REPORTER_ID"
 }
 
@@ -301,121 +319,71 @@ install_node22() {
     bash -i -c "nvm install $NODE22_VERSION"
 }
 
-# Install mongo4 in ~/.local/bin/mongo4
-# Arg1: a writable folder where to write downloaded files
-# NOTE: each mongo version is installed in a separate folder to support multiple versions
-install_mongo4() {
-    local DL_ROOT=$1
-    local DL_PATH="$DL_ROOT/mongo4"
-    mkdir -p "$DL_PATH" && cd "$DL_PATH"
-    case "$OS_ID" in
-        debian)
-            curl -OLsS http://ftp.us.debian.org/debian/pool/main/o/openssl/libssl1.1_1.1.1w-0+deb11u1_amd64.deb
-            DEBIAN_FRONTEND=noninteractive && dpkg -i libssl1.1_1.1.1w-0+deb11u1_amd64.deb
-            local MONGODB_SUFFIX=debian10-${MONGODB4_VERSION}
-            ;;
-        ubuntu)
-            # NOTE: this assumes ubuntu 22.04
-            curl -OLss http://launchpadlibrarian.net/715615335/libssl1.1_1.1.1f-1ubuntu2.22_amd64.deb
-            DEBIAN_FRONTEND=noninteractive && sudo dpkg -i libssl1.1_1.1.1f-1ubuntu2.22_amd64.deb
-            local MONGODB_SUFFIX=ubuntu2004-${MONGODB4_VERSION}
-            ;;
-        *)
-    esac
-
-    curl -OLsS "https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-${MONGODB_SUFFIX}.tgz"
-    tar xf "mongodb-linux-x86_64-${MONGODB_SUFFIX}.tgz"
-    mkdir -p ~/.local/bin/mongo4
-    cp -fR "mongodb-linux-x86_64-${MONGODB_SUFFIX}/bin/mongod" ~/.local/bin/mongo4
-    sudo mkdir -p /var/lib/mongo4 && sudo mkdir -p /var/log/mongodb4
-    sudo chmod a+rwx /var/lib/mongo4 && sudo chmod a+rwx /var/log/mongodb4
-    cd ~-
-}
-
-# Install mongo5 in ~/.local/bin/mongo5
+# Install mongo7 in ~/.local/bin/mongo7
 # Arg1: a writable folder where to write downloaded files
 # NOTE: each mongo version is installed in a separate folder to support multiple versions
-install_mongo5() {
+install_mongo7() {
     local DL_ROOT=$1
-    local DL_PATH="$DL_ROOT/mongo5"
+    local DL_PATH="$DL_ROOT/mongo7"
     mkdir -p "$DL_PATH" && cd "$DL_PATH"
     case "$OS_ID" in
         debian)
-            curl -OLsS http://ftp.us.debian.org/debian/pool/main/o/openssl/libssl1.1_1.1.1w-0+deb11u1_amd64.deb
-            DEBIAN_FRONTEND=noninteractive && dpkg -i libssl1.1_1.1.1w-0+deb11u1_amd64.deb
-            local MONGODB_SUFFIX=debian11-${MONGODB5_VERSION}
+            local MONGODB_SUFFIX=debian12-${MONGODB7_VERSION}
             ;;
         ubuntu)
-            # NOTE: this assumes ubuntu 22.04
-            curl -OLss http://launchpadlibrarian.net/715615335/libssl1.1_1.1.1f-1ubuntu2.22_amd64.deb
-            DEBIAN_FRONTEND=noninteractive && sudo dpkg -i libssl1.1_1.1.1f-1ubuntu2.22_amd64.deb
-            local MONGODB_SUFFIX=ubuntu2004-${MONGODB5_VERSION}
+            local MONGODB_SUFFIX=ubuntu2204-${MONGODB7_VERSION}
             ;;
         *)
     esac
 
     curl -OLsS "https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-${MONGODB_SUFFIX}.tgz"
     tar xf "mongodb-linux-x86_64-${MONGODB_SUFFIX}.tgz"
-    mkdir -p ~/.local/bin/mongo5
-    cp -fR "mongodb-linux-x86_64-${MONGODB_SUFFIX}/bin/mongod" ~/.local/bin/mongo5
-    sudo mkdir -p /var/lib/mongo5 && sudo mkdir -p /var/log/mongodb5
-    sudo chmod a+rwx /var/lib/mongo5 && sudo chmod a+rwx /var/log/mongodb5
+    mkdir -p ~/.local/bin/mongo7
+    cp -fR "mongodb-linux-x86_64-${MONGODB_SUFFIX}/bin/mongod" ~/.local/bin/mongo7
+    sudo mkdir -p /var/lib/mongo7 && sudo mkdir -p /var/log/mongodb7
+    sudo chmod a+rwx /var/lib/mongo7 && sudo chmod a+rwx /var/log/mongodb7
     cd ~-
 }
 
-# Install mongo6 in ~/.local/bin/mongo6
+# Install mongo8 in ~/.local/bin/mongo8
 # Arg1: a writable folder where to write downloaded files
 # NOTE: each mongo version is installed in a separate folder to support multiple versions
-install_mongo6() {
+install_mongo8() {
     local DL_ROOT=$1
-    local DL_PATH="$DL_ROOT/mongo6"
+    local DL_PATH="$DL_ROOT/mongo8"
     mkdir -p "$DL_PATH" && cd "$DL_PATH"
     case "$OS_ID" in
         debian)
-            curl -OLsS http://ftp.us.debian.org/debian/pool/main/o/openssl/libssl1.1_1.1.1w-0+deb11u1_amd64.deb
-            DEBIAN_FRONTEND=noninteractive && dpkg -i libssl1.1_1.1.1w-0+deb11u1_amd64.deb
-            local MONGODB_SUFFIX=debian11-${MONGODB6_VERSION}
+            local MONGODB_SUFFIX=debian12-${MONGODB8_VERSION}
             ;;
         ubuntu)
-            local MONGODB_SUFFIX=ubuntu2204-${MONGODB6_VERSION}
+            local MONGODB_SUFFIX=ubuntu2204-${MONGODB8_VERSION}
             ;;
         *)
     esac
 
     curl -OLsS "https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-${MONGODB_SUFFIX}.tgz"
     tar xf "mongodb-linux-x86_64-${MONGODB_SUFFIX}.tgz"
-    mkdir -p ~/.local/bin/mongo6
-    cp -fR "mongodb-linux-x86_64-${MONGODB_SUFFIX}/bin/mongod" ~/.local/bin/mongo6
-    sudo mkdir -p /var/lib/mongo6 && sudo mkdir -p /var/log/mongodb6
-    sudo chmod a+rwx /var/lib/mongo6 && sudo chmod a+rwx /var/log/mongodb6
+    mkdir -p ~/.local/bin/mongo8
+    cp -fR "mongodb-linux-x86_64-${MONGODB_SUFFIX}/bin/mongod" ~/.local/bin/mongo8
+    sudo mkdir -p /var/lib/mongo8 && sudo mkdir -p /var/log/mongodb8
+    sudo chmod a+rwx /var/lib/mongo8 && sudo chmod a+rwx /var/log/mongodb8
     cd ~-
 }
 
-# Install mongo7 in ~/.local/bin/mongo7
+# Install sonar-scanner in ~/.local/sonar-scanner-cli
 # Arg1: a writable folder where to write downloaded files
-# NOTE: each mongo version is installed in a separate folder to support multiple versions
-install_mongo7() {
+install_sonar_scanner_cli() {
     local DL_ROOT=$1
-    local DL_PATH="$DL_ROOT/mongo7"
-    mkdir -p "$DL_PATH" && cd "$DL_PATH"
-    case "$OS_ID" in
-        debian)
-            curl -OLsS http://ftp.us.debian.org/debian/pool/main/o/openssl/libssl1.1_1.1.1w-0+deb11u1_amd64.deb
-            DEBIAN_FRONTEND=noninteractive && dpkg -i libssl1.1_1.1.1w-0+deb11u1_amd64.deb
-            local MONGODB_SUFFIX=debian11-${MONGODB7_VERSION}
-            ;;
-        ubuntu)
-            local MONGODB_SUFFIX=ubuntu2204-${MONGODB7_VERSION}
-            ;;
-        *)
-    esac
-
-    curl -OLsS "https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-${MONGODB_SUFFIX}.tgz"
-    tar xf "mongodb-linux-x86_64-${MONGODB_SUFFIX}.tgz"
-    mkdir -p ~/.local/bin/mongo7
-    cp -fR "mongodb-linux-x86_64-${MONGODB_SUFFIX}/bin/mongod" ~/.local/bin/mongo7
-    sudo mkdir -p /var/lib/mongo7 && sudo mkdir -p /var/log/mongodb7
-    sudo chmod a+rwx /var/lib/mongo7 && sudo chmod a+rwx /var/log/mongodb7
+    local DL_PATH="$DL_ROOT/sonarscannercli"
+    if [ ! -d "$DL_PATH" ]; then
+        mkdir -p "$DL_PATH" && cd "$DL_PATH"
+        curl -OLsS https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-${SONAR_SCANNER_CLI_VERSION}-linux-x64.zip
+        unzip sonar-scanner-cli-${SONAR_SCANNER_CLI_VERSION}-linux-x64.zip
+        cd ~-
+    fi
+    cd "$DL_PATH"
+    mv sonar-scanner-${SONAR_SCANNER_CLI_VERSION}-linux-x64 ~/.local/sonar-scanner
     cd ~-
 }
 
@@ -476,25 +444,6 @@ install_helmfile() {
     cd ~-
 }
 
-# Install k9s in ~/.local/bin
-# Expected args:
-#  1. a writable folder where to write downloaded files
-install_k9s() {
-    local DL_ROOT=$1
-    local DL_PATH="$DL_ROOT/k9s"
-    if [ ! -d "$DL_PATH" ]; then
-        mkdir -p "$DL_PATH" && cd "$DL_PATH"
-        curl -OLsS https://github.com/derailed/k9s/releases/download/v${K9S_VERSION}/k9s_Linux_amd64.tar.gz
-        curl -OLsS https://github.com/derailed/k9s/releases/download/v${K9S_VERSION}/checksums.sha256
-        sha256sum --ignore-missing --quiet -c checksums.sha256
-        cd ~-
-    fi
-    cd "$DL_PATH"
-    tar xf k9s_Linux_amd64.tar.gz
-    cp k9s ~/.local/bin
-    cd ~-
-}
-
 # Install listed requirements
 # Usage: install_reqs mongo7 nvm node16 yq
 install_reqs() {
@@ -545,6 +494,61 @@ get_json_value() {
     yq --output-format=yaml ".$JSON_FIELD" "$JSON_SRC"
 }
 
+# Extract version major from a version string.
+# Expected args:
+# 1. the version string
+get_semver_major() {
+    local VERSION="$1"
+    local VERSION_REGEX="^([0-9]+)(\.[0-9]+)?(\.[0-9]+)?$"
+    if [[ "$VERSION" =~ $VERSION_REGEX ]]; then
+        printf "%s" "${BASH_REMATCH[1]}"
+    fi
+}
+
+# Extract version minor from a version string.
+# Expected args:
+# 1. the version string
+get_semver_minor() {
+    local VERSION="$1"
+    local VERSION_REGEX="^[0-9]+\.([0-9]+)(\.[0-9]+)?$"
+    if [[ "$VERSION" =~ $VERSION_REGEX ]]; then
+        printf "%s" "${BASH_REMATCH[1]}"
+    fi
+}
+
+# Extract version minor from a version string.
+# Expected args:
+# 1. the version string
+get_semver_patch() {
+    local VERSION="$1"
+    local VERSION_REGEX="^[0-9]+\.[0-9]+\.([0-9]+)$"
+    if [[ "$VERSION" =~ $VERSION_REGEX ]]; then
+        printf "%s" "${BASH_REMATCH[1]}"
+    fi
+}
+
+# Generates the markdown anchor corresponding to the given title taking
+# markdown flavors into account.
+# Expected args:
+# 1. the section title
+# 2. the markdown flavor (github, gitlab, ...)
+normalize_markdown_anchor() {
+    local SECTION_TITLE="$1"
+    local MARKDOWN_FLAVOR="$2"
+
+    case "$MARKDOWN_FLAVOR" in
+        github)
+            echo "$SECTION_TITLE" | tr '/' '-'
+            ;;
+        gitlab)
+            echo "$SECTION_TITLE" | tr -d '/'
+            ;;
+        *)
+            echo "$SECTION_TITLE"
+            ;;
+    esac
+}
+
 ### Git
 ###
 
@@ -753,7 +757,7 @@ begin_group() {
             echo "travis_fold:start:$TITLE"
         fi
     else
-        echo "%< --- $TITLE ------"
+        echo -e "${KASH_TXT_BOLD}%< --- $TITLE ------${KASH_TXT_RESET}"
     fi
 }
 
@@ -773,7 +777,7 @@ end_group() {
             echo "travis_fold:end:$TITLE"
         fi
     else
-        echo "------ $TITLE --- >%"
+        echo -e "${KASH_TXT_BOLD}------ $TITLE --- >%${KASH_TXT_RESET}"
     fi
 }
 
@@ -957,28 +961,82 @@ load_value_files() {
 ### Kalisio
 ###
 
+# Returns the kalisio flavor based on the git ref (tag or branch name).
+# Known flavors are 'dev', 'test' and 'prod'.
+# Expected args:
+# 1. the git ref name
+get_flavor_from_git_ref() {
+    local GIT_REF=$1
+
+    case "$GIT_REF" in
+        # Will match anything beginning with 'prod-'
+        prod-*)
+            printf "prod"
+            ;;
+        # Will match single 'test' or anything beginning with 'test-'
+        test | test-*)
+            printf "test"
+            ;;
+        # Anything else is 'dev' flavor
+        *)
+            printf "dev"
+            ;;
+    esac
+}
+
+# Returns the kalisio version based on the git ref (tag or branch name).
+# Version may be MAJOR.MINOR (eg. with 'test' flavors) or MAJOR.MINOR.PATCH (eg. with 'prod' flavors)
+# Expected args:
+# 1. the git ref name
+get_version_from_git_ref() {
+    local GIT_REF=$1
+
+    local VERSION_REGEX="-v([0-9]+\.[0-9]+(\.[0-9]+)?)"
+    if [[ "$GIT_REF" =~ $VERSION_REGEX ]]; then
+        printf "%s" "${BASH_REMATCH[1]}"
+    fi
+}
+
+# Returns the kalisio custom field based on the git ref (tag or branch name).
+# Expected args:
+# 1. the git ref name
+get_custom_from_git_ref() {
+    local GIT_REF=$1
+
+    local CUSTOM_REGEX="(^|-)([a-zA-Z0-9]+)$"
+    if [[ "$GIT_REF" =~ $CUSTOM_REGEX ]]; then
+        if [[ "${BASH_REMATCH[1]}" == "" ]]; then
+            # If first capture group is empty => that's probably a 'dev' flavor.
+            # The branch name = the custom field (except for master and main)
+            #
+            case "${BASH_REMATCH[2]}" in
+                # Also exclude 'test' as it's a valid branch name for test flavor
+                master | main | test)
+                    ;;
+                *)
+                    printf "%s" "${BASH_REMATCH[2]}"
+                    ;;
+            esac
+        else
+            # Otherwise, that's probably a test or prod flavor,
+            printf "%s" "${BASH_REMATCH[2]}"
+        fi
+    fi
+}
+
 # Returns the kalisio flavor (prod, test, dev) according to current branch/tag name
 # Expected args:
 # 1. the repository root folder
 get_flavor_from_git() {
     local REPO_DIR=$1
-    # Matches 'test' but also 'test-v1.2'
-    local TEST_FLAVOR_REGEX="^test(-v[0-9]+\.[0-9]+)?$"
-    # Only matches 'prod-v1.2.3'
-    local PROD_FLAVOR_REGEX="^prod-v[0-9]+\.[0-9]+\.[0-9]+$"
 
     local GIT_TAG
     GIT_TAG=$(get_git_tag "$REPO_DIR")
     local GIT_BRANCH
     GIT_BRANCH=$(get_git_branch "$REPO_DIR")
+    local GIT_REF="${GIT_TAG:-$GIT_BRANCH}"
 
-    if [[ "$GIT_TAG" =~ $PROD_FLAVOR_REGEX ]]; then
-        printf "prod"
-    elif [[ "$GIT_BRANCH" =~ $TEST_FLAVOR_REGEX ]]; then
-        printf "test"
-    else
-        printf "dev"
-    fi
+    get_flavor_from_git_ref "$GIT_REF"
 }
 
 # Returns the git ref that produced the given container tag.
@@ -1033,10 +1091,10 @@ run_kli() {
     fi
 
     cd "$WORK_DIR"
-    nvm exec "$NODE_VERSION" node "$WORK_DIR/kli/index.js" "$KLI_FILE" --clone --shallow-clone
+    nvm exec "$NODE_VERSION" node "$WORK_DIR/kli/index.js" "$KLI_FILE" --clone --shallow-clone --fail-on-error
     if [ "$KLI_RUN" = klifull ]; then
-        nvm exec "$NODE_VERSION" node "$WORK_DIR/kli/index.js" "$KLI_FILE" --install
-        nvm exec "$NODE_VERSION" node "$WORK_DIR/kli/index.js" "$KLI_FILE" --link --link-folder "$WORK_DIR/yarn-links"
+        nvm exec "$NODE_VERSION" node "$WORK_DIR/kli/index.js" "$KLI_FILE" --install --fail-on-error
+        nvm exec "$NODE_VERSION" node "$WORK_DIR/kli/index.js" "$KLI_FILE" --link --link-folder "$WORK_DIR/yarn-links" --fail-on-error
     fi
     cd ~-
 }
@@ -1086,6 +1144,11 @@ setup_app_workspace() {
     local DEVELOPMENT_DIR="$WORKSPACE_DIR/development"
     git_shallow_clone "$DEVELOPMENT_REPO_URL" "$DEVELOPMENT_DIR"
 
+    # NOTE: we don't reuse init_app_infos here since init_app_infos
+    # fetch app version from package.json (it requires a cloned repo)
+    # Here we might be setting up workspace for a specific
+    # branch / tag that's not currently checked out.
+
     # fetch app name and ref (tag or branch) required
     local APP_NAME
     APP_NAME=$(yq --output-format=yaml '.name' "$REPO_DIR/package.json")
@@ -1101,26 +1164,20 @@ setup_app_workspace() {
         GIT_REF="$7"
     fi
 
-    if [ -z "$KLI_BASE" ]; then
-        KLI_BASE="$DEVELOPMENT_DIR/$APP_NAME"
-    else
-        KLI_BASE="$DEVELOPMENT_DIR/$KLI_BASE/$APP_NAME"
-    fi
+    local APP_FLAVOR
+    APP_FLAVOR=$(get_flavor_from_git_ref "$GIT_REF")
+    local APP_VERSION
+    APP_VERSION=$(get_version_from_git_ref "$GIT_REF")
+    local APP_CUSTOM
+    APP_CUSTOM=$(get_custom_from_git_ref "$GIT_REF")
 
     # determine associated kli file
-    local KLI_FILE
-    local PROD_REGEX="^prod-v([0-9]+\.[0-9]+\.[0-9]+)$"
-    local TEST_REGEX="^test-v([0-9]+\.[0-9]+)$"
-    if [[ "$GIT_REF" =~ $PROD_REGEX ]]; then
-        KLI_FILE="$KLI_BASE/prod/$APP_NAME-${BASH_REMATCH[1]}.js"
-    elif [[ "$GIT_REF" =~ $TEST_REGEX ]]; then
-        KLI_FILE="$KLI_BASE/test/$APP_NAME-${BASH_REMATCH[1]}.js"
-    else
-        KLI_FILE="$KLI_BASE/dev/$APP_NAME-$GIT_REF.js"
-        if [ ! -f "$KLI_FILE" ]; then
-            KLI_FILE="$KLI_BASE/dev/$APP_NAME.js"
-        fi
-    fi
+    local KLI_FILE="$DEVELOPMENT_DIR"
+    [[ "$KLI_BASE" != "" ]] && KLI_FILE="$KLI_FILE/$KLI_BASE"
+    KLI_FILE="$KLI_FILE/$APP_NAME/$APP_FLAVOR/$APP_NAME"
+    [[ "$APP_VERSION" != "" ]] && KLI_FILE="$KLI_FILE-$APP_VERSION"
+    [[ "$APP_CUSTOM" != "" ]] && KLI_FILE="$KLI_FILE-$APP_CUSTOM"
+    KLI_FILE="$KLI_FILE.js"
 
     # run kli !
     if [ "$KLI_RUN" = kli ] || [ "$KLI_RUN" = klifull ]; then
@@ -1148,35 +1205,37 @@ init_app_infos() {
     APP_NAME=$(yq --output-format=yaml '.name' "$REPO_ROOT/package.json")
     local APP_VERSION
     APP_VERSION=$(yq --output-format=yaml '.version' "$REPO_ROOT/package.json")
-
-    KLI_BASE="$KLI_BASE/$APP_NAME"
+    local APP_VERSION_MAJOR
+    local APP_VERSION_MINOR
+    APP_VERSION_MAJOR=$(get_semver_major "$APP_VERSION")
+    APP_VERSION_MINOR=$(get_semver_minor "$APP_VERSION")
 
     local GIT_TAG
     GIT_TAG=$(get_git_tag "$REPO_ROOT")
     local GIT_BRANCH
     GIT_BRANCH=$(get_git_branch "$REPO_ROOT")
-
     local GIT_REF="${GIT_TAG:-$GIT_BRANCH}"
 
     local APP_FLAVOR
-    local KLI_FILE
-    local PROD_REGEX="^prod-v([0-9]+\.[0-9]+\.[0-9]+)$"
-    local TEST_REGEX="^test-v([0-9]+\.[0-9]+)$"
-    if [[ "$GIT_REF" =~ $PROD_REGEX ]]; then
-        APP_FLAVOR="prod"
-        KLI_FILE="$KLI_BASE/$APP_FLAVOR/$APP_NAME-${BASH_REMATCH[1]}.js"
-    elif [[ "$GIT_REF" =~ $TEST_REGEX ]]; then
-        APP_FLAVOR="test"
-        KLI_FILE="$KLI_BASE/$APP_FLAVOR/$APP_NAME-${BASH_REMATCH[1]}.js"
-    else
-        APP_FLAVOR="dev"
-        KLI_FILE="$KLI_BASE/$APP_FLAVOR/$APP_NAME-$GIT_REF.js"
-        if [ ! -f "$KLI_FILE" ]; then
-            KLI_FILE="$KLI_BASE/$APP_FLAVOR/$APP_NAME.js"
-        fi
-    fi
+    APP_FLAVOR=$(get_flavor_from_git_ref "$GIT_REF")
+    local APP_CUSTOM
+    APP_CUSTOM=$(get_custom_from_git_ref "$GIT_REF")
+
+    local KLI_FILE="$KLI_BASE/$APP_NAME/$APP_FLAVOR/$APP_NAME"
+    case "$APP_FLAVOR" in
+        prod)
+            KLI_FILE="$KLI_FILE-$APP_VERSION"
+            ;;
+        test)
+            KLI_FILE="$KLI_FILE-$APP_VERSION_MAJOR.$APP_VERSION_MINOR"
+            ;;
+        *)
+            ;;
+    esac
+    [[ "$APP_CUSTOM" != "" ]] && KLI_FILE="$KLI_FILE-$APP_CUSTOM"
+    KLI_FILE="$KLI_FILE.js"
 
-    APP_INFOS=("$APP_NAME" "$APP_VERSION" "$APP_FLAVOR" "$GIT_TAG" "$GIT_BRANCH" "$KLI_FILE")
+    APP_INFOS=("$APP_NAME" "$APP_VERSION" "$APP_FLAVOR" "$APP_CUSTOM" "$GIT_TAG" "$GIT_BRANCH" "$KLI_FILE")
 }
 
 # Extract app name from app infos
@@ -1197,22 +1256,28 @@ get_app_flavor() {
     echo "${APP_INFOS[2]}"
 }
 
+# Extract app flavor from app infos
+# NOTE: requires a call to init_app_infos first
+get_app_custom() {
+    echo "${APP_INFOS[3]}"
+}
+
 # Extract app tag from app infos
 # NOTE: requires a call to init_app_infos first
 get_app_tag() {
-    echo "${APP_INFOS[3]}"
+    echo "${APP_INFOS[4]}"
 }
 
 # Extract app branch from app infos
 # NOTE: requires a call to init_app_infos first
 get_app_branch() {
-    echo "${APP_INFOS[4]}"
+    echo "${APP_INFOS[5]}"
 }
 
 # Extract app kli file from app infos
 # NOTE: requires a call to init_app_infos first
 get_app_kli_file() {
-    echo "${APP_INFOS[5]}"
+    echo "${APP_INFOS[6]}"
 }
 
 # Run backend tests for the given app.
@@ -1257,15 +1322,19 @@ run_app_tests() {
     ## Run tests
     ##
 
+    pushd "$REPO_DIR/api"
+
     use_node "$NODE_VER"
-    yarn test:server
+    yarn test
 
     ## Publish code coverage
     ##
 
     if [ "$CODE_COVERAGE" = true ]; then
-        send_coverage_to_cc "$CC_TEST_REPORTER_ID"
+        send_coverage_to_cc "$CC_TEST_REPORTER_ID" "api"
     fi
+
+    popd
 }
 
 # Setup the workspace for a lib project.
@@ -1527,9 +1596,6 @@ build_docs () {
 
     begin_group "Building docs for $REPOSITORY ..."
 
-    # Build process requires node 18
-    use_node 18
-
     rm -f .postcssrc.js && cd docs && yarn install && yarn build
 
     if [ "$PUBLISH" = true ]; then
@@ -1553,107 +1619,360 @@ build_docs () {
     end_group "Building docs for $REPOSITORY ..."
 }
 
-# Build e2e tests
+### e2e tests
+###
+
+# Build the e2e tests container
 # Expected arguments
-# 1. Root directory
-# 2: true to publish result on harbor
+# 1. the app root directory
+# 2. the subdomain where the app is deployed
+# 3: true to publish built container on a registry
+# 4. the registry url, eg. "docker.io"
+# 5. the username to login the registry
+# 6. a file where the password is stored in cleartext
+# 7. the name to give to the built container image
+# 8. the tag to give to the built container image
 build_e2e_tests () {
     local ROOT_DIR="$1"
-    local PUBLISH="$2"
-
-    ## Init workspace
-    ##
+    local SUBDOMAIN="$2"
+    local PUBLISH="$3"
+    local REGISTRY_URL="$4"
+    local REGISTRY_USERNAME="$5"
+    local REGISTRY_PASSWORD_FILE="$6"
+    local IMAGE_NAME="$7"
+    local IMAGE_TAG="$8"
 
     local WORKSPACE_DIR
     WORKSPACE_DIR="$(dirname "$ROOT_DIR")"
-    init_app_infos "$ROOT_DIR" "$WORKSPACE_DIR/development/workspaces/apps"
+    # NOTE: KLI_BASE parameter is irrelevant, we don't use kli so just leave it empty
+    init_app_infos "$ROOT_DIR" ""
 
     local APP
     APP=$(get_app_name)
-    local VERSION
-    VERSION=$(get_app_version)
+    # local VERSION
+    # VERSION=$(get_app_version)
     local FLAVOR
     FLAVOR=$(get_app_flavor)
 
-    echo "About to build ${APP} v${VERSION}-$FLAVOR ..."
-
-    load_env_files "$WORKSPACE_DIR/development/common/kalisio_harbor.enc.env"
-    load_value_files "$WORKSPACE_DIR/development/common/KALISIO_HARBOR_PASSWORD.enc.value"
-
-    ## Build container
-    ##
-
-    local IMAGE_NAME="$KALISIO_HARBOR_URL/kalisio/$APP-e2e-tests"
-    local IMAGE_TAG="$VERSION-$FLAVOR"
-
-    begin_group "Building container ..."
+    begin_group "Building $REGISTRY_URL/$IMAGE_NAME:$IMAGE_TAG ..."
 
-    docker login --username "$KALISIO_HARBOR_USERNAME" --password-stdin "$KALISIO_HARBOR_URL" < "$KALISIO_HARBOR_PASSWORD"
+    docker login --username "$REGISTRY_USERNAME" --password-stdin "$REGISTRY_URL" < "$REGISTRY_PASSWORD_FILE"
     # DOCKER_BUILDKIT is here to be able to use Dockerfile specific dockerginore (e2e-tests.Dockerfile.dockerignore)
     DOCKER_BUILDKIT=1 docker build \
         --build-arg APP="$APP" \
         --build-arg NODE_APP_INSTANCE="$FLAVOR" \
-        --build-arg SUBDOMAIN="$FLAVOR.kalisio.xyz" \
-        --build-arg HEADLESS=true \
+        --build-arg SUBDOMAIN="$SUBDOMAIN" \
         -f "$ROOT_DIR/e2e-tests.Dockerfile" \
-        -t "$IMAGE_NAME:$IMAGE_TAG" \
+        -t "$REGISTRY_URL/$IMAGE_NAME:$IMAGE_TAG" \
         "$WORKSPACE_DIR"
-    docker tag "$IMAGE_NAME:$IMAGE_TAG" "$IMAGE_NAME:$FLAVOR"
+    docker tag "$REGISTRY_URL/$IMAGE_NAME:$IMAGE_TAG" "$REGISTRY_URL/$IMAGE_NAME:$FLAVOR"
 
     if [ "$PUBLISH" = true ]; then
-        docker push "$IMAGE_NAME:$IMAGE_TAG"
-        docker push "$IMAGE_NAME:$FLAVOR"
+        docker push "$REGISTRY_URL/$IMAGE_NAME:$IMAGE_TAG"
+        docker push "$REGISTRY_URL/$IMAGE_NAME:$FLAVOR"
     fi
 
-    docker logout "$KALISIO_HARBOR_URL"
+    docker logout "$REGISTRY_URL"
 
-    end_group "Building container ..."
+    end_group "Building $REGISTRY_URL/$IMAGE_NAME:$IMAGE_TAG ..."
 }
 
 # Run e2e tests
-# Specific error handling: set -uo pipefail to bypass errors
 # Expected arguments
-# 1. Root directory
+# 1. the app root directory
 # 2: the app name
-# 3: the slack webhook apps
 run_e2e_tests () {
     local ROOT_DIR="$1"
     local APP="$2"
-    local SLACK_WEBHOOK_APPS="$3"
-
-    ## Run tests & redirect output to a log file
-    ##
+    local TESTS_RESULTS="$ROOT_DIR/test/run/chrome"
 
     # Chrome
-    mkdir -p "$ROOT_DIR/test/run/chrome"
-    yarn test:client > "$ROOT_DIR/test/run/chrome/chrome_logs.txt" 2>&1
-    local RET_CODE=$?
+    mkdir -p "$TESTS_RESULTS"
+    yarn test:client 2>&1 | tee "$TESTS_RESULTS/logs.txt"
+    local RET="${PIPESTATUS[0]}"
 
     # Firefox
     # PUPPETEER_PRODUCT=firefox yarn add puppeteer
     # yarn link "@kalisio/kdk" --link-folder /opt/kalisio/yarn-links
     # export BROWSER="firefox"bucket
     # mkdir -p "$ROOT_DIR/test/run/firefox"
-    # yarn test:client  > "$ROOT_DIR/test/run/chrome/firefox_logs.txt" 2>&1
+    return "$RET" # return the exit code of the tests (= number of failed tests)
+}
 
-    ## Upload logs & screenshots to S3
-    ##
+# Upload e2e tests artefacts to some s3 storage.
+# Expected args:
+# 1. the app root dir
+# 2. the app name
+# 3. the number of failed tests
+# 4. the s3 bucket where to upload artefacts (with a rclone remote, like ovh:e2e-test/blabla)
+# 5. the rclone.conf file to use to upload artefacts
+# 6. the file where the upload report will be written (json)
+upload_e2e_tests_artefacts() {
+    local ROOT_DIR="$1"
+    local APP="$2"
+    local NUM_FAILED="$3"
+    local S3_BUCKET="$4"
+    local RCLONE_CONF="$5"
+    local UPLOAD_REPORT_FILE="$6"
+
+    local TIMESTAMP
+    TIMESTAMP="$(date +"%d-%m-%Y")"
+    local TESTS_RESULTS_DIR="$ROOT_DIR/test/run/chrome"
+    local WORK_DIR="$TMP_DIR/artefacts/$APP/$TIMESTAMP/e2e"
+    local REMOTE_DIR="$S3_BUCKET/$APP/$TIMESTAMP/e2e"
+
+    mkdir -p "$WORK_DIR"
+
+    # zip the whole tests results folder
+    local ZIP_FILE="$WORK_DIR/e2e-artefacts.zip"
+    cd "$TESTS_RESULTS_DIR"
+    zip -r "$ZIP_FILE" .
+    cd ~-
 
-    local CURRENT_DATE
-    CURRENT_DATE=$(date +"%d-%m-%Y")
-    local CHROME_LOGS_LINK=""
-    local SCREEN_LINK=""
+    # keep log file as is
+    cp "$TESTS_RESULTS_DIR/logs.txt" "$WORK_DIR/logs.txt"
 
-    zip -r "$TMP_DIR/screenshots.zip" "$ROOT_DIR/test/run"
+    # and keep captures and diffs for failed tests
+    local TESTS_WITH_DIFF=()
+    readarray -d '' DIFF_FILES < <(find "$TESTS_RESULTS_DIR" -type f -name 'diff.*.png' -print0)
+    for DIFF_FILE in "${DIFF_FILES[@]}"; do
+        local BASE_DIFF_FILE
+        BASE_DIFF_FILE="$(basename "$DIFF_FILE")"
+        local BASE_CAPTURE_FILE="${BASE_DIFF_FILE#diff.*}"
+        local CAPTURE_FILE
+        CAPTURE_FILE="$(dirname "$DIFF_FILE")/$BASE_CAPTURE_FILE"
 
-    rclone copy "$ROOT_DIR/test/run/chrome/chrome_logs.txt" "ovh-s3:/dev/e2e-tests/$APP/$CURRENT_DATE"
-    CHROME_LOGS_LINK=$(rclone link "ovh-s3:/dev/e2e-tests/$APP/$CURRENT_DATE/chrome_logs.txt")
+        local TEST_DIR
+        TEST_DIR="$(realpath -s --relative-to="$TESTS_RESULTS_DIR" "$DIFF_FILE")"
+        TEST_DIR="$(dirname "$TEST_DIR")"
+        TEST_DIR="$(dirname "$TEST_DIR")"
 
-    rclone copy "$TMP_DIR/screenshots.zip" "ovh-s3:/dev/e2e-tests/$APP/$CURRENT_DATE"
-    SCREEN_LINK=$(rclone link "ovh-s3:/dev/e2e-tests/$APP/$CURRENT_DATE/screenshots.zip")
+        local TEST_NAME
+        TEST_NAME="$TEST_DIR/${BASE_CAPTURE_FILE%.*}"
 
-    ## Report outcome to slack
-    ##
+        TESTS_WITH_DIFF+=("$TEST_NAME")
+
+        mkdir -p "$WORK_DIR/$TEST_DIR"
+        cp "$DIFF_FILE" "$WORK_DIR/$TEST_DIR"
+        cp "$CAPTURE_FILE" "$WORK_DIR/$TEST_DIR"
+    done
+
+    rclone --config "$RCLONE_CONF" copy "$TMP_DIR/artefacts" "$S3_BUCKET"
+
+    rm -fR "$WORK_DIR"
+
+    # now generate public http links
+    local ARTEFACTS_LINK
+    ARTEFACTS_LINK="$(rclone --config "$RCLONE_CONF" link "$REMOTE_DIR/e2e-artefacts.zip")"
+    local LOGS_LINK
+    LOGS_LINK="$(rclone --config "$RCLONE_CONF" link "$REMOTE_DIR/logs.txt")"
+
+    printf '{ "app": "%s", "timestamp": "%s", "num_failed": "%d", "artefacts": "%s", "logs": "%s", "num_diffs": "%d", "diffs": [' "$APP" "$TIMESTAMP" "$NUM_FAILED" "$ARTEFACTS_LINK" "$LOGS_LINK" "${#TESTS_WITH_DIFF[@]}" > "$UPLOAD_REPORT_FILE"
+
+    local COMMA=""
+    for TEST_NAME in "${TESTS_WITH_DIFF[@]}"; do
+        local CAPTURE_LINK
+        CAPTURE_LINK="$(rclone --config "$RCLONE_CONF" link "$REMOTE_DIR/$TEST_NAME.png")"
+        local DIFF_FILE
+        DIFF_FILE="$(dirname "$TEST_NAME")/diff.$(basename "$TEST_NAME").png"
+        local DIFF_LINK
+        DIFF_LINK="$(rclone --config "$RCLONE_CONF" link "$REMOTE_DIR/$DIFF_FILE")"
+        printf '%s { "name": "%s", "capture": "%s", "diff": "%s" }' "$COMMA" "$TEST_NAME" "$CAPTURE_LINK" "$DIFF_LINK" >> "$UPLOAD_REPORT_FILE"
+        COMMA=","
+    done
+
+    printf " ] }" >> "$UPLOAD_REPORT_FILE"
+}
+
+# Generates a markdown report file from the upload report file
+# generated by the upload_e2e_tests_artefacts function.
+# Expected args:
+# 1. the same upload report file used in upload_e2e_tests_artefacts
+# 2. the file where to write the markdown report
+# 3. the flavor to use for the markdown (see normalize_markdown_anchor)
+generate_e2e_tests_markdown_report() {
+    local UPLOAD_REPORT_FILE="$1"
+    local MD_REPORT_FILE="$2"
+    local MD_FLAVOR="$3"
+
+    local APP
+    APP=$(get_json_value "$UPLOAD_REPORT_FILE" "app")
+    local TIMESTAMP
+    TIMESTAMP=$(get_json_value "$UPLOAD_REPORT_FILE" "timestamp")
+    local NUM_FAILED
+    NUM_FAILED=$(get_json_value "$UPLOAD_REPORT_FILE" "num_failed")
+    local ARTEFACTS_LINK
+    ARTEFACTS_LINK=$(get_json_value "$UPLOAD_REPORT_FILE" "artefacts")
+    local LOGS_LINK
+    LOGS_LINK=$(get_json_value "$UPLOAD_REPORT_FILE" "logs")
+    local NUM_DIFFS
+    NUM_DIFFS=$(get_json_value "$UPLOAD_REPORT_FILE" "num_diffs")
+
+    printf "# [%s] (e2e run from %s)\n\n" "$(echo "$APP" | tr '[:lower:]' '[:upper:]')" "$TIMESTAMP" > "$MD_REPORT_FILE"
+    printf "[All artefacts](%s), [logs](%s)\n\n" "$ARTEFACTS_LINK" "$LOGS_LINK" >> "$MD_REPORT_FILE"
+
+    if (( NUM_FAILED == 0 )); then
+        printf "> [!TIP]\n> All tests have passed\n" >> "$MD_REPORT_FILE"
+    else
+        printf "> [!CAUTION]\n> **%d** tests have failed\n" "$NUM_FAILED" >> "$MD_REPORT_FILE"
+
+        local SECTIONS=()
+        for (( i = 0; i < NUM_DIFFS; ++i )); do
+            local TEST_NAME
+            TEST_NAME=$(get_json_value "$UPLOAD_REPORT_FILE" "diffs[$i].name")
+            printf ">   - [%s](#%s)\n" "$TEST_NAME" "$(normalize_markdown_anchor "$TEST_NAME" "$MD_FLAVOR")" >> "$MD_REPORT_FILE"
+
+            local CAPTURE_LINK
+            CAPTURE_LINK=$(get_json_value "$UPLOAD_REPORT_FILE" "diffs[$i].capture")
+            local DIFF_LINK
+            DIFF_LINK=$(get_json_value "$UPLOAD_REPORT_FILE" "diffs[$i].diff")
+
+            read -r -d '' SECTION <<EOF
+## $TEST_NAME
+Captured file | Diff file
+--------------|----------
+![Captured file]($CAPTURE_LINK)         | ![Diff file]($DIFF_LINK)
+
+EOF
+
+            SECTIONS+=("$SECTION")
+        done
+
+        printf "\n" >> "$MD_REPORT_FILE"
+
+        for SECTION in "${SECTIONS[@]}"; do
+            printf "%s\n" "$SECTION" >> "$MD_REPORT_FILE"
+        done
+    fi
+}
+
+# Add and commit the e2e tests report in a git repository.
+# Expected args:
+# 1. the same upload report file as upload_e2e_tests_artefacts
+# 2. the report file to add to the repo
+# 3. the repository url to use to clone and push (must be able to push!)
+# 4. a folder in which the report will be moved
+push_e2e_tests_report_to_git_repo() {
+    local UPLOAD_FILE="$1"
+    local REPORT_FILE="$2"
+    local REPOSITORY_URL="$3"
+    local REPORTS_BASE="$4"
+
+    local APP
+    APP=$(get_json_value "$UPLOAD_FILE" "app")
+    local TIMESTAMP
+    TIMESTAMP=$(get_json_value "$UPLOAD_FILE" "timestamp")
+
+    local WORK_DIR
+    WORK_DIR="$(mktemp -d -p "$TMP_DIR" push.XXXXXX)"
+
+    # Clone repo to a temp location
+    git clone --depth 1 "$REPOSITORY_URL" "$WORK_DIR"
+    # Copy report
+    local REPORT_DIR="$WORK_DIR"
+    [[ "$REPORTS_BASE" != "" ]] && REPORT_DIR="$REPORT_DIR/$REPORTS_BASE"
+    REPORT_DIR="$REPORT_DIR/$APP/$TIMESTAMP"
+    mkdir -p "$REPORT_DIR"
+
+    cp "$REPORT_FILE" "$REPORT_DIR"
+
+    # Try add link to 'latest' section
+    local LATEST_REPORT
+    LATEST_REPORT="$(realpath --relative-to="$WORK_DIR" "$REPORT_DIR")/$(basename "$REPORT_FILE")"
+
+    sed -i 's#^\['"$APP"' e2e\](.*)$#\['"$APP"' e2e\]('"${LATEST_REPORT//./\\.}"')#' "$WORK_DIR/README.md"
+
+    cd "$WORK_DIR"
+    git add --all
+    git -c user.name="CI bot" -c user.email="cibot@kalisio.com" commit --message "ci: e2e tests report from $TIMESTAMP"
+    git push origin
+    cd ~-
+
+    rm -fR "$WORK_DIR"
+}
+
+# Send the e2e tests report to a slack channel.
+# Expected args:
+# 1. the same upload report file as upload_e2e_tests_artefacts
+# 2. the slack channel webhook
+push_e2e_tests_report_to_slack() {
+    local UPLOAD_REPORT_FILE="$1"
+    local SLACK_WEBHOOK="$2"
+
+    local APP
+    APP=$(get_json_value "$UPLOAD_REPORT_FILE" "app")
+    local NUM_FAILED
+    NUM_FAILED=$(get_json_value "$UPLOAD_REPORT_FILE" "num_failed")
+    local ARTEFACTS_LINK
+    ARTEFACTS_LINK=$(get_json_value "$UPLOAD_REPORT_FILE" "artefacts")
+    local LOGS_LINK
+    LOGS_LINK=$(get_json_value "$UPLOAD_REPORT_FILE" "logs")
+
+    slack_e2e_report "$APP" "$NUM_FAILED" "$SLACK_WEBHOOK" "$LOGS_LINK" "$ARTEFACTS_LINK"
+}
+
+# Take all steps to run e2e test and push results to a git repository. Binary artefacts
+# are uploaded on an s3 bucket.
+# Expected args:
+# 1. the app root dir
+# 2. the app name
+# 3. the s3 bucket where to upload binary artefacts
+# 4. the rclone.conf file to use with rclone
+# 5. the git repository url where we'll push the final report (must be able to push!)
+# 6. a folder in which the report will be moved
+run_and_publish_e2e_tests_to_git_repo() {
+    local ROOT_DIR="$1"
+    local APP="$2"
+    local S3_BUCKET="$3"
+    local RCLONE_CONF="$4"
+    local REPOSITORY_URL="$5"
+    local REPORTS_BASE="$6"
+
+    run_e2e_tests "$ROOT_DIR" "$APP"
+    local NUM_FAILED="$?"
+
+    local MD_FLAVOR
+    [[ "$REPOSITORY_URL" = *gitlab* ]] && MD_FLAVOR="gitlab"
+    [[ "$REPOSITORY_URL" = *github* ]] && MD_FLAVOR="github"
+
+    local UPLOAD_REPORT_FILE="$TMP_DIR/e2e-upload-report.json"
+    local MD_REPORT_FILE="$TMP_DIR/e2e.md"
+
+    upload_e2e_tests_artefacts \
+        "$ROOT_DIR" "$APP" "$NUM_FAILED" \
+        "$S3_BUCKET" "$RCLONE_CONF" \
+        "$UPLOAD_REPORT_FILE"
+    generate_e2e_tests_markdown_report \
+        "$UPLOAD_REPORT_FILE" "$MD_REPORT_FILE" "$MD_FLAVOR"
+    push_e2e_tests_report_to_git_repo \
+        "$UPLOAD_REPORT_FILE" "$MD_REPORT_FILE" \
+        "$REPOSITORY_URL" "$REPORTS_BASE"
+}
+
+# Take all steps to run e2e test and push results to a slack channel. Binary artefacts
+# are uploaded on an s3 bucket.
+# Expected args:
+# 1. the app root dir
+# 2. the app name
+# 3. the s3 bucket where to upload binary artefacts
+# 4. the rclone.conf file to use with rclone
+# 5. the slack channel webhook
+run_and_publish_e2e_tests_to_slack() {
+    local ROOT_DIR="$1"
+    local APP="$2"
+    local S3_BUCKET="$3"
+    local RCLONE_CONF="$4"
+    local SLACK_WEBHOOK="$5"
+
+    run_e2e_tests "$ROOT_DIR" "$APP"
+    local NUM_FAILED="$?"
+
+    local UPLOAD_REPORT_FILE="$TMP_DIR/e2e-upload-report.json"
 
-    slack_e2e_report "$APP" "$RET_CODE" "$SLACK_WEBHOOK_APPS" "$CHROME_LOGS_LINK" "$SCREEN_LINK"
+    upload_e2e_tests_artefacts \
+        "$ROOT_DIR" "$APP" "$NUM_FAILED" \
+        "$S3_BUCKET" "$RCLONE_CONF" \
+        "$UPLOAD_REPORT_FILE"
+    push_e2e_tests_report_to_slack \
+        "$UPLOAD_REPORT_FILE" "$SLACK_WEBHOOK"
 }