chore: release 1.3.0

* fix: docker.yml

* feat: add helm chart config

* fix: helm config

* feat: add .github workflow for helm chart

---------

Co-authored-by: charlesgauthereau <charles.gauthereau@soluce-technologies.com>

.coderabbit.yaml

@@ -0,0 +1,23 @@
+reviews:
+  auto_review:
+    enabled: true                  
+    ignore_usernames: ["dependabot[bot]"] 
+    labels: ["!wip", "!draft"]     
+  auto_apply_labels: true        
+  suggested_reviewers: true     
+  auto_assign_reviewers: true   
+
+issue_enrichment:
+  auto_enrich:
+    enabled: true                  
+  labeling:
+    auto_apply_labels: true        
+    labeling_instructions:
+      - label: bug
+        instructions: "Error, crash, or incorrect behavior reports"
+      - label: enhancement
+        instructions: "Feature requests or improvements"
+      - label: documentation
+        instructions: "Docs updates or missing documentation"
+      - label: good first issue
+        instructions: "Beginner-friendly tasks suitable for new contributors"

.github/workflows/discord.yml

@@ -0,0 +1,73 @@
+name: Discord Notification
+
+on:
+  workflow_call:
+    inputs:
+      release_tag:
+        required: true
+        type: string
+      discord_title:
+        required: true
+        type: string
+      discord_color:
+        required: true
+        type: number
+      discord_footer:
+        required: true
+        type: string
+    secrets:
+      DISCORD_WEBHOOK:
+        required: true
+      GH_TOKEN:
+        required: true
+
+jobs:
+  notify-discord:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Send Discord Notification
+        env:
+          DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}
+          GH_TOKEN: ${{ secrets.GH_TOKEN }}
+        run: |
+          RELEASE_INFO=$(gh release view "${{ inputs.release_tag }}" -R ${{ github.repository }} --json name,url,body,author)
+
+          RELEASE_TITLE=$(echo "$RELEASE_INFO" | jq -r .name)
+          if [ -z "$RELEASE_TITLE" ] || [ "$RELEASE_TITLE" = "null" ]; then RELEASE_TITLE="${{ inputs.release_tag }}"; fi
+
+          RELEASE_URL=$(echo "$RELEASE_INFO" | jq -r .url)
+          RELEASE_BODY=$(echo "$RELEASE_INFO" | jq -r .body)
+
+          AUTHOR_NAME="Portabase"
+          AUTHOR_ICON="https://github.com/Portabase.png"
+
+          PAYLOAD=$(jq -n \
+            --arg title "$RELEASE_TITLE" \
+            --arg description "$RELEASE_BODY" \
+            --arg url "$RELEASE_URL" \
+            --arg author "$AUTHOR_NAME" \
+            --arg icon "$AUTHOR_ICON" \
+            --arg discord_title "${{ inputs.discord_title }}" \
+            --arg discord_footer "${{ inputs.discord_footer }}" \
+            --argjson discord_color ${{ inputs.discord_color }} \
+            '{
+              content: $discord_title,
+              embeds: [{
+                title: $title,
+                url: $url,
+                description: $description,
+                color: $discord_color,
+                author: {
+                  name: $author,
+                  icon_url: $icon
+                },
+                footer: {
+                  text: $discord_footer
+                }
+              }]
+            }'
+          )
+
+          curl -H "Content-Type: application/json" \
+               -d "$PAYLOAD" \
+               "$DISCORD_WEBHOOK"

.github/workflows/docker.yml

@@ -1,83 +1,18 @@
-#name: Docker Publish
-#
-#on:
-#  workflow_call:
-#    inputs:
-#      image_name:
-#        required: false
-#        type: string
-#        default: 'portabase/agent'
-#      add_latest:
-#        required: false
-#        type: boolean
-#        default: false
-#      target:
-#        required: false
-#        type: string
-#        default: 'prod'
-#      dockerfile:
-#        required: false
-#        type: string
-#        default: './docker/Dockerfile'
-#    secrets:
-#      DOCKER_USERNAME:
-#        required: true
-#      DOCKER_PASSWORD:
-#        required: true
-#
-#jobs:
-#  build-and-push:
-#    runs-on: ubuntu-latest
-#    permissions:
-#      packages: write
-#      contents: read
-#    steps:
-#      - name: Check out the repo
-#        uses: actions/checkout@v4
-#        with:
-#          fetch-depth: 0
-#
-#      - name: Set up QEMU (enables multi-arch emulation)
-#        uses: docker/setup-qemu-action@v3
-#
-#      - name: Set up Docker Buildx
-#        uses: docker/setup-buildx-action@v3
-#
-#      - name: Log in to Docker Hub
-#        uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a
-#        with:
-#          username: ${{ secrets.DOCKER_USERNAME }}
-#          password: ${{ secrets.DOCKER_PASSWORD }}
-#
-#      - name: Set tags
-#        id: set-tags
-#        run: |
-#          REF_NAME=${GITHUB_REF#refs/tags/}
-#          TAGS="${{ inputs.image_name }}:$REF_NAME"
-#          if [[ "${{ inputs.add_latest }}" == "true" ]]; then
-#            TAGS="$TAGS,${{ inputs.image_name }}:latest"
-#          fi
-#          echo "tags=$TAGS" >> $GITHUB_OUTPUT
-#
-#      - name: Build and push Docker image
-#        uses: docker/build-push-action@v6
-#        with:
-#          context: .
-#          file: ${{ inputs.dockerfile }}
-#          platforms: linux/amd64,linux/arm64
-#          push: true
-#          tags: ${{ steps.set-tags.outputs.tags }}
-#          target: ${{ inputs.target }}
-
 name: Docker Publish
 
 on:
   workflow_call:
     inputs:
+      version:
+        required: true
+        type: string
+      ref:
+        required: true
+        type: string
       image_name:
         required: false
         type: string
-        default: 'portabase/agent'
+        default: "portabase/agent"
       add_latest:
         required: false
         type: boolean
@@ -85,11 +20,11 @@ on:
       target:
         required: false
         type: string
-        default: 'prod'
+        default: "prod"
       dockerfile:
         required: false
         type: string
-        default: './docker/Dockerfile'
+        default: "./docker/Dockerfile"
     secrets:
       DOCKER_USERNAME:
         required: true
@@ -97,102 +32,108 @@ on:
         required: true
 
 jobs:
-  build-amd64:
-    name: Build AMD64 Image
-    runs-on: ubuntu-latest
-    outputs:
-      image: ${{ steps.set-tags.outputs.amd64_image }}
+  build:
+    name: Build architectures
+    runs-on: ${{ matrix.platform == 'linux/amd64' && 'ubuntu-latest' || 'ubuntu-24.04-arm' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ linux/amd64, linux/arm64 ]
     steps:
       - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref }}
+          fetch-depth: 0
 
-      - uses: docker/setup-buildx-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
 
-      - uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a
+      - name: Login to Docker
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
-      - name: Set image tag
-        id: set-tags
+      - name: Prepare Image Tags
+        id: prep
         run: |
-          REF_NAME=${GITHUB_REF#refs/tags/}
-          AMD64_IMAGE="${{ inputs.image_name }}:$REF_NAME-amd64"
-          echo "amd64_image=$AMD64_IMAGE" >> $GITHUB_OUTPUT
+          ARCH=${{ matrix.platform == 'linux/amd64' && 'amd64' || 'arm64' }}
+          echo "image=${{ inputs.image_name }}:${{inputs.version}}-$ARCH" >> $GITHUB_OUTPUT
+          echo "safe_platform=${{ matrix.platform == 'linux/amd64' && 'linux-amd64' || 'linux-arm64' }}" >> $GITHUB_OUTPUT
 
-      - name: Build and push AMD64
+
+      - name: Build and push image
         uses: docker/build-push-action@v6
         with:
           context: .
           file: ${{ inputs.dockerfile }}
-          platforms: linux/amd64
+          platforms: ${{ matrix.platform }}
           push: true
-          tags: ${{ steps.set-tags.outputs.amd64_image }}
+          tags: ${{ steps.prep.outputs.image }}
           target: ${{ inputs.target }}
 
-      - name: Set job output
-        run: |
-          echo "image=${{ steps.set-tags.outputs.amd64_image }}" >> $GITHUB_OUTPUT
+      - name: Save image name for manifest
+        run: echo "${{ steps.prep.outputs.image }}" > image.txt
 
-  build-arm64:
-    name: Build ARM64 Image
-    runs-on: ubuntu-24.04-arm
-    outputs:
-      image: ${{ steps.set-tags.outputs.arm64_image }}
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: docker/setup-buildx-action@v3
-
-      - uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a
+      - uses: actions/upload-artifact@v4
         with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-
-      - name: Set image tag
-        id: set-tags
-        run: |
-          REF_NAME=${GITHUB_REF#refs/tags/}
-          ARM64_IMAGE="${{ inputs.image_name }}:$REF_NAME-arm64"
-          echo "arm64_image=$ARM64_IMAGE" >> $GITHUB_OUTPUT
-
-      - name: Build and push ARM64
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: ${{ inputs.dockerfile }}
-          platforms: linux/arm64
-          push: true
-          tags: ${{ steps.set-tags.outputs.arm64_image }}
-          target: ${{ inputs.target }}
-
-      - name: Set job output
-        run: |
-          echo "image=${{ steps.set-tags.outputs.arm64_image }}" >> $GITHUB_OUTPUT
-
+          name: image-${{ steps.prep.outputs.safe_platform }}
+          path: image.txt
+          retention-days: 1
 
   create-manifest:
-    name: Create Multi-Arch Manifest
+    name: Create multi-arch manifest
     runs-on: ubuntu-latest
-    needs:
-      - build-amd64
-      - build-arm64
+    needs: build
     steps:
-      - uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a
+      - uses: actions/download-artifact@v4
+        with:
+          name: image-linux-amd64
+          path: /tmp/digests/amd64
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: image-linux-arm64
+          path: /tmp/digests/arm64
+
+      - name: Login to Docker
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
-      - name: Create Docker manifest
+      - name: Generate semantic tags
+        id: tags
         run: |
-          REF_NAME=${GITHUB_REF#refs/tags/}
-          IMAGE="${{ inputs.image_name }}:$REF_NAME"
-          AMD64_IMAGE="${{ needs.build-amd64.outputs.image }}"
-          ARM64_IMAGE="${{ needs.build-arm64.outputs.image }}"
+          VERSION="${{ inputs.version }}"
+          IFS='.' read -r MAJOR MINOR PATCH <<< "$VERSION"
           
-          docker manifest create $IMAGE $AMD64_IMAGE $ARM64_IMAGE
-          docker manifest push $IMAGE
-          
-          if [ "${{ inputs.add_latest }}" = "true" ]; then
-            docker manifest create ${{ inputs.image_name }}:latest $AMD64_IMAGE $ARM64_IMAGE
-            docker manifest push ${{ inputs.image_name }}:latest
+          echo "VERSION_TAG=$VERSION" >> $GITHUB_OUTPUT
+          if [ -n "$MINOR" ]; then
+            echo "MINOR_TAG=$MAJOR.$MINOR" >> $GITHUB_OUTPUT
           fi
+          if [ -n "$MAJOR" ]; then
+            echo "MAJOR_TAG=$MAJOR" >> $GITHUB_OUTPUT
+          fi
+          if [ "${{ inputs.add_latest }}" = "true" ]; then
+            echo "LATEST_TAG=latest" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Extract Docker metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ inputs.image_name }}
+          tags: |
+            type=raw,value=${{ steps.tags.outputs.VERSION_TAG }}
+            type=raw,value=${{ steps.tags.outputs.MINOR_TAG }}
+            type=raw,value=${{ steps.tags.outputs.MAJOR_TAG }}
+            type=raw,value=${{ steps.tags.outputs.LATEST_TAG }}
+
+      - name: Create and push manifest list
+        working-directory: /tmp/digests
+        run: |
+          DOCKER_IMAGES="$(cat amd64/image.txt) $(cat arm64/image.txt)"
+          TAG_ARGS=$(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON")
+          echo $TAG_ARGS
+          docker buildx imagetools create $TAG_ARGS $DOCKER_IMAGES

.github/workflows/github.yml

@@ -1,128 +0,0 @@
-name: GitHub Release
-
-on:
-  workflow_call:
-    inputs:
-      prerelease:
-        required: false
-        type: boolean
-        default: false
-      make_latest:
-        required: false
-        type: boolean
-        default: false
-      discord_title:
-        required: true
-        type: string
-      discord_color:
-        required: true
-        type: number
-      discord_footer:
-        required: true
-        type: string
-    secrets:
-      DISCORD_WEBHOOK:
-        required: true
-      GH_TOKEN:
-        required: true
-
-jobs:
-  create-release:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - name: Check out the repo
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Build Changelog
-        id: build_changelog
-        uses: mikepenz/release-changelog-builder-action@v5
-        with:
-          mode: "COMMIT"
-          configurationJson: |
-            {
-              "template": "#{{CHANGELOG}}",
-              "categories": [
-                {
-                    "title": "## Feature",
-                    "labels": ["feat", "feature"]
-                },
-                {
-                    "title": "## Fix",
-                    "labels": ["fix", "bug"]
-                },
-                {
-                    "title": "## Other",
-                    "labels": []
-                }
-              ],
-              "label_extractor": [
-                {
-                  "pattern": "^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test){1}(\([\w\-\.]+\))?(!)?: ([\w ])+([\s\S]*)",
-                  "on_property": "title",
-                  "target": "$1"
-                }
-              ]
-            }
-        env:
-          GITHUB_TOKEN: ${{ secrets.GH_TOKEN }}
-
-      - name: Create GitHub Release
-        uses: softprops/action-gh-release@v2
-        with:
-          generate_release_notes: false
-          body: ${{ steps.build_changelog.outputs.changelog }}
-          prerelease: ${{ inputs.prerelease }}
-          make_latest: ${{ inputs.make_latest }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GH_TOKEN }}
-
-      - name: Send Discord Notification
-        env:
-          DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}
-          GH_TOKEN: ${{ secrets.GH_TOKEN }}
-        run: |
-          RELEASE_INFO=$(gh release view "${{ github.ref_name }}" -R ${{ github.repository }} --json name,url,body,author)
-          
-          RELEASE_TITLE=$(echo "$RELEASE_INFO" | jq -r .name)
-          if [ -z "$RELEASE_TITLE" ] || [ "$RELEASE_TITLE" = "null" ]; then RELEASE_TITLE="${{ github.ref_name }}"; fi
-          
-          RELEASE_URL=$(echo "$RELEASE_INFO" | jq -r .url)
-          RELEASE_BODY=$(echo "$RELEASE_INFO" | jq -r .body)
-          
-          AUTHOR_NAME="Portabase"
-          AUTHOR_ICON="https://github.com/Portabase.png" 
-
-          PAYLOAD=$(jq -n \
-            --arg title "$RELEASE_TITLE" \
-            --arg description "$RELEASE_BODY" \
-            --arg url "$RELEASE_URL" \
-            --arg author "$AUTHOR_NAME" \
-            --arg icon "$AUTHOR_ICON" \
-            --arg discord_title "${{ inputs.discord_title }}" \
-            --arg discord_footer "${{ inputs.discord_footer }}" \
-            --argjson discord_color ${{ inputs.discord_color }} \
-            '{ 
-              content: $discord_title,
-              embeds: [{
-                title: $title,
-                url: $url,
-                description: $description,
-                color: $discord_color,
-                author: {
-                  name: $author,
-                  icon_url: $icon
-                },
-                footer: {
-                  text: $discord_footer
-                }
-              }]
-            }'
-          ) 
-          
-          curl -H "Content-Type: application/json" \
-               -d "$PAYLOAD" \
-               "$DISCORD_WEBHOOK"

.github/workflows/helm.yml

@@ -0,0 +1,37 @@
+name: Publish Helm Chart
+on:
+  workflow_call:
+    inputs:
+      version:
+        required: true
+        type: string
+    secrets:
+      GH_TOKEN:
+        required: true
+
+jobs:
+  publish-helm:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Helm
+        uses: azure/setup-helm@v4
+
+      - name: Package Helm chart
+        run: |
+          mkdir -p ./helm-packages
+          helm package helm \
+            --version ${{ inputs.version }} \
+            --app-version ${{ inputs.version }} \
+            --destination ./helm-packages
+
+      - name: Authenticate to GitHub Packages
+        run: |
+          echo "${{ secrets.GH_TOKEN }}" | helm registry login ghcr.io -u ${{ github.actor }} --password-stdin
+
+      - name: Push Helm chart to GitHub Packages (OCI)
+        run: |
+          helm push ./helm-packages/portabase-agent-${{ inputs.version }}.tgz oci://ghcr.io/portabase/charts

.github/workflows/release.yml

@@ -1,32 +1,148 @@
-name: Publish Docker image for release
+name: Auto Release & Publish
 
 on:
-  push:
-    tags:
-      - '*.*.*'
-      - '!*-*'
+  pull_request:
+    types: [ closed ]
+    branches:
+      - main
 
 permissions:
   contents: write
   packages: write
 
 jobs:
-  docker_publish:
+
+  check-skip:
+    runs-on: ubuntu-latest
+    outputs:
+      skip: ${{ steps.set-skip.outputs.skip }}
+    steps:
+      - name: Determine if release should be skipped
+        id: set-skip
+        run: |
+          TITLE="${{ github.event.pull_request.title }}"
+          echo "PR title: $TITLE"
+
+          if [[ "$TITLE" == *"[skip-release]"* ]]; then
+            echo "PR title contains [skip-release], skipping release jobs."
+            echo "skip=true" >> $GITHUB_OUTPUT
+          else
+            echo "skip=false" >> $GITHUB_OUTPUT
+          fi
+
+  create-release:
+    needs: check-skip
+    if: ${{ needs.check-skip.outputs.skip == 'false' }}
+    runs-on: ubuntu-latest
+    outputs:
+      draft_tag: ${{ steps.release_step.outputs.draft_tag }}
+      version: ${{ steps.release_step.outputs.version }}
+    steps:
+      - uses: actions/create-github-app-token@v1
+        id: app-token
+        with:
+          app-id: ${{ vars.APP_ID }}
+          private-key: ${{ secrets.APP_PRIVATE_KEY }}
+
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ steps.app-token.outputs.token }}
+          ref: main
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install cargo-edit
+        run: cargo install cargo-edit
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "lts/*"
+
+      - name: Install release-it globally
+        run: |
+          npm install -g release-it
+          npm install -g @release-it/conventional-changelog
+          npm install -g @release-it/bumper
+
+      - run: |
+          git config --global user.name 'github-actions[bot]'
+          git config --global user.email 'github-actions[bot]@users.noreply.github.com'
+
+      - name: Run release-it
+        id: release_step
+        run: |
+          git pull origin main
+
+          VERSION=$(release-it --ci --release-version)
+          echo $VERSION
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+          OUTPUT=$(release-it --ci)
+          echo "$OUTPUT"
+
+          DRAFT_TAG=$(echo "$OUTPUT" | grep -oE 'untagged-[a-z0-9]+')
+          echo $DRAFT_TAG
+          echo "draft_tag=$DRAFT_TAG" >> $GITHUB_OUTPUT
+        env:
+          GITHUB_TOKEN: ${{ steps.app-token.outputs.token }}
+
+  publish-docker:
+    needs: create-release
+    if: ${{ needs.create-release.result == 'success' }}
     uses: ./.github/workflows/docker.yml
     with:
+      version: ${{ needs.create-release.outputs.version }}
+      ref: ${{ needs.create-release.outputs.version }}
       add_latest: true
     secrets:
       DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
       DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
 
-  github_release:
-    needs: docker_publish
-    uses: ./.github/workflows/github.yml
+  publish-helm:
+    needs: create-release
+    if: ${{ needs.create-release.result == 'success' }}
+    uses: ./.github/workflows/helm.yml
     with:
-      prerelease: false
-      make_latest: true
+      version: ${{ needs.create-release.outputs.version }}
+    secrets:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  finalize-release:
+    needs:
+      - create-release
+      - publish-docker
+      - publish-helm
+    runs-on: ubuntu-latest
+    outputs:
+      release_tag: ${{ steps.publish_release_step.outputs.release_tag }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Publish GitHub Release
+        id: publish_release_step
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          OUTPUT=$(gh release edit ${{ needs.create-release.outputs.draft_tag }} --draft=false)
+          echo "$OUTPUT"
+          RELEASE_TAG=$(echo "$OUTPUT" | sed -E 's|.*/releases/tag/||')
+          echo "release_tag=$RELEASE_TAG" >> $GITHUB_OUTPUT
+
+  notify-discord:
+    needs:
+      - publish-docker
+      - publish-helm
+      - create-release
+      - finalize-release
+    uses: ./.github/workflows/discord.yml
+    with:
+      release_tag: ${{ needs.create-release.outputs.version }}
       discord_title: "||@release-agent|| New release published"
-      discord_color: 5814783
+      discord_color: 3066993
       discord_footer: "Portabase"
     secrets:
       DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}

.release-it.json

@@ -0,0 +1,62 @@
+{
+  "github": {
+    "release": true,
+    "draft": true,
+    "tokenRef": "GITHUB_TOKEN"
+  },
+  "git": {
+    "commit": true,
+    "commitMessage": "chore: release ${version}",
+    "requireCleanWorkingDir": true,
+    "tag": true,
+    "tagName": "${version}",
+    "push": true
+  },
+  "hooks": {
+    "before:bump": "cargo set-version ${version}"
+  },
+  "plugins": {
+    "@release-it/conventional-changelog": {
+      "preset": {
+        "name": "conventionalcommits",
+        "types": [
+          {
+            "type": "feat",
+            "section": "✨ Features"
+          },
+          {
+            "type": "fix",
+            "section": "🐛 Bug Fixes"
+          },
+          {
+            "type": "perf",
+            "section": "⚡️ Performance Improvements"
+          },
+          {
+            "type": "revert",
+            "section": "⏪️ Reverts"
+          },
+          {
+            "type": "docs",
+            "section": "📝 Documentation",
+            "hidden": true
+          },
+          {
+            "type": "chore",
+            "section": "🔧 Chores",
+            "hidden": true
+          }
+        ]
+      }
+    },
+    "@release-it/bumper": {
+      "out": [
+        {
+          "file": "CITATION.cff",
+          "path": "version",
+          "type": "text/yaml"
+        }
+      ]
+    }
+  }
+}

CITATION.cff

@@ -1,6 +1,6 @@
 cff-version: 1.2.0
 title: Portabase Agent (Rust)
-message: "If you use this software, please cite it as below."
+message: If you use this software, please cite it as below.
 type: software
 authors:
   - family-names: Gauthereau
@@ -9,7 +9,12 @@ authors:
     given-names: Killian
 repository-code: https://github.com/Portabase/agent-rust
 url: https://portabase.io
-abstract: "Portabase is a free, open-source, self-hosted solution for database administration, providing backup and restore capabilities, scheduling, retention policies, notifications, and support for multiple storage backends. Its headless agent architecture enables connection to multiple database instances securely and efficiently."
+abstract: >-
+  Portabase is a free, open-source, self-hosted solution for database
+  administration, providing backup and restore capabilities, scheduling,
+  retention policies, notifications, and support for multiple storage backends.
+  Its headless agent architecture enables connection to multiple database
+  instances securely and efficiently.
 keywords:
   - database
   - administration
@@ -22,5 +27,5 @@ keywords:
   - self-hosted
   - portabase
 license: Apache-2.0
-version: 1.0.4-rc.14
-date-released: "2026-01-28"
+version: 1.3.0
+date-released: '2026-02-24'

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "portabase-agent"
-version = "1.0.4-rc.14"
+version = "1.3.0"
 edition = "2024"
 
 [dependencies]
@@ -17,7 +17,7 @@ base64 = "0.22.1"
 thiserror = "2.0.17"
 log = "0.4.29"
 toml = "0.9.10"
-reqwest = { version = "0.13.1", features = ["json", "blocking", "multipart"] }
+reqwest = { version = "0.13.1", features = ["json", "blocking", "multipart", "stream", "query"] }
 anyhow = "1.0.100"
 tokio = { version = "1.49.0", features = ["rt", "rt-multi-thread", "macros", "fs"] }
 async-trait = "0.1.89"
@@ -28,11 +28,29 @@ flate2 = "1.1.5"
 tar = "0.4.44"
 tokio-postgres = "0.7.15"
 futures = "0.3.31"
-tracing-log = "0.2.0"
 tracing-appender = "0.2.4"
 time = { version = "0.3.44", features = ["macros"] }
 mongodb = "3.5.0"
+rand = "0.9.2"
+bytes = "1.11.0"
+async-stream = "0.3.6"
+uuid = { version = "1.20.0", features = ["v4"] }
+tokio-util = "0.7.18"
+aws-config = "1.8.13"
+aws-sdk-s3 = { version = "1.122.0", features = ["behavior-version-latest"] }
+async-compression = { version = "0.4.37", features = ["tokio", "gzip"] }
+tokio-tar = "0.3.1"
+oauth2 = "5.0.0"
+hyper = "1.8.1"
+async-http-client = "0.2.0"
+aes-gcm = "0.11.0-rc.3"
+generic-array = "0.14.7"
+futures-util = "0.3.31"
+tokio-stream = "0.1.18"
+aes = "0.9.0-rc.4"
+typenum = "1.19.0"
+
 
 [[bin]]
 name = "app"
-path = "src/main.rs"
+path = "src/main.rs"

Makefile

@@ -15,6 +15,10 @@ seed-mysql:
 	@echo "Seeding MySQL..."
 	mysql -h 127.0.0.1 -P "$$MYSQL_PORT" -u "$$MYSQL_USER" -p"$$MYSQL_PASSWORD" "$$MYSQL_DB" < ./scripts/mysql/seed-mysql.sql
 
+seed-mysql-1gb:
+	@echo "Seeding MySQL..."
+	mysql -h 127.0.0.1 -P "$$MYSQL_PORT" -u "$$MYSQL_USER" -p"$$MYSQL_PASSWORD" "$$MYSQL_DB" < ./scripts/mysql/seed-1gb.sql
+
 
 seed-postgres:
 	@echo "Seeding Postgres..."
@@ -26,4 +30,21 @@ seed-postgres-1gb:
 	docker exec -i -e PGPASSWORD=$$PG_PASSWORD $$PG_CONTAINER \
 		psql -U $$PG_USER -d $$PG_DB < ./scripts/postgres/seed-1gb.sql
 
+
+SQLITE_SEED_FILE := $(if $(filter big,$(SEED)),./scripts/sqlite/seed-big.sql,./scripts/sqlite/seed.sql)
+
+seed-sqlite:
+	@echo "Seeding Sqlite..."
+	@echo "Run as root to fix permissions inside the volume"
+	docker exec -u 0 -it db-sqlite sh -c "chmod -R 777 /workspace/data"
+	@echo "Create the database file (if it doesn’t exist)"
+	docker exec -u 0 -it db-sqlite sh -c "touch /workspace/data/app.db"
+	@echo "Seed the database"
+	docker exec -i db-sqlite sh -c "sqlite3 /workspace/data/app.db" < $(SQLITE_SEED_FILE)
+	@echo "Verify"
+	docker exec -it db-sqlite sqlite3 /workspace/data/app.db "SELECT name FROM sqlite_master WHERE type='table';"
+	@echo "Done"
+
+
+
 seed-all: seed-mongo seed-mysql seed-postgres seed-postgres-1gb

README.md

@@ -19,6 +19,7 @@
 [![PostgreSQL](https://img.shields.io/badge/python-3.13-blue.svg)](https://www.python.org/downloads/release/python-3120/)
 [![PostgreSQL](https://img.shields.io/badge/PostgreSQL-336791?logo=postgresql&logoColor=white)](https://www.postgresql.org/)
 [![MySQL](https://img.shields.io/badge/MySQL-4479A1?logo=mysql&logoColor=white)](https://www.mysql.com/)
+[![SQLite](https://img.shields.io/badge/-SQLite-blue?logo=sqlite&logoColor=white)](https://sqlite.org/)
 [![MariaDB](https://img.shields.io/badge/MariaDB-003545?logo=mariadb&logoColor=white)](https://mariadb.org/)
 [![MongoDB](https://img.shields.io/badge/-MongoDB-13aa52?logo=mongodb&logoColor=white)](https://www.mongodb.com/)
 [![Self Hosted](https://img.shields.io/badge/self--hosted-yes-brightgreen)](https://github.com/Portabase/portabase)
@@ -79,3 +80,5 @@ Distributed under the Apache License. See `LICENSE.txt` for more information.
 
 [Docker-url]: https://www.docker.com/
 
+
+

databases.json

@@ -34,11 +34,21 @@
       "name": "Test database 5 - MongoDB",
       "database": "testdb",
       "type": "mongodb",
-      "username": "",
-      "password": "",
       "port": 27017,
       "host": "db-mongodb",
       "generated_id": "16678147-ff7e-4c97-8c83-0adeff214681"
+    },
+    {
+      "name": "Test database 6 - SQLite DB",
+      "type": "sqlite",
+      "path": "/sqlite-data/workspace/data/app.db",
+      "generated_id": "16678178-ff7e-4c97-8c83-0adeff214681"
+    },
+    {
+      "name": "Test database 7 - SQLite DB",
+      "type": "sqlite",
+      "path": "/sqlite-data-2/workspace/data/app.db",
+      "generated_id": "16678179-ff7e-4c97-8c83-0adeff214681"
     }
   ]
 }

docker-compose.prod.yml

@@ -1,11 +1,11 @@
 services:
   rust-app:
-    build:
-      context: .
-      dockerfile: docker/Dockerfile
-      target: prod
-#    image: portabase/agent:latest
-    platform: linux/arm64
+#    build:
+#      context: .
+#      dockerfile: docker/Dockerfile
+#      target: prod
+    image: portabase/agent:latest
+#    platform: linux/arm64
     container_name: rust-prod
     volumes:
       - ./databases.json:/config/config.json
@@ -14,7 +14,7 @@ services:
       LOG: info
       TZ: "Europe/Paris"
       #      DATABASES_CONFIG_FILE: "config.toml"
-      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiY2VlZmNmNDQtOGE0YS00NjZlLTkwNDEtN2QzNDMzZjRjOTJkIiwicHVibGljS2V5IjoiLS0tLS1CRUdJTiBSU0EgUFVCTElDIEtFWS0tLS0tXG5NSUlCQ2dLQ0FRRUFuYUVKdnVBSExlNGF5d0RmNGplelVobm45VXRkdksyZ3pEMEg2cERJYXczYkJKRkpwVnVDXG5uVFV3MXA3Q2RnOXBzdjZhRnpyOXZPd0J2MjMzckxpdVpCT2lCb2p2Q0QrSlZid3hyTzBRRW5hN2dmaHV1ZGYwXG5VVlJOMkxmK1g1aTkvZzJTNm5xcExoTm1DaGFJNk8ybktYZUNlRmtubEErRUJrNnFoV1FCVGozb05TYTFTOFY1XG40UFRTT2I4NUo3a2k5YllEbXRiNWxrU3dCNXdXOTdtQjg0ZzI2WHAvU3FFcmhKc0NGK3YrN09vTWYzTzJqTTNoXG5XMUQ0MzBPRitWaklwUGdoV09rZy96NXZQUWFHRzhqQ0h4VDlJR0Q0bjhyS05LQ3FTOGNyN2diTGU0cWpNdmhvXG5BQVVvaHpHR2FRNkhlWlJ4S0UvM3J1a2JldnY5dnJ2TTNRSURBUUFCXG4tLS0tLUVORCBSU0EgUFVCTElDIEtFWS0tLS0tXG4ifQ"
+      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiOGZmMDE4NTQtYjJhMS00ZTE0LTkwMjctZTJiOWIxZjQ1YzdlIiwicHVibGljS2V5IjoiLS0tLS1CRUdJTiBSU0EgUFVCTElDIEtFWS0tLS0tXG5NSUlCQ2dLQ0FRRUE5TWV4M2pmdnVLdFB5YU1ERnh2Ulp2dmd3YkRJQ2JzQi81Wll5NDNSVVRBaXZRYjJiSDdYXG5qRHBQd1lJeCs4UFBrbHlRbDVMQzV1UWZEaCs4SVd4OG1LZ3FvMXpWMkdiZXdGbEdEWFYxVEdyU1ZEU25aSWR4XG52bWdYc29EeXhVMlJvWUFUMS9YMWxuc2YxenZKdkFMTkhXdEhRdk42SjVDZTFSMmFsendVRGFEVXlJNzRmSldQXG5tNTh0SDMrYklXL0VVTXdjaWNxM0oySWw3Vm9KNkZNUHJQL1ZSOWEvdFF1SU1qa200MXpFY2NscExPa2luRkxuXG54NmVUWkFSZUpya2UrbnRvZ2t4TGEyRWV5a1lUNzB4V3hKNWp5ZExBVnRvNkkyQlVLVVJoTkowTUFaU29NYUtvXG5iMGJRcnY1UzExZWllMnMrT2I3aTYzSFpkVUx0UmV1MVJ3SURBUUFCXG4tLS0tLUVORCBSU0EgUFVCTElDIEtFWS0tLS0tXG4ifQ"
     extra_hosts:
       - "localhost:host-gateway"
     networks:
@@ -22,6 +22,48 @@ services:
 
 
 
+  db-mongodb-auth:
+    container_name: db-mongodb-auth
+    image: mongo:latest
+    ports:
+      - "27082:27017"
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: root
+      MONGO_INITDB_ROOT_PASSWORD: rootpassword
+      MONGO_INITDB_DATABASE: testdbauth
+    command: mongod --auth
+    networks:
+      - portabase
+    volumes:
+      - mongodb-data-auth:/data/db
+    healthcheck:
+      test: [ "CMD", "mongo", "--eval", "db.adminCommand('ping')" ]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+
+  db-mongodb:
+    container_name: db-mongodb
+    image: mongo:latest
+    ports:
+      - "27083:27017"
+    volumes:
+      - mongodb-data:/data/db
+    healthcheck:
+      test: [ "CMD", "mongosh", "--eval", "db.adminCommand('ping')" ]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+    environment:
+      MONGO_INITDB_DATABASE: testdb
+    networks:
+      - portabase
+
+volumes:
+  mongodb-data:
+  mongodb-data-auth:
+
+
 networks:
   portabase:
     name: portabase_network

docker-compose.yml

@@ -11,12 +11,14 @@ services:
       #      - ./databases.toml:/config/config.toml
       - cargo-registry:/usr/local/cargo/registry
       - cargo-git:/usr/local/cargo/git
-      - cargo-target:/app/target
+      #      - cargo-target:/app/target
+#      - sqlite-data:/sqlite-data/workspace/data
+#      - ./scripts/sqlite/test-db:/sqlite-data-2/workspace/data
     environment:
       APP_ENV: development
       LOG: debug
       TZ: "Europe/Paris"
-      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiOGZmMDE4NTQtYjJhMS00ZTE0LTkwMjctZTJiOWIxZjQ1YzdlIiwicHVibGljS2V5IjoiLS0tLS1CRUdJTiBSU0EgUFVCTElDIEtFWS0tLS0tXG5NSUlCQ2dLQ0FRRUE5TWV4M2pmdnVLdFB5YU1ERnh2Ulp2dmd3YkRJQ2JzQi81Wll5NDNSVVRBaXZRYjJiSDdYXG5qRHBQd1lJeCs4UFBrbHlRbDVMQzV1UWZEaCs4SVd4OG1LZ3FvMXpWMkdiZXdGbEdEWFYxVEdyU1ZEU25aSWR4XG52bWdYc29EeXhVMlJvWUFUMS9YMWxuc2YxenZKdkFMTkhXdEhRdk42SjVDZTFSMmFsendVRGFEVXlJNzRmSldQXG5tNTh0SDMrYklXL0VVTXdjaWNxM0oySWw3Vm9KNkZNUHJQL1ZSOWEvdFF1SU1qa200MXpFY2NscExPa2luRkxuXG54NmVUWkFSZUpya2UrbnRvZ2t4TGEyRWV5a1lUNzB4V3hKNWp5ZExBVnRvNkkyQlVLVVJoTkowTUFaU29NYUtvXG5iMGJRcnY1UzExZWllMnMrT2I3aTYzSFpkVUx0UmV1MVJ3SURBUUFCXG4tLS0tLUVORCBSU0EgUFVCTElDIEtFWS0tLS0tXG4ifQ"
+      EDGE_KEY: "eyJzZXJ2ZXJVcmwiOiJodHRwOi8vbG9jYWxob3N0Ojg4ODciLCJhZ2VudElkIjoiNjI1MDQzY2YtN2MwMC00M2M4LWJjYzktZDM1MTk5ODk2ZGNkIiwibWFzdGVyS2V5QjY0IjoiQlhWM1hvbEM2NTZTVjdkTmdjV1BHUWxrKytycExJNmxHRGk3Q1BCNWllbz0ifQ=="
       #POOLING: 1
       #DATABASES_CONFIG_FILE: "config.toml"
     extra_hosts:
@@ -24,19 +26,19 @@ services:
     networks:
       - portabase
 
-#  db-postgres:
-#    container_name: db-postgres
-#    image: postgres:17-alpine
-#    ports:
-#      - "5436:5432"
-#    volumes:
-#      - postgres-data:/var/lib/postgresql/data
-#    environment:
-#      - POSTGRES_DB=devdb
-#      - POSTGRES_USER=devuser
-#      - POSTGRES_PASSWORD=changeme
-#    networks:
-#      - portabase
+  db-postgres:
+    container_name: db-postgres
+    image: postgres:17-alpine
+    ports:
+      - "5436:5432"
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    environment:
+      - POSTGRES_DB=devdb
+      - POSTGRES_USER=devuser
+      - POSTGRES_PASSWORD=changeme
+    networks:
+      - portabase
 #
 #  db-mariadb:
 #    container_name: db-mariadb
@@ -52,55 +54,66 @@ services:
 #      - mariadb-data:/var/lib/mysql
 #    networks:
 #      - portabase
+#
+#
+#  db-mongodb-auth:
+#    container_name: db-mongodb-auth
+#    image: mongo:latest
+#    ports:
+#      - "27082:27017"
+#    environment:
+#      MONGO_INITDB_ROOT_USERNAME: root
+#      MONGO_INITDB_ROOT_PASSWORD: rootpassword
+#      MONGO_INITDB_DATABASE: testdbauth
+#    command: mongod --auth
+#    networks:
+#      - portabase
+#    volumes:
+#      - mongodb-data-auth:/data/db
+#    healthcheck:
+#      test: [ "CMD", "mongo", "--eval", "db.adminCommand('ping')" ]
+#      interval: 5s
+#      timeout: 5s
+#      retries: 10
+#
+#  db-mongodb:
+#    container_name: db-mongodb
+#    image: mongo:latest
+#    ports:
+#      - "27083:27017"
+#    volumes:
+#      - mongodb-data:/data/db
+#    healthcheck:
+#      test: [ "CMD", "mongosh", "--eval", "db.adminCommand('ping')" ]
+#      interval: 5s
+#      timeout: 5s
+#      retries: 10
+#    environment:
+#      MONGO_INITDB_DATABASE: testdb
+#    networks:
+#      - portabase
 
+#  sqlite:
+#    container_name: db-sqlite
+#    image: keinos/sqlite3
+#    volumes:
+#      - sqlite-data:/workspace/data
+#    working_dir: /workspace
+#    command: tail -f /dev/null
+#    stdin_open: true
+#    tty: true
 
-  db-mongodb-auth:
-    container_name: db-mongodb-auth
-    image: mongo:latest
-    ports:
-      - "27082:27017"
-    environment:
-      MONGO_INITDB_ROOT_USERNAME: root
-      MONGO_INITDB_ROOT_PASSWORD: rootpassword
-      MONGO_INITDB_DATABASE: testdbauth
-    command: mongod --auth
-    networks:
-      - portabase
-    volumes:
-      - mongodb-data-auth:/data/db
-    healthcheck:
-      test: [ "CMD", "mongo", "--eval", "db.adminCommand('ping')" ]
-      interval: 5s
-      timeout: 5s
-      retries: 10
-
-  db-mongodb:
-    container_name: db-mongodb
-    image: mongo:latest
-    ports:
-      - "27083:27017"
-    volumes:
-      - mongodb-data:/data/db
-    healthcheck:
-      test: [ "CMD", "mongosh", "--eval", "db.adminCommand('ping')" ]
-      interval: 5s
-      timeout: 5s
-      retries: 10
-    environment:
-      MONGO_INITDB_DATABASE: testdb
-    networks:
-      - portabase
 
 volumes:
   cargo-registry:
   cargo-git:
-  cargo-target:
+  #  cargo-target:
 
-
-#  postgres-data:
+  postgres-data:
 #  mariadb-data:
-  mongodb-data:
-  mongodb-data-auth:
+#  mongodb-data:
+#  mongodb-data-auth:
+#  sqlite-data:
 
 networks:
   portabase:

docker/Dockerfile

@@ -15,6 +15,7 @@ RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
     zlib1g \
     curl \
     mariadb-client \
+    sqlite3 \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
@@ -58,7 +59,6 @@ FROM base AS dev
 
 RUN cargo install cargo-watch
 
-# Pre-cache dependencies
 COPY Cargo.toml Cargo.lock ./
 RUN mkdir src && echo "fn main() {}" > src/main.rs
 RUN cargo build
@@ -93,6 +93,7 @@ RUN apt-get update && apt-get install -y \
     libncurses6 \
     zlib1g \
     mariadb-client \
+    sqlite3 \
     && rm -rf /var/lib/apt/lists/*
 
 
@@ -110,126 +111,3 @@ COPY --from=base /usr/local/mongodb/bin/ /usr/local/mongodb/bin/
 ENV APP_ENV=production
 
 CMD ["/entrypoint.sh"]
-
-# =========================
-# Base image (shared)
-# =========================
-#FROM rust:1.92.0 AS base
-#
-#RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
-#    pkg-config \
-#    libssl-dev \
-#    tzdata \
-#    redis-server \
-#    ca-certificates \
-#    libpq5 \
-#    libreadline8 \
-#    libncurses6 \
-#    zlib1g \
-#    curl \
-#    mariadb-client \
-#    && apt-get clean \
-#    && rm -rf /var/lib/apt/lists/*
-#
-#ARG TARGETARCH
-#
-## =========================
-## PostgreSQL client binaries (versions 12-18)
-## =========================
-#RUN for v in 12 13 14 15 16 17 18; do mkdir -p /usr/lib/postgresql/$v/bin; done
-#
-#COPY assets/tools/amd64/postgresql/ /tmp/pg-x64/
-#COPY assets/tools/arm64/postgresql/ /tmp/pg-arm/
-#
-#RUN if [ "$TARGETARCH" = "amd64" ]; then \
-#        for v in 12 13 14 15 16 17 18; do \
-#            cp -r /tmp/pg-x64/postgresql-$v/bin/* /usr/lib/postgresql/$v/bin/; \
-#        done; \
-#    else \
-#        for v in 12 13 14 15 16 17 18; do \
-#            cp -r /tmp/pg-arm/postgresql-$v/bin/* /usr/lib/postgresql/$v/bin/; \
-#        done; \
-#    fi && \
-#    rm -rf /tmp/pg-x64 /tmp/pg-arm && \
-#    chmod +x /usr/lib/postgresql/*/bin/*
-#
-## =========================
-## MongoDB client binaries
-## =========================
-#COPY assets/tools/${TARGETARCH}/mongodb/ /usr/local/mongodb/
-#RUN chmod +x /usr/local/mongodb/bin/*
-#
-#WORKDIR /app
-#
-## =========================
-## Development image
-## =========================
-#FROM base AS dev
-#
-#RUN cargo install cargo-watch
-#
-#COPY Cargo.toml Cargo.lock ./
-#RUN mkdir src && echo "fn main() {}" > src/main.rs
-#RUN cargo build
-#RUN rm -rf src
-#
-#COPY entrypoint.sh /entrypoint.sh
-#RUN chmod +x /entrypoint.sh
-#
-#CMD ["/entrypoint.sh"]
-#
-## =========================
-## Builder (production)
-## =========================
-#FROM base AS builder
-#
-#ARG TARGETARCH
-#
-#RUN rustup target add x86_64-unknown-linux-gnu aarch64-unknown-linux-gnu
-#
-#COPY . .
-#
-#RUN if [ "$TARGETARCH" = "amd64" ]; then \
-#        cargo build --release --target x86_64-unknown-linux-gnu && \
-#        mv /app/target/x86_64-unknown-linux-gnu/release /app/target/release-app; \
-#    else \
-#        cargo build --release --target aarch64-unknown-linux-gnu && \
-#        mv /app/target/aarch64-unknown-linux-gnu/release /app/target/release-app; \
-#    fi
-#
-#
-#RUN echo "APP_VERSION=$(cargo pkgid | awk -F# '{print $2}')" > /app/version.env
-#
-## =========================
-## Runtime (production)
-## =========================
-#FROM ubuntu:24.04 AS prod
-#
-#RUN apt-get update && apt-get install -y \
-#    redis-server \
-#    ca-certificates \
-#    tzdata \
-#    libpq5 \
-#    libreadline8 \
-#    libncurses6 \
-#    zlib1g \
-#    mariadb-client \
-#    && rm -rf /var/lib/apt/lists/*
-#
-#WORKDIR /app
-#
-#ARG TARGETARCH
-#
-#COPY --from=builder /app/target/release-app/app /usr/local/bin/app
-#
-#COPY --from=builder /app/version.env /app/version.env
-#COPY entrypoint.sh /entrypoint.sh
-#RUN chmod +x /entrypoint.sh
-#
-#COPY --from=base /usr/lib/postgresql/ /usr/lib/postgresql/
-#COPY --from=base /usr/local/mongodb/bin/ /usr/local/mongodb/bin/
-#
-#ENV APP_ENV=production
-#
-#CMD ["/entrypoint.sh"]
-

helm/.helmignore

@@ -0,0 +1,17 @@
+.DS_Store
+.git/
+.gitignore
+.bzr/
+.bzrignore
+.hg/
+.hgignore
+.svn/
+*.swp
+*.bak
+*.tmp
+*.orig
+*~
+.project
+.idea/
+*.tmproj
+.vscode/

helm/Chart.yaml

@@ -0,0 +1,29 @@
+apiVersion: v2
+name: portabase-agent
+description: Helm chart for Portabase Agent
+type: application
+version: 0.0.0
+appVersion: "latest"
+keywords:
+  - postgresql
+  - mariadb
+  - mongodb
+  - mysql
+  - sqlite
+  - backup
+  - database
+  - restore
+  - agent
+home: https://github.com/Portabase/agent
+
+sources:
+  - https://github.com/Portabase/agent
+  - https://github.com/Portabase/agent/tree/main/helm
+
+maintainers:
+  - name: Charles Gauthereau
+    url: https://github.com/RambokDev
+  - name: Killian Larcher
+    url: https://github.com/KillianLarcher
+
+icon: https://raw.githubusercontent.com/Portabase/agent/main/.github/assets/logo.png

helm/README.md

@@ -0,0 +1,59 @@
+# Development Notes
+
+## Check that Kubernetes is reachable locally
+
+```bash
+kubectl get nodes
+```
+
+## Install the local Portabase Agent Helm chart
+
+```bash
+helm install portabase-agent . \ 
+--set env.EDGE_KEY=<your-edge-key>
+```
+
+## Check the pods
+
+```bash
+kubectl get pods
+```
+
+## Check the services
+
+```bash
+kubectl get svc
+```
+
+## To update .env variables or JSON config:
+```bash
+kubectl rollout restart deployment portabase-agent
+```
+
+## Install or upgrade the Helm chart
+```bash
+helm upgrade portabase-agent . \
+--reuse-values \
+--set env.EDGE_KEY="NEW_EDGE_KEY"
+```
+
+## Rollout  to restart
+```bash 
+kubectl rollout restart deployment portabase-agent
+```
+
+## List pods to get the pod name 
+
+```bash
+kubectl get pods -l app=portabase-agent
+```
+
+## Get logs for the pod
+```bash
+kubectl logs portabase-agent-6f7d4f5c6b-abc12
+```
+
+## Uninstall Agent
+``` bash
+helm uninstall portabase-agent
+```

helm/templates/configmap.yaml

@@ -0,0 +1,7 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: portabase-agent-config
+data:
+  config.json: |
+{{ .Values.volume.configFile.content | nindent 4 }}

helm/templates/deployment.yaml

@@ -0,0 +1,62 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: portabase-agent
+  labels:
+    app: portabase-agent
+spec:
+  replicas: {{ .Values.replicaCount }}
+  selector:
+    matchLabels:
+      app: portabase-agent
+  template:
+    metadata:
+      labels:
+        app: portabase-agent
+    spec:
+      hostAliases:
+      {{- range .Values.network.hostAliases }}
+        - ip: {{ .ip }}
+          hostnames:
+        {{- range .hostnames }}
+            - {{ . }}
+        {{- end }}
+      {{- end }}
+      containers:
+        - name: portabase-agent
+          image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
+          imagePullPolicy: {{ .Values.image.pullPolicy }}
+          envFrom:
+            - configMapRef:
+                name: portabase-agent-env
+          volumeMounts:
+            {{- if .Values.volume.configFile.enabled }}
+              {{- if .Values.volume.configFile.hostPath }}
+            - name: config
+              mountPath: /config/config.json
+              subPath: config.json
+              readOnly: true
+              # uses hostPath
+              {{- else }}
+            - name: config
+              mountPath: /config/config.json
+              subPath: config.json
+              # uses ConfigMap content
+              {{- end }}
+            {{- end }}
+      volumes:
+        {{- if .Values.volume.configFile.enabled }}
+          {{- if .Values.volume.configFile.hostPath }}
+        - name: config
+          hostPath:
+            path: {{ .Values.volume.configFile.hostPath }}
+            type: File
+          {{- else }}
+        - name: config
+          configMap:
+            name: portabase-agent-config
+            items:
+              - key: config.json
+                path: config.json
+          {{- end }}
+        {{- end }}

helm/templates/env-configmap.yaml

@@ -0,0 +1,10 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: portabase-agent-env
+data:
+  EDGE_KEY: {{ .Values.env.EDGE_KEY | quote }}
+  TZ: {{ .Values.env.TZ | quote }}
+  POLLING: {{ .Values.env.POLLING | quote }}
+  APP_ENV: {{ .Values.env.APP_ENV | quote }}
+  LOG: {{ .Values.env.LOG | quote }}

helm/values.yaml

@@ -0,0 +1,48 @@
+replicaCount: 1
+
+image:
+  repository: portabase/agent
+  tag: latest
+  pullPolicy: IfNotPresent
+
+env:
+  EDGE_KEY: "your_edge_key_here"
+  TZ: "UTC"
+  POLLING: "5"
+  APP_ENV: "production"
+  LOG: "info"
+
+resources:
+  limits:
+    cpu: 500m
+    memory: 512Mi
+  requests:
+    cpu: 250m
+    memory: 256Mi
+
+volume:
+  configFile:
+    enabled: true
+    hostPath: ""         # Use host file if set, otherwise use `content`
+    content: |           # JSON content for config.json if no hostPath
+      {
+        "databases": [
+          {
+            "name": "my-site-prod (readable name)",
+            "database": "devdb",
+            "type": "postgresql",
+            "host": "localhost",
+            "port": 5432,
+            "username": "admin_prod",
+            "password": "super_secure_password",
+            "generated_id": "550e8400-e29b-41d4-a716-446655440000"
+          }
+        ]
+      }
+
+
+network:
+  hostAliases:
+    - ip: "127.0.0.1"
+      hostnames:
+        - "localhost"

release

@@ -1,99 +0,0 @@
-#!/bin/bash
-
-set -e
-
-if [ -z "$1" ]; then
-  echo "Usage: ./release <version>"
-  echo "Example: ./release v1.0.0"
-  exit 1
-fi
-
-VERSION=$1
-CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
-
-if [ "$CURRENT_BRANCH" = "main" ]; then
-  if [[ ! "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-    echo "Error: On 'main' branch, only release tags (X.Y.Z) are allowed."
-    exit 1
-  fi
-else
-  if [[ ! "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+-rc\.[0-9]+$ ]]; then
-    echo "Error: On branch '$CURRENT_BRANCH', only RC tags matching X.Y.Z-rc.W are allowed (e.g., 1.0.0-rc.1)."
-    exit 1
-  fi
-fi
-
-CLEAN_VERSION=${VERSION#v}
-CURRENT_DATE=$(date +%Y-%m-%d)
-
-echo "Preparing release $VERSION..."
-
-
-# package.json
-if [ -f package.json ]; then
-  echo "Updating package.json..."
-  if sed --version >/dev/null 2>&1; then
-    sed -i "s/\"version\": \".*\"/\"version\": \"$CLEAN_VERSION\"/" package.json
-  else
-    sed -i '' "s/\"version\": \".*\"/\"version\": \"$CLEAN_VERSION\"/" package.json
-  fi
-fi
-
-# pyproject.toml
-if [ -f pyproject.toml ]; then
-  echo "Updating pyproject.toml..."
-  if sed --version >/dev/null 2>&1; then
-    sed -i "s/^version = \".*\"/version = \"$CLEAN_VERSION\"/" pyproject.toml
-  else
-    sed -i '' "s/^version = \".*\"/version = \"$CLEAN_VERSION\"/" pyproject.toml
-  fi
-fi
-
-# Cargo.toml
-if [ -f Cargo.toml ]; then
-  echo "Updating Cargo.toml..."
-  if sed --version >/dev/null 2>&1; then
-    sed -i "s/^version = \".*\"/version = \"$CLEAN_VERSION\"/" Cargo.toml
-  else
-    sed -i '' "s/^version = \".*\"/version = \"$CLEAN_VERSION\"/" Cargo.toml
-  fi
-fi
-
-# CITATION.cff
-if [ -f CITATION.cff ]; then
-  echo "Updating CITATION.cff..."
-  if sed --version >/dev/null 2>&1; then
-    sed -i "s/^version: .*/version: $CLEAN_VERSION/" CITATION.cff
-    sed -i "s/^date-released: .*/date-released: \"$CURRENT_DATE\"/" CITATION.cff
-  else
-    sed -i '' "s/^version: .*/version: $CLEAN_VERSION/" CITATION.cff
-    sed -i '' "s/^date-released: .*/date-released: \"$CURRENT_DATE\"/" CITATION.cff
-  fi
-fi
-
-
-
-
-
-git add .
-
-if ! git diff-index --quiet HEAD --; then
-  echo "Committing changes..."
-  git commit -m "chore(release): $VERSION"
-else
-  echo "No changes to commit. Proceeding to tag..."
-fi
-
-if git rev-parse "$VERSION" >/dev/null 2>&1; then
-    echo "Tag $VERSION already exists. Aborting."
-    exit 1
-fi
-
-echo "Creating tag $VERSION..."
-git tag -a "$VERSION" -m "Release $VERSION"
-
-echo "Pushing changes and tags to remote..."
-git push
-git push origin "$VERSION"
-
-echo "Successfully released $VERSION!"

scripts/README.md

@@ -1,12 +1,26 @@
 # Seed instructions
 
-## MongoDB 
 
 ```bash
 make seed-mongo     
 make seed-mongo-auth  
 make seed-mysql      
+make seed-mysql-1gb    
 make seed-postgres      
 make seed-postgres-1gb  
-make seed-all      
+make seed-all   
+make seed-sqlite   
+make seed-sqlite SEED=big   
+```
+
+## Verify commands 
+
+### Sqlite
+
+```bash
+docker exec -it db-sqlite sqlite3 /workspace/data/app.db "SELECT * FROM users LIMIT 10;"  
+```
+
+```bash
+docker exec -it db-sqlite sqlite3 /workspace/data/app.db "SELECT name FROM sqlite_master WHERE type='table';"
 ```

scripts/mysql/seed-1gb.sql

@@ -0,0 +1,53 @@
+CREATE DATABASE IF NOT EXISTS mariadb;
+USE mariadb;
+
+DROP TABLE IF EXISTS users;
+DROP TABLE IF EXISTS products;
+
+CREATE TABLE users (
+                       id BIGINT AUTO_INCREMENT PRIMARY KEY,
+                       username VARCHAR(50) NOT NULL UNIQUE,
+                       email VARCHAR(100) NOT NULL UNIQUE,
+                       password VARCHAR(255) NOT NULL,
+                       created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+) ENGINE=InnoDB;
+
+CREATE TABLE products (
+                          id BIGINT AUTO_INCREMENT PRIMARY KEY,
+                          name VARCHAR(100) NOT NULL,
+                          description MEDIUMTEXT,
+                          price DECIMAL(10,2) NOT NULL,
+                          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+) ENGINE=InnoDB;
+
+
+DELIMITER $$
+
+DROP PROCEDURE IF EXISTS seed_data$$
+CREATE PROCEDURE seed_data()
+BEGIN
+    DECLARE i BIGINT DEFAULT 1;
+    DECLARE j BIGINT;
+    DECLARE large_text TEXT;
+
+    SET large_text = REPEAT('Lorem ipsum dolor sit amet, consectetur adipiscing elit. ', 300);
+
+    WHILE i <= 200000 DO
+        INSERT INTO users (username, email, password)
+        VALUES (CONCAT('user', i), CONCAT('user', i, '@example.com'), 'changeme');
+        SET i = i + 1;
+END WHILE;
+
+    SET i = 1;
+    WHILE i <= 200000 DO
+        INSERT INTO products (name, description, price)
+        VALUES (CONCAT('Product ', i), large_text, ROUND(RAND()*1000,2));
+        SET i = i + 1;
+END WHILE;
+END$$
+
+DELIMITER ;
+
+CALL seed_data();
+
+DROP PROCEDURE IF EXISTS seed_data;

scripts/postgres/seed-1gb.sql

@@ -60,7 +60,7 @@ SELECT
     )
 FROM users u
          JOIN generate_series(1, 30) AS p(post_no)
-              ON u.id <= 300000;
+              ON u.id <= 500000;
 
 -- ============================================================
 -- OPTIONAL: FORCE DISK MATERIALIZATION

scripts/sqlite/seed-big.sql

@@ -0,0 +1,74 @@
+PRAGMA foreign_keys = ON;
+BEGIN TRANSACTION;
+
+-- Drop tables
+DROP TABLE IF EXISTS users;
+DROP TABLE IF EXISTS projects;
+DROP TABLE IF EXISTS tasks;
+
+-- Users
+CREATE TABLE users (
+                       id INTEGER PRIMARY KEY AUTOINCREMENT,
+                       email TEXT NOT NULL UNIQUE,
+                       full_name TEXT NOT NULL,
+                       role TEXT NOT NULL CHECK (role IN ('admin','manager','user')),
+                       created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Projects
+CREATE TABLE projects (
+                          id INTEGER PRIMARY KEY AUTOINCREMENT,
+                          name TEXT NOT NULL,
+                          description TEXT,
+                          owner_id INTEGER NOT NULL,
+                          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+                          FOREIGN KEY (owner_id) REFERENCES users(id) ON DELETE CASCADE
+);
+
+-- Tasks
+CREATE TABLE tasks (
+                       id INTEGER PRIMARY KEY AUTOINCREMENT,
+                       project_id INTEGER NOT NULL,
+                       title TEXT NOT NULL,
+                       status TEXT NOT NULL CHECK (status IN ('todo','in_progress','done')),
+                       priority INTEGER NOT NULL DEFAULT 3,
+                       due_date TEXT,
+                       created_at TEXT NOT NULL DEFAULT (datetime('now')),
+                       FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+);
+
+-- Seed minimal users
+INSERT INTO users (email, full_name, role) VALUES
+                                               ('admin@example.com', 'System Admin', 'admin'),
+                                               ('manager@example.com', 'Project Manager', 'manager'),
+                                               ('user@example.com', 'Standard User', 'user');
+
+-- Generate 10_000 projects
+WITH RECURSIVE numbers(x) AS (
+    SELECT 1
+    UNION ALL
+    SELECT x+1 FROM numbers WHERE x<10000
+)
+INSERT INTO projects (name, description, owner_id)
+SELECT
+    'Project #' || x,
+    'Auto-generated project description for project #' || x,
+    (1 + (x % 3)) -- cycle users 1..3
+FROM numbers;
+
+-- Generate 100_000 tasks
+WITH RECURSIVE numbers(x) AS (
+    SELECT 1
+    UNION ALL
+    SELECT x+1 FROM numbers WHERE x<100000
+)
+INSERT INTO tasks (project_id, title, status, priority, due_date)
+SELECT
+    (1 + (x % 10000)), -- project id cycle
+    'Task #' || x,
+    CASE (x % 3) WHEN 0 THEN 'todo' WHEN 1 THEN 'in_progress' ELSE 'done' END,
+    1 + (x % 5),
+    date('now', '+' || (x % 30) || ' days')
+FROM numbers;
+
+COMMIT;

scripts/sqlite/seed.sql

@@ -0,0 +1,59 @@
+PRAGMA foreign_keys = ON;
+
+BEGIN TRANSACTION;
+
+-- Drop existing tables (idempotent reset)
+DROP TABLE IF EXISTS users;
+DROP TABLE IF EXISTS projects;
+DROP TABLE IF EXISTS tasks;
+
+-- Users
+CREATE TABLE users (
+                       id INTEGER PRIMARY KEY AUTOINCREMENT,
+                       email TEXT NOT NULL UNIQUE,
+                       full_name TEXT NOT NULL,
+                       role TEXT NOT NULL CHECK (role IN ('admin','manager','user')),
+                       created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Projects
+CREATE TABLE projects (
+                          id INTEGER PRIMARY KEY AUTOINCREMENT,
+                          name TEXT NOT NULL,
+                          description TEXT,
+                          owner_id INTEGER NOT NULL,
+                          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+                          FOREIGN KEY (owner_id) REFERENCES users(id) ON DELETE CASCADE
+);
+
+-- Tasks
+CREATE TABLE tasks (
+                       id INTEGER PRIMARY KEY AUTOINCREMENT,
+                       project_id INTEGER NOT NULL,
+                       title TEXT NOT NULL,
+                       status TEXT NOT NULL CHECK (status IN ('todo','in_progress','done')),
+                       priority INTEGER NOT NULL DEFAULT 3,
+                       due_date TEXT,
+                       created_at TEXT NOT NULL DEFAULT (datetime('now')),
+                       FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+);
+
+-- Seed users
+INSERT INTO users (email, full_name, role) VALUES
+                                               ('admin@example.com', 'System Admin', 'admin'),
+                                               ('manager@example.com', 'Project Manager', 'manager'),
+                                               ('user@example.com', 'Standard User', 'user');
+
+-- Seed projects
+INSERT INTO projects (name, description, owner_id) VALUES
+                                                       ('Internal Tooling', 'Backoffice automation platform', 2),
+                                                       ('Client Portal', 'Customer-facing SaaS interface', 2);
+
+-- Seed tasks
+INSERT INTO tasks (project_id, title, status, priority, due_date) VALUES
+                                                                      (1, 'Define architecture', 'done', 1, date('now', '+3 days')),
+                                                                      (1, 'Implement authentication', 'in_progress', 1, date('now', '+7 days')),
+                                                                      (2, 'Design landing page', 'todo', 2, date('now', '+5 days')),
+                                                                      (2, 'Setup CI/CD', 'todo', 2, date('now', '+10 days'));
+
+COMMIT;

src/core/agent.rs

@@ -52,7 +52,7 @@ impl Agent {
             if db.data.backup.action {
                 let _ = self
                     .backup_service
-                    .dispatch(&db.generated_id, &config, method.clone())
+                    .dispatch(&db.generated_id, &config, method.clone(), &db.storages, db.encrypt)
                     .await;
             } else if db.data.restore.action {
                 let _ = self

src/core/context.rs

@@ -1,3 +1,4 @@
+use crate::services::api::ApiClient;
 use crate::settings::CONFIG;
 use crate::utils::edge_key::{EdgeKey, EdgeKeyError, decode_edge_key};
 use tracing::{debug, error, info};
@@ -6,6 +7,7 @@ use tracing::{debug, error, info};
 pub struct Context {
     #[allow(dead_code)]
     pub edge_key: EdgeKey,
+    pub api: ApiClient,
 }
 
 impl Context {
@@ -33,7 +35,13 @@ impl Context {
                 panic!("Cannot initialize AgentContext due to invalid EDGE_KEY");
             }
         };
+        
+        let server_url = format!("{}/api", edge_key.server_url);
+        let api_client = ApiClient::new(server_url);
 
-        Context { edge_key }
+        Context {
+            edge_key: edge_key,
+            api: api_client,
+        }
     }
 }

src/domain/factory.rs

@@ -6,6 +6,7 @@ use crate::services::config::{DatabaseConfig, DbType};
 use anyhow::Result;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
+use crate::domain::sqlite::database::SqliteDatabase;
 
 #[async_trait::async_trait]
 pub trait Database: Send + Sync {
@@ -27,6 +28,7 @@ impl DatabaseFactory {
             DbType::Mysql => Arc::new(MySQLDatabase::new(cfg)),
             DbType::Mariadb => Arc::new(MySQLDatabase::new(cfg)),
             DbType::MongoDB => Arc::new(MongoDatabase::new(cfg)),
+            DbType::Sqlite => Arc::new(SqliteDatabase::new(cfg)),
         }
     }
 
@@ -39,6 +41,7 @@ impl DatabaseFactory {
             DbType::Mysql => Arc::new(MySQLDatabase::new(cfg)),
             DbType::Mariadb => Arc::new(MySQLDatabase::new(cfg)),
             DbType::MongoDB => Arc::new(MongoDatabase::new(cfg)),
+            DbType::Sqlite => Arc::new(SqliteDatabase::new(cfg)),
         }
     }
 }

src/domain/mod.rs

@@ -2,4 +2,5 @@ pub mod factory;
 pub mod postgres;
 pub mod mysql;
 mod mongodb;
+mod sqlite;
 

src/domain/mongodb/backup.rs

@@ -15,7 +15,7 @@ pub async fn run(
 
         let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
         let mongodump = select_mongo_path().join("mongodump");
-        let uri = get_mongo_uri(cfg.clone());
+        let uri = get_mongo_uri(cfg.clone())?;
 
         let output = Command::new(mongodump)
             .arg(format!("--uri={}", uri))

src/domain/mongodb/connection.rs

@@ -3,7 +3,7 @@ use anyhow::Result;
 use mongodb::Client;
 
 pub async fn connect(cfg: DatabaseConfig) -> Result<Client> {
-    let uri = get_mongo_uri(cfg);
+    let uri = get_mongo_uri(cfg)?;
     let mut options = mongodb::options::ClientOptions::parse(&uri).await?;
     options.server_selection_timeout = Some(std::time::Duration::from_secs(3));
     options.connect_timeout = Some(std::time::Duration::from_secs(3));
@@ -15,14 +15,16 @@ pub fn select_mongo_path() -> std::path::PathBuf {
     "/usr/local/mongodb/bin".to_string().into()
 }
 
-pub fn get_mongo_uri(cfg: DatabaseConfig) -> String {
-    if cfg.username.is_empty() {
-        format!("mongodb://{}:{}/{}", cfg.host, cfg.port, cfg.database)
+pub fn get_mongo_uri(cfg: DatabaseConfig) -> Result<String> {
 
+    if cfg.username.is_empty() || cfg.password.is_empty() {
+        Ok(format!("mongodb://{}:{}/{}", cfg.host, cfg.port, cfg.database))
     } else {
-        format!(
+        Ok(format!(
             "mongodb://{}:{}@{}:{}/{}?authSource=admin",
             cfg.username, cfg.password, cfg.host, cfg.port, cfg.database
-        )
+        ))
     }
 }
+
+

src/domain/mongodb/ping.rs

@@ -1,14 +1,20 @@
 #![allow(dead_code)]
 
+use crate::domain::mongodb::connection::connect;
 use crate::services::config::DatabaseConfig;
 use anyhow::Result;
 use mongodb::bson::doc;
-use tracing::{error};
-use crate::domain::mongodb::connection::connect;
+use tracing::error;
 
 pub async fn run(cfg: DatabaseConfig) -> Result<bool> {
     let client = connect(cfg.clone()).await?;
-    let db_name = if cfg.username.is_empty() { &cfg.database } else { "admin" };
+
+    let db_name = if cfg.username.is_empty() && cfg.password.is_empty() {
+        &cfg.database
+    } else {
+        "admin"
+    };
+
     match client.database(db_name).run_command(doc! {"ping": 1}).await {
         Ok(_) => Ok(true),
         Err(e) => {

src/domain/mongodb/restore.rs

@@ -10,7 +10,7 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
         debug!("Starting MongoDB restore for database {}", cfg.name);
 
         let mongorestore = select_mongo_path().join("mongorestore");
-        let uri = get_mongo_uri(cfg.clone());
+        let uri = get_mongo_uri(cfg.clone())?;
 
         let output = Command::new(mongorestore)
             .arg(format!("--uri={}", uri))

src/domain/mysql/backup.rs

@@ -1,4 +1,4 @@
-use crate::domain::mysql::connection::server_version;
+use crate::domain::mysql::connection::{server_version};
 use crate::services::config::DatabaseConfig;
 use anyhow::{Context, Result};
 use std::collections::HashMap;

src/domain/mysql/connection.rs

@@ -3,6 +3,7 @@ use std::process::Command;
 use anyhow::Result;
 
 pub async fn server_version(cfg: &DatabaseConfig) -> Result<String> {
+
     let output = Command::new("mysql")
         .arg("--host").arg(&cfg.host)
         .arg("--port").arg(cfg.port.to_string())
@@ -25,3 +26,4 @@ pub async fn server_version(cfg: &DatabaseConfig) -> Result<String> {
 
     Ok(version)
 }
+

src/domain/mysql/database.rs

@@ -21,7 +21,7 @@ impl MySQLDatabase {
 
     fn build_env(&self) -> HashMap<String, String> {
         let mut envs = std::env::vars().collect::<HashMap<_, _>>();
-        envs.insert("MYSQL_PWD".to_string(), self.cfg.password.clone());
+        envs.insert("MYSQL_PWD".to_string(), self.cfg.password.to_string());
         envs
     }
 }

src/domain/mysql/ping.rs

@@ -1,19 +1,27 @@
 use crate::services::config::DatabaseConfig;
-use anyhow::Context;
 use std::collections::HashMap;
-use std::process::Command;
+use tokio::process::Command;
+use tokio::time::{Duration, timeout};
 
 pub async fn run(cfg: DatabaseConfig, env: HashMap<String, String>) -> anyhow::Result<bool> {
-    let output = Command::new("mysqladmin")
-        .arg("--host")
+
+    let mut cmd = Command::new("mysqladmin");
+    cmd.arg("--host")
         .arg(cfg.host)
         .arg("--port")
         .arg(cfg.port.to_string())
         .arg("--user")
         .arg(cfg.username)
         .arg("ping")
-        .envs(env)
-        .output()
-        .with_context(|| format!("Failed to ping MySQL server {}", cfg.name))?;
-    Ok(output.status.success())
+        .envs(env);
+
+    let result = timeout(Duration::from_secs(10), cmd.output()).await;
+
+    match result {
+        Ok(output) => {
+            let output = output?;
+            Ok(output.status.success())
+        }
+        Err(_) => Ok(false),
+    }
 }

src/domain/mysql/restore.rs

@@ -1,11 +1,10 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
 use std::fs::File;
 use std::io::{Read, Write};
-use anyhow::{Context, Result};
-use tracing::{debug, error, info};
 use std::path::PathBuf;
 use std::process::Command;
-
-use crate::services::config::DatabaseConfig;
+use tracing::{debug, error, info};
 
 pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
     let handle = tokio::task::spawn_blocking(move || -> Result<()> {
@@ -55,7 +54,8 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
             .with_context(|| format!("Failed to start mysql restore for {}", cfg.name))?;
 
         let mut stdin = child.stdin.take().context("Failed to open child stdin")?;
-        stdin.write_all(sql_content.as_bytes())
+        stdin
+            .write_all(sql_content.as_bytes())
             .context("Failed to write SQL content to mysql stdin")?;
         stdin.flush()?;
         drop(stdin);
@@ -74,8 +74,7 @@ pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
         Ok(())
     });
 
-    handle
-        .await??;
+    handle.await??;
 
     Ok(())
 }

src/domain/postgres/backup.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
-use tracing::{debug, error, info};
 use std::path::PathBuf;
 use std::process::Command;
+use tracing::{debug, error, info};
 
 use super::connection::{select_pg_path, server_version};
 use super::format::PostgresDumpFormat;

src/domain/postgres/connection.rs

@@ -1,11 +1,12 @@
-use std::path::Path;
 use crate::domain::postgres::format::PostgresDumpFormat;
 use crate::services::config::DatabaseConfig;
 use anyhow::Result;
+use std::path::Path;
 use tokio_postgres::{Client, NoTls};
-use tracing::info;
+use tracing::{error, info};
 
 pub async fn connect(cfg: &DatabaseConfig) -> Result<Client> {
+    info!("Connecting to postgres database {}:{}", cfg.host, cfg.port);
     let dsn = format!(
         "host={} port={} user={} password={} dbname={}",
         cfg.host, cfg.port, cfg.username, cfg.password, cfg.database
@@ -14,7 +15,7 @@ pub async fn connect(cfg: &DatabaseConfig) -> Result<Client> {
     let (client, connection) = tokio_postgres::connect(&dsn, NoTls).await?;
     tokio::spawn(async move {
         if let Err(e) = connection.await {
-            tracing::error!("Postgres connection error: {}", e);
+            error!("Postgres connection error: {}", e);
         }
     });
     Ok(client)
@@ -34,7 +35,7 @@ pub fn select_pg_path(version: &str) -> std::path::PathBuf {
 
 pub async fn terminate_connections(cfg: &DatabaseConfig) -> Result<()> {
     let mut admin = cfg.clone();
-    admin.database = "postgres".into();
+    admin.database = "postgres".to_string().into();
 
     let client = connect(&admin).await?;
 

src/domain/postgres/database.rs

@@ -28,7 +28,6 @@ impl Database for PostgresDatabase {
         match self.format {
             PostgresDumpFormat::Fc => ".dump",
             PostgresDumpFormat::Fd => ".gz",
-            // PostgresDumpFormat::Fd => ".tar.gz",
         }
     }
 
@@ -40,7 +39,6 @@ impl Database for PostgresDatabase {
         FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
         let res = backup::run(self.cfg.clone(), self.format, dir.to_path_buf()).await;
         FileLock::release(&self.cfg.generated_id).await?;
-
         res
     }
 

src/domain/postgres/restore.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
-use tracing::{debug, error, info};
 use std::path::PathBuf;
 use std::process::Command;
+use tracing::{debug, error, info};
 
 use super::connection::{select_pg_path, server_version, terminate_connections};
 use super::format::PostgresDumpFormat;
@@ -14,6 +14,7 @@ pub async fn run(
 ) -> Result<()> {
     tokio::task::spawn_blocking(move || -> Result<()> {
         debug!("Starting restore for database {}", cfg.name);
+
         let version = match futures::executor::block_on(server_version(&cfg)) {
             Ok(v) => {
                 debug!("Postgres version detected: {}", v);
@@ -86,6 +87,8 @@ pub async fn run(
                     }
                 };
 
+                info!("tar_gz {:?}", tar_gz);
+
                 let dec = flate2::read::GzDecoder::new(tar_gz);
                 let mut archive = tar::Archive::new(dec);
 
@@ -106,6 +109,7 @@ pub async fn run(
                 }
 
                 debug!("Listing contents of temp dir: {}", tmp_dir.path().display());
+
                 for entry in std::fs::read_dir(tmp_dir.path())? {
                     if let Ok(entry) = entry {
                         let path = entry.path();

src/domain/sqlite/backup.rs

@@ -0,0 +1,45 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use std::path::PathBuf;
+use std::process::Command;
+use tracing::{debug, error, info};
+
+pub async fn run(
+    cfg: DatabaseConfig,
+    backup_dir: PathBuf,
+    file_extension: &'static str,
+) -> Result<PathBuf> {
+    tokio::task::spawn_blocking(move || -> Result<PathBuf> {
+        debug!("Starting SQLite backup for database {}", cfg.name);
+
+        let db_path_str = if cfg.path.is_empty() {
+            anyhow::bail!("Database path not configured");
+        } else {
+            cfg.path.as_str().to_string()
+        };
+
+        let db_path = PathBuf::from(db_path_str);
+
+        if !db_path.exists() {
+            anyhow::bail!("SQLite database file not found: {}", db_path.display());
+        }
+
+        let file_path = backup_dir.join(format!("{}{}", cfg.generated_id, file_extension));
+
+        let output = Command::new("sqlite3")
+            .arg(db_path.as_os_str())
+            .arg(format!(".backup '{}'", file_path.display()))
+            .output()
+            .context("SQLite backup command failed to start")?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            error!("SQLite backup failed for {}: {}", cfg.name, stderr);
+            anyhow::bail!("SQLite backup failed for {}: {}", cfg.name, stderr);
+        }
+
+        info!("SQLite backup completed for {}", cfg.name);
+        Ok(file_path)
+    })
+        .await?
+}

src/domain/sqlite/database.rs

@@ -0,0 +1,43 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use std::path::{Path, PathBuf};
+
+use super::{backup, ping, restore};
+use crate::domain::factory::Database;
+use crate::services::config::DatabaseConfig;
+use crate::utils::locks::{DbOpLock, FileLock};
+
+pub struct SqliteDatabase {
+    cfg: DatabaseConfig,
+}
+
+impl SqliteDatabase {
+    pub fn new(cfg: DatabaseConfig) -> Self {
+        Self { cfg }
+    }
+}
+
+#[async_trait]
+impl Database for SqliteDatabase {
+    fn file_extension(&self) -> &'static str {
+        ".backup"
+    }
+
+    async fn ping(&self) -> Result<bool> {
+        ping::run(self.cfg.clone()).await
+    }
+
+    async fn backup(&self, dir: &Path) -> Result<PathBuf> {
+        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Backup.as_str()).await?;
+        let res = backup::run(self.cfg.clone(), dir.to_path_buf(), self.file_extension()).await;
+        FileLock::release(&self.cfg.generated_id).await?;
+        res
+    }
+
+    async fn restore(&self, file: &Path) -> Result<()> {
+        FileLock::acquire(&self.cfg.generated_id, DbOpLock::Restore.as_str()).await?;
+        let res = restore::run(self.cfg.clone(), file.to_path_buf()).await;
+        FileLock::release(&self.cfg.generated_id).await?;
+        res
+    }
+}

src/domain/sqlite/mod.rs

@@ -0,0 +1,4 @@
+mod backup;
+mod restore;
+mod ping;
+pub mod database;

src/domain/sqlite/ping.rs

@@ -0,0 +1,5 @@
+use crate::services::config::DatabaseConfig;
+
+pub async fn run(_cfg: DatabaseConfig) -> anyhow::Result<bool> {
+    Ok(true)
+}

src/domain/sqlite/restore.rs

@@ -0,0 +1,44 @@
+use crate::services::config::DatabaseConfig;
+use anyhow::{Context, Result};
+use std::path::PathBuf;
+use std::process::Command;
+use tracing::{debug, error, info};
+
+pub async fn run(cfg: DatabaseConfig, restore_file: PathBuf) -> Result<()> {
+    tokio::task::spawn_blocking(move || -> Result<()> {
+        debug!("Starting SQLite restore for database {}", cfg.name);
+
+        let db_path_str = if cfg.path.is_empty() {
+            anyhow::bail!("Database path not configured");
+        } else {
+            cfg.path.as_str().to_string()
+        };
+
+        let db_path = PathBuf::from(db_path_str);
+
+        if !restore_file.exists() {
+            anyhow::bail!("Restore file not found: {}", restore_file.display());
+        }
+
+        if db_path.exists() {
+            std::fs::remove_file(&db_path)
+                .with_context(|| format!("Failed to remove existing DB {}", db_path.display()))?;
+        }
+
+        let output = Command::new("sqlite3")
+            .arg(db_path.as_os_str())
+            .arg(format!(".restore '{}'", restore_file.display()))
+            .output()
+            .with_context(|| format!("Failed to run sqlite3 restore for {}", cfg.name))?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            error!("SQLite restore failed for {}: {}", cfg.name, stderr);
+            anyhow::bail!("SQLite restore failed for {}", cfg.name);
+        }
+
+        info!("SQLite restore completed for {}", cfg.name);
+        Ok(())
+    })
+    .await?
+}

src/services/api/client.rs

@@ -0,0 +1,83 @@
+#![allow(dead_code)]
+
+use reqwest::{Client, Method};
+use serde::de::DeserializeOwned;
+use std::time::Duration;
+use crate::services::api::ApiError;
+
+#[derive(Clone, Debug)]
+pub struct ApiClient {
+    base_url: String,
+    http: Client,
+}
+
+impl ApiClient {
+    pub fn new(base_url: impl Into<String>) -> Self {
+        let http = Client::builder()
+            .timeout(Duration::from_secs(30))
+            .build()
+            .expect("failed to build http client");
+
+        Self {
+            base_url: base_url.into(),
+            http,
+        }
+    }
+
+    pub async fn request<T: DeserializeOwned>(
+        &self,
+        method: Method,
+        path: &str,
+    ) -> Result<Option<T>, ApiError> {
+        let url = format!("{}{}", self.base_url, path);
+
+        let res = self.http.request(method, &url).send().await?;
+        let status = res.status();
+        let body = res.text().await.unwrap_or_default();
+
+        if !status.is_success() {
+            return Err(ApiError::HttpResponse { status, body });
+        }
+
+        if body.trim().is_empty() {
+            Ok(None)
+        } else {
+            Ok(Some(serde_json::from_str::<T>(&body)?))
+        }
+    }
+    pub async fn request_with_body<T, B>(
+        &self,
+        method: Method,
+        path: &str,
+        body: &B,
+    ) -> Result<Option<T>, ApiError>
+    where
+        T: DeserializeOwned,
+        B: serde::Serialize,
+    {
+        let url = format!("{}{}", self.base_url, path);
+
+        let res = self
+            .http
+            .request(method, &url)
+            .json(body)
+            .send()
+            .await?;
+
+        let status = res.status();
+        let body_text = res.text().await.unwrap_or_default();
+
+        if !status.is_success() {
+            return Err(ApiError::HttpResponse {
+                status,
+                body: body_text,
+            });
+        }
+
+        if body_text.trim().is_empty() {
+            Ok(None)
+        } else {
+            Ok(Some(serde_json::from_str::<T>(&body_text)?))
+        }
+    }
+}

src/services/api/endpoints/agent/backup/mod.rs

@@ -0,0 +1,67 @@
+pub mod upload;
+
+use crate::services::api::models::agent::backup::BackupResponse;
+use crate::services::api::{ApiClient, ApiError};
+use anyhow::Result;
+use reqwest::Method;
+use serde::Serialize;
+
+#[derive(Serialize)]
+pub struct BackupCreateRequest {
+    pub method: String,
+    #[serde(rename = "generatedId")]
+    pub generated_id: String,
+}
+
+#[derive(Serialize)]
+pub struct BackupUpdateRequest {
+    #[serde(rename = "backupId")]
+    pub backup_id: String,
+    pub status: String,
+    pub size: Option<u64>,
+    #[serde(rename = "generatedId")]
+    pub generated_id: String,
+}
+
+
+impl ApiClient {
+    pub async fn backup_create(
+        &self,
+        method: impl Into<String>,
+        agent_id: impl Into<String>,
+        generated_id: impl Into<String>,
+    ) -> Result<Option<BackupResponse>, ApiError> {
+        let body = BackupCreateRequest {
+            method: method.into(),
+            generated_id: generated_id.into(),
+        };
+
+        let agent_id = agent_id.into();
+        let path = format!("/agent/{}/backup", agent_id);
+
+        self.request_with_body(Method::POST, path.as_str(), &body)
+            .await
+    }
+
+    pub async fn backup_update(
+        &self,
+        agent_id: impl Into<String>,
+        backup_id: impl Into<String>,
+        status: impl Into<String>,
+        file_size: impl Into<Option<u64>>,
+        generated_id: impl Into<String>,
+    ) -> Result<Option<BackupResponse>, ApiError> {
+        let body = BackupUpdateRequest {
+            backup_id: backup_id.into(),
+            status: status.into(),
+            size: file_size.into(),
+            generated_id: generated_id.into(),
+        };
+
+        let agent_id = agent_id.into();
+        let path = format!("/agent/{}/backup", agent_id);
+
+        self.request_with_body(Method::PATCH, path.as_str(), &body)
+            .await
+    }
+}

src/services/api/endpoints/agent/backup/upload/init.rs

@@ -0,0 +1,37 @@
+use crate::services::api::{ApiClient, ApiError};
+use anyhow::Result;
+use reqwest::Method;
+use serde::Serialize;
+use crate::services::api::models::agent::backup::BackupUploadResponse;
+
+#[derive(Serialize)]
+pub struct InitUploadRequest {
+    #[serde(rename = "generatedId")]
+    pub generated_id: String,
+    #[serde(rename = "storageChannelId")]
+    pub storage_channel_id: String,
+    #[serde(rename = "backupId")]
+    pub backup_id: String,
+}
+
+impl ApiClient {
+    pub async fn backup_upload_init(
+        &self,
+        agent_id: impl Into<String>,
+        generated_id: impl Into<String>,
+        storage_channel_id: impl Into<String>,
+        backup_id: impl Into<String>,
+    ) -> Result<Option<BackupUploadResponse>, ApiError> {
+        let body = InitUploadRequest {
+            generated_id: generated_id.into(),
+            storage_channel_id: storage_channel_id.into(),
+            backup_id: backup_id.into(),
+        };
+
+        let agent_id = agent_id.into();
+        let path = format!("/agent/{}/backup/upload/init", agent_id);
+
+        self.request_with_body(Method::POST, path.as_str(), &body)
+            .await
+    }
+}

src/services/api/endpoints/agent/backup/upload/mod.rs

@@ -0,0 +1,2 @@
+pub mod init;
+pub mod status;

src/services/api/endpoints/agent/backup/upload/status.rs

@@ -0,0 +1,46 @@
+use crate::services::api::models::agent::backup::BackupUploadResponse;
+use crate::services::api::{ApiClient, ApiError};
+use anyhow::Result;
+use reqwest::Method;
+use serde::Serialize;
+
+#[derive(Serialize)]
+pub struct StatusUploadRequest {
+    #[serde(rename = "generatedId")]
+    pub generated_id: String,
+    #[serde(rename = "backupStorageId")]
+    pub backup_storage_id: String,
+    pub status: String,
+    pub path: String,
+    pub size: u64,
+    #[serde(rename = "backupId")]
+    pub backup_id: String,
+}
+
+impl ApiClient {
+    pub async fn backup_upload_status(
+        &self,
+        agent_id: impl Into<String>,
+        generated_id: impl Into<String>,
+        backup_storage_id: impl Into<String>,
+        status: impl Into<String>,
+        remote_path: impl Into<String>,
+        total_size: impl Into<u64>,
+        backup_id: impl Into<String>,
+    ) -> Result<Option<BackupUploadResponse>, ApiError> {
+        let body = StatusUploadRequest {
+            generated_id: generated_id.into(),
+            backup_storage_id: backup_storage_id.into(),
+            status: status.into(),
+            path: remote_path.into(),
+            size: total_size.into(),
+            backup_id: backup_id.into(),
+        };
+
+        let agent_id = agent_id.into();
+        let path = format!("/agent/{}/backup/upload/status", agent_id);
+
+        self.request_with_body(Method::PATCH, path.as_str(), &body)
+            .await
+    }
+}

src/services/api/endpoints/agent/mod.rs

@@ -0,0 +1,3 @@
+pub mod status;
+pub mod backup;
+pub mod restore;

src/services/api/endpoints/agent/restore/mod.rs

@@ -0,0 +1,33 @@
+use crate::services::api::models::agent::restore::ResultRestoreResponse;
+use crate::services::api::{ApiClient, ApiError};
+use anyhow::Result;
+use reqwest::Method;
+use serde::Serialize;
+
+#[derive(Serialize)]
+pub struct ResultRestoreRequest {
+    #[serde(rename = "generatedId")]
+    pub generated_id: String,
+    pub status: String,
+}
+
+impl ApiClient {
+    pub async fn restore_result(
+        &self,
+        agent_id: impl Into<String>,
+        generated_id: impl Into<String>,
+        status: impl Into<String>,
+    ) -> Result<Option<ResultRestoreResponse>, ApiError> {
+        let body = ResultRestoreRequest {
+            generated_id: generated_id.into(),
+            status: status.into(),
+        };
+
+        let agent_id = agent_id.into();
+
+        let path = format!("/agent/{}/restore", agent_id);
+
+        self.request_with_body(Method::POST, path.as_str(), &body)
+            .await
+    }
+}

src/services/api/endpoints/agent/status.rs

@@ -0,0 +1,36 @@
+use crate::services::api::models::agent;
+use crate::services::api::{ApiClient, ApiError};
+use agent::status::PingResult;
+use anyhow::Result;
+use reqwest::Method;
+use serde::Serialize;
+
+#[derive(Serialize)]
+pub struct DatabasePayload<'a> {
+    pub name: &'a str,
+    pub dbms: &'a str,
+    #[serde(rename = "generatedId")]
+    pub generated_id: &'a str,
+}
+
+#[derive(Serialize)]
+pub struct StatusRequest<'a> {
+    pub version: &'a str,
+    pub databases: Vec<DatabasePayload<'a>>,
+}
+
+impl ApiClient {
+    pub async fn agent_status<'a>(
+        &self,
+        agent_id: impl Into<String>,
+        version: &'a str,
+        databases: Vec<DatabasePayload<'a>>,
+    ) -> Result<Option<PingResult>, ApiError> {
+        let body = StatusRequest { version, databases };
+
+        let agent_id = agent_id.into();
+        let path = format!("/agent/{}/status", agent_id);
+
+        self.request_with_body(Method::POST, path.as_str(), &body).await
+    }
+}

src/services/api/endpoints/mod.rs

@@ -0,0 +1,3 @@
+pub mod agent;
+
+pub use agent::status;

src/services/api/error.rs

@@ -0,0 +1,21 @@
+use reqwest::StatusCode;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+#[allow(dead_code)]
+pub enum ApiError {
+    #[error("http client error: {0}")]
+    Http(#[from] reqwest::Error),
+
+    #[error("serialization error: {0}")]
+    Serialization(#[from] serde_json::Error),
+
+    #[error("api error: status={status}, body={body}")]
+    HttpResponse {
+        status: StatusCode,
+        body: String,
+    },
+
+    #[error("api returned unexpected response")]
+    UnexpectedResponse,
+}

src/services/api/mod.rs

@@ -0,0 +1,8 @@
+pub mod client;
+pub mod error;
+pub mod models;
+pub mod endpoints;
+
+pub use client::ApiClient;
+pub use error::ApiError;
+

src/services/api/models/agent/backup.rs

@@ -0,0 +1,24 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct BackupStorage {
+    pub id: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct BackupUploadResponse {
+    pub message: String,
+    #[serde(rename = "backupStorage")]
+    pub backup_storage: BackupStorage,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Backup {
+    pub id: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct BackupResponse {
+    pub message: String,
+    pub backup: Backup,
+}

src/services/api/models/agent/mod.rs

@@ -0,0 +1,3 @@
+pub mod status;
+pub mod backup;
+pub mod restore;

src/services/api/models/agent/restore.rs

@@ -0,0 +1,7 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ResultRestoreResponse {
+    pub message: String,
+    pub status: bool,
+}

src/services/api/models/agent/status.rs

@@ -0,0 +1,57 @@
+#![allow(dead_code)]
+
+use serde::{Deserialize, Serialize};
+use toml::Value;
+use crate::utils::deserializer::deserialize_snake_case;
+
+#[derive(Debug, Deserialize)]
+pub struct PingResult {
+    pub agent: AgentInfo,
+    pub databases: Vec<DatabaseStatus>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct AgentInfo {
+    pub id: String,
+    #[serde(rename = "lastContact")]
+    pub last_contact: String,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(rename_all = "snake_case")]
+pub struct DatabaseStorage {
+    pub id: String,
+    #[serde(deserialize_with = "deserialize_snake_case")]
+    pub config: Value,
+    pub provider: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct DatabaseStatus {
+    pub dbms: String,
+    #[serde(rename = "generatedId")]
+    pub generated_id: String,
+    pub storages: Vec<DatabaseStorage>,
+    pub encrypt: bool,
+    pub data: DatabaseData,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct DatabaseData {
+    pub backup: BackupInfo,
+    pub restore: RestoreInfo,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BackupInfo {
+    pub action: bool,
+    pub cron: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct RestoreInfo {
+    pub action: bool,
+    pub file: Option<String>,
+    #[serde(rename = "metaFile")]
+    pub meta_file: Option<String>,
+}

src/services/api/models/mod.rs

@@ -0,0 +1,2 @@
+pub mod agent;
+

src/services/backup.rs

@@ -1,219 +0,0 @@
-#![allow(dead_code)]
-
-use crate::core::context::Context;
-use crate::domain::factory::DatabaseFactory;
-use crate::services::config::{DatabaseConfig, DatabasesConfig, DbType};
-use crate::utils::common::BackupMethod;
-use crate::utils::file::full_extension;
-use anyhow::Result;
-use hex;
-use openssl::encrypt::Encrypter;
-use openssl::hash::MessageDigest;
-use openssl::pkey::PKey;
-use openssl::rand::rand_bytes;
-use openssl::rsa::Padding;
-use openssl::symm::{Cipher, Crypter, Mode};
-use reqwest::multipart::{Form, Part};
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-use tempfile::TempDir;
-use tokio::fs;
-use tracing::{error, info};
-
-#[derive(Debug)]
-pub struct BackupResult {
-    pub generated_id: String,
-    pub db_type: DbType,
-    pub status: String,
-    pub backup_file: Option<PathBuf>,
-    pub code: Option<String>,
-}
-
-pub struct BackupService {
-    ctx: Arc<Context>,
-}
-
-impl BackupService {
-    pub fn new(ctx: Arc<Context>) -> Self {
-        Self { ctx }
-    }
-
-    pub async fn dispatch(
-        &self,
-        generated_id: &String,
-        config: &DatabasesConfig,
-        method: BackupMethod,
-    ) {
-        if let Some(cfg) = config
-            .databases
-            .iter()
-            .find(|c| c.generated_id == generated_id.as_str())
-        {
-            let db_cfg = cfg.clone();
-            let ctx_clone = self.ctx.clone();
-
-            tokio::spawn(async move {
-                match TempDir::new() {
-                    Ok(temp_dir) => {
-                        let tmp_path = temp_dir.path().to_path_buf();
-                        info!("Created temp directory {}", tmp_path.display());
-
-                        match BackupService::run(db_cfg, &tmp_path).await {
-                            Ok(result) => {
-                                let service = BackupService { ctx: ctx_clone };
-                                service.send_result(result, method).await;
-                            }
-                            Err(e) => error!("Backup error {}", e),
-                        }
-                        // TempDir is automatically deleted when dropped here
-                    }
-                    Err(e) => error!("Failed to create temp dir: {}", e),
-                }
-            });
-        }
-    }
-
-    pub async fn run(cfg: DatabaseConfig, tmp_path: &Path) -> Result<BackupResult> {
-        let db_instance = DatabaseFactory::create_for_backup(cfg.clone()).await;
-        let generated_id = cfg.generated_id.clone();
-        let db_type = cfg.db_type.clone();
-
-        let reachable = db_instance.ping().await.unwrap_or(false);
-        info!("Reachable: {}", reachable);
-        if !reachable {
-            return Ok(BackupResult {
-                generated_id,
-                db_type,
-                status: "failed".into(),
-                backup_file: None,
-                code: None,
-            });
-        }
-
-        match db_instance.backup(tmp_path).await {
-            Ok(file) => Ok(BackupResult {
-                generated_id,
-                db_type,
-                status: "success".into(),
-                backup_file: Some(file),
-                code: None,
-            }),
-            Err(e) => match e.to_string().as_str() {
-                "backup_already_in_progress" => Ok(BackupResult {
-                    generated_id,
-                    db_type,
-                    status: "failed".into(),
-                    backup_file: None,
-                    code: Some(e.to_string()),
-                }),
-                _ => Ok(BackupResult {
-                    generated_id,
-                    db_type,
-                    status: "failed".into(),
-                    backup_file: None,
-                    code: None,
-                }),
-            },
-        }
-    }
-
-    pub async fn send_result(&self, result: BackupResult, method: BackupMethod) {
-        if result.code.as_deref() == Some("backup_already_in_progress") {
-            info!(
-                "[BackupService] Skipping send for DB {}: backup already in progress",
-                result.generated_id
-            );
-            return;
-        }
-
-        info!(
-            "[BackupService] DB: {} Type: {} Status: {} File: {:?}",
-            result.generated_id,
-            result.db_type.as_str(),
-            result.status,
-            result.backup_file
-        );
-
-        let client = reqwest::Client::new();
-        let url = format!(
-            "{}/api/agent/{}/backup",
-            self.ctx.edge_key.server_url, self.ctx.edge_key.agent_id
-        );
-
-        let mut form = Form::new()
-            .text("generatedId", result.generated_id.clone())
-            .text("status", result.status.clone())
-            .text("method", method.to_string());
-
-        if let Some(file_path) = result.backup_file {
-            match fs::read(&file_path).await {
-                Ok(raw_data) => {
-                    // AES key + IV
-                    let mut aes_key = [0u8; 32];
-                    rand_bytes(&mut aes_key).unwrap();
-
-                    let mut iv = [0u8; 16];
-                    rand_bytes(&mut iv).unwrap();
-
-                    // AES CBC PKCS7 encryption
-                    let cipher = Cipher::aes_256_cbc();
-                    let mut encrypter =
-                        Crypter::new(cipher, Mode::Encrypt, &aes_key, Some(&iv)).unwrap();
-                    encrypter.pad(true);
-                    let mut encrypted = vec![0u8; raw_data.len() + cipher.block_size()];
-                    let count = encrypter.update(&raw_data, &mut encrypted).unwrap();
-                    let rest = encrypter.finalize(&mut encrypted[count..]).unwrap();
-                    encrypted.truncate(count + rest);
-
-                    // Encrypt AES key with RSA public key
-                    let pub_key_pem = self.ctx.edge_key.public_key.as_bytes();
-                    let pkey = PKey::public_key_from_pem(pub_key_pem).unwrap();
-
-                    let mut encrypter = Encrypter::new(&pkey).unwrap();
-                    // Set OAEP padding (default OAEP uses SHA1, so override)
-                    encrypter.set_rsa_padding(Padding::PKCS1_OAEP).unwrap();
-                    // Set OAEP hash to SHA‑256
-                    encrypter.set_rsa_oaep_md(MessageDigest::sha256()).unwrap();
-                    encrypter.set_rsa_mgf1_md(MessageDigest::sha256()).unwrap();
-
-                    let mut encrypted_key = vec![0u8; encrypter.encrypt_len(&aes_key).unwrap()];
-                    let encrypted_len = encrypter.encrypt(&aes_key, &mut encrypted_key).unwrap();
-                    encrypted_key.truncate(encrypted_len);
-
-                    let extension = full_extension(&file_path);
-
-                    // Attach file and AES info to multipart form
-                    form = form
-                        .part(
-                            "file",
-                            Part::bytes(encrypted)
-                                .file_name(format!("{}.enc", result.generated_id)),
-                        )
-                        .text("aes_key", hex::encode(encrypted_key))
-                        .text("iv", hex::encode(iv))
-                        .text("extension", extension);
-                }
-                Err(e) => {
-                    error!("Failed to read backup file: {}", e);
-                }
-            }
-        } else {
-            form = form.text("file", "");
-        }
-
-        match client.post(&url).multipart(form).send().await {
-            Ok(resp) => {
-                let status = resp.status();
-                if status.is_success() {
-                    info!("Backup result sent successfully");
-                } else {
-                    let text = resp.text().await.unwrap_or_default(); // consumes resp
-                    error!("Backup result failed, status: {}, body: {}", status, text);
-                }
-            }
-            Err(e) => {
-                error!("Failed to send backup result: {}", e);
-            }
-        }
-    }
-}

src/services/backup/compressor.rs

@@ -0,0 +1,20 @@
+use super::service::BackupService;
+use crate::utils::compress::compress_to_tar_gz_large;
+use std::path::PathBuf;
+use anyhow::Result;
+
+impl BackupService {
+
+    pub async fn compress_backup(
+        &self,
+        backup_file: Option<PathBuf>,
+    ) -> Result<PathBuf> {
+
+        let file = backup_file
+            .ok_or_else(|| anyhow::anyhow!("No backup file generated"))?;
+
+        let compression = compress_to_tar_gz_large(&file).await?;
+
+        Ok(compression.compressed_path)
+    }
+}

src/services/backup/dispatcher.rs

@@ -0,0 +1,44 @@
+use super::service::BackupService;
+use crate::services::config::DatabasesConfig;
+use crate::services::api::models::agent::status::DatabaseStorage;
+use crate::utils::common::BackupMethod;
+use tracing::error;
+
+impl BackupService {
+
+    pub async fn dispatch(
+        &self,
+        generated_id: &String,
+        config: &DatabasesConfig,
+        method: BackupMethod,
+        storages: &Vec<DatabaseStorage>,
+        encrypt: bool,
+    ) {
+
+        let Some(cfg) = config
+            .databases
+            .iter()
+            .find(|c| c.generated_id == generated_id.as_str())
+        else {
+            error!("Database config not found for {}", generated_id);
+            return;
+        };
+
+        let service = Self {
+            ctx: self.ctx.clone(),
+        };
+
+        let db_cfg = cfg.clone();
+        let storages = storages.clone();
+        let generated_id = generated_id.clone();
+
+        tokio::spawn(async move {
+            if let Err(e) = service
+                .execute_backup(generated_id, db_cfg, method, storages, encrypt)
+                .await
+            {
+                error!("Backup execution failed: {}", e);
+            }
+        });
+    }
+}

src/services/backup/executor.rs

@@ -0,0 +1,49 @@
+use super::service::BackupService;
+use crate::services::config::DatabaseConfig;
+use crate::services::api::models::agent::status::DatabaseStorage;
+use crate::utils::common::BackupMethod;
+use crate::utils::locks::FileLock;
+
+use tempfile::TempDir;
+use anyhow::Result;
+
+impl BackupService {
+
+    pub async fn execute_backup(
+        &self,
+        generated_id: String,
+        db_cfg: DatabaseConfig,
+        method: BackupMethod,
+        storages: Vec<DatabaseStorage>,
+        encrypt: bool,
+    ) -> Result<()> {
+
+        if FileLock::is_locked(&generated_id).await? {
+            anyhow::bail!("backup already running");
+        }
+        
+        let backup = self.create_backup_record(&generated_id, &method).await?;
+        let backup_id = backup.backup.id;
+
+        let temp_dir = TempDir::new()?;
+        let tmp_path = temp_dir.path();
+
+        let mut result = Self::run(db_cfg, tmp_path).await?;
+
+        if result.status == "failed" {
+            self.send_result(result, vec![], &backup_id).await?;
+            return Ok(());
+        }
+
+        let compressed = self.compress_backup(result.backup_file.take()).await?;
+        result.backup_file = Some(compressed);
+
+        let uploads = self
+            .upload(result.clone(), method, storages, encrypt, &backup_id)
+            .await?;
+
+        self.send_result(result, uploads, &backup_id).await?;
+
+        Ok(())
+    }
+}

src/services/backup/helpers.rs

@@ -0,0 +1,26 @@
+use super::service::BackupService;
+use crate::utils::common::BackupMethod;
+use anyhow::{Result, anyhow};
+use crate::services::api::models::agent::backup::BackupResponse;
+
+impl BackupService {
+
+    pub async fn create_backup_record(
+        &self,
+        generated_id: &str,
+        method: &BackupMethod,
+    ) -> Result<BackupResponse> {
+
+        let response = self
+            .ctx
+            .api
+            .backup_create(
+                method.to_string(),
+                self.ctx.edge_key.agent_id.clone(),
+                generated_id,
+            )
+            .await?;
+
+        response.ok_or_else(|| anyhow!("backup_create returned empty response"))
+    }
+}

src/services/backup/mod.rs

@@ -0,0 +1,11 @@
+pub mod service;
+pub mod dispatcher;
+pub mod executor;
+pub mod compressor;
+pub mod uploader;
+pub mod result;
+pub mod models;
+pub mod helpers;
+pub mod runner;
+
+pub use service::BackupService;

src/services/backup/models.rs

@@ -0,0 +1,22 @@
+#![allow(dead_code)]
+
+use std::path::PathBuf;
+use crate::services::config::DbType;
+
+#[derive(Debug, Clone)]
+pub struct BackupResult {
+    pub generated_id: String,
+    pub db_type: DbType,
+    pub status: String,
+    pub backup_file: Option<PathBuf>,
+    pub code: Option<String>,
+}
+
+#[derive(Debug)]
+pub struct UploadResult {
+    pub storage_id: String,
+    pub success: bool,
+    pub error: Option<String>,
+    pub remote_file_path: Option<String>,
+    pub total_size: Option<u64>,
+}

src/services/backup/result.rs

@@ -0,0 +1,45 @@
+use super::models::{BackupResult, UploadResult};
+use super::service::BackupService;
+use crate::services::api::ApiError;
+use crate::services::api::models::agent::backup::BackupResponse;
+use anyhow::Result;
+use tracing::error;
+
+impl BackupService {
+    pub async fn send_result(
+        &self,
+        result: BackupResult,
+        upload_results: Vec<UploadResult>,
+        backup_id: &String,
+    ) -> Result<Option<BackupResponse>, ApiError> {
+        let status = if upload_results.iter().any(|r| r.success) {
+            "success"
+        } else {
+            "failed"
+        };
+
+        let file_size = upload_results
+            .iter()
+            .filter_map(|r| r.total_size)
+            .reduce(|a, b| a + b)
+            .map(|sum| sum / upload_results.len() as u64);
+
+        self.ctx
+            .api
+            .backup_update(
+                self.ctx.edge_key.agent_id.clone(),
+                backup_id,
+                status,
+                file_size,
+                &result.generated_id,
+            )
+            .await
+            .map_err(|e| {
+                error!(
+                    "backup_update failed (generated_id={}, backup_id={}): {}",
+                    result.generated_id, backup_id, e
+                );
+                e.into()
+            })
+    }
+}

src/services/backup/runner.rs

@@ -0,0 +1,70 @@
+use super::models::BackupResult;
+use super::service::BackupService;
+
+use crate::domain::factory::DatabaseFactory;
+use crate::services::config::DatabaseConfig;
+
+use anyhow::Result;
+use std::path::Path;
+use tracing::{error, info};
+
+impl BackupService {
+
+    pub async fn run(
+        cfg: DatabaseConfig,
+        tmp_path: &Path,
+    ) -> Result<BackupResult> {
+
+        let db = DatabaseFactory::create_for_backup(cfg.clone()).await;
+
+        let generated_id = cfg.generated_id.clone();
+        let db_type = cfg.db_type.clone();
+
+        let reachable = match db.ping().await {
+            Ok(v) => v,
+            Err(e) => {
+                error!("Ping failed: {}", e);
+                return Err(e.into());
+            }
+        };
+
+        info!("Reachable: {}", reachable);
+
+        if !reachable {
+            return Ok(BackupResult {
+                generated_id,
+                db_type,
+                status: "failed".into(),
+                backup_file: None,
+                code: None,
+            });
+        }
+
+        match db.backup(tmp_path).await {
+
+            Ok(file) => Ok(BackupResult {
+                generated_id,
+                db_type,
+                status: "success".into(),
+                backup_file: Some(file),
+                code: None,
+            }),
+
+            Err(e) if e.to_string() == "backup_already_in_progress" => Ok(BackupResult {
+                generated_id,
+                db_type,
+                status: "failed".into(),
+                backup_file: None,
+                code: Some("backup_already_in_progress".into()),
+            }),
+
+            Err(_) => Ok(BackupResult {
+                generated_id,
+                db_type,
+                status: "failed".into(),
+                backup_file: None,
+                code: None,
+            }),
+        }
+    }
+}

src/services/backup/service.rs

@@ -0,0 +1,12 @@
+use std::sync::Arc;
+use crate::core::context::Context as CoreContext;
+
+pub struct BackupService {
+    pub ctx: Arc<CoreContext>,
+}
+
+impl BackupService {
+    pub fn new(ctx: Arc<CoreContext>) -> Self {
+        Self { ctx }
+    }
+}

src/services/backup/uploader.rs

@@ -0,0 +1,181 @@
+use super::service::BackupService;
+use super::models::{BackupResult, UploadResult};
+
+use crate::services::storage;
+use crate::services::api::models::agent::status::DatabaseStorage;
+use crate::utils::common::BackupMethod;
+
+use futures::future::join_all;
+use anyhow::{Result, bail};
+use tracing::{info, error};
+
+impl BackupService {
+
+    pub async fn upload(
+        &self,
+        result: BackupResult,
+        method: BackupMethod,
+        storages: Vec<DatabaseStorage>,
+        encrypt: bool,
+        backup_id: &String,
+    ) -> Result<Vec<UploadResult>> {
+
+        if result.code.as_deref() == Some("backup_already_in_progress") {
+            info!("Skipping send: backup already in progress");
+            bail!("backup_already_in_progress");
+        }
+
+        let ctx = self.ctx.clone();
+
+        let futures = storages.into_iter().map(|storage| {
+
+            let ctx_clone = ctx.clone();
+            let result_clone = result.clone();
+            let provider = storage::get_provider(&storage);
+
+            let storage_id = storage.id.clone();
+            let generated_id = result_clone.generated_id.clone();
+
+            async move {
+
+                info!("Uploading storage -> {:?} for {:?}", storage.provider, storage_id);
+
+                /*
+                 INIT STEP
+                */
+                let init = match ctx_clone.api
+                    .backup_upload_init(
+                        ctx_clone.edge_key.agent_id.clone(),
+                        generated_id.clone(),
+                        storage_id.clone(),
+                        backup_id,
+                    )
+                    .await
+                {
+                    Ok(v) => v,
+                    Err(e) => {
+                        error!("backup_upload_init failed: {}", e);
+
+                        return UploadResult {
+                            storage_id,
+                            success: false,
+                            error: Some("backup_upload_init failed".into()),
+                            remote_file_path: None,
+                            total_size: None,
+                        };
+                    }
+                };
+
+                let backup_storage_id = match init {
+                    Some(v) => v.backup_storage.id,
+                    None => {
+                        return UploadResult {
+                            storage_id,
+                            success: false,
+                            error: Some("backup_upload_init returned empty response".into()),
+                            remote_file_path: None,
+                            total_size: None,
+                        };
+                    }
+                };
+
+                /*
+                 PROVIDER CHECK
+                */
+                let Some(provider) = provider else {
+                    error!("Skipping storage due to missing provider");
+
+                    return UploadResult {
+                        storage_id,
+                        success: false,
+                        error: Some("missing provider".into()),
+                        remote_file_path: None,
+                        total_size: None,
+                    };
+                };
+
+                /*
+                 STORAGE UPLOAD
+                */
+                let upload_result = provider
+                    .upload(
+                        ctx_clone.clone(),
+                        result_clone,
+                        method,
+                        &storage,
+                        Some(encrypt),
+                    )
+                    .await;
+
+                let status = if upload_result.success { "success" } else { "failed" };
+
+                if status != "success" {
+                    return upload_result;
+                }
+
+                info!(
+                    "Storage {} uploaded to remote path {:?}",
+                    storage_id,
+                    upload_result.remote_file_path
+                );
+
+                /*
+                 METADATA VALIDATION
+                */
+                let (remote_path, total_size) = match (
+                    &upload_result.remote_file_path,
+                    upload_result.total_size,
+                ) {
+                    (Some(path), Some(size)) => (path.clone(), size),
+                    _ => {
+                        return UploadResult {
+                            storage_id,
+                            success: false,
+                            error: Some("remote_file_path or total_size missing".into()),
+                            remote_file_path: None,
+                            total_size: None,
+                        };
+                    }
+                };
+
+                /*
+                 STATUS UPDATE
+                */
+                match ctx_clone.api.backup_upload_status(
+                    ctx_clone.edge_key.agent_id.clone(),
+                    generated_id,
+                    backup_storage_id,
+                    status,
+                    remote_path,
+                    total_size,
+                    backup_id,
+                ).await {
+
+                    Ok(_) => upload_result,
+
+                    Err(err) => {
+                        error!(
+                            "backup_upload_status failed (storage_id={}): {}",
+                            storage_id,
+                            err
+                        );
+
+                        UploadResult {
+                            storage_id,
+                            success: false,
+                            error: Some(err.to_string()),
+                            remote_file_path: None,
+                            total_size: None,
+                        }
+                    }
+                }
+            }
+        });
+
+        let results: Vec<UploadResult> = join_all(futures).await;
+
+        info!("Upload results: {:#?}", results);
+
+        Ok(results)
+    }
+}

src/services/config.rs

@@ -9,6 +9,7 @@ use std::path::Path;
 use std::sync::Arc;
 use toml;
 use tracing::info;
+use uuid::Uuid;
 
 #[derive(Debug, Deserialize, Clone)]
 #[serde(rename_all = "lowercase")]
@@ -16,8 +17,8 @@ pub enum DbType {
     Mysql,
     Mariadb,
     Postgresql,
-    MongoDB
-    // Sqlite,
+    MongoDB,
+    Sqlite,
     // Add other DB types if needed
 }
 
@@ -28,7 +29,7 @@ impl DbType {
             DbType::Mariadb => "mysql",
             DbType::Postgresql => "postgresql",
             DbType::MongoDB => "mongodb",
-            // DbType::Sqlite => "sqlite",
+            DbType::Sqlite => "sqlite",
         }
     }
 }
@@ -45,6 +46,7 @@ pub struct DatabaseConfig {
     pub port: u16,
     pub host: String,
     pub generated_id: String,
+    pub path: String,
 }
 
 #[allow(dead_code)]
@@ -53,6 +55,29 @@ pub struct DatabasesConfig {
     pub databases: Vec<DatabaseConfig>,
 }
 
+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize, Clone)]
+pub struct InputDatabaseConfig {
+    pub name: String,
+    pub database: Option<String>,
+    #[serde(rename = "type")]
+    pub db_type: DbType,
+    pub username: Option<String>,
+    pub password: Option<String>,
+    pub port: Option<u16>,
+    pub host: Option<String>,
+    pub generated_id: String,
+    pub path: Option<String>,
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Deserialize, Clone)]
+pub struct InputDatabasesConfig {
+    pub databases: Vec<InputDatabaseConfig>,
+}
+
+
 pub struct ConfigService {
     ctx: Arc<Context>,
 }
@@ -95,7 +120,7 @@ impl ConfigService {
         file.read_to_string(&mut contents)
             .map_err(|e| format!("Failed to read config file: {}", e))?;
 
-        let config: DatabasesConfig = match extension {
+        let input_config: InputDatabasesConfig = match extension {
             "json" => {
                 serde_json::from_str(&contents).map_err(|e| format!("JSON parsing error: {}", e))?
             }
@@ -105,8 +130,71 @@ impl ConfigService {
             _ => return Err("Unsupported config file format. Use .json or .toml".to_string()),
         };
 
-        info!("Databases : {:?} instances loaded", config.databases.len());
+        fn required<T: Clone>(opt: &Option<T>, db_name: &str, field_name: &str) -> Result<T, String> {
+            match opt {
+                Some(v) => Ok(v.clone()),
+                None => {
+                    let msg = format!("Missing required field '{}' for database '{}'", field_name, db_name);
+                    Err(msg)
+                }
+            }
+        }
 
-        Ok(config)
+        fn optional<T: Clone>(opt: &Option<T>) -> T where T: Default {
+            opt.clone().unwrap_or_default()
+        }
+
+        let mut databases = Vec::with_capacity(input_config.databases.len());
+
+        for db in input_config.databases {
+            if Uuid::parse_str(&db.generated_id).is_err() {
+                return Err(format!("Invalid UUID for database '{}'", db.name));
+            }
+
+            let username = match db.db_type {
+                DbType::Postgresql | DbType::Mysql | DbType::Mariadb => required(&db.username, &db.name, "username")?,
+                _ => optional(&db.username),
+            };
+
+            let password = match db.db_type {
+                DbType::Postgresql | DbType::Mysql | DbType::Mariadb => required(&db.password, &db.name, "password")?,
+                _ => optional(&db.password),
+            };
+
+            let host = match db.db_type {
+                DbType::Postgresql | DbType::Mysql | DbType::Mariadb | DbType::MongoDB => required(&db.host, &db.name, "host")?,
+                DbType::Sqlite => optional(&db.host),
+            };
+
+            let port = match db.db_type {
+                DbType::Postgresql | DbType::Mysql | DbType::Mariadb | DbType::MongoDB => required(&db.port, &db.name, "port")?,
+                DbType::Sqlite => db.port.unwrap_or(0),
+            };
+
+            let database_name = match db.db_type {
+                DbType::Sqlite => optional(&db.database),
+                _ => required(&db.database, &db.name, "database")?
+            };
+
+            let path_val = match db.db_type {
+                DbType::Sqlite => required(&db.path, &db.name, "path")?,
+                _ => optional(&db.path),
+            };
+
+            databases.push(DatabaseConfig {
+                name: db.name,
+                database: database_name,
+                db_type: db.db_type,
+                username,
+                password,
+                host,
+                port,
+                generated_id: db.generated_id,
+                path: path_val,
+            });
+        }
+
+        info!("Databases: {} instances loaded", databases.len());
+        Ok(DatabasesConfig { databases })
     }
 }

src/services/cron.rs

@@ -1,11 +1,13 @@
 #![allow(dead_code)]
 
 use crate::core::context::Context;
-use crate::services::status::DatabaseStatus;
+use crate::utils::common::vec_to_option_json;
 use crate::utils::redis_client;
 use crate::utils::task_manager::cron::check_and_update_cron;
-use std::sync::Arc;
 use redis::aio::MultiplexedConnection;
+use serde_json::{Value, json};
+use std::sync::Arc;
+use crate::services::api::models::agent::status::DatabaseStatus;
 
 pub struct CronService {
     ctx: Arc<Context>,
@@ -23,6 +25,12 @@ impl CronService {
         let dbms = database.dbms.as_str();
         let task_name = format!("periodic.backup_{}", generated_id);
         let args = vec![generated_id.to_string(), dbms.to_string()];
+        let storages: Option<Value> = vec_to_option_json(database.storages.clone());
+        let encrypt: bool = database.encrypt;
+        let metadata = json!({
+            "storages": storages,
+            "encrypt": encrypt
+        });
 
         check_and_update_cron(
             &mut self.conn,
@@ -30,7 +38,9 @@ impl CronService {
             args,
             "tasks.database.periodic_backup",
             task_name,
-        ).await;
+            Option::from(metadata),
+        )
+        .await;
 
         Ok(true)
     }

src/services/mod.rs

@@ -1,5 +1,7 @@
 pub mod config;
-pub mod status;
 pub mod cron;
 pub mod backup;
-pub mod restore;
+pub mod restore;
+mod storage;
+pub mod api;
+pub mod status;

src/services/restore.rs

@@ -1,162 +0,0 @@
-#![allow(dead_code)]
-
-use crate::core::context::Context;
-use crate::domain::factory::DatabaseFactory;
-use crate::services::config::{DatabaseConfig, DatabasesConfig};
-use crate::services::status::DatabaseStatus;
-use anyhow::Result;
-use tracing::{error, info};
-use serde::Serialize;
-use std::path::Path;
-use std::sync::Arc;
-use tempfile::TempDir;
-
-#[derive(Debug, Serialize)]
-pub struct RestoreResult {
-    #[serde(rename = "generatedId")]
-    pub generated_id: String,
-    pub status: String,
-}
-
-pub struct RestoreService {
-    ctx: Arc<Context>,
-}
-
-impl RestoreService {
-    pub fn new(ctx: Arc<Context>) -> Self {
-        Self { ctx }
-    }
-
-    pub async fn dispatch(&self, db: &DatabaseStatus, config: &DatabasesConfig) {
-        if let Some(cfg) = config
-            .databases
-            .iter()
-            .find(|c| c.generated_id == db.generated_id)
-        {
-            let db_cfg = cfg.clone();
-            let ctx_clone = self.ctx.clone();
-            let file_to_restore = db.data.restore.file.clone();
-
-            tokio::spawn(async move {
-                match TempDir::new() {
-                    Ok(temp_dir) => {
-                        let tmp_path = temp_dir.path().to_path_buf();
-                        info!("Created temp directory {}", tmp_path.display());
-
-                        match RestoreService::run(db_cfg, &tmp_path, &file_to_restore).await {
-                            Ok(result) => {
-                                let service = RestoreService { ctx: ctx_clone };
-                                service.send_result(result).await;
-                            }
-                            Err(e) => error!("Restoration error {}", e),
-                        }
-                        // TempDir is automatically deleted when dropped here
-                    }
-                    Err(e) => error!("Failed to create temp dir: {}", e),
-                }
-            });
-        }
-    }
-
-    pub async fn run(
-        cfg: DatabaseConfig,
-        tmp_path: &Path,
-        file_url: &str,
-    ) -> Result<RestoreResult> {
-        let generated_id = cfg.generated_id.clone();
-
-        info!("File url: {}", file_url);
-
-        let client = reqwest::Client::new();
-        let response = client.get(file_url).send().await?;
-        if !response.status().is_success() {
-            error!("Backup download failed with status {}", response.status());
-            return Ok(RestoreResult {
-                generated_id,
-                status: "failed".into(),
-            });
-        }
-
-        let bytes = response.bytes().await?;
-
-        let ext = if bytes.starts_with(b"PGDMP") {
-            // Postgres custom format
-            "dump"
-        } else if bytes.starts_with(&[0x1F, 0x8B]) {
-            // gzip compressed -> could be Postgres directory dump or MySQL gzipped SQL
-            "tar.gz"
-        } else if bytes.starts_with(b"--") || bytes.starts_with(b"/*") {
-            // Plain MySQL SQL dump
-            "sql"
-        } else {
-            // Fallback generic
-            "dump"
-        };
-
-        info!("Backup dump from {} to {}", tmp_path.display(), ext);
-
-        let backup_file_path = tmp_path.join(format!("backup_file_tmp.{}", ext));
-        tokio::fs::write(&backup_file_path, &bytes).await?;
-        info!("Backup downloaded to {}", backup_file_path.display());
-
-        let db_instance = DatabaseFactory::create_for_restore(cfg.clone(), &backup_file_path).await;
-        let reachable = db_instance.ping().await.unwrap_or(false);
-        info!("Reachable: {}", reachable);
-        if !reachable {
-            return Ok(RestoreResult {
-                generated_id,
-                status: "failed".into(),
-            });
-        }
-
-        match db_instance.restore(&backup_file_path).await {
-            Ok(_) => Ok(RestoreResult {
-                generated_id,
-                status: "success".into(),
-            }),
-            Err(e) => {
-                log::error!("Restore failed: {:?}", e);
-                Ok(RestoreResult {
-                    generated_id,
-                    status: "failed".into(),
-                })
-            }
-        }
-    }
-
-    pub async fn send_result(&self, result: RestoreResult) {
-        info!(
-            "[RestoreService] DB: {} | Status: {}",
-            result.generated_id, result.status,
-        );
-
-        let client = reqwest::Client::new();
-        let url = format!(
-            "{}/api/agent/{}/restore",
-            self.ctx.edge_key.server_url, self.ctx.edge_key.agent_id
-        );
-
-        let body = RestoreResult {
-            generated_id: result.generated_id,
-            status: result.status,
-        };
-
-        match client.post(&url).json(&body).send().await {
-            Ok(resp) => {
-                let status = resp.status();
-                if status.is_success() {
-                    info!("Restoration result sent successfully");
-                } else {
-                    let text = resp.text().await.unwrap_or_default(); // consumes resp
-                    error!(
-                        "Restoration result failed, status: {}, body: {}",
-                        status, text
-                    );
-                }
-            }
-            Err(e) => {
-                error!("Failed to send restoration result: {}", e);
-            }
-        }
-    }
-}

src/services/restore/archive.rs

@@ -0,0 +1,61 @@
+use super::service::RestoreService;
+
+use crate::utils::compress::decompress_large_tar_gz;
+use crate::utils::file::decrypt_file_stream_gcm;
+
+use anyhow::Result;
+use std::path::{Path, PathBuf};
+
+impl RestoreService {
+
+    pub async fn prepare_archive(
+        &self,
+        downloaded_file: PathBuf,
+        tmp_path: &Path,
+    ) -> Result<PathBuf> {
+
+        let filename = downloaded_file
+            .file_name()
+            .unwrap()
+            .to_string_lossy()
+            .to_string();
+
+        let is_legacy = filename.ends_with(".sql") || filename.ends_with(".dump");
+
+        if is_legacy {
+            return Ok(downloaded_file);
+        }
+
+        let encrypted = filename.ends_with(".tar.gz.enc");
+
+        let mut archive = downloaded_file.clone();
+
+        if encrypted {
+
+            let new_name = filename.strip_suffix(".enc").unwrap();
+
+            let decrypted = tmp_path.join(new_name);
+
+            decrypt_file_stream_gcm(
+                downloaded_file,
+                decrypted.clone(),
+                self.ctx.edge_key.master_key_b64.clone(),
+            )
+                .await?;
+
+            archive = decrypted;
+        }
+
+        let files = decompress_large_tar_gz(archive.as_path(), tmp_path).await?;
+
+        if files.is_empty() {
+            anyhow::bail!("archive empty");
+        }
+
+        if files.len() == 1 {
+            Ok(files[0].clone())
+        } else {
+            Ok(archive)
+        }
+    }
+}

src/services/restore/dispatcher.rs

@@ -0,0 +1,42 @@
+use super::service::RestoreService;
+use crate::services::config::DatabasesConfig;
+use crate::services::api::models::agent::status::DatabaseStatus;
+
+use tracing::error;
+
+impl RestoreService {
+
+    pub async fn dispatch(&self, db: &DatabaseStatus, config: &DatabasesConfig) {
+
+        let Some(cfg) = config
+            .databases
+            .iter()
+            .find(|c| c.generated_id == db.generated_id)
+        else {
+            error!("Database config not found");
+            return;
+        };
+
+        let Some(file_to_restore) = db.data.restore.file.clone() else {
+            error!("restore file not found");
+            return;
+        };
+
+        let service = Self {
+            ctx: self.ctx.clone(),
+        };
+
+        let db_cfg = cfg.clone();
+
+        tokio::spawn(async move {
+
+            if let Err(e) = service
+                .execute_restore(db_cfg, file_to_restore)
+                .await
+            {
+                error!("Restore failed: {}", e);
+            }
+
+        });
+    }
+}

src/services/restore/downloader.rs

@@ -0,0 +1,53 @@
+use super::service::RestoreService;
+
+use reqwest::{Client, Url};
+use anyhow::Result;
+use std::path::{Path, PathBuf};
+use tracing::info;
+
+impl RestoreService {
+
+    pub async fn download_backup(
+        &self,
+        file_url: &str,
+        tmp_path: &Path,
+    ) -> Result<PathBuf> {
+
+        let client = Client::new();
+
+        let response = client.get(file_url).send().await?;
+
+        if !response.status().is_success() {
+            anyhow::bail!("download failed");
+        }
+
+        let filename_from_header = response
+            .headers()
+            .get(reqwest::header::CONTENT_DISPOSITION)
+            .and_then(|v| v.to_str().ok())
+            .and_then(|s| s.split("filename=").nth(1))
+            .map(|f| f.trim_matches('"').to_string());
+
+
+        let filename_from_url = Url::parse(file_url).ok().and_then(|u| {
+            u.path_segments()?
+                .last()
+                .filter(|s| !s.is_empty())
+                .map(|s| s.to_string())
+        });
+
+        let filename = filename_from_header
+            .or(filename_from_url)
+            .unwrap_or_else(|| "downloaded_file".to_string());
+
+        let path = tmp_path.join(&filename);
+
+        let bytes = response.bytes().await?;
+
+        tokio::fs::write(&path, &bytes).await?;
+
+        info!("Backup downloaded to {}", path.display());
+
+        Ok(path)
+    }
+}

src/services/restore/executor.rs

@@ -0,0 +1,30 @@
+use super::service::RestoreService;
+use crate::services::config::DatabaseConfig;
+use tempfile::TempDir;
+use anyhow::Result;
+use tracing::info;
+
+impl RestoreService {
+
+    pub async fn execute_restore(
+        &self,
+        cfg: DatabaseConfig,
+        file_url: String,
+    ) -> Result<()> {
+
+        let temp_dir = TempDir::new()?;
+        let tmp_path = temp_dir.path();
+
+        info!("Created temp directory {}", tmp_path.display());
+
+        let downloaded = self.download_backup(&file_url, tmp_path).await?;
+
+        let backup_file = self.prepare_archive(downloaded, tmp_path).await?;
+
+        let result = self.run_restore(cfg, backup_file).await?;
+
+        self.send_result(result).await;
+
+        Ok(())
+    }
+}

src/services/restore/mod.rs

@@ -0,0 +1,10 @@
+pub mod service;
+pub mod dispatcher;
+pub mod executor;
+pub mod downloader;
+pub mod archive;
+pub mod runner;
+pub mod result;
+pub mod models;
+
+pub use service::RestoreService;

src/services/restore/models.rs

@@ -0,0 +1,8 @@
+use serde::Serialize;
+
+#[derive(Debug, Serialize)]
+pub struct RestoreResult {
+    #[serde(rename = "generatedId")]
+    pub generated_id: String,
+    pub status: String,
+}

src/services/restore/result.rs

@@ -0,0 +1,30 @@
+use super::service::RestoreService;
+use super::models::RestoreResult;
+
+use tracing::{info, error};
+
+impl RestoreService {
+    pub async fn send_result(&self, result: RestoreResult) {
+
+        info!(
+            "[RestoreService] DB: {} | Status: {}",
+            result.generated_id, result.status
+        );
+
+        match self.ctx
+            .api
+            .restore_result(
+                self.ctx.edge_key.agent_id.clone(),
+                &result.generated_id,
+                &result.status,
+            )
+            .await {
+            Ok(_) => {
+                info!("Restoration result sent successfully");
+            }
+            Err(e) => {
+                error!("Failed to send restoration result: {}", e);
+            }
+        }
+    }
+}

src/services/restore/runner.rs

@@ -0,0 +1,51 @@
+use super::service::RestoreService;
+use super::models::RestoreResult;
+
+use crate::domain::factory::DatabaseFactory;
+use crate::services::config::DatabaseConfig;
+
+use anyhow::Result;
+use std::path::PathBuf;
+use tracing::{info, error};
+
+impl RestoreService {
+
+    pub async fn run_restore(
+        &self,
+        cfg: DatabaseConfig,
+        backup_file: PathBuf,
+    ) -> Result<RestoreResult> {
+
+        let generated_id = cfg.generated_id.clone();
+
+        let db = DatabaseFactory::create_for_restore(cfg.clone(), &backup_file).await;
+
+        let reachable = db.ping().await.unwrap_or(false);
+
+        info!("Reachable: {}", reachable);
+
+        if !reachable {
+            return Ok(RestoreResult {
+                generated_id,
+                status: "failed".into(),
+            });
+        }
+
+        match db.restore(&backup_file).await {
+
+            Ok(_) => Ok(RestoreResult {
+                generated_id,
+                status: "success".into(),
+            }),
+
+            Err(e) => {
+                error!("Restore failed: {:?}", e);
+
+                Ok(RestoreResult {
+                    generated_id,
+                    status: "failed".into(),
+                })
+            }
+        }
+    }
+}

src/services/restore/service.rs

@@ -0,0 +1,12 @@
+use std::sync::Arc;
+use crate::core::context::Context;
+
+pub struct RestoreService {
+    pub ctx: Arc<Context>,
+}
+
+impl RestoreService {
+    pub fn new(ctx: Arc<Context>) -> Self {
+        Self { ctx }
+    }
+}

src/services/status.rs

@@ -4,68 +4,11 @@ use crate::core::context::Context;
 use crate::services::config::DatabaseConfig;
 use crate::settings::CONFIG;
 use reqwest::Client;
-use serde::{Deserialize, Serialize};
 use std::error::Error;
 use std::sync::Arc;
-use tracing::{error, info};
+use crate::services::api::endpoints::status::DatabasePayload;
+use crate::services::api::models::agent::status::PingResult;
 
-/// Payload for sending database info in the request
-#[derive(Serialize)]
-struct DatabasePayload<'a> {
-    name: &'a str,
-    dbms: &'a str,
-    #[serde(rename = "generatedId")]
-    generated_id: &'a str,
-}
-
-/// Body for the status API request
-#[derive(Serialize)]
-struct StatusRequestBody<'a> {
-    version: &'a str,
-    databases: Vec<DatabasePayload<'a>>,
-}
-
-/// Typed structs for the response
-#[derive(Debug, Deserialize)]
-pub struct PingResult {
-    pub agent: AgentInfo,
-    pub databases: Vec<DatabaseStatus>,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct AgentInfo {
-    pub id: String,
-    #[serde(rename = "lastContact")]
-    pub last_contact: String,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct DatabaseStatus {
-    pub dbms: String,
-    #[serde(rename = "generatedId")]
-    pub generated_id: String,
-    pub data: DatabaseData,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct DatabaseData {
-    pub backup: BackupInfo,
-    pub restore: RestoreInfo,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct BackupInfo {
-    pub action: bool,
-    pub cron: Option<String>, // can be null
-}
-
-#[derive(Debug, Deserialize)]
-pub struct RestoreInfo {
-    pub action: bool,
-    pub file: String,
-}
-
-/// Service for contacting the agent API
 pub struct StatusService {
     ctx: Arc<Context>,
     client: Client,
@@ -92,27 +35,7 @@ impl StatusService {
             .collect();
 
         let version_str = CONFIG.app_version.as_str();
-
-        let body = StatusRequestBody {
-            version: &version_str,
-            databases: databases_payload,
-        };
-
-        let url = format!(
-            "{}/api/agent/{}/status",
-            edge_key.server_url, edge_key.agent_id
-        );
-        info!("Status request | {}", url);
-
-        let resp = self.client.post(&url).json(&body).send().await?;
-        if !resp.status().is_success() {
-            let msg = format!("Request failed with status: {}", resp.status());
-            error!("{}", msg);
-            return Err(msg.into());
-        }
-
-        let result: PingResult = resp.json().await?;
-
+        let result = self.ctx.api.agent_status(&edge_key.agent_id, &version_str, databases_payload).await?.unwrap();
         Ok(result)
     }
 }

src/services/storage/mod.rs

@@ -0,0 +1,40 @@
+pub mod providers;
+
+use crate::core::context::Context;
+use crate::utils::common::BackupMethod;
+use async_trait::async_trait;
+use providers::local;
+use providers::s3;
+use providers::google_drive;
+use std::sync::Arc;
+use tracing::{error, info};
+use crate::services::api::models::agent::status::DatabaseStorage;
+use crate::services::backup::models::{BackupResult, UploadResult};
+
+#[async_trait]
+pub trait StorageProvider: Send + Sync {
+    async fn upload(
+        &self,
+        ctx: Arc<Context>,
+        result: BackupResult,
+        method: BackupMethod,
+        config: &DatabaseStorage,
+        encrypt: Option<bool>,
+    ) -> UploadResult;
+}
+
+/// Factory to create provider instance from storage config
+pub fn get_provider(storage: &DatabaseStorage) -> Option<Box<dyn StorageProvider>> {
+    info!("Getting provider");
+    info!("{:#?}", storage.provider.as_str());
+
+    match storage.provider.as_str() {
+        "local" => Some(Box::new(local::LocalProvider {})),
+        "s3" => Some(Box::new(s3::S3Provider {})),
+        "google-drive" => Some(Box::new(google_drive::GoogleDriveProvider {})),
+        _ => {
+            error!("Unknown storage provider: {}", storage.provider);
+            None
+        }
+    }
+}

src/services/storage/providers/google_drive/helpers.rs

@@ -0,0 +1,272 @@
+use anyhow::{Context, Result, anyhow};
+use futures::StreamExt;
+use oauth2::{
+    AuthUrl, ClientId, ClientSecret, RefreshToken, TokenResponse, TokenUrl, basic::BasicClient,
+    reqwest::Client as OAuth2ReqwestClient,
+};
+use reqwest::{Client as ReqwestClient, StatusCode};
+use serde_json::{Value, json};
+use futures::{Stream};
+use bytes::Bytes;
+use reqwest::{Client, header};
+use crate::services::storage::providers::google_drive::models::GoogleDriveProviderConfig;
+
+pub async fn get_google_drive_token(config: &GoogleDriveProviderConfig) -> Result<String> {
+    let http_client = OAuth2ReqwestClient::new();
+
+    let oauth_client = BasicClient::new(ClientId::new(config.client_id.clone()))
+        .set_client_secret(ClientSecret::new(config.client_secret.clone()))
+        .set_auth_uri(
+            AuthUrl::new("https://accounts.google.com/o/oauth2/auth".to_string())
+                .context("invalid auth uri")?,
+        )
+        .set_token_uri(
+            TokenUrl::new("https://oauth2.googleapis.com/token".to_string())
+                .context("invalid token uri")?,
+        );
+
+    let token_result = oauth_client
+        .exchange_refresh_token(&RefreshToken::new(config.refresh_token.clone()))
+        .request_async(&http_client)
+        .await
+        .context("failed to exchange refresh token")?;
+
+    Ok(token_result.access_token().secret().clone())
+}
+
+pub async fn ensure_folder_path(config: &GoogleDriveProviderConfig, path_parts: &[&str]) -> Result<String> {
+    if path_parts.is_empty() {
+        return Ok(config.folder_id.clone());
+    }
+
+    let token = get_google_drive_token(config).await?;
+    let client = ReqwestClient::new();
+    let mut parent_id = config.folder_id.clone();
+
+    for &name in path_parts {
+        let query = format!(
+            "'{parent_id}' in parents and name='{name}' and mimeType='application/vnd.google-apps.folder' and trashed=false"
+        );
+
+        let res = client
+            .get("https://www.googleapis.com/drive/v3/files")
+            .bearer_auth(&token)
+            .query(&[
+                ("q", query),
+                ("fields", "files(id,name)".to_string()),
+                ("supportsAllDrives", "true".to_string()),
+                ("includeItemsFromAllDrives", "true".to_string()),
+                ("corpora", "allDrives".to_string()),
+            ])
+            .send()
+            .await
+            .context("list folders failed")?
+            .json::<Value>()
+            .await?;
+
+        if let Some(files) = res["files"].as_array() {
+            if let Some(folder) = files.first() {
+                if let Some(id) = folder["id"].as_str() {
+                    parent_id = id.to_string();
+                    continue;
+                }
+            }
+        }
+
+        let create_payload = json!({
+            "name": name,
+            "mimeType": "application/vnd.google-apps.folder",
+            "parents": [parent_id],
+            "supportsAllDrives": true,
+        });
+
+        let folder = client
+            .post("https://www.googleapis.com/drive/v3/files")
+            .bearer_auth(&token)
+            .json(&create_payload)
+            .send()
+            .await
+            .context("create folder failed")?
+            .json::<Value>()
+            .await?;
+
+        parent_id = folder["id"]
+            .as_str()
+            .ok_or_else(|| anyhow!("No id returned after folder creation"))?
+            .to_string();
+    }
+
+    Ok(parent_id)
+}
+
+pub async fn find_file_by_name(
+    config: &GoogleDriveProviderConfig,
+    file_name: &str,
+    folder_id: &str,
+) -> Result<Option<String>> {
+    let token = get_google_drive_token(config).await?;
+    let client = ReqwestClient::new();
+
+    let query = format!("'{folder_id}' in parents and name='{file_name}' and trashed=false");
+
+    let res = client
+        .get("https://www.googleapis.com/drive/v3/files")
+        .bearer_auth(&token)
+        .query(&[
+            ("q", query),
+            ("fields", "files(id,name)".to_string()),
+            ("supportsAllDrives", "true".to_string()),
+            ("includeItemsFromAllDrives", "true".to_string()),
+            ("corpora", "allDrives".to_string()),
+        ])
+        .send()
+        .await?
+        .json::<Value>()
+        .await?;
+
+    if let Some(files) = res["files"].as_array() {
+        if let Some(file) = files.first() {
+            if let Some(id) = file["id"].as_str() {
+                return Ok(Some(id.to_string()));
+            }
+        }
+    }
+
+    Ok(None)
+}
+
+pub async fn upload_stream_to_google_drive(
+    config: &GoogleDriveProviderConfig,
+    full_path: &str,
+    mut content_stream: impl Stream<Item = Result<Bytes, std::io::Error>> + Send + Unpin + 'static,
+    total_size: u64,
+    mime_type: Option<&str>,
+) -> Result<()> {
+    let path_parts: Vec<&str> = full_path.split('/').filter(|s| !s.is_empty()).collect();
+    if path_parts.is_empty() {
+        return Err(anyhow::anyhow!("Invalid path: empty"));
+    }
+
+    let file_name = *path_parts.last().unwrap();
+    let folder_path = &path_parts[..path_parts.len() - 1];
+
+    let folder_id = ensure_folder_path(config, folder_path).await?;
+
+    if find_file_by_name(config, file_name, &folder_id).await?.is_some() {
+        return Err(anyhow::anyhow!("File already exists: {}", full_path));
+    }
+
+    let token = get_google_drive_token(config).await?;
+    let client = Client::new();
+
+    let mime = mime_type.unwrap_or("application/octet-stream");
+
+    let metadata = json!({
+        "name": file_name,
+        "parents": [folder_id],
+        "mimeType": mime,
+        "supportsAllDrives": true,
+    });
+
+    let session_res = client
+        .post("https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable")
+        .bearer_auth(&token)
+        .header("X-Upload-Content-Type", mime)
+        .header("X-Upload-Content-Length", total_size.to_string())  // Helps a lot
+        .json(&metadata)
+        .send()
+        .await
+        .context("Failed to initiate resumable upload")?;
+
+    if session_res.status() != StatusCode::OK {
+        let text = session_res.text().await.unwrap_or_default();
+        return Err(anyhow::anyhow!("Initiate failed: {}", text));
+    }
+
+    let upload_url = session_res
+        .headers()
+        .get(header::LOCATION)
+        .ok_or_else(|| anyhow::anyhow!("No Location header"))?
+        .to_str()?
+        .to_string();
+
+    const CHUNK_SIZE: u64 = 8 * 1024 * 1024;
+
+    let mut uploaded: u64 = 0;
+
+    while uploaded < total_size {
+        let chunk_size = (total_size - uploaded).min(CHUNK_SIZE);
+
+        let mut chunk_bytes = Vec::with_capacity(chunk_size as usize);
+        let mut remaining = chunk_size;
+
+        while remaining > 0 {
+            match content_stream.next().await {
+                Some(Ok(bytes)) => {
+                    let to_take = remaining.min(bytes.len() as u64) as usize;
+                    chunk_bytes.extend_from_slice(&bytes[..to_take]);
+                    remaining -= to_take as u64;
+
+                    if to_take < bytes.len() {
+                        // TODO : Put remainder back
+                    }
+                }
+                Some(Err(e)) => return Err(e).context("Stream error during chunk"),
+                None => {
+                    if uploaded + chunk_bytes.len() as u64 != total_size {
+                        return Err(anyhow::anyhow!("Stream ended early"));
+                    }
+                }
+            }
+        }
+
+        if chunk_bytes.is_empty() && uploaded < total_size {
+            return Err(anyhow::anyhow!("Unexpected end of stream"));
+        }
+
+        let range_end = uploaded + chunk_bytes.len() as u64 - 1;
+        let content_range = if uploaded + chunk_bytes.len() as u64 == total_size {
+            format!("bytes {}-{}/{}", uploaded, range_end, total_size)
+        } else {
+            format!("bytes {}-{}/*", uploaded, range_end)
+        };
+
+        let mut retries = 0;
+        loop {
+            let res = client
+                .put(&upload_url)
+                .header("Content-Range", &content_range)
+                .header("Content-Length", chunk_bytes.len().to_string())
+                .body(chunk_bytes.clone())  // clone is cheap if small; optimize later if needed
+                .send()
+                .await;
+
+            match res {
+                Ok(resp) if resp.status().is_success() || resp.status() == StatusCode::PERMANENT_REDIRECT => {
+                    // 200 or 308 = good
+                    uploaded += chunk_bytes.len() as u64;
+                    tracing::info!("Uploaded {}/{} bytes", uploaded, total_size);
+                    break;
+                }
+                Ok(resp) if resp.status() == StatusCode::TOO_MANY_REQUESTS => {
+                    // Backoff on 429
+                    tokio::time::sleep(std::time::Duration::from_secs(5 * (1 << retries))).await;
+                }
+                Ok(resp) => {
+                    let text = resp.text().await.unwrap_or_default();
+                    return Err(anyhow::anyhow!("Chunk upload failed: {}", text));
+                }
+                Err(e) if e.is_timeout() || e.is_connect() => {
+                    if retries > 5 {
+                        return Err(e).context("Too many retries");
+                    }
+                    retries += 1;
+                    tokio::time::sleep(std::time::Duration::from_secs(2u64.pow(retries))).await;
+                }
+                Err(e) => return Err(e).context("Chunk request failed"),
+            }
+        }
+    }
+
+    Ok(())
+}

src/services/storage/providers/google_drive/mod.rs

@@ -0,0 +1,129 @@
+mod helpers;
+mod models; 
+
+use crate::core::context::Context;
+use crate::services::api::models::agent::status::DatabaseStorage;
+use crate::services::storage::StorageProvider;
+use crate::utils::common::BackupMethod;
+use crate::utils::file::{full_file_name, full_file_path};
+use crate::utils::stream::build_stream;
+use async_trait::async_trait;
+use std::sync::Arc;
+use tokio::fs;
+use tracing::{error, info};
+use crate::services::backup::models::{BackupResult, UploadResult};
+use crate::services::storage::providers::google_drive::helpers::{upload_stream_to_google_drive};
+use crate::services::storage::providers::google_drive::models::GoogleDriveProviderConfig;
+
+pub struct GoogleDriveProvider {}
+
+#[async_trait]
+impl StorageProvider for GoogleDriveProvider {
+    async fn upload(
+        &self,
+        ctx: Arc<Context>,
+        result: BackupResult,
+        _method: BackupMethod,
+        storage: &DatabaseStorage,
+        encrypt: Option<bool>,
+    ) -> UploadResult {
+        let Some(file_path) = result.backup_file else {
+            return UploadResult {
+                storage_id: storage.id.clone(),
+                success: false,
+                error: Some("Missing backup file path".to_string()),
+                remote_file_path: None,
+                total_size: None,
+            };
+        };
+
+        let total_size = match fs::metadata(&file_path).await {
+            Ok(meta) => meta.len(),
+            Err(e) => {
+                error!("Failed to get file size: {}", e);
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let encrypt = encrypt.unwrap_or(false);
+
+        let upload = match build_stream(
+            &file_path,
+            encrypt,
+            &ctx.edge_key.master_key_b64
+        )
+            .await
+        {
+            Ok(u) => u,
+            Err(e) => {
+                error!("Stream build failed: {}", e);
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let config: GoogleDriveProviderConfig = match storage.clone().config.try_into() {
+            Ok(c) => c,
+            Err(e) => {
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+
+        let file_name = full_file_name(encrypt);
+
+        info!("Uploading file {}", file_name);
+
+        let remote_file_path = full_file_path(&file_name);
+
+        match upload_stream_to_google_drive(
+            &config,
+            &remote_file_path,
+            upload.stream,   
+            total_size,
+            Some("application/octet-stream"),
+        ).await {
+            Ok(_file_id) => {
+                
+                info!("Google Drive upload successful");
+
+                UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: true,
+                    error: None,
+                    remote_file_path: Some(remote_file_path),
+                    total_size: Some(total_size),
+                }
+            }
+            Err(e) => {
+                error!("Google Drive upload failed: {:?}", e);
+
+                UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: Some(total_size),
+                }
+            }
+        }
+
+    }
+}

src/services/storage/providers/google_drive/models.rs

@@ -0,0 +1,11 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct GoogleDriveProviderConfig {
+    pub client_id: String,
+    pub client_secret: String,
+    pub refresh_token: String,
+    pub folder_id: String,
+}
+
+

src/services/storage/providers/local.rs

@@ -0,0 +1,116 @@
+use crate::core::context::Context;
+use crate::services::api::models::agent::status::DatabaseStorage;
+use crate::services::storage::StorageProvider;
+use crate::utils::common::BackupMethod;
+use crate::utils::file::{full_file_name, full_file_path};
+use crate::utils::stream::build_stream;
+use crate::utils::tus::upload_to_tus_stream_with_headers;
+use async_trait::async_trait;
+use reqwest::header::{HeaderMap, HeaderValue};
+use std::sync::Arc;
+use tokio::fs;
+use tracing::error;
+use crate::services::backup::models::{BackupResult, UploadResult};
+
+pub struct LocalProvider;
+
+#[async_trait]
+impl StorageProvider for LocalProvider {
+    async fn upload(
+        &self,
+        ctx: Arc<Context>,
+        result: BackupResult,
+        method: BackupMethod,
+        storage: &DatabaseStorage,
+        encrypt: Option<bool>,
+    ) -> UploadResult {
+        let Some(file_path) = result.backup_file else {
+            return UploadResult {
+                storage_id: storage.id.clone(),
+                success: false,
+                error: Some("File path error".to_string()),
+                remote_file_path: None,
+                total_size: None,
+            };
+        };
+
+        let encrypt = encrypt.unwrap_or(false);
+
+        let file_name = full_file_name(encrypt);
+        let remote_file_path = full_file_path(&file_name);
+
+        let total_size = match fs::metadata(&file_path).await {
+            Ok(meta) => meta.len(),
+            Err(e) => {
+                error!("Failed to get file size: {}", e);
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let upload = match build_stream(
+            &file_path,
+            encrypt,
+            &ctx.edge_key.master_key_b64
+        )
+        .await
+        {
+            Ok(u) => u,
+            Err(e) => {
+                error!("Stream build failed: {}", e);
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None
+                };
+            }
+        };
+
+        let mut extra_headers = HeaderMap::new();
+
+        extra_headers.insert("X-File-Name", HeaderValue::from_str(&file_name).unwrap());
+        extra_headers.insert("X-File-Size", HeaderValue::from_str(&total_size.to_string()).unwrap());
+        extra_headers.insert(
+            "X-File-Path",
+            HeaderValue::from_str(&remote_file_path).unwrap(),
+        );
+        extra_headers.insert(
+            "X-Generated-Id",
+            HeaderValue::from_str(&result.generated_id).unwrap(),
+        );
+        extra_headers.insert("X-Status", HeaderValue::from_str(&result.status).unwrap());
+        extra_headers.insert(
+            "X-Method",
+            HeaderValue::from_str(&method.to_string()).unwrap(),
+        );
+        
+        let tus_endpoint = format!("{}/tus/files", ctx.edge_key.server_url);
+
+        match upload_to_tus_stream_with_headers(upload.stream, &tus_endpoint, extra_headers, total_size).await {
+            Ok(_) => UploadResult {
+                storage_id: storage.id.clone(),
+                success: true,
+                error: None,
+                remote_file_path: Some(remote_file_path),
+                total_size: Some(total_size),
+            },
+            Err(e) => {
+                error!("Local upload failed: {}", e);
+                UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                }
+            }
+        }
+    }
+}

src/services/storage/providers/mod.rs

@@ -0,0 +1,3 @@
+pub mod local;
+pub mod s3;
+pub mod google_drive;

src/services/storage/providers/s3/mod.rs

@@ -0,0 +1,314 @@
+mod models;
+
+use crate::core::context::Context;
+use crate::services::api::models::agent::status::DatabaseStorage;
+use crate::services::storage::StorageProvider;
+use crate::services::storage::providers::s3::models::S3ProviderConfig;
+use crate::utils::common::BackupMethod;
+use crate::utils::file::{full_file_name, full_file_path};
+use crate::utils::stream::build_stream;
+use async_trait::async_trait;
+use aws_sdk_s3 as s3;
+use aws_sdk_s3::config::BehaviorVersion;
+use aws_sdk_s3::config::Region;
+use aws_sdk_s3::primitives::ByteStream;
+use aws_sdk_s3::types::{CompletedMultipartUpload, CompletedPart};
+use futures::StreamExt;
+use std::pin::Pin;
+use std::sync::Arc;
+use tokio::fs;
+use tracing::{error, info};
+use crate::services::backup::models::{BackupResult, UploadResult};
+
+pub struct S3Provider {}
+
+#[async_trait]
+impl StorageProvider for S3Provider {
+    async fn upload(
+        &self,
+        ctx: Arc<Context>,
+        result: BackupResult,
+        _method: BackupMethod,
+        storage: &DatabaseStorage,
+        encrypt: Option<bool>,
+    ) -> UploadResult {
+        let Some(file_path) = result.backup_file else {
+            return UploadResult {
+                storage_id: storage.id.clone(),
+                success: false,
+                error: Some("Missing backup file path".to_string()),
+                remote_file_path: None,
+                total_size: None,
+            };
+        };
+
+        let total_size = match fs::metadata(&file_path).await {
+            Ok(meta) => meta.len(),
+            Err(e) => {
+                error!("Failed to get file size: {}", e);
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let encrypt = encrypt.unwrap_or(false);
+
+        let upload = match build_stream(&file_path, encrypt, &ctx.edge_key.master_key_b64).await {
+            Ok(u) => u,
+            Err(e) => {
+                error!("Stream build failed: {}", e);
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let config: S3ProviderConfig = match storage.clone().config.try_into() {
+            Ok(c) => c,
+            Err(e) => {
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let credentials = s3::config::Credentials::new(
+            config.access_key.clone(),
+            config.secret_key.clone(),
+            None,
+            None,
+            "static-creds",
+        );
+
+        let region = Region::new(config.region.clone().unwrap_or("us-east-1".to_string()));
+        
+        let endpoint = if let Some(port) = &config.port {
+            if port.trim().is_empty() {
+                format!("{}://{}", if config.ssl { "https" } else { "http" }, config.end_point_url)
+            } else {
+                format!("{}://{}:{}", if config.ssl { "https" } else { "http" }, config.end_point_url, port)
+            }
+        } else {
+            format!("{}://{}", if config.ssl { "https" } else { "http" }, config.end_point_url)
+        };
+
+        info!("S3 endpoint to {}", &endpoint);
+
+        let sdk_config = s3::config::Builder::new()
+            .credentials_provider(credentials)
+            .region(region)
+            .force_path_style(true)
+            .endpoint_url(endpoint)
+            .behavior_version(BehaviorVersion::latest())
+            .build();
+
+        let client = s3::Client::from_conf(sdk_config);
+
+        const PART_SIZE: usize = 100 * 1024 * 1024; // 100 MiB
+
+        let file_name = full_file_name(encrypt);
+
+        info!("Uploading file {}", file_name);
+
+        let bucket = &config.bucket_name;
+        let remote_file_path = full_file_path(&file_name);
+        info!("S3 key {:}", remote_file_path);
+        info!(
+            "Starting multipart upload to s3://{}/{}",
+            bucket, remote_file_path
+        );
+
+        let create_resp = match client
+            .create_multipart_upload()
+            .bucket(bucket)
+            .key(&remote_file_path)
+            .send()
+            .await
+        {
+            Ok(r) => r,
+            Err(e) => {
+                error!("Failed to create multipart upload: {}", e);
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let upload_id = match create_resp.upload_id {
+            Some(id) => id,
+            None => {
+                return UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some("No upload ID returned".to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                };
+            }
+        };
+
+        let mut parts: Vec<CompletedPart> = Vec::new();
+        let mut part_number: i32 = 1;
+        let mut buffer: Vec<u8> = Vec::with_capacity(PART_SIZE);
+
+        let mut peekable = upload.stream.peekable();
+
+        while let Some(item) = peekable.next().await {
+            let bytes = match item {
+                Ok(b) => b,
+                Err(e) => {
+                    error!("Stream error during upload: {}", e);
+                    let _ = client
+                        .abort_multipart_upload()
+                        .bucket(bucket)
+                        .key(&remote_file_path)
+                        .upload_id(&upload_id)
+                        .send()
+                        .await;
+                    return UploadResult {
+                        storage_id: storage.id.clone(),
+                        success: false,
+                        error: Some(format!("Stream error: {}", e)),
+                        remote_file_path: None,
+                        total_size: None,
+                    };
+                }
+            };
+
+            buffer.extend_from_slice(&bytes);
+
+            let is_last = {
+                let pinned = Pin::new(&mut peekable);
+                let peek_future = pinned.peek();
+                peek_future.await.is_none()
+            };
+
+            let should_upload = buffer.len() >= PART_SIZE || is_last;
+
+            if should_upload && !buffer.is_empty() {
+                let body = ByteStream::from(buffer.clone());
+
+                match client
+                    .upload_part()
+                    .bucket(bucket)
+                    .key(&remote_file_path)
+                    .upload_id(&upload_id)
+                    .part_number(part_number)
+                    .body(body)
+                    .send()
+                    .await
+                {
+                    Ok(resp) => {
+                        if let Some(etag) = resp.e_tag {
+                            parts.push(
+                                CompletedPart::builder()
+                                    .part_number(part_number)
+                                    .e_tag(etag)
+                                    .build(),
+                            );
+                            info!("Uploaded part {} ({} bytes)", part_number, buffer.len());
+                        }
+                    }
+                    Err(e) => {
+                        error!("Failed to upload part {}: {}", part_number, e);
+                        let _ = client
+                            .abort_multipart_upload()
+                            .bucket(bucket)
+                            .key(&remote_file_path)
+                            .upload_id(&upload_id)
+                            .send()
+                            .await;
+                        return UploadResult {
+                            storage_id: storage.id.clone(),
+                            success: false,
+                            error: Some(e.to_string()),
+                            remote_file_path: None,
+                            total_size: None,
+                        };
+                    }
+                }
+                buffer.clear();
+                part_number += 1;
+            }
+        }
+
+        if !buffer.is_empty() {
+            let _ = client
+                .abort_multipart_upload()
+                .bucket(bucket)
+                .key(&remote_file_path)
+                .upload_id(&upload_id)
+                .send()
+                .await;
+            return UploadResult {
+                storage_id: storage.id.clone(),
+                success: false,
+                error: Some("No parts were uploaded".to_string()),
+                remote_file_path: None,
+                total_size: None,
+            };
+        }
+
+        let completed = CompletedMultipartUpload::builder()
+            .set_parts(Some(parts))
+            .build();
+
+        match client
+            .complete_multipart_upload()
+            .bucket(bucket)
+            .key(&remote_file_path)
+            .upload_id(&upload_id)
+            .multipart_upload(completed)
+            .send()
+            .await
+        {
+            Ok(_) => {
+                info!(
+                    "Successfully completed multipart upload: {}",
+                    remote_file_path
+                );
+                UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: true,
+                    error: None,
+                    remote_file_path: Some(remote_file_path),
+                    total_size: Some(total_size),
+                }
+            }
+            Err(e) => {
+                error!("Failed to complete multipart upload: {}", e);
+                let _ = client
+                    .abort_multipart_upload()
+                    .bucket(bucket)
+                    .key(&remote_file_path)
+                    .upload_id(&upload_id)
+                    .send()
+                    .await;
+                UploadResult {
+                    storage_id: storage.id.clone(),
+                    success: false,
+                    error: Some(e.to_string()),
+                    remote_file_path: None,
+                    total_size: None,
+                }
+            }
+        }
+    }
+}