chore: release 1.23.1

Dev

.env.e2e

@@ -1,41 +0,0 @@
-PROJECT_URL=http://localhost:8887
-
-E2E_NOTIFICATION_SMTP_HOST="smtp.lunaris-mail.test"
-E2E_NOTIFICATION_SMTP_PORT="587"
-E2E_NOTIFICATION_SMTP_USER="e2e_user_7f9a2c"
-E2E_NOTIFICATION_SMTP_PASSWORD="uR8vK3mZpQ92xTnB"
-E2E_NOTIFICATION_SMTP_FROM="e2e-sender@lunaris-mail.test"
-E2E_NOTIFICATION_SMTP_TO="e2e-recipient@lunaris-mail.test"
-E2E_NOTIFICATION_SLACK_WEBHOOK="https://hooks.slack.com/services/T00000000/B00000000/AbCdEfGhIjKlMnOpQrStUvWx"
-E2E_NOTIFICATION_DISCORD_WEBHOOK="https://discord.com/api/webhooks/123456789012345678/qtY8xKpLmN4vBzR6sWdE9uHaC3fGjT2"
-E2E_NOTIFICATION_TELEGRAM_BOT_TOKEN="7352198460:AAHkLm9vPqR2sTuVwXyZ1234567890abcd"
-E2E_NOTIFICATION_TELEGRAM_CHAT_ID="-1002847391826"
-E2E_NOTIFICATION_TELEGRAM_TOPIC_ID="42"
-E2E_NOTIFICATION_GOTIFY_SERVER_URL="https://gotify-e2e.lunaris.test"
-E2E_NOTIFICATION_GOTIFY_APP_TOKEN="gfy_8a92f3c1d7e64b0aa51c"
-E2E_NOTIFICATION_NTFY_TOPIC="e2e-alerts-7f9a2c"
-E2E_NOTIFICATION_NTFY_SERVER_URL="https://ntfy.sh"
-E2E_NOTIFICATION_NTFY_TOKEN="tk_e2e_9c7f4a1b6d2e8f0"
-E2E_NOTIFICATION_NTFY_USERNAME="ntfy_e2e_user"
-E2E_NOTIFICATION_NTFY_PASSWORD="NtFyP4ss_8rQ2zLm"
-E2E_NOTIFICATION_WEBHOOK_URL="https://webhook-e2e.lunaris.test/notify"
-E2E_NOTIFICATION_WEBHOOK_SECRET_HEADER="X-E2E-Signature"
-E2E_NOTIFICATION_WEBHOOK_SECRET="whsec_2f8a9c4e71b6d3a0"
-
-E2E_STORAGE_AWS_S3_ENDPOINT_URL="https://s3.eu-west-3.amazonaws.com"
-E2E_STORAGE_AWS_S3_REGION="eu-west-3"
-E2E_STORAGE_AWS_S3_ACCESS_KEY="AKIAE2E7F9A2C4D6B8QX"
-E2E_STORAGE_AWS_S3_SECRET_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
-E2E_STORAGE_AWS_S3_BUCKET_NAME="e2e-bucket-7f9a2c"
-E2E_STORAGE_AWS_S3_PORT="443"
-
-E2E_STORAGE_R2_ENDPOINT_URL="https://7f9a2c4d6b8q.r2.cloudflarestorage.com"
-E2E_STORAGE_R2_REGION="auto"
-E2E_STORAGE_R2_ACCESS_KEY="R2E2E7F9A2C4D6B8QX"
-E2E_STORAGE_R2_SECRET_KEY="r2sec_8vK3mZpQ92xTnBuR4sWdE9uHaC3fGjT2"
-E2E_STORAGE_R2_BUCKET_NAME="r2-e2e-bucket-7f9a2c"
-E2E_STORAGE_R2_PORT="443"
-
-E2E_STORAGE_GOOGLE_DRIVE_CLIENT_ID="735219846012-e2e7f9a2c4d6b8q.apps.googleusercontent.com"
-E2E_STORAGE_GOOGLE_DRIVE_CLIENT_SECRET="GOCSPX-e2e_8vK3mZpQ92xTnBuR4sWd"
-E2E_STORAGE_GOOGLE_DRIVE_FOLDER_ID="1E2e7F9a2C4d6B8qXzLmNoPqRsTuVwXyZ"

.env.example

@@ -15,6 +15,15 @@ PROJECT_NAME="Portabase"
 PROJECT_URL=http://localhost:8887
 PROJECT_SECRET=
 
+AUTH_DEFAULT_USER_NAME="Portabase Admin"
+AUTH_DEFAULT_USER=user@example.com
+# Password must contain at least 8 characters
+# Password must contain at least 1 number
+# Password must contain at least 1 lowercase letter
+# Password must contain at least 1 uppercase letter
+# Password must contain at least 1 special character
+AUTH_DEFAULT_PASSWORD=testPASS123456!
+
 # SMTP (email)
 SMTP_HOST=
 SMTP_PORT=
@@ -64,4 +73,14 @@ AUTH_PASSKEY_ENABLED=true
 # Retention
 RETENTION_CRON="* * * * *"
 
-TRUSTED_DOMAINS="http://localhost:8887, http://localhost:3055, http://localhost:3056, http://localhost:3057"
+TRUSTED_DOMAINS="http://localhost:8887, http://localhost:3055, http://localhost:3056"
+
+#OPENAPI_ENABLED=true
+#API_ENABLED=true
+#MCP_ENABLED=true
+
+# Default to false
+#TUSD_BEHIND_PROXY=true
+
+#Skip the onboarding on fresh instance
+#SKIP_ONBOARDING=true

.eslintrc.json

@@ -1,11 +1,7 @@
 {
-  "extends": [
-    "next/core-web-vitals",
-    "plugin:tailwindcss/recommended"
-  ],
+  "extends": ["next/core-web-vitals", "plugin:tailwindcss/recommended"],
   "rules": {
     "react/no-unescaped-entities": "off",
     "react-hooks/rules-of-hooks": "off"
-
   }
 }

.github/CONTRIBUTING.md

@@ -14,8 +14,9 @@ Please take a moment to review this guide. It will help you understand how to co
 2. [Reporting Issues](#reporting-issues)
 3. [Submitting Changes](#submitting-changes)
 4. [Code Style Guidelines](#code-style-guidelines)
-5. [Pull Request Process](#pull-request-process)
-6. [Community Guidelines](#community-guidelines)
+5. [E2E Tests](#e2e-tests)
+6. [Pull Request Process](#pull-request-process)
+7. [Community Guidelines](#community-guidelines)
 
 ---
 
@@ -88,6 +89,14 @@ If you encounter a bug or have a suggestion for improvement, follow these steps:
 
 ---
 
+## E2E Tests
+
+E2E tests now live in a dedicated repository: [Portabase/e2e-tests](https://github.com/Portabase/e2e-tests).
+
+If your contribution needs corresponding end-to-end test coverage, add it there instead of this repo.
+
+---
+
 ## Pull Request Process
 
 1. Ensure your code passes all tests and linters.

.github/workflows/discord.yml

@@ -24,50 +24,86 @@ on:
 jobs:
   notify-discord:
     runs-on: ubuntu-latest
+
     steps:
       - name: Send Discord Notification
         env:
           DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}
           GH_TOKEN: ${{ secrets.GH_TOKEN }}
+          RELEASE_TAG: ${{ inputs.release_tag }}
+          DISCORD_TITLE: ${{ inputs.discord_title }}
+          DISCORD_COLOR: ${{ inputs.discord_color }}
+          DISCORD_FOOTER: ${{ inputs.discord_footer }}
         run: |
-          RELEASE_INFO=$(gh release view "${{ inputs.release_tag }}" -R ${{ github.repository }} --json name,url,body,author)
+          set -euo pipefail
 
-          RELEASE_TITLE=$(echo "$RELEASE_INFO" | jq -r .name)
-          if [ -z "$RELEASE_TITLE" ] || [ "$RELEASE_TITLE" = "null" ]; then RELEASE_TITLE="${{ inputs.release_tag }}"; fi
+          RELEASE_INFO=$(gh release view "$RELEASE_TAG" -R "${{ github.repository }}" --json name,url,body,author)
 
-          RELEASE_URL=$(echo "$RELEASE_INFO" | jq -r .url)
-          RELEASE_BODY=$(echo "$RELEASE_INFO" | jq -r .body)
+          RELEASE_TITLE=$(echo "$RELEASE_INFO" | jq -r '.name // empty')
+          if [ -z "$RELEASE_TITLE" ]; then
+            RELEASE_TITLE="$RELEASE_TAG"
+          fi
+
+          RELEASE_URL=$(echo "$RELEASE_INFO" | jq -r '.url // empty')
+          RELEASE_BODY=$(echo "$RELEASE_INFO" | jq -r '.body // ""')
 
           AUTHOR_NAME="Portabase"
           AUTHOR_ICON="https://github.com/Portabase.png"
 
-          PAYLOAD=$(jq -n \
+          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 }} \
+            --arg discord_title "$DISCORD_TITLE" \
+            --arg discord_footer "$DISCORD_FOOTER" \
+            --argjson discord_color "$DISCORD_COLOR" \
             '{
-              content: $discord_title,
+              content: (
+                if ($discord_title | length) > 1900
+                then ($discord_title[0:1900] + "...")
+                else $discord_title
+                end
+              ),
               embeds: [{
-                title: $title,
+                title: (
+                  if ($title | length) > 256
+                  then ($title[0:253] + "...")
+                  else $title
+                  end
+                ),
                 url: $url,
-                description: $description,
+                description: (
+                  if ($description | length) > 3800
+                  then ($description[0:3800] + "\n\n...")
+                  else $description
+                  end
+                ),
                 color: $discord_color,
                 author: {
-                  name: $author,
+                  name: (
+                    if ($author | length) > 256
+                    then ($author[0:253] + "...")
+                    else $author
+                    end
+                  ),
                   icon_url: $icon
                 },
                 footer: {
-                  text: $discord_footer
+                  text: (
+                    if ($discord_footer | length) > 512
+                    then ($discord_footer[0:509] + "...")
+                    else $discord_footer
+                    end
+                  )
                 }
               }]
-            }'
-          )
+            }' > payload.json
 
-          curl -H "Content-Type: application/json" \
-               -d "$PAYLOAD" \
-               "$DISCORD_WEBHOOK"
+          cat payload.json | jq .
+
+          curl --fail-with-body -sS \
+            -H "Content-Type: application/json" \
+            -d @payload.json \
+            "$DISCORD_WEBHOOK?wait=true"

.github/workflows/docker.yml

@@ -73,7 +73,7 @@ jobs:
           tags: ${{ steps.prep.outputs.image }}
           target: ${{ inputs.target }}
           cache-from: type=gha,scope=build-${{ matrix.platform }}
-          cache-to: type=gha,mode=max,scope=build-${{ matrix.platform }}
+          cache-to: type=gha,mode=max,scope=build-${{ matrix.platform }},ignore-error=true
 
       - name: Save image name for manifest
         run: echo "${{ steps.prep.outputs.image }}" > image.txt

.github/workflows/e2e.yml

@@ -4,161 +4,83 @@ on:
   pull_request:
     branches: [main]
 
+permissions:
+  contents: read
+  packages: write
+
 jobs:
-  build-and-test:
+  build-image:
     runs-on: ubuntu-latest
     if: github.event.pull_request.head.repo.full_name == github.repository
+    outputs:
+      image: ${{ steps.image.outputs.ref }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
+      - name: Compute image reference
+        id: image
+        run: echo "ref=ghcr.io/${GITHUB_REPOSITORY_OWNER,,}/portabase:${GITHUB_SHA}" >> "$GITHUB_OUTPUT"
 
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to GHCR
+        uses: docker/login-action@v3
         with:
-          node-version: 22
-          cache: 'pnpm'
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Build Docker image
+      - name: Build and push Docker image
         uses: docker/build-push-action@v6
         with:
           context: .
           file: ./docker/dockerfile/Dockerfile
-          push: false
-          load: true
-          tags: portabase/portabase:test
+          push: true
+          tags: ${{ steps.image.outputs.ref }}
+          target: prod
 
-      - name: Create shared Docker network
-        run: |
-          docker network inspect portabase >/dev/null 2>&1 || \
-            docker network create portabase
-
-      - name: Seed OIDC services
-        run: make seed-auth
-
-      - name: Wait for OIDC providers
-        run: |
-          for i in {1..60}; do
-            if curl -fsS http://localhost:3056/realms/master/.well-known/openid-configuration >/dev/null; then
-              echo "Keycloak is ready"
-              break
-            fi
-            if [ "$i" -eq 60 ]; then
-              echo "Timeout: Keycloak never became ready"
-              docker compose -f docker-compose.oidc.yml logs
-              exit 1
-            fi
-            echo "Waiting for Keycloak... ($i/60)"
-            sleep 2
-          done
-
-          for i in {1..60}; do
-            if curl -fsS http://localhost:3055/healthz >/dev/null; then
-              echo "Pocket ID is ready"
-              break
-            fi
-            if [ "$i" -eq 60 ]; then
-              echo "Timeout: Pocket ID never became ready"
-              docker compose -f docker-compose.oidc.yml logs
-              exit 1
-            fi
-            echo "Waiting for Pocket ID... ($i/60)"
-            sleep 2
-          done
-
-          for i in {1..60}; do
-            if curl -fsS http://localhost:3057/application/o/portabase/.well-known/openid-configuration >/dev/null; then
-              echo "Authentik is ready"
-              break
-            fi
-            if [ "$i" -eq 60 ]; then
-              echo "Timeout: Authentik never became ready"
-              docker compose -f docker-compose.oidc.yml logs
-              exit 1
-            fi
-            echo "Waiting for Authentik... ($i/60)"
-            sleep 2
-          done
-
-      - name: Start E2E app stack
-        run: docker compose -f docker-compose.prod.yml up -d --no-build
-
-      - name: Wait for app port to be listening
-        run: |
-          for i in {1..40}; do
-            if curl -fsS http://localhost:8887/ >/dev/null; then
-              echo "App is responding on port 8887"
-              exit 0
-            fi
-            echo "Waiting for app readiness... ($i/40)"
-            sleep 2
-          done
-          echo "Timeout: app never became ready"
-          docker compose -f docker-compose.prod.yml logs
-          exit 1
-
-      - name: Install Playwright browsers
-        run: pnpm exec playwright install --with-deps chromium
-
-      - name: Run Playwright tests
-        run: pnpm exec playwright test
-        env:
-          PROJECT_URL: http://localhost:8887
-          # E2E Notification
-          E2E_NOTIFICATION_SMTP_HOST: ${{ secrets.E2E_NOTIFICATION_SMTP_HOST }}
-          E2E_NOTIFICATION_SMTP_PORT: ${{ secrets.E2E_NOTIFICATION_SMTP_PORT }}
-          E2E_NOTIFICATION_SMTP_USER: ${{ secrets.E2E_NOTIFICATION_SMTP_USER }}
-          E2E_NOTIFICATION_SMTP_PASSWORD: ${{ secrets.E2E_NOTIFICATION_SMTP_PASSWORD }}
-          E2E_NOTIFICATION_SMTP_FROM: ${{ secrets.E2E_NOTIFICATION_SMTP_FROM }}
-          E2E_NOTIFICATION_SMTP_TO: ${{ secrets.E2E_NOTIFICATION_SMTP_TO }}
-          E2E_NOTIFICATION_SLACK_WEBHOOK: ${{ secrets.E2E_NOTIFICATION_SLACK_WEBHOOK }}
-          E2E_NOTIFICATION_DISCORD_WEBHOOK: ${{ secrets.E2E_NOTIFICATION_DISCORD_WEBHOOK }}
-          E2E_NOTIFICATION_TELEGRAM_BOT_TOKEN: ${{ secrets.E2E_NOTIFICATION_TELEGRAM_BOT_TOKEN }}
-          E2E_NOTIFICATION_TELEGRAM_CHAT_ID: ${{ secrets.E2E_NOTIFICATION_TELEGRAM_CHAT_ID }}
-          E2E_NOTIFICATION_TELEGRAM_TOPIC_ID: ${{ secrets.E2E_NOTIFICATION_TELEGRAM_TOPIC_ID }}
-          E2E_NOTIFICATION_GOTIFY_SERVER_URL: ${{ secrets.E2E_NOTIFICATION_GOTIFY_SERVER_URL }}
-          E2E_NOTIFICATION_GOTIFY_APP_TOKEN: ${{ secrets.E2E_NOTIFICATION_GOTIFY_APP_TOKEN }}
-          E2E_NOTIFICATION_NTFY_TOPIC: ${{ secrets.E2E_NOTIFICATION_NTFY_TOPIC }}
-          E2E_NOTIFICATION_NTFY_SERVER_URL: ${{ secrets.E2E_NOTIFICATION_NTFY_SERVER_URL }}
-          E2E_NOTIFICATION_NTFY_TOKEN: ${{ secrets.E2E_NOTIFICATION_NTFY_TOKEN }}
-          E2E_NOTIFICATION_NTFY_USERNAME: ${{ secrets.E2E_NOTIFICATION_NTFY_USERNAME }}
-          E2E_NOTIFICATION_NTFY_PASSWORD: ${{ secrets.E2E_NOTIFICATION_NTFY_PASSWORD }}
-          E2E_NOTIFICATION_WEBHOOK_URL: ${{ secrets.E2E_NOTIFICATION_WEBHOOK_URL }}
-          E2E_NOTIFICATION_WEBHOOK_SECRET_HEADER: ${{ secrets.E2E_NOTIFICATION_WEBHOOK_SECRET_HEADER }}
-          E2E_NOTIFICATION_WEBHOOK_SECRET: ${{ secrets.E2E_NOTIFICATION_WEBHOOK_SECRET }}
-
-          # E2E Storage
-          E2E_STORAGE_AWS_S3_ENDPOINT_URL: ${{ secrets.E2E_STORAGE_AWS_S3_ENDPOINT_URL }}
-          E2E_STORAGE_AWS_S3_REGION: ${{ secrets.E2E_STORAGE_AWS_S3_REGION }}
-          E2E_STORAGE_AWS_S3_ACCESS_KEY: ${{ secrets.E2E_STORAGE_AWS_S3_ACCESS_KEY }}
-          E2E_STORAGE_AWS_S3_SECRET_KEY: ${{ secrets.E2E_STORAGE_AWS_S3_SECRET_KEY }}
-          E2E_STORAGE_AWS_S3_BUCKET_NAME: ${{ secrets.E2E_STORAGE_AWS_S3_BUCKET_NAME }}
-          E2E_STORAGE_AWS_S3_PORT: ${{ secrets.E2E_STORAGE_AWS_S3_PORT }}
-          E2E_STORAGE_R2_ENDPOINT_URL: ${{ secrets.E2E_STORAGE_R2_ENDPOINT_URL }}
-          E2E_STORAGE_R2_REGION: ${{ secrets.E2E_STORAGE_R2_REGION }}
-          E2E_STORAGE_R2_ACCESS_KEY: ${{ secrets.E2E_STORAGE_R2_ACCESS_KEY }}
-          E2E_STORAGE_R2_SECRET_KEY: ${{ secrets.E2E_STORAGE_R2_SECRET_KEY }}
-          E2E_STORAGE_R2_BUCKET_NAME: ${{ secrets.E2E_STORAGE_R2_BUCKET_NAME }}
-          E2E_STORAGE_R2_PORT: ${{ secrets.E2E_STORAGE_R2_PORT }}
-          E2E_STORAGE_GOOGLE_DRIVE_CLIENT_ID: ${{ secrets.E2E_STORAGE_GOOGLE_DRIVE_CLIENT_ID }}
-          E2E_STORAGE_GOOGLE_DRIVE_CLIENT_SECRET: ${{ secrets.E2E_STORAGE_GOOGLE_DRIVE_CLIENT_SECRET }}
-          E2E_STORAGE_GOOGLE_DRIVE_FOLDER_ID: ${{ secrets.E2E_STORAGE_GOOGLE_DRIVE_FOLDER_ID }}
-
-      - name: Upload report if failed
-        if: failure()
-        uses: actions/upload-artifact@v4
-        with:
-          name: playwright-report
-          path: playwright-report/
-          retention-days: 7
-
-      - name: Cleanup
-        if: always()
-        run: |
-          docker compose -f docker-compose.prod.yml down --volumes || true
-          docker compose -f docker-compose.oidc.yml down --volumes || true
+  run-e2e:
+    if: github.event.pull_request.head.repo.full_name == github.repository
+    needs: build-image
+    uses: portabase/e2e-tests/.github/workflows/run-e2e.yml@main
+    with:
+      server_image: ${{ needs.build-image.outputs.image }}
+    secrets:
+      E2E_NOTIFICATION_SMTP_HOST: ${{ secrets.E2E_NOTIFICATION_SMTP_HOST }}
+      E2E_NOTIFICATION_SMTP_PORT: ${{ secrets.E2E_NOTIFICATION_SMTP_PORT }}
+      E2E_NOTIFICATION_SMTP_USER: ${{ secrets.E2E_NOTIFICATION_SMTP_USER }}
+      E2E_NOTIFICATION_SMTP_PASSWORD: ${{ secrets.E2E_NOTIFICATION_SMTP_PASSWORD }}
+      E2E_NOTIFICATION_SMTP_FROM: ${{ secrets.E2E_NOTIFICATION_SMTP_FROM }}
+      E2E_NOTIFICATION_SMTP_TO: ${{ secrets.E2E_NOTIFICATION_SMTP_TO }}
+      E2E_NOTIFICATION_SLACK_WEBHOOK: ${{ secrets.E2E_NOTIFICATION_SLACK_WEBHOOK }}
+      E2E_NOTIFICATION_DISCORD_WEBHOOK: ${{ secrets.E2E_NOTIFICATION_DISCORD_WEBHOOK }}
+      E2E_NOTIFICATION_TELEGRAM_BOT_TOKEN: ${{ secrets.E2E_NOTIFICATION_TELEGRAM_BOT_TOKEN }}
+      E2E_NOTIFICATION_TELEGRAM_CHAT_ID: ${{ secrets.E2E_NOTIFICATION_TELEGRAM_CHAT_ID }}
+      E2E_NOTIFICATION_TELEGRAM_TOPIC_ID: ${{ secrets.E2E_NOTIFICATION_TELEGRAM_TOPIC_ID }}
+      E2E_NOTIFICATION_GOTIFY_SERVER_URL: ${{ secrets.E2E_NOTIFICATION_GOTIFY_SERVER_URL }}
+      E2E_NOTIFICATION_GOTIFY_APP_TOKEN: ${{ secrets.E2E_NOTIFICATION_GOTIFY_APP_TOKEN }}
+      E2E_NOTIFICATION_NTFY_TOPIC: ${{ secrets.E2E_NOTIFICATION_NTFY_TOPIC }}
+      E2E_NOTIFICATION_NTFY_SERVER_URL: ${{ secrets.E2E_NOTIFICATION_NTFY_SERVER_URL }}
+      E2E_NOTIFICATION_NTFY_TOKEN: ${{ secrets.E2E_NOTIFICATION_NTFY_TOKEN }}
+      E2E_NOTIFICATION_NTFY_USERNAME: ${{ secrets.E2E_NOTIFICATION_NTFY_USERNAME }}
+      E2E_NOTIFICATION_NTFY_PASSWORD: ${{ secrets.E2E_NOTIFICATION_NTFY_PASSWORD }}
+      E2E_NOTIFICATION_WEBHOOK_URL: ${{ secrets.E2E_NOTIFICATION_WEBHOOK_URL }}
+      E2E_NOTIFICATION_WEBHOOK_SECRET_HEADER: ${{ secrets.E2E_NOTIFICATION_WEBHOOK_SECRET_HEADER }}
+      E2E_NOTIFICATION_WEBHOOK_SECRET: ${{ secrets.E2E_NOTIFICATION_WEBHOOK_SECRET }}
+      E2E_STORAGE_AWS_S3_ENDPOINT_URL: ${{ secrets.E2E_STORAGE_AWS_S3_ENDPOINT_URL }}
+      E2E_STORAGE_AWS_S3_REGION: ${{ secrets.E2E_STORAGE_AWS_S3_REGION }}
+      E2E_STORAGE_AWS_S3_ACCESS_KEY: ${{ secrets.E2E_STORAGE_AWS_S3_ACCESS_KEY }}
+      E2E_STORAGE_AWS_S3_SECRET_KEY: ${{ secrets.E2E_STORAGE_AWS_S3_SECRET_KEY }}
+      E2E_STORAGE_AWS_S3_BUCKET_NAME: ${{ secrets.E2E_STORAGE_AWS_S3_BUCKET_NAME }}
+      E2E_STORAGE_AWS_S3_PORT: ${{ secrets.E2E_STORAGE_AWS_S3_PORT }}
+      E2E_STORAGE_R2_ENDPOINT_URL: ${{ secrets.E2E_STORAGE_R2_ENDPOINT_URL }}
+      E2E_STORAGE_R2_REGION: ${{ secrets.E2E_STORAGE_R2_REGION }}
+      E2E_STORAGE_R2_ACCESS_KEY: ${{ secrets.E2E_STORAGE_R2_ACCESS_KEY }}
+      E2E_STORAGE_R2_SECRET_KEY: ${{ secrets.E2E_STORAGE_R2_SECRET_KEY }}
+      E2E_STORAGE_R2_BUCKET_NAME: ${{ secrets.E2E_STORAGE_R2_BUCKET_NAME }}
+      E2E_STORAGE_R2_PORT: ${{ secrets.E2E_STORAGE_R2_PORT }}
+      E2E_STORAGE_GOOGLE_DRIVE_CLIENT_ID: ${{ secrets.E2E_STORAGE_GOOGLE_DRIVE_CLIENT_ID }}
+      E2E_STORAGE_GOOGLE_DRIVE_CLIENT_SECRET: ${{ secrets.E2E_STORAGE_GOOGLE_DRIVE_CLIENT_SECRET }}
+      E2E_STORAGE_GOOGLE_DRIVE_FOLDER_ID: ${{ secrets.E2E_STORAGE_GOOGLE_DRIVE_FOLDER_ID }}

.github/workflows/release.yml

@@ -32,7 +32,7 @@ jobs:
 
   create-release:
     needs: check-skip
-    if: ${{ needs.check-skip.outputs.skip == 'false' }}
+    if: ${{ needs.check-skip.outputs.skip == 'false' && github.event.pull_request.merged == true }}
     runs-on: ubuntu-latest
     outputs:
       draft_tag: ${{ steps.release_step.outputs.draft_tag }}

.gitignore

@@ -9,6 +9,8 @@
 
 # testing
 /coverage
+gcs-data/
+gcs-storage/
 
 # next.js
 /.next/
@@ -28,6 +30,8 @@ yarn-error.log*
 
 # local env files
 .env*.local
+.env
+**/.env
 
 # vercel
 .vercel
@@ -42,6 +46,8 @@ public/uploads/*
 private/uploads/*
 private/keys/*
 
+private/telemetry/*
+
 /.env
 
 seeds/pocket-id/*.db
@@ -60,3 +66,4 @@ certificates
 .codex
 /docs
 .worktrees
+.superpowers

CITATION.cff

@@ -33,5 +33,5 @@ keywords:
   - web-ui
   - agent
 license: Apache-2.0
-version: 1.15.0
+version: 1.23.1
 date-released: '2026-03-02'

Makefile

@@ -5,73 +5,52 @@ up:
 
 seed-keycloak:
 	@[ $$(ls -1 seeds/keycloak/*.json 2>/dev/null | wc -l) -gt 0 ] || (echo "No realm export found in seeds/keycloak. Add an export from Keycloak first."; exit 1)
-	@docker compose -f docker-compose.oidc.yml stop keycloak >/dev/null 2>&1 || true
-	@docker compose -f docker-compose.oidc.yml rm -f -s keycloak >/dev/null 2>&1 || true
-	@docker volume rm portabase-oidc_keycloak-data >/dev/null 2>&1 || true
-	@docker compose -f docker-compose.oidc.yml up -d keycloak
+	@docker compose -f docker-compose.func.yml stop keycloak >/dev/null 2>&1 || true
+	@docker compose -f docker-compose.func.yml rm -f -s keycloak >/dev/null 2>&1 || true
+	@docker volume rm portabase-dev-func_keycloak-data >/dev/null 2>&1 || true
+	@docker compose -f docker-compose.func.yml up -d keycloak
 	@echo "Keycloak seed import triggered from seeds/keycloak/*.json"
 
 seed-pocket:
 	@[ -f seeds/pocket-id/portabase.zip ] || (echo "No export found in seeds/pocket-id. Add an export from Pocket ID first."; exit 1)
-	@docker compose -f docker-compose.oidc.yml stop pocket-id >/dev/null 2>&1 || true
-	@docker compose -f docker-compose.oidc.yml rm -f -s pocket-id >/dev/null 2>&1 || true
-	@docker volume rm portabase-oidc_pocket-id-data >/dev/null 2>&1 || true
-	@docker compose -f docker-compose.oidc.yml run --rm -v $$(pwd)/seeds/pocket-id/portabase.zip:/tmp/portabase.zip pocket-id ./pocket-id import --yes --path /tmp/portabase.zip >/dev/null
-	@docker compose -f docker-compose.oidc.yml up -d pocket-id
+	@docker compose -f docker-compose.func.yml stop pocket-id >/dev/null 2>&1 || true
+	@docker compose -f docker-compose.func.yml rm -f -s pocket-id >/dev/null 2>&1 || true
+	@docker volume rm portabase-dev-func_pocket-id-data >/dev/null 2>&1 || true
+	@docker compose -f docker-compose.func.yml run --rm -v $$(pwd)/seeds/pocket-id/portabase.zip:/tmp/portabase.zip pocket-id ./pocket-id import --yes --path /tmp/portabase.zip >/dev/null
+	@docker compose -f docker-compose.func.yml up -d pocket-id
 	@sleep 2
-	@docker compose -f docker-compose.oidc.yml exec pocket-id ./pocket-id one-time-access-token admin
+	@docker compose -f docker-compose.func.yml exec pocket-id ./pocket-id one-time-access-token admin
 	@echo "Pocket ID data restored from seeds/pocket-id/portabase.zip"
 
-seed-authentik:
-	@docker compose -f docker-compose.oidc.yml stop authentik-postgresql authentik-server authentik-worker >/dev/null 2>&1 || true
-	@docker compose -f docker-compose.oidc.yml rm -f -s authentik-postgresql authentik-server authentik-worker >/dev/null 2>&1 || true
-	@docker volume rm portabase-oidc_authentik-data >/dev/null 2>&1 || true
-	@docker compose -f docker-compose.oidc.yml up -d authentik-postgresql authentik-server authentik-worker
-	@docker compose -f docker-compose.oidc.yml run --rm authentik-bootstrap
-	@echo "Authentik seed/bootstrap completed"
-
-seed-auth: seed-keycloak seed-pocket seed-authentik
+seed-auth: seed-keycloak seed-pocket
 
 pocket-token:
-	@docker compose -f docker-compose.oidc.yml exec pocket-id ./pocket-id one-time-access-token admin
+	@docker compose -f docker-compose.func.yml exec pocket-id ./pocket-id one-time-access-token admin
 
 export-pocket:
 	@echo "Exporting Pocket ID data to seeds/pocket-id/portabase.zip..."
 	@mkdir -p ./seeds/pocket-id
-	@docker compose -f docker-compose.oidc.yml exec pocket-id ./pocket-id export --path /tmp/portabase-export.zip
-	@docker compose -f docker-compose.oidc.yml cp pocket-id:/tmp/portabase-export.zip ./seeds/pocket-id/portabase.zip
-	@docker compose -f docker-compose.oidc.yml exec pocket-id rm /tmp/portabase-export.zip
+	@docker compose -f docker-compose.func.yml exec pocket-id ./pocket-id export --path /tmp/portabase-export.zip
+	@docker compose -f docker-compose.func.yml cp pocket-id:/tmp/portabase-export.zip ./seeds/pocket-id/portabase.zip
+	@docker compose -f docker-compose.func.yml exec pocket-id rm /tmp/portabase-export.zip
 	@echo "Pocket ID data exported to seeds/pocket-id/portabase.zip"
 
 export-keycloak:
 	@echo "Exporting Keycloak configuration and users to seeds/keycloak/*.json..."
 	@mkdir -p ./seeds/keycloak
 	@rm -f ./seeds/keycloak/*.json
-	@docker compose -f docker-compose.oidc.yml stop keycloak >/dev/null 2>&1
+	@docker compose -f docker-compose.func.yml stop keycloak >/dev/null 2>&1
 	@docker rm -f kc-exporter >/dev/null 2>&1 || true
-	@docker compose -f docker-compose.oidc.yml run --name kc-exporter keycloak export --dir /tmp/kc-export --users realm_file
+	@docker compose -f docker-compose.func.yml run --name kc-exporter keycloak export --dir /tmp/kc-export --users realm_file
 	@docker cp kc-exporter:/tmp/kc-export/. ./seeds/keycloak/
 	@docker rm -f kc-exporter >/dev/null 2>&1
-	@docker compose -f docker-compose.oidc.yml start keycloak >/dev/null 2>&1
+	@docker compose -f docker-compose.func.yml start keycloak >/dev/null 2>&1
 	@echo "Keycloak configuration and users exported to seeds/keycloak/*.json"
 
-e2e-auto:
-	@echo "Starting E2E testing..."
-	@docker network inspect portabase >/dev/null 2>&1 || docker network create portabase
-	@$(MAKE) seed-auth
-	@docker compose -f docker-compose.prod.yml up -d
-	@CI=true PROJECT_URL=http://localhost:8887 pnpm playwright test --project=chromium || (docker compose -f docker-compose.prod.yml down --volumes && docker compose -f docker-compose.oidc.yml down --volumes && exit 1)
-	@docker compose -f docker-compose.prod.yml down --volumes
-	@docker compose -f docker-compose.oidc.yml down --volumes
-	@echo "Finished E2E testing successfully."
+seed-blob:
+	@chmod +x seeds/azurite/azurite-seed.sh
+	@bash seeds/azurite/azurite-seed.sh
 
-e2e-manual:
-	@echo "Starting E2E testing..."
-	@docker network inspect portabase >/dev/null 2>&1 || docker network create portabase
-	@docker compose -f e2e/helpers/agent/docker-compose.database.yml up -d
-	@$(MAKE) seed-auth
-	@docker compose -f docker-compose.prod.yml up -d
-	@pnpm playwright test --ui || (docker compose -f docker-compose.prod.yml down --volumes && docker compose -f docker-compose.oidc.yml down --volumes && exit 1)
-	@docker compose -f docker-compose.prod.yml down --volumes
-	@docker compose -f docker-compose.oidc.yml down --volumes
-	@echo "Finished E2E testing successfully."
+list-blob:
+	@chmod +x seeds/azurite/azurite-list.sh
+	@bash seeds/azurite/azurite-list.sh

README.md

@@ -54,12 +54,13 @@
 
 ## Installation
 
-You have 4 ways to install Portabase:
+You have 5 ways to install Portabase:
 
 - Automated CLI (recommended) - [details](https://portabase.io/docs/dashboard/setup#cli)
 - Docker Run - [details](https://portabase.io/docs/dashboard/setup#docker)
 - Docker Compose setup - [details](https://portabase.io/docs/dashboard/setup#docker-compose)
-- Kubernetes with Helm [details](https://portabase.io/docs/dashboard/setup#helm)
+- Unraid Community Apps - [details](https://ca.unraid.net/apps/portabase-dashboard-1sdc97m05ufd7q) - [unraid support thread](https://forums.unraid.net/topic/199072-support-portabase-dashboard-agent-dockers/)
+- Kubernetes with Helm - [details](https://portabase.io/docs/dashboard/setup#helm)
 - Development setup - [details](https://portabase.io/docs/dashboard/setup#development)
 
 **Ensure Docker is installed on your machine before getting started.**
@@ -77,6 +78,7 @@ You have 4 ways to install Portabase:
 | **Valkey**         | ✅ Stable  | 7.2+                          | No      |
 | **Firebird**       | ✅ Stable  | 3.0, 4.0, 5.0                 | Yes     |
 | **MSSQL Server**   | ✅ Stable  | 2017, 2019, 2022, Azure SQL         | Yes     |
+| **Docker Volume**  | ✅ Stable  | Docker Engine 20.10+  | Yes |
 
 See the [Database Servers documentation](https://portabase.io/docs/agent/db) for version-specific backup and restore details.
 
@@ -88,7 +90,7 @@ See the [Database Servers documentation](https://portabase.io/docs/agent/db) for
 
 ## License
 
-Distributed under the Apache License. See `LICENSE.txt` for more details.
+Distributed under the Apache License. See `LICENSE.txt` for more details. 
 
 
 [Docker]: https://img.shields.io/badge/Docker-2496ED?logo=docker&logoColor=fff&style=for-the-badge

app/(auth)/forgot-password/page.tsx

@@ -1,9 +1,9 @@
 import { CardContent, CardHeader } from "@/components/ui/card";
 
 import { TooltipProvider } from "@/components/ui/tooltip";
-import { ForgotPasswordForm } from "@/components/wrappers/auth/login/forgot-password-form/forgot-password-form";
+import { ForgotPasswordForm } from "@/features/auth/components/forgot-password-form";
 import { env } from "@/env.mjs";
-import { CardAuth } from "@/features/layout/card-auth";
+import { CardAuth } from "@/features/layout/components/card-auth";
 import { redirect } from "next/navigation";
 
 export default async function RoutePage(props: { searchParams: Promise<{ callbackUrl: string | undefined }> }) {

app/(auth)/guard/page.tsx

@@ -1,9 +1,9 @@
 import {CardContent, CardHeader} from "@/components/ui/card";
 import {TooltipProvider} from "@/components/ui/tooltip";
-import {GuardForm} from "@/components/wrappers/auth/guard/guard-form";
+import {GuardForm} from "@/features/auth/components/guard-form";
 import {cookies} from "next/headers";
 import {redirect} from "next/navigation";
-import {CardAuth} from "@/features/layout/card-auth";
+import {CardAuth} from "@/features/layout/components/card-auth";
 
 export default async function GuardPage() {
 

app/(auth)/layout.tsx

@@ -1,7 +1,9 @@
 import React from "react";
 import { redirect } from "next/navigation";
 import { currentUser } from "@/lib/auth/current-user";
-import { AuthLogoSection } from "@/components/wrappers/auth/auth-logo-section";
+import { isOnboardingDone } from "@/db/services/setting";
+import { AuthLogoSection } from "@/features/auth/components/auth-logo-section";
+import { env } from "@/env.mjs";
 import { Heart } from "lucide-react";
 
 export default async function Layout({
@@ -9,6 +11,10 @@ export default async function Layout({
 }: {
   children: React.ReactNode;
 }) {
+  if (env.SKIP_ONBOARDING !== "true" && !(await isOnboardingDone())) {
+    redirect("/welcome");
+  }
+
   const user = await currentUser();
 
   if (user && !user.banned && user.role !== "pending") {

app/(auth)/login/page.tsx

@@ -1,12 +1,12 @@
-import { LoginForm } from "@/components/wrappers/auth/login/login-form/login-form";
+import { LoginForm } from "@/features/auth/components/login-form";
 import { Metadata } from "next";
 import { SUPPORTED_PROVIDERS } from "@/lib/auth/config";
-import { SocialAuthButtons } from "@/components/wrappers/auth/social-buttons";
+import { SocialAuthButtons } from "@/features/auth/components/social-buttons";
 import { TooltipProvider } from "@/components/ui/tooltip";
 import { CardContent, CardHeader } from "@/components/ui/card";
 import Link from "next/link";
 import { Separator } from "@/components/ui/separator";
-import { CardAuth } from "@/features/layout/card-auth";
+import { CardAuth } from "@/features/layout/components/card-auth";
 import { env } from "@/env.mjs";
 
 export const metadata: Metadata = {

app/(auth)/register/page.tsx

@@ -1,5 +1,5 @@
 import { PageParams } from "@/types/next";
-import { RegisterForm } from "@/components/wrappers/auth/register/register-form/register-form";
+import { RegisterForm } from "@/features/auth/components/register-form";
 import { Metadata } from "next";
 import { redirect } from "next/navigation";
 import { env } from "@/env.mjs";

app/(auth)/reset-password/page.tsx

@@ -1,10 +1,10 @@
 import { CardContent, CardHeader } from "@/components/ui/card";
 import { TooltipProvider } from "@/components/ui/tooltip";
-import { ResetPasswordForm } from "@/components/wrappers/auth/login/reset-password-form/reset-password-form";
+import { ResetPasswordForm } from "@/features/auth/components/reset-password-form";
 import { redirect } from "next/navigation";
 import { auth } from "@/lib/auth/auth";
 import { Avatar, AvatarImage, AvatarFallback } from "@radix-ui/react-avatar";
-import { CardAuth } from "@/features/layout/card-auth";
+import { CardAuth } from "@/features/layout/components/card-auth";
 import { env } from "@/env.mjs";
 
 export default async function RoutePage(props: { searchParams: Promise<{ token: string | undefined }> }) {

app/(customer)/dashboard/(admin)/admin/organizations/[organizationId]/page.tsx

@@ -3,8 +3,8 @@ import {eq} from "drizzle-orm";
 import {db} from "@/db";
 import * as drizzleDb from "@/db";
 import {PageParams} from "@/types/next";
-import {Page} from "@/features/layout/page";
-import {OrganizationManagement} from "@/components/wrappers/dashboard/admin/organizations/organization/organization-management";
+import {Page} from "@/features/layout/components/page";
+import {OrganizationManagement} from "@/features/organizations/components/admin-organization-management";
 import {buildOrganizationWithMembers} from "@/utils/common";
 import {isUUID} from "@/utils/text";
 import {user} from "@/db/schema/02_user";

app/(customer)/dashboard/(admin)/admin/organizations/page.tsx

@@ -1,10 +1,10 @@
 import {PageParams} from "@/types/next";
-import {Page, PageActions, PageContent, PageHeader, PageTitle} from "@/features/layout/page";
+import {Page, PageActions, PageContent, PageHeader, PageTitle} from "@/features/layout/components/page";
 import {db} from "@/db";
 import {
     AdminOrganizationAddModal
-} from "@/components/wrappers/dashboard/admin/organizations/organization/admin-organization-add-modal";
-import {AdminOrganizationList} from "@/components/wrappers/dashboard/admin/organizations/organization/admin-orgnization-list";
+} from "@/features/organizations/components/admin-organization-add-modal";
+import {AdminOrganizationList} from "@/features/organizations/components/admin-organization-list";
 import {isNull} from "drizzle-orm";
 
 export default async function RoutePage(props: PageParams<{}>) {

app/(customer)/dashboard/(admin)/admin/settings/page.tsx

@@ -1,9 +1,9 @@
 import {PageParams} from "@/types/next";
-import {Page, PageContent, PageHeader, PageTitle} from "@/features/layout/page";
+import {Page, PageContent, PageHeader, PageTitle} from "@/features/layout/components/page";
 import {db} from "@/db";
 import {logger} from "@/lib/logger";
 import {notFound} from "next/navigation";
-import {SettingsTabs} from "@/components/wrappers/dashboard/admin/settings/settings-tabs";
+import {SettingsTabs} from "@/features/settings/components/settings-tabs";
 import {desc, isNull} from "drizzle-orm";
 import * as drizzleDb from "@/db";
 import {StorageChannelWith} from "@/db/schema/12_storage-channel";

app/(customer)/dashboard/(admin)/admin/users/page.tsx

@@ -1,21 +1,28 @@
 import {PageParams} from "@/types/next";
-import {Page, PageActions, PageContent, PageHeader, PageTitle} from "@/features/layout/page";
+import {Page, PageActions, PageContent, PageHeader, PageTitle} from "@/features/layout/components/page";
 import {db} from "@/db";
 import {desc, isNull} from "drizzle-orm";
-import {AdminUserList} from "@/components/wrappers/dashboard/admin/users/admin-user-list";
-import {AdminUserAddModal} from "@/components/wrappers/dashboard/admin/users/admin-user-add-modal";
+import {AdminUserList} from "@/features/users/components/admin-user-list";
+import {AdminUserAddModal} from "@/features/users/components/admin-user-add-modal";
 import {SUPPORTED_PROVIDERS} from "@/lib/auth/config";
+import {getSettings} from "@/db/services/setting";
+import {resolveAvatarUrl} from "@/utils/resolve-avatar-url";
 
 export default async function RoutePage(props: PageParams<{}>) {
 
-    const users = await db.query.user.findMany({
-        where: (fields) => isNull(fields.deletedAt),
-        with: {
-            accounts: true
-        },
-        orderBy: (fields) => desc(fields.createdAt),
+    const [settings, users] = await Promise.all([
+        getSettings(),
+        db.query.user.findMany({
+            where: (fields) => isNull(fields.deletedAt),
+            with: { accounts: true },
+            orderBy: (fields) => desc(fields.createdAt),
+        }),
+    ]);
+
+    const avatarUrls = Object.fromEntries(
+        users.map((u) => [u.id, resolveAvatarUrl(u, settings)])
+    );
 
-    });
     const organizations = await db.query.organization.findMany({
         with: {
             members: true,
@@ -30,13 +37,15 @@ export default async function RoutePage(props: PageParams<{}>) {
             <PageHeader className="flex flex-col">
                 <div className="flex justify-between">
                     <PageTitle className="mb-3">Active users</PageTitle>
-                    <PageActions>
-                        <AdminUserAddModal organizations={organizations}/>
-                    </PageActions>
+                    {isPasswordAuthEnabled && (
+                        <PageActions>
+                            <AdminUserAddModal organizations={organizations}/>
+                        </PageActions>
+                    )}
                 </div>
             </PageHeader>
             <PageContent className="flex flex-col gap-5">
-                <AdminUserList users={users} isPasswordAuthEnabled={isPasswordAuthEnabled}/>
+                <AdminUserList users={users} isPasswordAuthEnabled={isPasswordAuthEnabled} avatarUrls={avatarUrls}/>
             </PageContent>
         </Page>
     );

app/(customer)/dashboard/(admin)/agents/[agentId]/page.tsx

@@ -4,17 +4,17 @@ import {
   PageContent,
   PageDescription,
   PageTitle,
-} from "@/features/layout/page";
+} from "@/features/layout/components/page";
 import { db } from "@/db";
 import * as drizzleDb from "@/db";
 import {eq, isNull} from "drizzle-orm";
 import { notFound } from "next/navigation";
-import { ButtonDeleteAgent } from "@/components/wrappers/dashboard/agent/button-delete-agent/button-delete-agent";
+import { ButtonDeleteAgent } from "@/features/agents/components/agent-delete-button";
 import { capitalizeFirstLetter } from "@/utils/text";
 import { generateEdgeKey } from "@/utils/edge_key";
 import { getServerUrl } from "@/utils/get-server-url";
-import { AgentContentPage } from "@/components/wrappers/dashboard/agent/agent-content";
-import { AgentDialog } from "@/features/agents/components/agent.dialog";
+import { AgentContentPage } from "@/features/agents/components/agent-content";
+import { AgentDialog } from "@/features/agents/components/agent-dialog";
 
 
 export default async function RoutePage(
@@ -81,7 +81,7 @@ export default async function RoutePage(
         </PageDescription>
       )}
       <PageContent className="flex flex-col w-full h-full justify-between gap-6">
-        <AgentContentPage agent={agent} edgeKey={edgeKey} />
+        <AgentContentPage agent={agent} edgeKey={edgeKey} canDeleteDatabases={true} />
       </PageContent>
     </Page>
   );

app/(customer)/dashboard/(admin)/agents/page.tsx

@@ -1,13 +1,13 @@
 import {PageParams} from "@/types/next";
-import {AgentCard} from "@/components/wrappers/dashboard/agent/agent-card/agent-card";
-import {CardsWithPagination} from "@/components/wrappers/common/cards-with-pagination";
-import {Page, PageActions, PageContent, PageHeader, PageTitle} from "@/features/layout/page";
+import {AgentCard} from "@/features/agents/components/agent-card";
+import {CardsWithPagination} from "@/components/common/cards-with-pagination";
+import {Page, PageActions, PageContent, PageHeader, PageTitle} from "@/features/layout/components/page";
 import {notFound} from "next/navigation";
 import {db} from "@/db";
 import * as drizzleDb from "@/db";
 import {and, desc, eq, isNull, not} from "drizzle-orm";
 import {Metadata} from "next";
-import {AgentDialog} from "@/features/agents/components/agent.dialog";
+import {AgentDialog} from "@/features/agents/components/agent-dialog";
 
 export const metadata: Metadata = {
     title: "Agents",

app/(customer)/dashboard/(admin)/notifications/channels/page.tsx

@@ -1,11 +1,11 @@
 import {PageParams} from "@/types/next";
-import {Page, PageActions, PageContent, PageHeader, PageTitle} from "@/features/layout/page";
+import {Page, PageActions, PageContent, PageHeader, PageTitle} from "@/features/layout/components/page";
 import {Metadata} from "next";
 import {db} from "@/db";
 import {notificationChannel, NotificationChannelWith} from "@/db/schema/09_notification-channel";
 import {desc, isNull} from "drizzle-orm";
-import {ChannelsSection} from "@/components/wrappers/dashboard/admin/channels/channels-section";
-import {ChannelAddEditModal} from "@/components/wrappers/dashboard/admin/channels/channel/channel-add-edit-modal";
+import {ChannelsSection} from "@/features/channel/components/channels-section";
+import {ChannelAddEditModal} from "@/features/channel/components/channel-add-edit-modal";
 import * as drizzleDb from "@/db";
 
 export const metadata: Metadata = {

app/(customer)/dashboard/(admin)/notifications/logs/page.tsx

@@ -1,7 +1,7 @@
 import {PageParams} from "@/types/next";
-import {Page, PageContent, PageHeader, PageTitle} from "@/features/layout/page";
+import {Page, PageContent, PageHeader, PageTitle} from "@/features/layout/components/page";
 import {Metadata} from "next";
-import {NotificationLogsList} from "@/components/wrappers/dashboard/admin/notifications/logs/notification-logs-list";
+import {NotificationLogsList} from "@/features/notifications/components/notification-logs-list";
 import {notFound} from "next/navigation";
 import {getNotificationHistory} from "@/db/services/notification-log";
 

app/(customer)/dashboard/(admin)/storages/channels/page.tsx

@@ -1,12 +1,12 @@
 import {PageParams} from "@/types/next";
-import {Page, PageActions, PageContent, PageHeader, PageTitle} from "@/features/layout/page";
+import {Page, PageActions, PageContent, PageHeader, PageTitle} from "@/features/layout/components/page";
 import {Metadata} from "next";
-import {ChannelsSection} from "@/components/wrappers/dashboard/admin/channels/channels-section";
+import {ChannelsSection} from "@/features/channel/components/channels-section";
 import {db} from "@/db";
 import {desc, eq, isNull} from "drizzle-orm";
 import * as drizzleDb from "@/db";
 import {StorageChannelWith} from "@/db/schema/12_storage-channel";
-import {ChannelAddEditModal} from "@/components/wrappers/dashboard/admin/channels/channel/channel-add-edit-modal";
+import {ChannelAddEditModal} from "@/features/channel/components/channel-add-edit-modal";
 
 export const metadata: Metadata = {
     title: "Storage Channels",

app/(customer)/dashboard/(organization)/migration/page.tsx

@@ -1,10 +1,10 @@
 import {PageParams} from "@/types/next";
-import {Page, PageContent, PageHeader, PageTitle} from "@/features/layout/page";
+import {Page, PageContent, PageHeader, PageTitle} from "@/features/layout/components/page";
 import {notFound} from "next/navigation";
 import {getOrganization} from "@/lib/auth/auth";
 import {Metadata} from "next";
 import {db} from "@/db";
-import {MigrationTool} from "@/components/wrappers/dashboard/organization/migration/migration-tool";
+import {MigrationTool} from "@/features/migration/components/migration-tool";
 
 export const metadata: Metadata = {
     title: "Projects",

app/(customer)/dashboard/(organization)/projects/[projectId]/database/[databaseId]/page.tsx

@@ -1,115 +1,128 @@
-import {PageParams} from "@/types/next";
-import {notFound, redirect} from "next/navigation";
-import {Page} from "@/features/layout/page";
-import {db} from "@/db";
-import {eq, and, inArray} from "drizzle-orm";
+import { PageParams } from "@/types/next";
+import { notFound, redirect } from "next/navigation";
+import { Page } from "@/features/layout/components/page";
+import { db } from "@/db";
+import { eq, and, inArray, isNull } from "drizzle-orm";
 import * as drizzleDb from "@/db";
-import {getOrganizationProjectDatabases} from "@/lib/services";
-import {getActiveMember, getOrganization} from "@/lib/auth/auth";
-import {BackupModalProvider} from "@/components/wrappers/dashboard/database/backup/backup-modal-context";
-import {DatabaseContent} from "@/components/wrappers/dashboard/projects/database/database-content";
-import {getHealthLast12hLogs} from "@/db/services/healthcheck";
+import { getOrganizationProjectDatabases } from "@/db/services/project";
+import { getActiveMember, getOrganization } from "@/lib/auth/auth";
+import { BackupModalProvider } from "@/features/database/components/backup-modal-context";
+import { DatabaseContent } from "@/features/database/components/database-content";
+import { getHealthLast12hLogs } from "@/db/services/healthcheck";
+import { LogsModalProvider } from "@/features/logs/components/logs-modal-context";
 
-export default async function RoutePage(props: PageParams<{
+export default async function RoutePage(
+  props: PageParams<{
     projectId: string;
-    databaseId: string
-}>) {
-    const {projectId, databaseId} = await props.params;
+    databaseId: string;
+  }>,
+) {
+  const { projectId, databaseId } = await props.params;
 
-    const organization = await getOrganization({});
-    const activeMember = await getActiveMember()
+  const organization = await getOrganization({});
+  const activeMember = await getActiveMember();
 
-    if (!organization || !activeMember) {
-        notFound();
-    }
+  if (!organization || !activeMember) {
+    notFound();
+  }
 
-    const databasesProject = await getOrganizationProjectDatabases({
-        organizationSlug: organization.slug,
-        projectId: projectId
-    })
+  const databasesProject = await getOrganizationProjectDatabases({
+    organizationSlug: organization.slug,
+    projectId: projectId,
+  });
 
-    const dbItem = await db.query.database.findFirst({
-        where: and(inArray(drizzleDb.schemas.backup.id, databasesProject.ids ?? []), eq(drizzleDb.schemas.database.id, databaseId), eq(drizzleDb.schemas.database.projectId, projectId)),
-        with: {
-            project: true,
-            retentionPolicy: true,
-            alertPolicies: true,
-            storagePolicies: true
-        }
-    });
+  const dbItem = await db.query.database.findFirst({
+    where: and(
+      inArray(drizzleDb.schemas.backup.id, databasesProject.ids ?? []),
+      eq(drizzleDb.schemas.database.id, databaseId),
+      eq(drizzleDb.schemas.database.projectId, projectId),
+    ),
+    with: {
+      project: true,
+      retentionPolicy: true,
+      alertPolicies: true,
+      storagePolicies: true,
+    },
+  });
 
-    if (!dbItem) {
-        redirect("/dashboard/projects");
-    }
+  if (!dbItem) {
+    redirect("/dashboard/projects");
+  }
 
-    const backups = await db.query.backup.findMany({
-        where: eq(drizzleDb.schemas.backup.databaseId, dbItem.id),
-        with: {
-            restorations: true,
-            storages: {
-                with: {
-                    storageChannel: true
-                }
-            }
-        },
-        orderBy: (b, {desc}) => [desc(b.createdAt)],
-    });
+  const totalBackups = await db
+    .select({ count: drizzleDb.schemas.backup.id })
+    .from(drizzleDb.schemas.backup)
+    .where(eq(drizzleDb.schemas.backup.databaseId, dbItem.id))
+    .then((rows) => rows.length);
 
-    const restorations = await db.query.restoration.findMany({
-        where: eq(drizzleDb.schemas.restoration.databaseId, dbItem.id),
-        orderBy: (r, {desc}) => [desc(r.createdAt)],
-    });
+  const availableBackups = await db
+    .select({ count: drizzleDb.schemas.backup.id })
+    .from(drizzleDb.schemas.backup)
+    .where(
+      and(
+        eq(drizzleDb.schemas.backup.databaseId, dbItem.id),
+        isNull(drizzleDb.schemas.backup.deletedAt),
+      ),
+    )
+    .then((rows) => rows.length);
 
-    const isAlreadyBackup = backups.some((b) => b.status === "waiting" || b.status === "ongoing");
-    const isAlreadyRestore = restorations.some((r) => r.status === "waiting");
+  const successfulBackups = await db
+    .select({ count: drizzleDb.schemas.backup.id })
+    .from(drizzleDb.schemas.backup)
+    .where(
+      and(
+        eq(drizzleDb.schemas.backup.databaseId, dbItem.id),
+        eq(drizzleDb.schemas.backup.status, "success"),
+      ),
+    )
+    .then((rows) => rows.length);
 
-    const totalBackups = await db.select({count: drizzleDb.schemas.backup.id})
-        .from(drizzleDb.schemas.backup)
-        .where(eq(drizzleDb.schemas.backup.databaseId, dbItem.id))
-        .then(rows => rows.length);
+  const isAlreadyRestore = await db
+    .select({ count: drizzleDb.schemas.restoration.id })
+    .from(drizzleDb.schemas.restoration)
+    .where(
+      and(
+        eq(drizzleDb.schemas.restoration.databaseId, dbItem.id),
+        eq(drizzleDb.schemas.restoration.status, "waiting"),
+      ),
+    )
+    .then((rows) => rows.length > 0);
 
-    const availableBackups = backups.filter(b => !b.deletedAt).length;
+  const [settings] = await db
+    .select()
+    .from(drizzleDb.schemas.setting)
+    .where(eq(drizzleDb.schemas.setting.name, "system"))
+    .limit(1);
+  if (!settings) {
+    notFound();
+  }
 
-    const successfulBackups = await db.select({count: drizzleDb.schemas.backup.id})
-        .from(drizzleDb.schemas.backup)
-        .where(and(
-            eq(drizzleDb.schemas.backup.databaseId, dbItem.id),
-            eq(drizzleDb.schemas.backup.status, "success")
-        ))
-        .then(rows => rows.length);
+  const databaseHealthLogs = dbItem
+    ? await getHealthLast12hLogs({ id: dbItem.id })
+    : [];
 
+  const successRate =
+    totalBackups > 0 ? (successfulBackups / totalBackups) * 100 : null;
 
-    const [settings] = await db.select().from(drizzleDb.schemas.setting).where(eq(drizzleDb.schemas.setting.name, "system")).limit(1);
-    if (!settings) {
-        notFound();
-    }
-
-    const databaseHealthLogs = dbItem ? await getHealthLast12hLogs({ id: dbItem.id }) : []
-
-
-    const successRate = totalBackups > 0 ? (successfulBackups / totalBackups) * 100 : null;
-
-    const isMember = activeMember?.role === "member";
-
-    return (
-        <Page>
-            <BackupModalProvider>
-                <DatabaseContent
-                    activeMember={activeMember}
-                    settings={settings}
-                    database={dbItem}
-                    databaseHealthLogs={databaseHealthLogs}
-                    isAlreadyRestore={isAlreadyRestore}
-                    restorations={restorations}
-                    backups={backups}
-                    totalBackups={totalBackups}
-                    availableBackups={availableBackups}
-                    successRate={successRate}
-                    organizationId={organization.id}
-                    activeOrganizationChannels={[]}
-                    activeOrganizationStorageChannels={[]}
-                />
-            </BackupModalProvider>
-        </Page>
-    );
-}
+  return (
+    <Page>
+      <LogsModalProvider>
+        <BackupModalProvider>
+          <DatabaseContent
+            activeMember={activeMember}
+            settings={settings}
+            database={dbItem}
+            databaseHealthLogs={databaseHealthLogs}
+            isAlreadyRestore={isAlreadyRestore}
+            totalBackups={totalBackups}
+            availableBackups={availableBackups}
+            successRate={successRate}
+            organizationId={organization.id}
+            activeOrganizationChannels={[]}
+            activeOrganizationStorageChannels={[]}
+          />
+        </BackupModalProvider>
+      </LogsModalProvider>
+    </Page>
+  );
+}

app/(customer)/dashboard/(organization)/projects/[projectId]/page.tsx

@@ -1,106 +1,123 @@
-import {PageParams} from "@/types/next";
-import {Page, PageContent, PageTitle} from "@/features/layout/page";
-import {
-    ButtonDeleteProject
-} from "@/components/wrappers/dashboard/projects/button-delete-project/button-delete-project";
-import {CardsWithPagination} from "@/components/wrappers/common/cards-with-pagination";
-import {ProjectDatabaseCard} from "@/components/wrappers/dashboard/projects/project-card/project-database-card";
-import {notFound, redirect} from "next/navigation";
-import {db} from "@/db";
-import {eq} from "drizzle-orm";
-import {getActiveMember, getOrganization} from "@/lib/auth/auth";
+import { PageParams } from "@/types/next";
+import { Page, PageContent, PageTitle } from "@/features/layout/components/page";
+import { ButtonDeleteProject } from "@/features/projects/components/project-delete-button";
+import { CardsWithPagination } from "@/components/common/cards-with-pagination";
+import { ProjectDatabaseCard } from "@/features/projects/components/project-database-card";
+import { ProjectDatabaseSelection } from "@/features/projects/components/project-database-selection";
+import { notFound, redirect } from "next/navigation";
+import { db } from "@/db";
+import { eq } from "drizzle-orm";
+import { getActiveMember, getOrganization } from "@/lib/auth/auth";
 import * as drizzleDb from "@/db";
-import {capitalizeFirstLetter} from "@/utils/text";
-import {ProjectDialog} from "@/features/projects/components/project.dialog";
-import {ProjectWith} from "@/db/schema/06_project";
-import {isUuidv4} from "@/utils/verify-uuid";
-import {getOrganizationAvailableDatabases} from "@/db/services/database";
+import { capitalizeFirstLetter, isUUID } from "@/utils/text";
+import { ProjectDialog } from "@/features/projects/components/project-dialog";
+import { ProjectWith } from "@/db/schema/06_project";
+import { getOrganizationAvailableDatabases } from "@/db/services/database";
 
+export default async function RoutePage(
+  props: PageParams<{
+    projectId: string;
+  }>,
+) {
+  const { projectId } = await props.params;
 
-export default async function RoutePage(props: PageParams<{
-    projectId: string
-}>) {
-    const {
-        projectId
-    } = await props.params;
+  if (!isUUID(projectId)) {
+    notFound();
+  }
 
-    if (!isUuidv4(projectId)) {
-        notFound()
-    }
+  const organization = await getOrganization({});
+  const activeMember = await getActiveMember();
 
-    const organization = await getOrganization({});
-    const activeMember = await getActiveMember()
+  if (!organization) {
+    notFound();
+  }
+  const org = await db.query.organization.findFirst({
+    where: eq(drizzleDb.schemas.organization.slug, organization.slug),
+  });
 
-    if (!organization) {
-        notFound();
-    }
-    const org = await db.query.organization.findFirst({
-        where: eq(drizzleDb.schemas.organization.slug, organization.slug),
-    });
+  if (!org) notFound();
 
-    if (!org) notFound();
+  const proj = await db.query.project.findFirst({
+    where: (proj, { and, eq, not }) =>
+      and(
+        eq(proj.id, projectId),
+        eq(proj.organizationId, org.id),
+        not(eq(proj.isArchived, true)),
+      ),
+    with: {
+      databases: true,
+    },
+  });
 
-    const proj = await db.query.project.findFirst({
-        where: (proj, {
-            and,
-            eq,
-            not
-        }) => and(eq(proj.id, projectId), eq(proj.organizationId, org.id), not(eq(proj.isArchived, true))),
-        with: {
-            databases: true,
-        },
-    });
+  if (!proj) {
+    redirect("/dashboard/projects");
+  }
 
-    if (!proj) {
-        redirect("/dashboard/projects");
-    }
+  const availableDatabases = await getOrganizationAvailableDatabases(
+    organization.id,
+    proj.id,
+  );
+  const isMember = activeMember?.role === "member";
 
-    const availableDatabases = await getOrganizationAvailableDatabases(organization.id, proj.id)
-    const isMember = activeMember?.role === "member";
-
-    return (
-        <Page>
-            <div className="justify-between gap-2 sm:flex">
-                <PageTitle className="flex flex-col md:flex-row items-center justify-between w-full ">
-                    <div className="min-w-full md:min-w-fit ">
-                        {capitalizeFirstLetter(proj.name)}
-                    </div>
-                    {!isMember && (
-                        <div className="flex items-center gap-2 md:justify-between w-full ">
-                            <div className="flex items-center gap-2">
-                                <ProjectDialog
-                                    databases={availableDatabases}
-                                    organization={org}
-                                    project={proj as ProjectWith}
-                                    isEdit={true}
-                                />
-                            </div>
-                            <div className="flex items-center gap-2">
-                                <ButtonDeleteProject projectId={projectId} text={"Delete Project"}/>
-                            </div>
-                        </div>
-                    )}
-                </PageTitle>
+  return (
+    <Page>
+      <div className="justify-between gap-2 sm:flex">
+        <PageTitle className="flex flex-col md:flex-row items-center justify-between w-full ">
+          <div className="min-w-full md:min-w-fit ">
+            {capitalizeFirstLetter(proj.name)}
+          </div>
+          {!isMember && (
+            <div className="flex items-center gap-2 md:justify-between w-full ">
+              <div className="flex items-center gap-2">
+                <ProjectDialog
+                  databases={availableDatabases}
+                  organization={org}
+                  project={proj as ProjectWith}
+                  isEdit={true}
+                />
+              </div>
+              <div className="flex items-center gap-2">
+                <ButtonDeleteProject
+                  projectId={projectId}
+                  text={"Delete Project"}
+                />
+              </div>
             </div>
-            <PageContent className="flex flex-col w-full h-full">
-                {proj.databases.length > 0 ? (
-                    <CardsWithPagination
-                        data={proj.databases}
-                        organizationSlug={organization.slug}
-                        // @ts-ignore
-                        cardItem={ProjectDatabaseCard}
-                        cardsPerPage={20}
-                        numberOfColumns={3}
-                        pageSizeOptions={[10, 20, 50]}
-                        extendedProps={proj}
-                    />
-                ) : (
-                    <div className="flex flex-col items-center justify-center h-full text-muted-foreground py-20">
-                        <p className="text-lg font-medium">No databases found</p>
-                        <p className="text-sm mt-2">You haven’t added any databases to this project yet.</p>
-                    </div>
-                )}
-            </PageContent>
-        </Page>
-    );
-}
+          )}
+        </PageTitle>
+      </div>
+      <PageContent className="flex flex-col w-full h-full">
+        {proj.databases.length > 0 ? (
+          isMember ? (
+            <CardsWithPagination
+              data={[...proj.databases].sort(
+                (a, b) =>
+                  new Date(b.createdAt).getTime() -
+                  new Date(a.createdAt).getTime(),
+              )}
+              organizationSlug={organization.slug}
+              // @ts-ignore
+              cardItem={ProjectDatabaseCard}
+              cardsPerPage={20}
+              numberOfColumns={3}
+              pageSizeOptions={[10, 20, 50]}
+              extendedProps={proj}
+            />
+          ) : (
+            <ProjectDatabaseSelection
+              projectId={proj.id}
+              databases={proj.databases}
+            />
+          )
+        ) : (
+          <div className="flex flex-col items-center justify-center h-full text-muted-foreground py-20">
+            <p className="text-lg font-medium">No databases found</p>
+            <p className="text-sm mt-2">
+              You haven’t added any databases to this project yet.
+            </p>
+          </div>
+        )}
+      </PageContent>
+    </Page>
+  );
+}

app/(customer)/dashboard/(organization)/projects/page.tsx

@@ -1,13 +1,13 @@
 import {PageParams} from "@/types/next";
-import {CardsWithPagination} from "@/components/wrappers/common/cards-with-pagination";
-import {Page, PageActions, PageContent, PageHeader, PageTitle} from "@/features/layout/page";
-import {ProjectCard} from "@/components/wrappers/dashboard/projects/project-card/project-card";
+import {CardsWithPagination} from "@/components/common/cards-with-pagination";
+import {Page, PageActions, PageContent, PageHeader, PageTitle} from "@/features/layout/components/page";
+import {ProjectCard} from "@/features/projects/components/project-card";
 import {db} from "@/db";
 import {notFound} from "next/navigation";
 import {getActiveMember, getOrganization} from "@/lib/auth/auth";
-import {EmptyStatePlaceholder} from "@/components/wrappers/common/empty-state-placeholder";
+import {EmptyStatePlaceholder} from "@/components/common/empty-state-placeholder";
 import {Metadata} from "next";
-import {ProjectDialog} from "@/features/projects/components/project.dialog";
+import {ProjectDialog} from "@/features/projects/components/project-dialog";
 import {DatabaseWith} from "@/db/schema/07_database";
 import {getOrganizationAvailableDatabases} from "@/db/services/database";
 

app/(customer)/dashboard/(organization)/settings/agents/[agentId]/page.tsx

@@ -4,17 +4,17 @@ import {
     PageContent,
     PageDescription,
     PageTitle,
-} from "@/features/layout/page";
+} from "@/features/layout/components/page";
 import {db} from "@/db";
 import * as drizzleDb from "@/db";
 import {eq} from "drizzle-orm";
 import {notFound} from "next/navigation";
-import {ButtonDeleteAgent} from "@/components/wrappers/dashboard/agent/button-delete-agent/button-delete-agent";
+import {ButtonDeleteAgent} from "@/features/agents/components/agent-delete-button";
 import {capitalizeFirstLetter} from "@/utils/text";
 import {generateEdgeKey} from "@/utils/edge_key";
 import {getServerUrl} from "@/utils/get-server-url";
-import {AgentContentPage} from "@/components/wrappers/dashboard/agent/agent-content";
-import {AgentDialog} from "@/features/agents/components/agent.dialog";
+import {AgentContentPage} from "@/features/agents/components/agent-content";
+import {AgentDialog} from "@/features/agents/components/agent-dialog";
 import {getActiveMember, getOrganization} from "@/lib/auth/auth";
 import {currentUser} from "@/lib/auth/current-user";
 import {computeOrganizationPermissions} from "@/lib/acl/organization-acl";
@@ -94,7 +94,7 @@ export default async function RoutePage(
                 </PageDescription>
             )}
             <PageContent className="flex flex-col w-full h-full justify-between gap-6">
-                <AgentContentPage agent={agent} edgeKey={edgeKey}/>
+                <AgentContentPage agent={agent} edgeKey={edgeKey} canDeleteDatabases={!!agent.organizationId}/>
             </PageContent>
         </Page>
     );

app/(customer)/dashboard/(organization)/settings/page.tsx

@@ -4,17 +4,17 @@ import {
     PageContent,
     PageHeader,
     PageTitle,
-} from "@/features/layout/page";
+} from "@/features/layout/components/page";
 import {currentUser} from "@/lib/auth/current-user";
 import {getActiveMember, getOrganization} from "@/lib/auth/auth";
 import {notFound} from "next/navigation";
 import {Metadata} from "next";
-import {OrganizationTabs} from "@/components/wrappers/dashboard/organization/tabs/organization-tabs";
+import {OrganizationTabs} from "@/features/organizations/components/organization-tabs";
 import {getOrganizationChannels} from "@/db/services/notification-channel";
 import {computeOrganizationPermissions} from "@/lib/acl/organization-acl";
 import {getOrganizationStorageChannels} from "@/db/services/storage-channel";
-import {DeleteOrganizationButton} from "@/components/wrappers/dashboard/organization/delete-organization-button";
-import {EditOrganizationDialog} from "@/features/organization/components/edit-organization.dialog";
+import {DeleteOrganizationButton} from "@/features/organizations/components/organization-delete-button";
+import {EditOrganizationDialog} from "@/features/organizations/components/organization-edit-dialog";
 import {db} from "@/db";
 import {isNull} from "drizzle-orm";
 import * as drizzleDb from "@/db";
@@ -47,7 +47,9 @@ export default async function RoutePage(props: PageParams<{ slug: string }>) {
     const organizationWithMembers = await db.query.organization.findFirst({
         where: eq(drizzleDb.schemas.organization.id, organization.id),
         with: {
-            projects: true,
+            projects: {
+                where: eq(drizzleDb.schemas.project.isArchived, false),
+            },
             members: {
                 with: {
                     user: true,

app/(customer)/dashboard/(organization)/statistics/page.tsx

@@ -1,8 +1,8 @@
 import {PageParams} from "@/types/next";
-import {Page, PageContent, PageHeader, PageTitle} from "@/features/layout/page";
+import {Page, PageContent, PageHeader, PageTitle} from "@/features/layout/components/page";
 import {Card, CardContent, CardHeader, CardTitle} from "@/components/ui/card";
-import {EvolutionLineChart} from "@/components/wrappers/dashboard/statistics/charts/evolution-line-chart";
-import {PercentageLineChart} from "@/components/wrappers/dashboard/statistics/charts/percentage-line-chart";
+import {EvolutionLineChart} from "@/features/statistics/components/evolution-line-chart";
+import {PercentageLineChart} from "@/features/statistics/components/percentage-line-chart";
 import {notFound} from "next/navigation";
 import {db} from "@/db";
 import {and, asc, count, eq, inArray} from "drizzle-orm";
@@ -29,7 +29,7 @@ export default async function RoutePage(props: PageParams<{}>) {
     if (!org) notFound();
 
     const projects = await db.query.project.findMany({
-        where: eq(drizzleDb.schemas.project.organizationId, org.id),
+        where: and(eq(drizzleDb.schemas.project.organizationId, org.id), eq(drizzleDb.schemas.project.isArchived, false))
     });
 
     const projectIds = projects.map(project => project.id);

app/(customer)/dashboard/home/page.tsx

@@ -1,11 +1,12 @@
 import {PageParams} from "@/types/next";
-import {Page, PageContent, PageHeader, PageTitle} from "@/features/layout/page";
+import {Page, PageContent, PageHeader, PageTitle} from "@/features/layout/components/page";
 import {Card, CardContent, CardHeader, CardTitle} from "@/components/ui/card";
 import {Building2, Database, DatabaseBackup, Folder, RefreshCcw, Server, Workflow} from "lucide-react";
 import {currentUser} from "@/lib/auth/current-user";
 import {notFound} from "next/navigation";
 import {db} from "@/db";
-import {and, asc, eq, inArray} from "drizzle-orm";
+
+import {and, asc, eq, inArray, not} from "drizzle-orm";
 import * as drizzleDb from "@/db";
 import {listOrganizations} from "@/lib/auth/auth";
 import {Metadata} from "next";
@@ -23,7 +24,9 @@ export default async function RoutePage(props: PageParams<{}>) {
 
     const organizationIds = organizations.map(project => project.id);
 
-    const agents = await db.query.agent.findMany({});
+    const agents = await db.query.agent.findMany({
+        where: not(eq(drizzleDb.schemas.agent.isArchived, true)),
+    });
 
     const projects = await db.query.project.findMany({
         where: and(inArray(drizzleDb.schemas.project.organizationId, organizationIds), eq(drizzleDb.schemas.project.isArchived, false)),

app/(customer)/dashboard/layout.tsx

@@ -2,22 +2,28 @@ import { ReactNode } from "react";
 import { redirect } from "next/navigation";
 
 import { SidebarInset, SidebarProvider } from "@/components/ui/sidebar";
-import { AppSidebar } from "@/components/wrappers/dashboard/common/sidebar/app-sidebar";
-import { Header } from "@/features/layout/Header";
+import { AppSidebar } from "@/features/layout/components/app-sidebar";
+import { Header } from "@/features/layout/components/header";
 import { currentUser } from "@/lib/auth/current-user";
-import { ThemeMetaUpdater } from "@/features/browser/theme-meta-updater";
+import { isOnboardingDone } from "@/db/services/setting";
+import { env } from "@/env.mjs";
+import { ModeToggle } from "@/features/theme/components/mode-toggle";
+import { UpdateNotification } from "@/features/updates/components/update-notification";
 
 export default async function Layout({ children }: { children: ReactNode }) {
+  if (env.SKIP_ONBOARDING !== "true" && !(await isOnboardingDone())) {
+    redirect("/welcome");
+  }
+
   const user = await currentUser();
   if (!user) redirect("/login");
 
   return (
     <SidebarProvider>
       <div className="flex flex-col lg:flex-row w-full">
-        <ThemeMetaUpdater />
-        <AppSidebar />
+        <AppSidebar updateNotification={<UpdateNotification />} />
         <SidebarInset>
-          <Header />
+          <Header actions={<ModeToggle />} />
           <main className="h-full">{children}</main>
         </SidebarInset>
       </div>

app/(customer)/dashboard/loading.tsx

@@ -1,4 +1,4 @@
-import { LoadingSpinner } from "@/components/wrappers/common/loading/loading-spinner";
+import { LoadingSpinner } from "@/components/common/loading-spinner";
 
 export default function Loading() {
     return (

app/(landing)/page.tsx

@@ -1,8 +1,14 @@
 import { redirect } from "next/navigation";
-import { getCurrentOrganizationSlug } from "@/features/dashboard/organization-cookie";
+import { getCurrentOrganizationSlug } from "@/features/organizations/utils/organization-cookie";
 import { currentUser } from "@/lib/auth/current-user";
+import { isOnboardingDone } from "@/db/services/setting";
+import { env } from "@/env.mjs";
 
 export default async function Index() {
+    if (env.SKIP_ONBOARDING !== "true" && !(await isOnboardingDone())) {
+        redirect("/welcome");
+    }
+
     const user = await currentUser();
     if (user) {
         const currentOrganizationSlug = await getCurrentOrganizationSlug();

app/(welcome)/welcome/onboarding-client.tsx

@@ -0,0 +1,29 @@
+"use client";
+
+import { useRouter } from "next/navigation";
+import { OnboardingProvider } from "@onboardjs/react";
+import { onboardingSteps } from "@/features/onboarding/onboarding-steps";
+import { OnboardingShell } from "@/features/onboarding/onboarding-shell";
+import type { OnboardingFlowData } from "@/features/onboarding/types";
+
+type Props = {
+    initialStepId: string;
+    initialFlowData: Partial<OnboardingFlowData>;
+};
+
+export const OnboardingClient = ({ initialStepId, initialFlowData }: Props) => {
+    const router = useRouter();
+
+    return (
+        <OnboardingProvider
+            steps={onboardingSteps}
+            initialStepId={initialStepId}
+            initialContext={{ flowData: initialFlowData }}
+            onFlowComplete={async () => {
+                router.push("/dashboard/home");
+            }}
+        >
+            <OnboardingShell />
+        </OnboardingProvider>
+    );
+};

app/(welcome)/welcome/page.tsx

@@ -0,0 +1,19 @@
+import { redirect } from "next/navigation";
+import { resolveOnboardingState } from "@/features/onboarding/onboarding-state";
+import { OnboardingClient } from "./onboarding-client";
+
+export default async function WelcomePage() {
+    const result = await resolveOnboardingState();
+
+    if ("redirect" in result) {
+        redirect(result.redirect);
+    }
+
+    return (
+        <OnboardingClient
+            key={result.stepId}
+            initialStepId={result.stepId}
+            initialFlowData={result.flowData}
+        />
+    );
+}

app/api/agent/[agentId]/backup/route.ts

@@ -5,10 +5,11 @@ import {db as dbClient, db} from "@/db";
 import {getDatabaseOrThrow, withAgentCheck} from "./helpers";
 import {Backup} from "@/db/schema/07_database";
 import {withUpdatedAt} from "@/db/utils";
-import {eventEmitter} from "@/features/shared/event";
-import {sendNotificationsBackupRestore} from "@/features/notifications/helpers";
+import {eventEmitter} from "@/lib/event";
+import {sendNotificationsBackupRestore} from "@/features/notifications/utils/notifications.helpers";
 import {EventKind} from "@/features/notifications/types";
 import {logger} from "@/lib/logger";
+import {JobLogEntry} from "@/features/logs/types";
 
 const log = logger.child({module: "api/agent/backup/route"});
 
@@ -22,6 +23,8 @@ export type BodyPatch = {
     status: "success" | "failed"
     size: number
     generatedId: string
+    logs: JobLogEntry[]
+    durationMs: number
 }
 
 export const POST = withAgentCheck(async (request: Request, {params, agent}: {
@@ -30,6 +33,7 @@ export const POST = withAgentCheck(async (request: Request, {params, agent}: {
 }) => {
     try {
         const body: BodyPost = await request.json();
+
         const method = body.method
         const database = await getDatabaseOrThrow(body.generatedId);
 
@@ -104,7 +108,6 @@ export const PATCH = withAgentCheck(async (request: Request, {params, agent}: {
 }) => {
     try {
         const body: BodyPatch = await request.json();
-        log.info({data: body}, "Body from PATH in backup route");
 
         const status = body.status
         const backupId = body.backupId
@@ -127,12 +130,37 @@ export const PATCH = withAgentCheck(async (request: Request, {params, agent}: {
             .update(drizzleDb.schemas.backup)
             .set(withUpdatedAt({
                 status: status,
-                fileSize: backupSize
+                fileSize: backupSize,
+                durationMs: body.durationMs
             }))
             .where(eq(drizzleDb.schemas.backup.id, backup.id))
             .returning();
 
 
+        const logsToInsert = body.logs.map((entry) => ({
+            backupId: backup.id,
+            restorationId: null,
+
+            loggedAt: new Date(entry.timestamp),
+
+            entryType: entry.type,
+            level: entry.level,
+
+            message: entry.message,
+            command: entry.command ?? null,
+            output: entry.output ?? null,
+
+            exitCode: entry.exit_code ?? null,
+            durationMs: entry.duration_ms ?? null,
+        }));
+
+        if (logsToInsert.length > 0) {
+            await dbClient
+                .insert(drizzleDb.schemas.jobLog)
+                .values(logsToInsert);
+        }
+
+
         eventEmitter.emit('modification', {update: true});
         await sendNotificationsBackupRestore(database, status == "failed" ? "error_backup" : "success_backup" as EventKind);
 

app/api/agent/[agentId]/backup/upload/init/route.ts

@@ -1,79 +1,86 @@
-import {NextResponse} from "next/server";
-import {and, eq} from "drizzle-orm";
+import { NextResponse } from "next/server";
+import { and, eq } from "drizzle-orm";
 import * as drizzleDb from "@/db";
-import {db} from "@/db";
-import {getDatabaseOrThrow, withAgentCheck} from "../../helpers";
-import {isUuidv4} from "@/utils/verify-uuid";
-import {eventEmitter} from "@/features/shared/event";
-import {logger} from "@/lib/logger";
+import { db } from "@/db";
+import { getDatabaseOrThrow, withAgentCheck } from "../../helpers";
+import { eventEmitter } from "@/lib/event";
+import { logger } from "@/lib/logger";
+import { isUUID } from "@/utils/text";
 
-const log = logger.child({module: "api/agent/backup/upload/init"});
+const log = logger.child({ module: "api/agent/backup/upload/init" });
 
 export type Body = {
-    generatedId: string
-    storageChannelId: string
-    backupId: string
-}
-export const POST = withAgentCheck(async (request: Request, {params, agent}: {
-    params: Promise<{ agentId: string }>,
-    agent: any
-}) => {
+  generatedId: string;
+  storageChannelId: string;
+  backupId: string;
+};
+export const POST = withAgentCheck(
+  async (
+    request: Request,
+    {
+      params,
+      agent,
+    }: {
+      params: Promise<{ agentId: string }>;
+      agent: any;
+    },
+  ) => {
     try {
-        const body: Body = await request.json();
+      const body: Body = await request.json();
 
-        log.info({data: body}, "Body for backup upload init");
+      log.info({ data: body }, "Body for backup upload init");
 
-        const generatedId = body.generatedId;
-        const storageChannelId = body.storageChannelId;
-        const backupId = body.backupId;
-
-        if (!generatedId || !isUuidv4(generatedId)) {
-            return NextResponse.json(
-                {error: "generatedId is not a valid UUID"},
-                {status: 400}
-            );
-        }
-
-        const database = await getDatabaseOrThrow(generatedId);
-
-        const backup = await db.query.backup.findFirst({
-            where: and(
-                eq(drizzleDb.schemas.backup.id, backupId),
-                eq(drizzleDb.schemas.backup.databaseId, database.id),
-            ),
-        });
-
-        if (!backup) {
-            return NextResponse.json(
-                {error: "Unable to find the corresponding backup"},
-                {status: 404}
-            );
-        }
-
-        const [backupStorage] = await db
-            .insert(drizzleDb.schemas.backupStorage)
-            .values({
-                backupId: backup.id,
-                storageChannelId: storageChannelId,
-                status: "pending",
-            })
-            .returning();
-
-        eventEmitter.emit('modification', {update: true});
+      const generatedId = body.generatedId;
+      const storageChannelId = body.storageChannelId;
+      const backupId = body.backupId;
 
+      if (!generatedId || !isUUID(generatedId)) {
         return NextResponse.json(
-            {
-                message: "Backup storage successfully created",
-                backupStorage: backupStorage
-            },
-            {status: 200}
+          { error: "generatedId is not a valid UUID" },
+          { status: 400 },
         );
+      }
+
+      const database = await getDatabaseOrThrow(generatedId);
+
+      const backup = await db.query.backup.findFirst({
+        where: and(
+          eq(drizzleDb.schemas.backup.id, backupId),
+          eq(drizzleDb.schemas.backup.databaseId, database.id),
+        ),
+      });
+
+      if (!backup) {
+        return NextResponse.json(
+          { error: "Unable to find the corresponding backup" },
+          { status: 404 },
+        );
+      }
+
+      const [backupStorage] = await db
+        .insert(drizzleDb.schemas.backupStorage)
+        .values({
+          backupId: backup.id,
+          storageChannelId: storageChannelId,
+          status: "pending",
+        })
+        .returning();
+
+      eventEmitter.emit("modification", { update: true });
+
+      return NextResponse.json(
+        {
+          message: "Backup storage successfully created",
+          backupStorage: backupStorage,
+        },
+        { status: 200 },
+      );
     } catch (error) {
-        log.error({error: error}, "Error in POST for INIT backup");
-        return NextResponse.json(
-            {error: "Internal server error"},
-            {status: 500}
-        );
+      log.error({ error: error }, "Error in POST for INIT backup");
+      return NextResponse.json(
+        { error: "Internal server error" },
+        { status: 500 },
+      );
     }
-});
-
+  },
+);

app/api/agent/[agentId]/backup/upload/status/route.ts

@@ -4,7 +4,7 @@ import * as drizzleDb from "@/db";
 import {db as dbClient, db} from "@/db";
 import {withUpdatedAt} from "@/db/utils";
 import {getDatabaseOrThrow, withAgentCheck} from "../../helpers";
-import {eventEmitter} from "@/features/shared/event";
+import {eventEmitter} from "@/lib/event";
 import {logger} from "@/lib/logger";
 
 const log = logger.child({module: "api/agent/backup/upload/status"});

app/api/agent/[agentId]/restore/route.ts

@@ -1,84 +1,124 @@
-import {NextResponse} from "next/server";
-import {isUuidv4} from "@/utils/verify-uuid";
+import { NextResponse } from "next/server";
 import * as drizzleDb from "@/db";
-import {db} from "@/db";
-import {and, eq} from "drizzle-orm";
-import {sendNotificationsBackupRestore} from "@/features/notifications/helpers";
-import {logger} from "@/lib/logger";
-import {withUpdatedAt} from "@/db/utils";
+import { db as dbClient, db } from "@/db";
+import { and, eq } from "drizzle-orm";
+import { sendNotificationsBackupRestore } from "@/features/notifications/utils/notifications.helpers";
+import { logger } from "@/lib/logger";
+import { withUpdatedAt } from "@/db/utils";
+import { JobLogEntry } from "@/features/logs/types";
+import { isUUID } from "@/utils/text";
 
-const log = logger.child({module: "api/agent/restore"});
+const log = logger.child({ module: "api/agent/restore" });
 
 export type BodyResultRestore = {
-    generatedId: string
-    status: string
-}
-type RestorationStatus = 'waiting' | 'ongoing' | 'failed' | 'success';
-
+  generatedId: string;
+  status: string;
+  logs: JobLogEntry[];
+  durationMs: number;
+};
+type RestorationStatus = "waiting" | "ongoing" | "failed" | "success";
 
 export async function POST(
-    request: Request,
-    {params}: { params: Promise<{ agentId: string }> }
+  request: Request,
+  { params }: { params: Promise<{ agentId: string }> },
 ) {
+  try {
+    const agentId = (await params).agentId;
+    const body: BodyResultRestore = await request.json();
 
-    try {
-
-        const agentId = (await params).agentId
-        const body: BodyResultRestore = await request.json();
-
-
-        if (!isUuidv4(body.generatedId)) {
-            return NextResponse.json(
-                {error: "generatedId is not a valid uuid"},
-                {status: 500}
-            );
-        }
-
-        const agent = await db.query.agent.findFirst({
-            where: and(eq(drizzleDb.schemas.agent.id, agentId), eq(drizzleDb.schemas.agent.isArchived, false)),
-        })
-        if (!agent) {
-            return NextResponse.json({error: "Agent not found"}, {status: 404})
-        }
-
-        const database = await db.query.database.findFirst({
-            where: eq(drizzleDb.schemas.database.agentDatabaseId, body.generatedId),
-            with: {
-                alertPolicies: true
-            }
-        })
-
-        if (!database) {
-            return NextResponse.json({error: "Database associated with generatedId provided not found"}, {status: 404})
-        }
-
-        const restoration = await db.query.restoration.findFirst({
-            where: and(eq(drizzleDb.schemas.restoration.status, "ongoing"), eq(drizzleDb.schemas.restoration.databaseId, database.id),)
-        })
-
-        if (!restoration) {
-            return NextResponse.json({error: "Unable to fin the corresponding restoration"}, {status: 404})
-        }
-
-
-        await db
-            .update(drizzleDb.schemas.restoration)
-            .set(withUpdatedAt({status: body.status as RestorationStatus}))
-            .where(eq(drizzleDb.schemas.restoration.id, restoration.id));
-
-        await sendNotificationsBackupRestore(database, body.status == "failed" ? "error_restore" : "success_restore");
-
-        const response = {
-            status: true,
-            message: "Restoration successfully updated"
-        }
-
-        return Response.json(response, {status: 200})
-    } catch (error) {
-        log.error({error: error}, "Error in POST handler")
-        return NextResponse.json(
-            {error: 'Internal server error'},
-            {status: 500}
-        );
+    if (!isUUID(body.generatedId)) {
+      return NextResponse.json(
+        { error: "generatedId is not a valid uuid" },
+        { status: 500 },
+      );
     }
-}
+
+    const agent = await db.query.agent.findFirst({
+      where: and(
+        eq(drizzleDb.schemas.agent.id, agentId),
+        eq(drizzleDb.schemas.agent.isArchived, false),
+      ),
+    });
+    if (!agent) {
+      return NextResponse.json({ error: "Agent not found" }, { status: 404 });
+    }
+
+    const database = await db.query.database.findFirst({
+      where: eq(drizzleDb.schemas.database.agentDatabaseId, body.generatedId),
+      with: {
+        alertPolicies: true,
+      },
+    });
+
+    if (!database) {
+      return NextResponse.json(
+        { error: "Database associated with generatedId provided not found" },
+        { status: 404 },
+      );
+    }
+
+    const restoration = await db.query.restoration.findFirst({
+      where: and(
+        eq(drizzleDb.schemas.restoration.status, "ongoing"),
+        eq(drizzleDb.schemas.restoration.databaseId, database.id),
+      ),
+    });
+
+    if (!restoration) {
+      return NextResponse.json(
+        { error: "Unable to fin the corresponding restoration" },
+        { status: 404 },
+      );
+    }
+
+    const [restorationUpdated] = await db
+      .update(drizzleDb.schemas.restoration)
+      .set(
+        withUpdatedAt({
+          status: body.status as RestorationStatus,
+          durationMs: body.durationMs,
+        }),
+      )
+      .where(eq(drizzleDb.schemas.restoration.id, restoration.id))
+      .returning();
+
+    const logsToInsert = body.logs.map((entry) => ({
+      backupId: null,
+      restorationId: restorationUpdated.id,
+
+      loggedAt: new Date(entry.timestamp),
+
+      entryType: entry.type,
+      level: entry.level,
+
+      message: entry.message,
+      command: entry.command ?? null,
+      output: entry.output ?? null,
+
+      exitCode: entry.exit_code ?? null,
+      durationMs: entry.duration_ms ?? null,
+    }));
+
+    if (logsToInsert.length > 0) {
+      await dbClient.insert(drizzleDb.schemas.jobLog).values(logsToInsert);
+    }
+
+    await sendNotificationsBackupRestore(
+      database,
+      body.status == "failed" ? "error_restore" : "success_restore",
+    );
+
+    const response = {
+      status: true,
+      message: "Restoration successfully updated",
+    };
+
+    return Response.json(response, { status: 200 });
+  } catch (error) {
+    log.error({ error: error }, "Error in POST handler");
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 },
+    );
+  }
+}

app/api/agent/[agentId]/status/route.ts

@@ -1,99 +1,95 @@
-import {NextResponse} from "next/server";
-import {handleDatabases} from "./helpers";
+import { NextResponse } from "next/server";
+import { handleDatabases } from "@/features/agents/utils/status/status.helpers";
+import { Body } from "@/features/agents/types";
 import * as drizzleDb from "@/db";
-import {db} from "@/db";
-import {EDbmsSchema} from "@/db/schema/types";
-import {and, eq} from "drizzle-orm";
-import {isUuidv4} from "@/utils/verify-uuid";
-import {withUpdatedAt} from "@/db/utils";
-import {logger} from "@/lib/logger";
-
-
-const log = logger.child({module: "api/agent/status/route"});
-
-
-export type databaseAgent = {
-    name: string,
-    dbms: EDbmsSchema,
-    generatedId: string
-    pingStatus: boolean
-}
-
-export type Body = {
-    version: string,
-    databases: databaseAgent[]
-}
+import { db } from "@/db";
+import { and, eq } from "drizzle-orm";
+import { withUpdatedAt } from "@/db/utils";
+import { logger } from "@/lib/logger";
+import { isUUID } from "@/utils/text";
 
+const log = logger.child({ module: "api/agent/status/route" });
 
 export async function POST(
-    request: Request,
-    {params}: { params: Promise<{ agentId: string }> }
+  request: Request,
+  { params }: { params: Promise<{ agentId: string }> },
 ) {
-    try {
-        const agentId = (await params).agentId
-        log.debug(`Agent ID: ${agentId}`)
-        const body: Body = await request.json();
-        const lastContact = new Date();
-        let message: string
+  try {
+    const agentId = (await params).agentId;
+    log.debug(`Agent ID: ${agentId}`);
+    const body: Body = await request.json();
+    const lastContact = new Date();
+    let message: string;
 
-        if (!isUuidv4(agentId)) {
-            message = "agentId is not a valid uuid"
-            log.error({error: message}, "An error occurred")
-            return NextResponse.json(
-                {error: "agentId is not a valid uuid"},
-                {status: 500}
-            );
-        }
-
-        const agent = await db.query.agent.findFirst({
-            where: and(eq(drizzleDb.schemas.agent.id, agentId), eq(drizzleDb.schemas.agent.isArchived, false)),
-        })
-
-        if (!agent) {
-            message = "Agent not found"
-            return NextResponse.json({error: message}, {status: 404})
-        }
-
-        const [settings] = await db.select().from(drizzleDb.schemas.setting).where(eq(drizzleDb.schemas.setting.name, "system")).limit(1);
-        if (!settings) {
-            return NextResponse.json({error: "An error occured"}, {status: 404})
-        }
-
-        const databasesResponse = await handleDatabases(body, agent, lastContact, settings)
-
-        await db
-            .update(drizzleDb.schemas.agent)
-            .set(withUpdatedAt({
-                version: body.version,
-                lastContact: lastContact,
-                healthErrorCount: null
-            }))
-            .where(eq(drizzleDb.schemas.agent.id, agentId));
-
-        await db
-            .insert(drizzleDb.schemas.healthcheckLog)
-            .values({
-                kind: "agent",
-                status: "success",
-                objectId: agentId,
-                date: lastContact
-            })
-
-        const response = {
-            agent: {
-                id: agentId,
-                lastContact: lastContact
-            },
-            databases: databasesResponse
-        }
-
-        return Response.json(response)
-    } catch (error) {
-        log.error({error: error}, "Error in POST handler")
-        return NextResponse.json(
-            {error: 'Internal server error'},
-            {status: 500}
-        );
+    if (!isUUID(agentId)) {
+      message = "agentId is not a valid uuid";
+      log.error({ error: message }, "An error occurred");
+      return NextResponse.json(
+        { error: "agentId is not a valid uuid" },
+        { status: 500 },
+      );
     }
-}
 
+    const agent = await db.query.agent.findFirst({
+      where: and(
+        eq(drizzleDb.schemas.agent.id, agentId),
+        eq(drizzleDb.schemas.agent.isArchived, false),
+      ),
+    });
+
+    if (!agent) {
+      message = "Agent not found";
+      return NextResponse.json({ error: message }, { status: 404 });
+    }
+
+    const [settings] = await db
+      .select()
+      .from(drizzleDb.schemas.setting)
+      .where(eq(drizzleDb.schemas.setting.name, "system"))
+      .limit(1);
+    if (!settings) {
+      return NextResponse.json({ error: "An error occurred" }, { status: 404 });
+    }
+
+    const databasesResponse = await handleDatabases(
+      body,
+      agent,
+      lastContact,
+      settings,
+    );
+
+    await db
+      .update(drizzleDb.schemas.agent)
+      .set(
+        withUpdatedAt({
+          version: body.version,
+          lastContact: lastContact,
+          healthErrorCount: null,
+        }),
+      )
+      .where(eq(drizzleDb.schemas.agent.id, agentId));
+
+    await db.insert(drizzleDb.schemas.healthcheckLog).values({
+      kind: "agent",
+      status: "success",
+      objectId: agentId,
+      date: lastContact,
+    });
+
+    const response = {
+      agent: {
+        id: agentId,
+        lastContact: lastContact,
+      },
+      databases: databasesResponse,
+    };
+
+    return Response.json(response);
+  } catch (error) {
+    log.error({ error: error }, "Error in POST handler");
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 },
+    );
+  }
+}

app/api/auth/[...all]/route.ts

@@ -1,4 +1,37 @@
 import { auth } from "@/lib/auth/auth";
 import { toNextJsHandler } from "better-auth/next-js";
+import { NextRequest, NextResponse } from "next/server";
+import { headers } from "next/headers";
 
-export const { GET, POST } = toNextJsHandler(auth.handler);
+const authHandler = toNextJsHandler(auth.handler);
+
+async function blockApiKeyCreateForRestrictedUsers(
+  req: NextRequest,
+): Promise<NextResponse | null> {
+  const url = req.nextUrl;
+  if (req.method !== "POST" || !url.pathname.endsWith("/api-key/create")) {
+    return null;
+  }
+  const session = await auth.api.getSession({ headers: await headers() });
+  if (!session?.user) {
+    return null;
+  }
+  // @ts-ignore
+  if (session.user.banned || (session.user.role as string) === "pending") {
+    return NextResponse.json(
+      { error: "Account not eligible to create API keys" },
+      { status: 403 },
+    );
+  }
+  return null;
+}
+
+export async function GET(req: NextRequest) {
+  return authHandler.GET(req);
+}
+
+export async function POST(req: NextRequest) {
+  const guard = await blockApiKeyCreateForRestrictedUsers(req);
+  if (guard) return guard;
+  return authHandler.POST(req);
+}

app/api/config/route.ts

@@ -4,6 +4,6 @@ export async function GET() {
   return NextResponse.json({
     PROJECT_URL: process.env.PROJECT_URL,
     PROJECT_NAME: process.env.PROJECT_NAME,
-    PROJECT_DESCRIPTION: process.env.PROJECT_DESCRIPTION,
+    PROJECT_DESCRIPTION: process.env.PROJECT_DESCRIPTION
   });
 }

app/api/events/route.ts

@@ -1,7 +1,7 @@
 import {auth} from "@/lib/auth/auth";
 import {headers} from "next/headers";
 import {NextResponse} from "next/server";
-import {eventEmitter} from "@/features/shared/event";
+import {eventEmitter} from "@/lib/event";
 import {logger} from "@/lib/logger";
 
 const log = logger.child({module: "api/events"});

app/api/files/backups/route.ts

@@ -1,7 +1,7 @@
 import {NextResponse} from "next/server";
 import path from "path";
 import type {StorageInput} from "@/features/storages/types";
-import {dispatchStorage} from "@/features/storages/dispatch";
+import {dispatchStorage} from "@/features/storages/utils/storages.dispatch";
 import {Readable} from "node:stream";
 import {logger} from "@/lib/logger";
 

app/api/files/images/[fileName]/route.ts

@@ -2,7 +2,7 @@ import {NextResponse} from "next/server";
 import {auth} from "@/lib/auth/auth";
 import {headers} from "next/headers";
 import {StorageInput} from "@/features/storages/types";
-import {dispatchStorage} from "@/features/storages/dispatch";
+import {dispatchStorage} from "@/features/storages/utils/storages.dispatch";
 import {Readable} from "node:stream";
 import {logger} from "@/lib/logger";
 

app/api/tus/hooks/route.ts

@@ -1,11 +1,16 @@
 import {NextResponse} from "next/server";
 import fs from "fs";
 import path from "path";
+import {and, eq} from "drizzle-orm";
+import {db} from "@/db";
+import * as drizzleDb from "@/db";
 import {env} from "@/env.mjs";
 import {logger} from "@/lib/logger";
 
 const log = logger.child({module: "api/tus/hooks"});
 
+const FILE_PATH_RE = /^backups\/\d{4}-\d{2}-\d{2}\/[A-Za-z0-9._-]+$/;
+
 export async function POST(request: Request) {
     try {
         const body = await request.json();
@@ -24,17 +29,61 @@ export async function POST(request: Request) {
                 event.Upload.Offset === event.Upload.Size
             ) {
                 const id = event.Upload.ID;
-                const fileName = headers["X-File-Name"]?.[0];
                 const filePath = headers["X-File-Path"]?.[0];
 
-                if (!filePath) {
-                    return NextResponse.json({error: "Missing X-File-Path"}, {status: 500});
+                if (!filePath || !FILE_PATH_RE.test(filePath)) {
+                    log.warn({filePath}, "Rejected invalid X-File-Path in TUS hook");
+                    return NextResponse.json({error: "Invalid file path"}, {status: 400});
+                }
+
+                const generatedId = headers["X-Generated-Id"]?.[0];
+                const backupStorageId = headers["X-Backup-Storage-Id"]?.[0];
+
+
+                console.log(`Backup Storage ID : ${backupStorageId}`);
+                console.log(`generatedId : ${generatedId}`);
+
+                if (backupStorageId) {
+                    if (!generatedId) {
+                        log.warn("Missing X-Generated-Id in TUS hook");
+                        return NextResponse.json({error: "Forbidden"}, {status: 403});
+                    }
+
+                    const database = await db.query.database.findFirst({
+                        where: eq(drizzleDb.schemas.database.agentDatabaseId, generatedId),
+                    });
+
+                    if (!database) {
+                        log.warn({generatedId}, "No database for X-Generated-Id in TUS hook");
+                        return NextResponse.json({error: "Forbidden"}, {status: 403});
+                    }
+
+                    const storage = await db.query.backupStorage.findFirst({
+                        where: and(
+                            eq(drizzleDb.schemas.backupStorage.id, backupStorageId),
+                        ),
+                        with: {backup: true},
+                    });
+
+                    if (!storage || storage.backup?.databaseId !== database.id) {
+                        log.warn({backupStorageId, generatedId}, "No pending backup storage matches TUS hook");
+                        return NextResponse.json({error: "Forbidden"}, {status: 403});
+                    }
+                } else {
+                    log.warn("TUS hook without X-Backup-Storage-Id (legacy agent)");
                 }
 
                 const uploadDir = path.join(env.PRIVATE_PATH!, "/uploads/");
 
                 const oldFilePath = path.join(uploadDir, "tmp", id);
-                const newFilePath = path.join(uploadDir, filePath);
+
+                const resolvedBase = path.resolve(uploadDir);
+                const newFilePath = path.resolve(resolvedBase, filePath);
+                const rel = path.relative(resolvedBase, newFilePath);
+                if (rel.startsWith("..") || path.isAbsolute(rel)) {
+                    log.warn({filePath}, "Rejected path traversal in TUS hook");
+                    return NextResponse.json({error: "Invalid file path"}, {status: 400});
+                }
 
                 fs.mkdirSync(path.dirname(newFilePath), {recursive: true});
 
@@ -74,7 +123,7 @@ export async function POST(request: Request) {
         }
         return NextResponse.json({});
     } catch (error) {
-        log.error({error: error},"TUS Hook error");
+        log.error({error: error}, "TUS Hook error");
         return NextResponse.json({error: "Internal server error"}, {status: 500});
     }
-}
+}

app/api/v1/agents/[id]/key/route.ts

@@ -0,0 +1,34 @@
+import {withApiKey} from "@/lib/api-v1/middleware";
+import {ApiKeyContext} from "@/lib/api-v1/types";
+import {NextResponse} from "next/server";
+import {getAgent, resolveAgentAccess} from "@/lib/api-v1/services/agents";
+import {logger} from "@/lib/logger";
+import {generateEdgeKey} from "@/utils/edge_key";
+import {getServerUrl} from "@/utils/get-server-url";
+
+const log = logger.child({ module: "api/v1/agents/[id]/key" });
+
+export const GET = withApiKey(
+    async (_req: Request, ctx: ApiKeyContext, params?: Record<string, string>) => {
+        try {
+            const id = params?.id;
+            if (!id) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+            const access = await resolveAgentAccess(id, ctx.user);
+
+            if (access === "forbidden") return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+            if (access === "not_found") return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+            const agent = await getAgent(id);
+
+            if (!agent) return NextResponse.json({ error: "Agent not found" }, { status: 404 });
+
+            const edgeKey = await generateEdgeKey(getServerUrl(), agent.id);
+
+            return NextResponse.json({ data: edgeKey });
+        } catch (error) {
+            log.error({ error }, "Error in GET /api/v1/agents/[id]");
+            return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+        }
+    }
+);

app/api/v1/agents/[id]/route.ts

@@ -0,0 +1,77 @@
+import {NextResponse} from "next/server";
+import {withApiKey} from "@/lib/api-v1/middleware";
+import {logger} from "@/lib/logger";
+import {ApiKeyContext} from "@/lib/api-v1/types";
+import {getAgent, resolveAgentAccess} from "@/lib/api-v1/services/agents";
+import {deleteAgentService} from "@/features/agents/actions/agent-delete.action";
+
+const log = logger.child({module: "api/v1/agents/[id]"});
+
+export const GET = withApiKey(
+    async (_req: Request, ctx: ApiKeyContext, params?: Record<string, string>) => {
+        try {
+            const id = params?.id;
+            if (!id) return NextResponse.json({error: "Not found"}, {status: 404});
+
+            const access = await resolveAgentAccess(id, ctx.user);
+
+            if (access === "forbidden") return NextResponse.json({error: "Forbidden"}, {status: 403});
+            if (access === "not_found") return NextResponse.json({error: "Not found"}, {status: 404});
+
+            const agent = await getAgent(id, {
+                includeDatabases: true,
+                includeOrganizations: false,
+            });
+
+            if (!agent) return NextResponse.json({error: "Not found"}, {status: 404});
+            return NextResponse.json({data: agent});
+        } catch (error) {
+            log.error({error}, "Error in GET /api/v1/agents/[id]");
+            return NextResponse.json({error: "Internal server error"}, {status: 500});
+        }
+    }
+);
+
+export const DELETE = withApiKey(
+    async (_req: Request, ctx: ApiKeyContext, params?: Record<string, string>) => {
+        try {
+            const id = params?.id;
+            if (!id) return NextResponse.json({error: "Not found"}, {status: 404});
+
+            const access = await resolveAgentAccess(id, ctx.user);
+            if (access === "forbidden") return NextResponse.json({error: "Forbidden"}, {status: 403});
+            if (access === "not_found") return NextResponse.json({error: "Not found"}, {status: 404});
+
+
+            const agent = await getAgent(id, {
+                includeDatabases: false,
+                includeOrganizations: true,
+            });
+
+            if (!agent) return NextResponse.json({error: "Agent no found"}, {status: 404});
+
+            const organizationIds = agent.organizations.map(org => org.organizationId)
+
+            const canDeleteGlobalAgent =
+                ctx.user.permissions.isAdmin || ctx.user.permissions.isSuperAdmin;
+
+            if (!agent.organizationId && !canDeleteGlobalAgent) {
+                return NextResponse.json(
+                    { error: "Forbidden" },
+                    { status: 403 }
+                );
+            }
+
+            await deleteAgentService({
+                agentId: agent.id,
+                organizationId: agent.organizationId ?? undefined,
+                organizationIds: organizationIds
+            });
+
+            return new Response(null, {status: 204});
+        } catch (error) {
+            log.error({error}, "Error in DELETE /api/v1/agents/[id]");
+            return NextResponse.json({error: "Internal server error"}, {status: 500});
+        }
+    }
+);

app/api/v1/agents/route.ts

@@ -0,0 +1,112 @@
+import { NextResponse } from "next/server";
+import { withApiKey } from "@/lib/api-v1/middleware";
+import { db } from "@/db";
+import * as drizzleDb from "@/db";
+import { inArray, eq, and, or, isNull } from "drizzle-orm";
+import { z } from "zod";
+import { logger } from "@/lib/logger";
+import {createAgentService} from "@/features/agents/actions/agents.action";
+import { ActionError } from "@/lib/safe-actions/actions";
+import {getAccessibleAgentIds} from "@/lib/api-v1/services/agents";
+import {ApiKeyContext} from "@/lib/api-v1/types";
+import {parseJsonBody} from "@/lib/api-v1/validation/json-body";
+
+const log = logger.child({ module: "api/v1/agents" });
+
+export const GET = withApiKey(async (_req: Request, ctx: ApiKeyContext) => {
+  try {
+    const agentIds = await getAccessibleAgentIds(ctx.user);
+
+    if (agentIds.length === 0) {
+      return NextResponse.json({ data: [] });
+    }
+
+    const agents = await db.query.agent.findMany({
+      where: and(
+        inArray(drizzleDb.schemas.agent.id, agentIds),
+        or(
+          eq(drizzleDb.schemas.agent.isArchived, false),
+          isNull(drizzleDb.schemas.agent.isArchived)
+        )
+      ),
+    });
+
+    return NextResponse.json({ data: agents });
+  } catch (error) {
+    log.error({ error }, "Error in GET /api/v1/agents");
+    return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+  }
+});
+
+const CreateAgentSchema = z.object({
+  name: z.string().min(1, "name is required"),
+  organizationId: z.string().uuid("organizationId must be a valid UUID").optional(),
+});
+
+export const POST = withApiKey(
+    async (req: Request, ctx: ApiKeyContext) => {
+      try {
+
+        const body = await parseJsonBody(req, CreateAgentSchema);
+
+        if (!body.ok) {
+          return body.response;
+        }
+
+        const { name, organizationId } = body.data;
+
+        const org = ctx.organizations.find(
+            (org) => org.id === organizationId
+        );
+
+        if (
+            organizationId &&
+            (!org || !org.permissions.canManageAgents)
+        ) {
+          return NextResponse.json(
+              { error: "Forbidden" },
+              { status: 403 }
+          );
+        }
+
+        const canCreateGlobalAgent =
+            ctx.user.permissions.isAdmin || ctx.user.permissions.isSuperAdmin;
+
+        if (!organizationId && !canCreateGlobalAgent) {
+          return NextResponse.json(
+              { error: "Forbidden" },
+              { status: 403 }
+          );
+        }
+
+        const createdAgent = await createAgentService({
+          organizationId,
+          data: {
+            name,
+            description: "",
+          },
+        });
+
+        return NextResponse.json(
+            { data: createdAgent },
+            { status: 201 }
+        );
+      } catch (error: unknown) {
+        if (error instanceof ActionError) {
+          return NextResponse.json(
+              { error: error.message },
+              { status: 400 }
+          );
+        }
+
+        log.error({error},
+            "Error in POST /api/v1/agents"
+        );
+
+        return NextResponse.json(
+            { error: "Internal server error" },
+            { status: 500 }
+        );
+      }
+    }
+);

app/api/v1/databases/[id]/backup/[backupId]/route.ts

@@ -0,0 +1,61 @@
+import { NextResponse } from "next/server";
+import { withApiKey } from "@/lib/api-v1/middleware";
+import { db } from "@/db";
+import * as drizzleDb from "@/db";
+import { and, eq, isNull } from "drizzle-orm";
+import { logger } from "@/lib/logger";
+import { ApiKeyContext } from "@/lib/api-v1/types";
+import {requireDatabaseAccess} from "@/lib/api-v1/services/databases";
+
+const log = logger.child({
+  module: "api/v1/databases/[id]/backup/[backupId]",
+});
+
+export const GET = withApiKey(
+    async (_req: Request, ctx: ApiKeyContext, params?: Record<string, string>) => {
+      try {
+        const guard = await requireDatabaseAccess(params, ctx.user);
+
+        if (!guard.ok) {
+          return guard.response;
+        }
+
+        const { id } = guard.data;
+        const backupId = params?.backupId;
+
+        if (!backupId) {
+          return NextResponse.json({ error: "Not found" }, { status: 404 });
+        }
+
+        const backup = await db.query.backup.findFirst({
+          where: and(
+              eq(drizzleDb.schemas.backup.id, backupId),
+              eq(drizzleDb.schemas.backup.databaseId, id),
+              isNull(drizzleDb.schemas.backup.deletedAt)
+          ),
+          with: {
+            storages: {
+              where: (backupStorage, { isNull }) =>
+                  isNull(backupStorage.deletedAt),
+            },
+          },
+        });
+
+        if (!backup) {
+          return NextResponse.json({ error: "Not found" }, { status: 404 });
+        }
+
+        return NextResponse.json({ data: backup });
+      } catch (error) {
+        log.error(
+            { error },
+            "Error in GET /api/v1/databases/[id]/backup/[backupId]"
+        );
+
+        return NextResponse.json(
+            { error: "Internal server error" },
+            { status: 500 }
+        );
+      }
+    }
+);

app/api/v1/databases/[id]/backup/route.ts

@@ -0,0 +1,96 @@
+import { NextResponse } from "next/server";
+import { withApiKey } from "@/lib/api-v1/middleware";
+import { db } from "@/db";
+import * as drizzleDb from "@/db";
+import {and, desc, eq, inArray, isNull} from "drizzle-orm";
+import { logger } from "@/lib/logger";
+import { ApiKeyContext } from "@/lib/api-v1/types";
+import {requireDatabaseAccess} from "@/lib/api-v1/services/databases";
+
+const log = logger.child({ module: "api/v1/databases/[id]/backup" });
+
+export const GET = withApiKey(
+    async (_req: Request, ctx: ApiKeyContext, params?: Record<string, string>) => {
+      try {
+        const guard = await requireDatabaseAccess(params, ctx.user);
+
+        if (!guard.ok) {
+          return guard.response;
+        }
+
+        const { id } = guard.data;
+
+        const backups = await db.query.backup.findMany({
+          where: and(
+              eq(drizzleDb.schemas.backup.databaseId, id),
+              isNull(drizzleDb.schemas.backup.deletedAt)
+          ),
+          orderBy: [desc(drizzleDb.schemas.backup.createdAt)],
+        });
+
+        return NextResponse.json({ data: backups });
+      } catch (error) {
+        log.error({ error }, "Error in GET /api/v1/databases/[id]/backup");
+
+        return NextResponse.json(
+            { error: "Internal server error" },
+            { status: 500 }
+        );
+      }
+    }
+);
+
+export const POST = withApiKey(
+    async (_req: Request, ctx: ApiKeyContext, params?: Record<string, string>) => {
+      try {
+        const guard = await requireDatabaseAccess(params, ctx.user);
+
+        if (!guard.ok) {
+          return guard.response;
+        }
+
+        const { id } = guard.data;
+
+        const existingBackup = await db.query.backup.findFirst({
+          where: and(
+              eq(drizzleDb.schemas.backup.databaseId, id),
+              inArray(drizzleDb.schemas.backup.status, ["waiting", "ongoing"])
+          ),
+        });
+
+        if (existingBackup) {
+          return NextResponse.json(
+              {
+                error:
+                    "A backup is already waiting or ongoing for this database",
+              },
+              { status: 409 }
+          );
+        }
+
+        const [createdBackup] = await db
+            .insert(drizzleDb.schemas.backup)
+            .values({
+              databaseId: id,
+              status: "waiting",
+            })
+            .returning();
+
+        if (!createdBackup) {
+          return NextResponse.json(
+              { error: "Failed to create backup" },
+              { status: 500 }
+          );
+        }
+
+        return NextResponse.json({ data: createdBackup }, { status: 201 });
+      } catch (error) {
+        log.error({ error }, "Error in POST /api/v1/databases/[id]/backup");
+
+        return NextResponse.json(
+            { error: "Internal server error" },
+            { status: 500 }
+        );
+      }
+    }
+);

app/api/v1/databases/[id]/restore/route.ts

@@ -0,0 +1,122 @@
+import { NextResponse } from "next/server";
+import { withApiKey } from "@/lib/api-v1/middleware";
+import { db } from "@/db";
+import * as drizzleDb from "@/db";
+import {and, eq, inArray, isNull} from "drizzle-orm";
+import { z } from "zod";
+import { logger } from "@/lib/logger";
+import { ApiKeyContext } from "@/lib/api-v1/types";
+import { parseJsonBody } from "@/lib/api-v1/validation/json-body";
+import {requireDatabaseAccess} from "@/lib/api-v1/services/databases";
+
+const log = logger.child({ module: "api/v1/databases/[id]/restore" });
+
+const RestoreSchema = z.object({
+  backupId: z.string().uuid("backupId must be a valid UUID"),
+  backupStorageId: z.string().uuid("backupStorageId must be a valid UUID"),
+});
+
+export const POST = withApiKey(
+    async (req: Request, ctx: ApiKeyContext, params?: Record<string, string>) => {
+      try {
+        const guard = await requireDatabaseAccess(params, ctx.user);
+
+        if (!guard.ok) {
+          return guard.response;
+        }
+
+        const { id } = guard.data;
+
+        const body = await parseJsonBody(req, RestoreSchema);
+
+        if (!body.ok) {
+          return body.response;
+        }
+
+        const { backupId, backupStorageId } = body.data;
+
+        const backupRecord = await db.query.backup.findFirst({
+          where: and(
+              eq(drizzleDb.schemas.backup.id, backupId),
+              eq(drizzleDb.schemas.backup.databaseId, id),
+              isNull(drizzleDb.schemas.backup.deletedAt)
+          ),
+          columns: {
+            id: true,
+          },
+        });
+
+        if (!backupRecord) {
+          return NextResponse.json(
+              { error: "Backup not found for this database" },
+              { status: 404 }
+          );
+        }
+
+        const backupStorage = await db.query.backupStorage.findFirst({
+          where: and(
+              eq(drizzleDb.schemas.backupStorage.id, backupStorageId),
+              eq(drizzleDb.schemas.backupStorage.backupId, backupId),
+              isNull(drizzleDb.schemas.backupStorage.deletedAt)
+          ),
+        });
+
+        if (!backupStorage) {
+          return NextResponse.json(
+              { error: "Backup storage not found" },
+              { status: 404 }
+          );
+        }
+
+        if (backupStorage.status !== "success") {
+          return NextResponse.json(
+              { error: "Backup storage is not in a successful state" },
+              { status: 422 }
+          );
+        }
+
+        const existingRestorationBackup = await db.query.restoration.findFirst({
+          where: and(
+              eq(drizzleDb.schemas.restoration.databaseId, id),
+              inArray(drizzleDb.schemas.restoration.status, ["waiting", "ongoing"])
+          ),
+        });
+
+        if (existingRestorationBackup) {
+          return NextResponse.json(
+              {
+                error:
+                    "A restoration is already waiting or ongoing for this database",
+              },
+              { status: 409 }
+          );
+        }
+
+        const [restoration] = await db
+            .insert(drizzleDb.schemas.restoration)
+            .values({
+              databaseId: id,
+              backupId,
+              backupStorageId,
+              status: "waiting",
+            })
+            .returning();
+
+        if (!restoration) {
+          return NextResponse.json(
+              { error: "Failed to create restoration" },
+              { status: 500 }
+          );
+        }
+
+        return NextResponse.json({ data: restoration }, { status: 201 });
+      } catch (error) {
+        log.error({ error }, "Error in POST /api/v1/databases/[id]/restore");
+
+        return NextResponse.json(
+            { error: "Internal server error" },
+            { status: 500 }
+        );
+      }
+    }
+);

app/api/v1/databases/[id]/route.ts

@@ -0,0 +1,44 @@
+import { NextResponse } from "next/server";
+import { withApiKey } from "@/lib/api-v1/middleware";
+import { db } from "@/db";
+import * as drizzleDb from "@/db";
+import { and, eq, isNull } from "drizzle-orm";
+import { logger } from "@/lib/logger";
+import { ApiKeyContext } from "@/lib/api-v1/types";
+import {requireDatabaseAccess} from "@/lib/api-v1/services/databases";
+
+const log = logger.child({ module: "api/v1/databases/[id]" });
+
+export const GET = withApiKey(
+    async (_req: Request, ctx: ApiKeyContext, params?: Record<string, string>) => {
+      try {
+        const guard = await requireDatabaseAccess(params, ctx.user);
+
+        if (!guard.ok) {
+          return guard.response;
+        }
+
+        const { id } = guard.data;
+
+        const database = await db.query.database.findFirst({
+          where: and(
+              eq(drizzleDb.schemas.database.id, id),
+              isNull(drizzleDb.schemas.database.deletedAt)
+          ),
+        });
+
+        if (!database) {
+          return NextResponse.json({ error: "Not found" }, { status: 404 });
+        }
+
+        return NextResponse.json({ data: database });
+      } catch (error) {
+        log.error({ error }, "Error in GET /api/v1/databases/[id]");
+
+        return NextResponse.json(
+            { error: "Internal server error" },
+            { status: 500 }
+        );
+      }
+    }
+);

app/api/v1/databases/[id]/status/route.ts

@@ -0,0 +1,72 @@
+import { NextResponse } from "next/server";
+import { withApiKey } from "@/lib/api-v1/middleware";
+import { db } from "@/db";
+import * as drizzleDb from "@/db";
+import { and, desc, eq, isNull } from "drizzle-orm";
+import { logger } from "@/lib/logger";
+import { ApiKeyContext } from "@/lib/api-v1/types";
+import {requireDatabaseAccess} from "@/lib/api-v1/services/databases";
+
+const log = logger.child({ module: "api/v1/databases/[id]/status" });
+
+export const GET = withApiKey(
+    async (_req: Request, ctx: ApiKeyContext, params?: Record<string, string>) => {
+      try {
+        const guard = await requireDatabaseAccess(params, ctx.user);
+
+        if (!guard.ok) {
+          return guard.response;
+        }
+
+        const { id } = guard.data;
+
+        const [database, latestBackup, latestRestoration] = await Promise.all([
+          db.query.database.findFirst({
+            where: and(
+                eq(drizzleDb.schemas.database.id, id),
+                isNull(drizzleDb.schemas.database.deletedAt)
+            ),
+          }),
+
+          db.query.backup.findFirst({
+            where: and(
+                eq(drizzleDb.schemas.backup.databaseId, id),
+                isNull(drizzleDb.schemas.backup.deletedAt)
+            ),
+            orderBy: [desc(drizzleDb.schemas.backup.createdAt)],
+          }),
+
+          db.query.restoration.findFirst({
+            where: and(
+                eq(drizzleDb.schemas.restoration.databaseId, id),
+                isNull(drizzleDb.schemas.restoration.deletedAt)
+            ),
+            orderBy: [desc(drizzleDb.schemas.restoration.createdAt)],
+          }),
+        ]);
+
+        if (!database) {
+          return NextResponse.json(
+              { error: "Database not found" },
+              { status: 404 }
+          );
+        }
+
+        return NextResponse.json({
+          data: {
+            isWaitingForBackup: database.isWaitingForBackup,
+            lastContact: database.lastContact,
+            latestBackup: latestBackup ?? null,
+            latestRestoration: latestRestoration ?? null,
+          },
+        });
+      } catch (error) {
+        log.error({ error }, "Error in GET /api/v1/databases/[id]/status");
+
+        return NextResponse.json(
+            { error: "Internal server error" },
+            { status: 500 }
+        );
+      }
+    }
+);

app/api/v1/databases/route.ts

@@ -0,0 +1,24 @@
+import { NextResponse } from "next/server";
+import { withApiKey } from "@/lib/api-v1/middleware";
+import { logger } from "@/lib/logger";
+import { ApiKeyContext } from "@/lib/api-v1/types";
+import { getAccessibleDatabases } from "@/lib/api-v1/services/databases";
+
+const log = logger.child({ module: "api/v1/databases" });
+
+export const GET = withApiKey(async (_req: Request, ctx: ApiKeyContext) => {
+  try {
+    const databases = await getAccessibleDatabases(ctx.user);
+
+    return NextResponse.json({
+      data: databases,
+    });
+  } catch (error) {
+    log.error({ error }, "Error in GET /api/v1/databases");
+
+    return NextResponse.json(
+        { error: "Internal server error" },
+        { status: 500 }
+    );
+  }
+});

app/api/v1/docs/route.ts

@@ -0,0 +1,45 @@
+export const dynamic = "force-dynamic";
+
+const html = `<!DOCTYPE html>
+<html>
+  <head>
+    <title>Portabase API Docs</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <link
+      rel="stylesheet"
+      href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5.32.6/swagger-ui.css"
+      integrity="sha384-9Q2fpS+xeS4ffJy6CagnwoUl+4ldAYhOs9pgZuEKxypVModhmZFzeMlvVsAjf7uT"
+      crossorigin="anonymous"
+    />
+    <style>
+      body { margin: 0; }
+    </style>
+  </head>
+  <body>
+    <div id="swagger-ui"></div>
+    <script src="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5.32.6/swagger-ui-bundle.js" integrity="sha384-EYdOaiRwn44zNjrw+Tfs06qYz9BGQVo2f4/pLY5i7VorbjnZNhdplAbTBk8FXHUJ" crossorigin="anonymous"></script>
+    <script src="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5.32.6/swagger-ui-standalone-preset.js" integrity="sha384-49fpFaVrAWI/qdgl9Vv5E/4NXxRUiJX5vGuLws1NUpTWGtEqzWEx8gHTw2UTehFK" crossorigin="anonymous"></script>
+    <script>
+      window.onload = function () {
+        SwaggerUIBundle({
+          url: "/api/v1/openapi",
+          dom_id: "#swagger-ui",
+          presets: [
+            SwaggerUIBundle.presets.apis,
+            SwaggerUIStandalonePreset,
+          ],
+          layout: "StandaloneLayout",
+          persistAuthorization: true,
+          filter: true,
+        });
+      };
+    </script>
+  </body>
+</html>`;
+
+export function GET() {
+  return new Response(html, {
+    headers: { "Content-Type": "text/html; charset=utf-8" },
+  });
+}

app/api/v1/mcp/route.ts

@@ -0,0 +1,31 @@
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { NextResponse } from "next/server";
+import { withApiKey } from "@/lib/api-v1/middleware";
+import { createPortabaseMcpServer } from "@/lib/mcp/server";
+import type { ApiKeyContext } from "@/lib/api-v1/types";
+import { env } from "@/env.mjs";
+
+/**
+ * MCP endpoint — Streamable HTTP transport, stateless mode.
+ *
+ * Auth is handled by withApiKey before MCP is ever touched.
+ * The validated key is forwarded by MCP tools to downstream /api/v1 REST calls.
+ */
+const apiEnabled = env.API_ENABLED;
+const mcpEnabled = env.MCP_ENABLED;
+
+export const POST = apiEnabled && mcpEnabled
+  ? withApiKey(async (req: Request, ctx: ApiKeyContext) => {
+      const apiKey = req.headers.get("x-api-key")!;
+
+      const server = createPortabaseMcpServer(ctx, apiKey);
+
+      const transport = new WebStandardStreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+      });
+
+      await server.connect(transport);
+
+      return transport.handleRequest(req);
+    })
+  : () => NextResponse.json({ error: "Not found" }, { status: 404 });

app/api/v1/openapi/route.ts

@@ -0,0 +1,8 @@
+import { NextResponse } from "next/server";
+import { buildSpec } from "@/lib/api-v1/openapi/spec";
+
+export const dynamic = "force-dynamic";
+
+export function GET() {
+  return NextResponse.json(buildSpec());
+}

app/layout.tsx

@@ -1,7 +1,7 @@
 import type { Metadata } from "next";
 import type React from "react";
 import "./globals.css";
-import { ConsoleSilencer } from "@/components/wrappers/common/console-silencer";
+import { ConsoleSilencer } from "@/components/common/console-silencer";
 import { author, geistMono, poppins } from "@/fonts/fonts";
 import { cn } from "@/lib/utils";
 import { Providers } from "./providers";

app/not-found.tsx

@@ -1,4 +1,5 @@
-import BackButton from "@/components/wrappers/common/button/back-button";
+import Link from "next/link";
+import { Button } from "@/components/ui/button";
 
 export default async function NotFound() {
   return (
@@ -12,7 +13,9 @@ export default async function NotFound() {
             The content you are trying to view is not available.
           </p>
         </div>
-        <BackButton>Go home</BackButton>
+        <Button asChild>
+          <Link href="/">Go home</Link>
+        </Button>
       </div>
     </div>
   );

app/providers.tsx

@@ -4,9 +4,9 @@ import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { type PropsWithChildren, Suspense } from "react";
 
 import { Toaster } from "@/components/ui/sonner";
-import { ErrorLayout } from "@/components/wrappers/common/error-layout";
-import { ThemeMetaUpdaterRoot } from "@/features/browser/theme-meta-updater-root";
-import { ThemeProvider } from "@/features/theme/theme-provider";
+import { ErrorLayout } from "@/components/common/error-layout";
+import { ThemeMetaUpdater } from "@/features/theme/components/theme-meta-updater";
+import { ThemeProvider } from "@/features/theme/components/theme-provider";
 
 export type ProviderProps = PropsWithChildren<{}>;
 const queryClient = new QueryClient();
@@ -14,8 +14,13 @@ const queryClient = new QueryClient();
 export const Providers = (props: ProviderProps) => {
   return (
     <Suspense fallback={null}>
-      <ThemeProvider attribute="class" defaultTheme="system" enableSystem>
-        <ThemeMetaUpdaterRoot />
+      <ThemeProvider
+        attribute="class"
+        defaultTheme="light"
+        enableSystem
+        storageKey="portabase_theme"
+      >
+        <ThemeMetaUpdater />
         <QueryClientProvider client={queryClient}>
           <ErrorLayout>
             <Toaster />

docker-compose.func.yml

@@ -0,0 +1,35 @@
+name: portabase-dev-func
+
+services:
+  keycloak:
+    image: quay.io/keycloak/keycloak:latest
+    command: start-dev --import-realm
+    # environment:
+    #   KC_BOOTSTRAP_ADMIN_USERNAME: admin
+    #   KC_BOOTSTRAP_ADMIN_PASSWORD: admin
+    ports:
+      - "3056:8080"
+    volumes:
+      - keycloak-data:/opt/keycloak/data
+      - ./seeds/keycloak:/opt/keycloak/data/import:ro
+      - ./export:/tmp/export
+  pocket-id:
+    image: ghcr.io/pocket-id/pocket-id
+    restart: unless-stopped
+    environment:
+      - APP_URL=http://localhost:3055
+      - ENCRYPTION_KEY=QwHyjbZvSsDUAcjpdmSPsuYxaH6vET6OeBaeLwXccCb43L6Om3W1AoU5pKIJTzYr
+    ports:
+      - 3055:1411
+    volumes:
+      - pocket-id-data:/app/data
+      - ./seeds/pocket-id:/seed:ro
+    healthcheck:
+      test: "curl -f http://localhost:1411/healthz"
+      interval: 1m30s
+      timeout: 5s
+      retries: 2
+      start_period: 10s
+volumes:
+  keycloak-data:
+  pocket-id-data:

docker-compose.oidc.yml

@@ -1,138 +0,0 @@
-name: portabase-oidc
-
-services:
-
-  keycloak:
-    image: quay.io/keycloak/keycloak:latest
-    restart: unless-stopped
-    command: start-dev --import-realm
-    environment:
-      KC_BOOTSTRAP_ADMIN_USERNAME: bootstrap-admin
-      KC_BOOTSTRAP_ADMIN_PASSWORD: admin
-      KC_HEALTH_ENABLED: "true"
-    ports:
-      - "3056:8080"
-    volumes:
-      - keycloak-data:/opt/keycloak/data
-      - ./seeds/keycloak:/opt/keycloak/data/import:ro
-      - ./export:/tmp/export
-    healthcheck:
-      test: [ "CMD-SHELL", "bash -ec '</dev/tcp/127.0.0.1/8080'" ]
-      interval: 30s
-      timeout: 5s
-      retries: 10
-      start_period: 30s
-
-  pocket-id:
-    image: ghcr.io/pocket-id/pocket-id
-    restart: unless-stopped
-    environment:
-      - APP_URL=http://localhost:3055
-      - ENCRYPTION_KEY=QwHyjbZvSsDUAcjpdmSPsuYxaH6vET6OeBaeLwXccCb43L6Om3W1AoU5pKIJTzYr
-    ports:
-      - "3055:1411"
-    volumes:
-      - pocket-id-data:/app/data
-      - ./seeds/pocket-id:/seed:ro
-    healthcheck:
-      test: "curl -f http://localhost:1411/healthz"
-      interval: 1m30s
-      timeout: 5s
-      retries: 2
-      start_period: 10s
-
-  authentik-server:
-    image: ghcr.io/goauthentik/server:2026.2.3
-    restart: unless-stopped
-    command: server
-    environment:
-      AUTHENTIK_POSTGRESQL__HOST: authentik-postgresql
-      AUTHENTIK_POSTGRESQL__USER: authentik
-      AUTHENTIK_POSTGRESQL__PASSWORD: authentik
-      AUTHENTIK_POSTGRESQL__NAME: authentik
-      AUTHENTIK_SECRET_KEY: changemechangemechangemechangeme
-    ports:
-      - "3057:9000"
-    depends_on:
-      authentik-postgresql:
-        condition: service_healthy
-    healthcheck:
-      test: [ "CMD-SHELL", "python -c \"import urllib.request; urllib.request.urlopen('http://127.0.0.1:9000/-/health/live/')\"" ]
-      interval: 30s
-      timeout: 5s
-      retries: 10
-      start_period: 30s
-
-  authentik-postgresql:
-    image: postgres:16-alpine
-    restart: unless-stopped
-    environment:
-      POSTGRES_DB: authentik
-      POSTGRES_USER: authentik
-      POSTGRES_PASSWORD: authentik
-    volumes:
-      - authentik-data:/var/lib/postgresql/data
-    healthcheck:
-      test: [ "CMD-SHELL", "pg_isready -U authentik -d authentik" ]
-      start_period: 20s
-      interval: 30s
-      retries: 5
-      timeout: 5s
-
-  authentik-worker:
-    image: ghcr.io/goauthentik/server:2026.2.3
-    restart: unless-stopped
-    command: worker
-    user: root
-    environment:
-      AUTHENTIK_POSTGRESQL__HOST: authentik-postgresql
-      AUTHENTIK_POSTGRESQL__USER: authentik
-      AUTHENTIK_POSTGRESQL__PASSWORD: authentik
-      AUTHENTIK_POSTGRESQL__NAME: authentik
-      AUTHENTIK_SECRET_KEY: changemechangemechangemechangeme
-      AUTHENTIK_BOOTSTRAP_PASSWORD: portabase-bootstrap-password
-      AUTHENTIK_BOOTSTRAP_TOKEN: portabase-bootstrap-token
-      AUTHENTIK_BOOTSTRAP_EMAIL: akadmin@portabase.local
-    volumes:
-      - ./seeds/authentik/blueprints/portabase-oidc.yaml:/blueprints/portabase-oidc.yaml:ro
-    shm_size: 512mb
-    depends_on:
-      authentik-postgresql:
-        condition: service_healthy
-
-  authentik-bootstrap:
-    image: ghcr.io/goauthentik/server:2026.2.3
-    entrypoint: [ "/bin/sh", "/seeds/bootstrap.sh" ]
-    environment:
-      AUTHENTIK_BASE_URL: http://authentik-server:9000
-      AUTHENTIK_API_TOKEN: portabase-bootstrap-token
-      AUTHENTIK_DISCOVERY_PATH: /application/o/portabase/.well-known/openid-configuration
-      AUTHENTIK_SECRET_KEY: changemechangemechangemechangeme
-      AUTHENTIK_POSTGRESQL__HOST: authentik-postgresql
-      AUTHENTIK_POSTGRESQL__USER: authentik
-      AUTHENTIK_POSTGRESQL__PASSWORD: authentik
-      AUTHENTIK_POSTGRESQL__NAME: authentik
-      AUTHENTIK_BOOTSTRAP_EMAIL: akadmin@portabase.local
-      AUTHENTIK_TEST_USER_USERNAME: admin@example.com
-      AUTHENTIK_TEST_USER_EMAIL: admin@example.com
-      AUTHENTIK_TEST_USER_NAME: Portabase Admin
-      AUTHENTIK_TEST_USER_PASSWORD: testPASS123456!
-      AUTHENTIK_TEST_GROUP: admin
-      AUTHENTIK_PROVIDER_NAME: portabase
-      AUTHENTIK_APPLICATION_NAME: Portabase
-      AUTHENTIK_APPLICATION_SLUG: portabase
-      AUTHENTIK_CLIENT_ID: portabase
-      AUTHENTIK_CLIENT_SECRET: portabase-e2e-secret
-      AUTHENTIK_REDIRECT_URI: http://localhost:8887/api/auth/sso/callback/authentik
-    volumes:
-      - ./seeds/authentik:/seeds:ro
-    depends_on:
-      authentik-server:
-        condition: service_healthy
-      authentik-worker:
-        condition: service_healthy
-
-volumes:
-  keycloak-data:
-  pocket-id-data:
-  authentik-data:

docker-compose.prod.yml

@@ -1,46 +1,45 @@
-name: portabase-prod
-
 services:
-
   app:
     build:
-      context: .
-      dockerfile: docker/dockerfile/Dockerfile
-      target: prod
+     context: .
+     dockerfile: docker/dockerfile/Dockerfile
+     target: prod
+#    image: portabase/portabase:1
     ports:
-      - '8887:80'
+      - "8887:80"
     environment:
       TZ: "Europe/Paris"
+    env_file:
+      - .env
     volumes:
-      - portabase-prod-data:/data
+      - portabase-data:/data
     depends_on:
       db:
         condition: service_healthy
+    container_name: portabase-app-prod
     healthcheck:
-      test: [ "CMD-SHELL", "curl -f http://localhost/api/health" ]
+      test: ["CMD-SHELL", "curl -f http://localhost/api/health"]
       interval: 30s
       timeout: 5s
       retries: 3
       start_period: 60s
-    extra_hosts:
-      - "localhost:host-gateway"
 
   db:
-    image: postgres:17-alpine
+    image: postgres:16-alpine
     ports:
       - "5433:5432"
     volumes:
-      - portabase-prod-postgres-data:/var/lib/postgresql/data
+      - postgres-data:/var/lib/postgresql/data
     environment:
       - POSTGRES_DB=devdb
       - POSTGRES_USER=devuser
       - POSTGRES_PASSWORD=changeme
     healthcheck:
-      test: [ "CMD-SHELL", "pg_isready -U devuser -d devdb" ]
+      test: ["CMD-SHELL", "pg_isready -U devuser -d devdb"]
       interval: 10s
       timeout: 5s
       retries: 5
 
 volumes:
-  portabase-prod-data:
-  portabase-prod-postgres-data:
+  portabase-data:
+  postgres-data:

docker-compose.yml

@@ -6,7 +6,7 @@ services:
     ports:
       - "5433:5432"
     volumes:
-      - portabase-dev-postgres-data:/var/lib/postgresql/data
+      - postgres-data:/var/lib/postgresql/data
     environment:
       - POSTGRES_DB=devdb
       - POSTGRES_USER=devuser
@@ -41,5 +41,118 @@ services:
       - "8025:8025"
       - "1025:1025"
 
+  azurite:
+    image: mcr.microsoft.com/azure-storage/azurite
+    command: azurite --blobHost 0.0.0.0 --skipApiVersionCheck
+    ports:
+      - "10000:10000"
+    volumes:
+      - azurite-data:/data
+    extra_hosts:
+      - "localhost:host-gateway"
+    networks:
+      - portabase
+
+    #  DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://127.0.0.1:10000/devstoreaccount1;QueueEndpoint=http://127.0.0.1:10001/devstoreaccount1;TableEndpoint=http://127.0.0.1:10002/devstoreaccount1;
+
+  gcs:
+    image: fsouza/fake-gcs-server:latest
+    container_name: fake-gcs
+    ports:
+      - "4443:4443"
+    command:
+      - "-scheme"
+      - "http"
+      - "-port"
+      - "4443"
+      - "-public-host"
+      - "localhost:4443"
+      - "-external-url"
+      - "http://localhost:4443"
+      - "-backend"
+      - "filesystem"
+      - "-filesystem-root"
+      - "/storage"
+    volumes:
+      - gcs-data:/data
+      - gcs-storage:/storage
+    networks:
+      - portabase
+
+  gcs-init:
+    image: curlimages/curl:latest
+    depends_on:
+      - gcs
+    entrypoint: ["/bin/sh", "-c"]
+    command: >
+      'until curl -fsS http://gcs:4443/storage/v1/b >/dev/null; do sleep 1; done;
+      curl -fsS http://gcs:4443/storage/v1/b/portabase >/dev/null
+      || curl -fsS -X POST "http://gcs:4443/storage/v1/b?project=local"
+      -H "Content-Type: application/json"
+      -d "{\"name\":\"portabase\"}"'
+    networks:
+      - portabase
+
+  #   curl http://localhost:4443/storage/v1/b
+  #   projectId: "test-project",
+  #   bucketName: "portabase",
+  #   clientEmail: "fake@test.iam.gserviceaccount.com",
+  #   privateKey: "unused-when-emulated",
+
+  rustfs:
+    image: rustfs/rustfs:latest
+    container_name: rustfs
+    environment:
+      - RUSTFS_ROOT_USER=admin
+      - RUSTFS_ROOT_PASSWORD=root-password
+      - RUSTFS_ACCESS_KEY=access-key
+      - RUSTFS_SECRET_KEY=secret-key
+      - RUSTFS_VOLUMES=/data
+      - RUSTFS_ADDRESS=:9000
+      - RUSTFS_CONSOLE_ENABLE=true
+      - RUSTFS_CONSOLE_ADDRESS=:9001
+    volumes:
+      - rustfs-data:/data
+    healthcheck:
+      test: [ "CMD", "curl", "-sf", "http://localhost:9000/health" ]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 10s
+    ports:
+      - "9001:9001"
+      - "9000:9000"
+    extra_hosts:
+      - "localhost:host-gateway"
+    networks:
+      - portabase
+
+  rustfs-init:
+    image: rustfs/rc:latest
+    container_name: rustfs-init
+    depends_on:
+      rustfs:
+        condition: service_healthy
+    entrypoint: >
+      /bin/sh -c "
+      until (/usr/bin/rc alias set rustfs http://rustfs:9000 access-key secret-key) do echo '...waiting...' && sleep 1; done;
+      /usr/bin/rc mb rustfs/portabase;
+      echo 'RustFS initialization complete';
+      tail -f /dev/null
+      "
+    networks:
+      - portabase
+
+
+
 volumes:
-  portabase-dev-postgres-data:
+  postgres-data:
+  azurite-data:
+  gcs-data:
+  gcs-storage:
+  rustfs-data:
+
+networks:
+  portabase:
+    name: portabase_network
+    external: true

docker/dockerfile/Dockerfile

@@ -1,11 +1,33 @@
-FROM --platform=$BUILDPLATFORM node:22-bullseye AS base
+FROM --platform=$BUILDPLATFORM node:22-slim AS runtime-base
 
-RUN apt-get update && apt-get install -y \
+RUN apt-get update && apt-get install -y --no-install-recommends \
     curl \
     ca-certificates \
     bash \
     tzdata \
     libc6 \
+    nginx \
+    gnupg \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN mkdir -p /etc/apt/keyrings \
+    && curl -fsSL https://www.postgresql.org/media/keys/ACCC4CF8.asc \
+    | gpg --dearmor -o /etc/apt/keyrings/postgresql.gpg \
+    && echo "deb [signed-by=/etc/apt/keyrings/postgresql.gpg] http://apt.postgresql.org/pub/repos/apt bookworm-pgdg main" \
+    > /etc/apt/sources.list.d/pgdg.list
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    postgresql-18 \
+    postgresql-client-18 \
+    postgresql-contrib-18 \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV PATH="/usr/lib/postgresql/18/bin:${PATH}"
+
+
+FROM runtime-base AS build-base
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
     build-essential \
     g++ \
     make \
@@ -13,25 +35,9 @@ RUN apt-get update && apt-get install -y \
     automake \
     libtool \
     git \
-    nginx \
     && rm -rf /var/lib/apt/lists/*
 
 
-RUN mkdir -p /etc/apt/keyrings \
-    && curl -fsSL https://www.postgresql.org/media/keys/ACCC4CF8.asc \
-    | gpg --dearmor -o /etc/apt/keyrings/postgresql.gpg \
-    && echo "deb [signed-by=/etc/apt/keyrings/postgresql.gpg] http://apt.postgresql.org/pub/repos/apt bullseye-pgdg main" \
-    > /etc/apt/sources.list.d/pgdg.list
-
-RUN apt-get update && apt-get install -y \
-    postgresql-18 \
-    postgresql-client-18 \
-    postgresql-contrib-18 \
-    && rm -rf /var/lib/apt/lists/*
-
-ENV PATH="/usr/lib/postgresql/18/bin:${PATH}"
-
-
 FROM --platform=$BUILDPLATFORM golang:1.23-bookworm AS tusd-base
 
 ARG TUSD_VERSION=2.8.0
@@ -51,7 +57,7 @@ FROM scratch AS tusd-dist
 COPY --from=tusd-base /tusddist/tusd /tusd
 
 
-FROM base AS build-env
+FROM build-base AS build-env
 
 RUN corepack enable && corepack prepare pnpm@latest --activate
 
@@ -83,7 +89,7 @@ COPY . .
 ENV NEXT_TELEMETRY_DISABLED=1
 RUN pnpm run build
 
-FROM base AS prod
+FROM runtime-base AS prod
 
 WORKDIR /app
 ENV NODE_ENV=production
@@ -92,6 +98,7 @@ ENV PORT=80
 ENV HOSTNAME="0.0.0.0"
 ENV PGDATA=/data/postgres
 ENV PRIVATE_PATH=/data/private
+ENV TUSD_BEHIND_PROXY=false
 
 
 RUN addgroup --system --gid 1001 nodejs
@@ -104,7 +111,6 @@ COPY --from=builder /app/drizzle.config.ts ./
 COPY --from=builder --chown=1001:1001 /app/.next/standalone ./
 COPY --from=builder --chown=1001:1001 /app/.next/static ./.next/static
 COPY --chown=1001:1001 src/db ./src/db
-COPY --from=deps /app/node_modules ./node_modules
 
 COPY --from=tusd-dist /tusd /usr/local/bin/tusd
 RUN chmod +x /usr/local/bin/tusd

docker/entrypoints/app-prod-entrypoint.sh

@@ -72,7 +72,18 @@ fi
 
 mkdir -p /data/private/uploads/tmp
 echo "▶ Starting tusd server..."
-tusd --base-path /tus/files/ --upload-dir /data/private/uploads/tmp --hooks-http http://127.0.0.1:3000/api/tus/hooks --port 1080 --max-size 21474836480 &
+TUSD_BEHIND_PROXY_FLAG=""
+if [ "${TUSD_BEHIND_PROXY:-false}" = "true" ]; then
+    TUSD_BEHIND_PROXY_FLAG="--behind-proxy"
+    echo "[INFO] TUSD_BEHIND_PROXY=true, enabling tusd proxy mode"
+fi
+tusd \
+    --base-path /tus/files/ \
+    --upload-dir /data/private/uploads/tmp \
+    --hooks-http http://127.0.0.1:3000/api/tus/hooks \
+    --port 1080 \
+    --max-size 21474836480 \
+    $TUSD_BEHIND_PROXY_FLAG &
 
 echo "▶ Starting Next.js server..."
 PORT=3000 node server.js &

docker/nginx/nginx.conf

@@ -1,6 +1,11 @@
 events {}
 
 http {
+    map $http_x_forwarded_proto $forwarded_proto {
+        default $scheme;
+        "~*^\s*(https?)\s*(?:,|$)" $1;
+    }
+
     client_max_body_size 20G;
     ignore_invalid_headers  off;
 
@@ -18,13 +23,18 @@ http {
 
             proxy_set_header Host $http_host;
             proxy_set_header X-Forwarded-Host $http_host;
-            proxy_set_header X-Forwarded-Proto $scheme;
+            proxy_set_header X-Forwarded-Proto $forwarded_proto;
             proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 
             proxy_set_header         Upgrade $http_upgrade;
             proxy_set_header         Connection "upgrade";
         }
 
+        location = /api/tus/hooks {
+            deny all;
+            return 404;
+        }
+
         location / {
             proxy_pass http://127.0.0.1:3000;
 
@@ -34,7 +44,7 @@ http {
 
             proxy_set_header Host $http_host;
             proxy_set_header X-Forwarded-Host $http_host;
-            proxy_set_header X-Forwarded-Proto $scheme;
+            proxy_set_header X-Forwarded-Proto $forwarded_proto;
             proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
         }
     }

e2e/access-management.spec.ts

@@ -1,74 +0,0 @@
-import {expect, test} from "@playwright/test";
-import {users} from "./helpers/auth";
-import {changeUserRole, create, switchToDefault} from "./helpers/access-management";
-import {LOCAL_STORAGE_PATH} from "./helpers/session";
-
-test.use({storageState: LOCAL_STORAGE_PATH});
-
-const firstOrganization = "Organization A";
-const secondOrganization = "Organization B";
-
-test.describe.serial(() => {
-    test("Create an organization from organizations page", async ({page}) => {
-        await page.goto("/dashboard/admin/organizations");
-        await expect(page.getByRole("heading", {name: "Active organizations"})).toBeVisible();
-
-        await create(page, "button", firstOrganization);
-
-        await expect(page.getByText(/Organization has been successfully created\./i)).toBeVisible();
-        await expect(page).toHaveURL("/dashboard/admin/organizations");
-        await expect(page.getByRole("button", {name: firstOrganization, exact: true})).toBeVisible();
-
-        await switchToDefault(page);
-    });
-
-    test("Create an organization from sidebar button", async ({page}) => {
-        await page.goto("/dashboard/home");
-        await expect(page.getByRole("heading", {name: "Dashboard"})).toBeVisible();
-
-        await create(page, "sidebar", secondOrganization);
-
-        await expect(page.getByText(/Organization has been successfully created\./i)).toBeVisible();
-        await expect(page).toHaveURL("/dashboard/home");
-        await expect(page.getByRole("button", {name: secondOrganization, exact: true})).toBeVisible();
-
-        await switchToDefault(page);
-    });
-
-    test("Change John Doe's role from pending to user", async ({page}) => {
-        await page.goto("/dashboard/admin/users");
-        await expect(page.getByText(users.normal.email, {exact: true})).toBeVisible();
-
-        const userRow = page.locator("tr").filter({hasText: users.normal.email}).first();
-        await expect(userRow).toBeVisible();
-        await userRow.locator("button").last().click();
-        await page.getByRole('menuitem', {name: 'Role'}).click();
-
-        await expect(page.getByRole("heading", {name: "Change the user's role"})).toBeVisible();
-
-        await changeUserRole(page, "user")
-
-        await expect(page.getByText("User role changed successfully.")).toBeVisible();
-        await expect(page.locator("tr").filter({hasText: users.normal.email}).getByText("user", {exact: true})).toBeVisible();
-    });
-
-    test("Add John Doe to Organization A", async ({page}) => {
-        await page.goto("/dashboard/admin/organizations");
-        await expect(page.getByRole("heading", {name: "Active organizations"})).toBeVisible();
-
-        const organizationRow = page.locator("tr").filter({hasText: firstOrganization}).first();
-        await expect(organizationRow).toBeVisible();
-        await organizationRow.locator('a[href*="/dashboard/admin/organizations/"], a[href*="organizations/"]').click();
-
-        await expect(page.getByText(firstOrganization, {exact: true})).toBeVisible();
-        await page.getByRole("button", {name: /Add member/i}).click();
-        await expect(page.getByRole("heading", {name: "Add member to your organization"})).toBeVisible();
-
-        await page.getByPlaceholder("Enter a user email").fill(users.normal.email);
-        await page.getByRole("option", {name: new RegExp(users.normal.email, "i")}).click();
-        await page.getByRole("button", {name: "Confirm"}).click();
-
-        await expect(page.getByText("Member successfully added!")).toBeVisible();
-        await expect(page.getByText(users.normal.email, {exact: true})).toBeVisible();
-    });
-});

e2e/agent.spec.ts

@@ -1,79 +0,0 @@
-import {expect, test} from "@playwright/test";
-import {create, edit, get, launch, remove} from "./helpers/agent";
-import {LOCAL_STORAGE_PATH} from "./helpers/session";
-
-const agent = {
-    aName: "Agent A",
-    aUpdatedName: "Agent A Updated",
-    bName: "Agent B",
-    description: "Agent created by Playwright E2E",
-    updatedDescription: "Agent updated by Playwright E2E",
-};
-
-test.use({storageState: LOCAL_STORAGE_PATH});
-
-test.describe.serial(() => {
-    let agentWorkspace: string | null = null;
-
-    test("Create agent A from empty state", async ({page}) => {
-        await page.goto("/dashboard/agents");
-        await expect(page.getByRole("heading", {name: "Agents"})).toBeVisible();
-        await expect(page.getByText("Create new Agent", {exact: true})).toBeVisible();
-        await create(page, "emptyState", agent.aName, agent.description);
-
-        await expect(page.getByText("Success creating agent")).toBeVisible();
-        await expect(get(page, agent.aName)).toBeVisible();
-        await expect(page.getByText("Create new Agent", {exact: true})).toHaveCount(0);
-    });
-
-    test("Edit agent A", async ({page}) => {
-        await page.goto("/dashboard/agents");
-        await expect(page.getByRole("heading", {name: "Agents"})).toBeVisible();
-        await expect(get(page, agent.aName)).toBeVisible();
-
-        await edit(page, agent.aName, agent.aUpdatedName, agent.updatedDescription);
-
-        await expect(page.getByText("Success updating agent")).toBeVisible();
-        await expect(page.getByText(agent.aUpdatedName, {exact: true})).toBeVisible();
-        await expect(page.getByText(agent.updatedDescription, {exact: true})).toBeVisible();
-    });
-
-    test("Create agent B from classic button", async ({page}) => {
-        await page.goto("/dashboard/agents");
-        await expect(page.getByRole("heading", {name: "Agents"})).toBeVisible();
-        await expect(page.getByRole("button", {name: /Create Agent/i})).toBeVisible();
-        await create(page, "button", agent.bName, agent.description);
-
-        await expect(page.getByText("Success creating agent")).toBeVisible();
-        await expect(get(page, agent.bName)).toBeVisible();
-    });
-
-    test("Delete Agent B", async ({page}) => {
-        await page.goto("/dashboard/agents");
-        await expect(page.getByRole("heading", {name: "Agents"})).toBeVisible();
-        await expect(get(page, agent.bName)).toBeVisible();
-        await remove(page, agent.bName);
-
-        await expect(page.getByText("Agent has been successfully deleted.")).toBeVisible();
-        await expect(page).toHaveURL("/dashboard/agents");
-        await expect(page.getByText(agent.bName)).toHaveCount(0);
-    });
-
-    test("Launch the updated agent", async ({page}) => {
-        await page.goto("/dashboard/agents");
-        await expect(page.getByRole("heading", {name: "Agents"})).toBeVisible();
-        await get(page, agent.aName).click();
-
-        await expect(page).toHaveURL(/\/dashboard\/agents\/.+/);
-        await expect(page.getByText(agent.aUpdatedName, {exact: true})).toBeVisible();
-        await expect(page.getByText("Registration & Setup")).toBeVisible();
-
-        const commandInput = page.locator("input[readonly]").last();
-        await page.locator("input[readonly]").first().locator("xpath=following-sibling::button[1]").click();
-        const edgeKey = await commandInput.inputValue();
-
-        await launch(edgeKey)
-
-        await expect(page.getByRole("heading", { name: "Managed Databases" })).toBeVisible();
-    });
-});

e2e/auth.spec.ts

@@ -1,104 +0,0 @@
-import {test, expect} from '@playwright/test';
-import {login, register, users} from "./helpers/auth";
-import {LOCAL_STORAGE_PATH} from "./helpers/session";
-
-const TIMEOUT = undefined
-// const TIMEOUT = 5000
-
-test.use({storageState: LOCAL_STORAGE_PATH})
-
-test.describe.serial( () => {
-
-    test('Redirect to login if not connected', async ({page}) => {
-        await page.goto('/dashboard/projects');
-        await expect(page).toHaveURL("login?redirect=%2Fdashboard%2Fprojects", {timeout: TIMEOUT});
-    });
-
-    test('Password too short', async ({page}) => {
-        await page.goto('')
-        await page.click('text=Sign up')
-        await expect(page).toHaveURL('/register')
-
-        let password = '123456'
-        await register(page, users["admin"].username, users["admin"].email, password, password)
-
-        const toast = page.locator('text=Must have at least 8 character')
-        await expect(toast).toBeVisible()
-    })
-
-    test('Password too simple', async ({page}) => {
-        await page.goto('')
-        await page.click('text=Sign up')
-        await expect(page).toHaveURL('/register')
-
-        let password = '12345678'
-        await register(page, users["admin"].username, users["admin"].email, password, password)
-
-        const toast = page.locator('text=Your password must contain at least one uppercase letter, one lowercase letter, one number, and one special character.')
-        await expect(toast).toBeVisible()
-    })
-
-    test('Password and confirm password mismatch', async ({page}) => {
-        await page.goto('/')
-        await page.click('text=Sign up')
-        await expect(page).toHaveURL('/register')
-
-        let password = 'testPASS123456!'
-        let confirmPassword = 'testPASS123456!!'
-        await register(page, users["admin"].username, users["admin"].email, password, confirmPassword)
-
-        const toast = page.locator('text=The passwords did not match')
-        await expect(toast).toBeVisible()
-    })
-
-    test('Successful register for admin', async ({page}) => {
-        await page.goto('/')
-
-        await page.click('text=Sign up')
-        await expect(page).toHaveURL('/register')
-
-        await register(page, users["admin"].username, users["admin"].email, users["admin"].password, users["admin"].password)
-
-        await expect(page).toHaveURL('/login', {timeout: TIMEOUT})
-    })
-
-    test('User already exists.', async ({page}) => {
-        await page.goto('/')
-
-        await page.click('text=Sign up')
-        await expect(page).toHaveURL('/register')
-
-        await register(page, users["admin"].username, users["admin"].email, users["admin"].password, users["admin"].password)
-
-        const toast = page.locator('text=User already exists. Use another email.')
-        await expect(toast).toBeVisible()
-    })
-
-    test('Successful register for normal', async ({page}) => {
-        await page.goto('/')
-
-        await page.click('text=Sign up')
-        await expect(page).toHaveURL('/register')
-
-        await register(page, users["normal"].username, users["normal"].email, users["normal"].password, users["normal"].password)
-
-        await expect(page).toHaveURL('/login', {timeout: TIMEOUT})
-    })
-
-    test('Failed login because account not active', async ({page}) => {
-        await page.goto('/login')
-        await login(page, users["normal"].email, users["normal"].password)
-
-        const toast = page.locator('text=Your account is not active.')
-        await expect(toast).toBeVisible()
-    })
-
-    test('Successful login', async ({page}) => {
-        await page.goto('/login')
-        await login(page, users["admin"].email, users["admin"].password)
-
-        await expect(page).toHaveURL('/dashboard/home', {timeout: TIMEOUT})
-        await expect(page.getByRole('link', {name: 'Logo Portabase'})).toBeVisible()
-        await page.context().storageState({path: LOCAL_STORAGE_PATH})
-    })
-})

e2e/cleanup.spec.ts

@@ -1,32 +0,0 @@
-import {expect, test} from "@playwright/test";
-import fs from "fs";
-import {logout} from "./helpers/auth";
-import {LOCAL_STORAGE_PATH} from "./helpers/session";
-
-
-test.use({storageState: LOCAL_STORAGE_PATH});
-
-test.describe( () => {
-    test.afterAll(async () => {
-        if (fs.existsSync(LOCAL_STORAGE_PATH)) {
-            fs.unlinkSync(LOCAL_STORAGE_PATH);
-        }
-    });
-
-    test("Remove shared storage state", async ({page}) => {
-        await test.step("Logout shared authenticated session", async () => {
-            if (!fs.existsSync(LOCAL_STORAGE_PATH)) {
-                return;
-            }
-
-            const content = fs.readFileSync(LOCAL_STORAGE_PATH, "utf-8").trim();
-            if (!content || content === "{}") {
-                return;
-            }
-
-            await page.goto('/dashboard/home');
-            await logout(page);
-            await expect(page).toHaveURL(/\/login(?:\?.*)?$/);
-        });
-    });
-});

e2e/helpers/access-management.ts

@@ -1,70 +0,0 @@
-import {Page} from "@playwright/test";
-
-export function getUserRow(page: Page, email: string) {
-    return page.locator("tr").filter({hasText: email}).first();
-}
-
-export function getOrganizationRow(page: Page, organizationName: string) {
-    return page.locator("tr").filter({hasText: organizationName}).first();
-}
-
-/**
- * Create an organization from the selected entrypoint.
- *
- * Available entrypoints:
- * - `button`: the organizations page create button.
- * - `sidebar`: the sidebar organization switcher.
- *
- * Executes from:
- * - `/dashboard/admin/organizations` for "button" entrypoint
- * - any `/dashboard/**` page for "sidebar" entrypoint
- */
-export async function create(page: Page, entrypoint: "button" | "sidebar", name: string) {
-    if (entrypoint === "sidebar") {
-        await page.getByRole("button", {name: "Default Organization"}).click();
-        await page.getByText("Create organization", {exact: true}).click();
-    } else {
-        await page.getByRole("button", {name: /Create a new organization/i}).click();
-    }
-
-    await page.getByLabel("Name").fill(name);
-    await page.getByRole("button", {name: "Create"}).click();
-}
-
-/**
- * Switch the active organization from the sidebar switcher.
- *
- * Executes from: any `/dashboard/**` if the sidebar is visible.
- */
-export async function switchTo(page: Page, name: string) {
-    await page.getByTestId('organization-dropdown').click();
-    await page.getByRole('menuitem', {name: name}).click();
-}
-
-/**
- * Switch back to the default organization.
- *
- * Executes from: any `/dashboard/**` if the sidebar is visible.
- */
-export async function switchToDefault(page: Page) {
-    await switchTo(page, "Default Organization");
-}
-
-const ROLE_LABELS = {
-    pending: "Pending",
-    user: "User",
-    admin: "Admin",
-} as const;
-
-/**
- * Change the global role of a user from the admin users role modal.
- *
- * Executes from: the "Change the user's role" dialog opened from `/dashboard/admin/users`.
- */
-export async function changeUserRole(page: Page, role: keyof typeof ROLE_LABELS) {
-    const roleOption = ROLE_LABELS[role];
-
-    await page.getByRole("combobox").click();
-    await page.getByRole("option", {name: roleOption}).click();
-    await page.getByRole("button", {name: "Validate"}).click();
-}

e2e/helpers/agent-cli.ts

@@ -1,107 +0,0 @@
-import * as pty from "node-pty";
-
-type InteractiveStep = {
-    match: RegExp;
-    reply: string;
-};
-
-function normalizeOutput(output: string) {
-    return output.replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, "");
-}
-
-/**
- * Run an interactive CLI command and answer prompts in sequence.
- * Entry point:
- * - `command` is the full CLI command executed in the PTY.
- * - `cwd` is the local workspace where the command is launched.
- * - `steps` defines which prompt text is matched and which reply is sent.
- * - `timeoutMs` controls when the command is aborted if it stalls.
- * Executes from: not page-bound; runs from a local test workspace on the Node.js side.
- */
-export async function runInteractiveCommand(
-    command: string,
-    cwd: string,
-    steps: InteractiveStep[],
-    timeoutMs: number = 120_000,
-) {
-    await new Promise<void>((resolve, reject) => {
-        const child = pty.spawn("sh", ["-lc", command], {
-            cwd,
-            env: {
-                ...process.env,
-                TERM: "xterm-256color",
-            },
-            cols: 120,
-            rows: 30,
-        });
-
-        let currentStep = 0;
-        let output = "";
-        const timer = setTimeout(() => {
-            child.kill();
-            reject(new Error(`Interactive command timed out.\n\nCommand: ${command}\n\nOutput:\n${normalizeOutput(output)}`));
-        }, timeoutMs);
-
-        const handleChunk = (chunk: string) => {
-            output += chunk;
-            const normalizedOutput = normalizeOutput(output);
-
-            while (currentStep < steps.length && steps[currentStep].match.test(normalizedOutput)) {
-                child.write(steps[currentStep].reply);
-                currentStep += 1;
-            }
-        };
-
-        child.onData(handleChunk);
-        child.onExit(({exitCode}) => {
-            clearTimeout(timer);
-            if (exitCode === 0) {
-                resolve();
-                return;
-            }
-
-            reject(new Error(`Interactive command failed with exit code ${exitCode}.\n\nCommand: ${command}\n\nOutput:\n${normalizeOutput(output)}`));
-        });
-    });
-}
-
-/**
- * Create and configure a Portabase agent with two Docker-backed databases.
- * Entry point:
- * - `command` is the CLI setup command copied from the agent details page.
- * - `cwd` is the local workspace where the agent is installed.
- * - this helper answers the wizard for PostgreSQL first, then MariaDB.
- * Executes from: not page-bound; runs from a local test workspace on the Node.js side.
- */
-export async function createAgentWithDockerDatabases(command: string, cwd: string) {
-    await runInteractiveCommand(command, cwd, [
-        {
-            match: /configure.*database|add.*database/i,
-            reply: "y\n",
-        },
-        {
-            match: /docker.*new local container|manual.*external|external.*existing/i,
-            reply: "\r",
-        },
-        {
-            match: /postgresql|mariadb/i,
-            reply: "\r",
-        },
-        {
-            match: /another.*database|add.*another|configure.*another/i,
-            reply: "y\n",
-        },
-        {
-            match: /docker.*new local container|manual.*external|external.*existing/i,
-            reply: "\r",
-        },
-        {
-            match: /postgresql|mariadb/i,
-            reply: "\u001B[B\r",
-        },
-        {
-            match: /another.*database|add.*another|configure.*another/i,
-            reply: "n\n",
-        },
-    ]);
-}

e2e/helpers/agent.ts

@@ -1,80 +0,0 @@
-import {Page} from "@playwright/test";
-import {execSync} from "node:child_process";
-
-
-/**
- * Locate an agent card in the list.
-
- * Executes from: `/dashboard/agents`.
- */
-export function get(page: Page, name: string) {
-    return page.locator('a[href^="/dashboard/agents"]').filter({hasText: name}).first();
-}
-
-/**
- * Create an agent from the selected entrypoint.
- *
- * Available entrypoints:
- * - `button`: the classic create button.
- * - `emptyState`: the empty-state CTA.
- * - `auto`: uses the classic create button and falls back to the empty-state CTA.
- *
- * Executes from: `/dashboard/agents`.
- */
-export async function create(page: Page, entrypoint: "auto" | "emptyState" | "button" = "auto", agentName: string, description: string) {
-    if (entrypoint === "auto") {
-        const createButton = page.getByRole("button", {name: /Create Agent/i});
-        if (await createButton.isVisible()) await page.getByRole("button", {name: /Create Agent/i}).click();
-        await page.getByText("Create new Agent", {exact: true}).click();
-    } else if (entrypoint === "button") {
-        await page.getByRole("button", {name: /Create Agent/i}).click();
-    } else if (entrypoint === "emptyState") {
-        await page.getByText("Create new Agent", {exact: true}).click();
-    }
-
-    await page.getByLabel("Name").fill(agentName);
-    await page.getByLabel("Description").fill(description);
-    await page.getByRole("button", {name: "Create"}).click();
-}
-
-/**
- * Edit an existing agent (name and description) from its details page.
- *
- * Executes from: `/dashboard/agents/[agentId]`.
- */
-export async function edit(page: Page, currentName: string, updatedName: string, updatedDescription: string) {
-    await get(page, currentName).click();
-
-    await page
-        .getByRole("button", {name: /Delete Agent/i})
-        .locator("xpath=ancestor::div[1]/preceding-sibling::div[1]/*[1]")
-        .click();
-
-    await page.getByLabel("Name").fill(updatedName);
-    await page.getByLabel("Description").fill(updatedDescription);
-    await page.getByRole("button", {name: "Update"}).click();
-}
-
-/**
- * Delete an agent from its details page.
-
- * Executes from: `/dashboard/agents/[agentId]`.
- */
-export async function remove(page: Page, name: string) {
-    await get(page, name).click();
-    await page.getByRole("button", {name: /Delete Agent/i}).click();
-    await page.getByRole("button", {name: "Delete", exact: true}).click();
-}
-
-
-export async function launch(edgeKey: string) {
-    const output = execSync(
-        `EDGE_KEY=${edgeKey} docker compose -f e2e/helpers/agent/docker-compose.agent-a.yml up -d`,
-        {
-            cwd: process.cwd(),
-            encoding: "utf-8",
-            stdio: ["ignore", "pipe", "pipe"],
-        },
-    );
-    return output;
-}

e2e/helpers/agent/databases.json

@@ -1,154 +0,0 @@
-{
-  "databases": [
-    {
-      "name": "PostgreSQL 18",
-      "database": "backup_e2e",
-      "type": "postgresql",
-      "username": "backup",
-      "password": "backup",
-      "port": 5432,
-      "host": "postgresql-18",
-      "generated_id": "9f8a5b18-0f45-4b4c-a821-93d7e46ef001"
-    },
-    {
-      "name": "PostgreSQL 17",
-      "database": "backup_e2e",
-      "type": "postgresql",
-      "username": "backup",
-      "password": "backup",
-      "port": 5432,
-      "host": "postgresql-17",
-      "generated_id": "9f8a5b18-0f45-4b4c-a821-93d7e46ef002"
-    },
-    {
-      "name": "PostgreSQL 16",
-      "database": "backup_e2e",
-      "type": "postgresql",
-      "username": "backup",
-      "password": "backup",
-      "port": 5432,
-      "host": "postgresql-16",
-      "generated_id": "9f8a5b18-0f45-4b4c-a821-93d7e46ef003"
-    },
-    {
-      "name": "PostgreSQL 15",
-      "database": "backup_e2e",
-      "type": "postgresql",
-      "username": "backup",
-      "password": "backup",
-      "port": 5432,
-      "host": "postgresql-15",
-      "generated_id": "9f8a5b18-0f45-4b4c-a821-93d7e46ef004"
-    },
-    {
-      "name": "PostgreSQL 14",
-      "database": "backup_e2e",
-      "type": "postgresql",
-      "username": "backup",
-      "password": "backup",
-      "port": 5432,
-      "host": "postgresql-14",
-      "generated_id": "9f8a5b18-0f45-4b4c-a821-93d7e46ef005"
-    },
-    {
-      "name": "PostgreSQL 13",
-      "database": "backup_e2e",
-      "type": "postgresql",
-      "username": "backup",
-      "password": "backup",
-      "port": 5432,
-      "host": "postgresql-13",
-      "generated_id": "9f8a5b18-0f45-4b4c-a821-93d7e46ef006"
-    },
-    {
-      "name": "PostgreSQL 12",
-      "database": "backup_e2e",
-      "type": "postgresql",
-      "username": "backup",
-      "password": "backup",
-      "port": 5432,
-      "host": "postgresql-12",
-      "generated_id": "9f8a5b18-0f45-4b4c-a821-93d7e46ef007"
-    },
-    {
-      "name": "MySQL 8.4",
-      "database": "backup_e2e",
-      "type": "mysql",
-      "username": "backup",
-      "password": "backup",
-      "port": 3306,
-      "host": "mysql-8.4",
-      "generated_id": "9f8a5b18-0f45-4b4c-a821-93d7e46ef008"
-    },
-    {
-      "name": "MySQL 8.0",
-      "database": "backup_e2e",
-      "type": "mysql",
-      "username": "backup",
-      "password": "backup",
-      "port": 3306,
-      "host": "mysql-8.0",
-      "generated_id": "9f8a5b18-0f45-4b4c-a821-93d7e46ef009"
-    },
-    {
-      "name": "MariaDB 11.4",
-      "database": "backup_e2e",
-      "type": "mariadb",
-      "username": "backup",
-      "password": "backup",
-      "port": 3306,
-      "host": "mariadb-11.4",
-      "generated_id": "9f8a5b18-0f45-4b4c-a821-93d7e46ef010"
-    },
-    {
-      "name": "MariaDB 11.3",
-      "database": "backup_e2e",
-      "type": "mariadb",
-      "username": "backup",
-      "password": "backup",
-      "port": 3306,
-      "host": "mariadb-11.3",
-      "generated_id": "9f8a5b18-0f45-4b4c-a821-93d7e46ef011"
-    },
-    {
-      "name": "MariaDB 11.2",
-      "database": "backup_e2e",
-      "type": "mariadb",
-      "username": "backup",
-      "password": "backup",
-      "port": 3306,
-      "host": "mariadb-11.2",
-      "generated_id": "9f8a5b18-0f45-4b4c-a821-93d7e46ef012"
-    },
-    {
-      "name": "MariaDB 11.1",
-      "database": "backup_e2e",
-      "type": "mariadb",
-      "username": "backup",
-      "password": "backup",
-      "port": 3306,
-      "host": "mariadb-11.1",
-      "generated_id": "9f8a5b18-0f45-4b4c-a821-93d7e46ef013"
-    },
-    {
-      "name": "MariaDB 11.0",
-      "database": "backup_e2e",
-      "type": "mariadb",
-      "username": "backup",
-      "password": "backup",
-      "port": 3306,
-      "host": "mariadb-11.0",
-      "generated_id": "9f8a5b18-0f45-4b4c-a821-93d7e46ef014"
-    },
-    {
-      "name": "MariaDB 10.11",
-      "database": "backup_e2e",
-      "type": "mariadb",
-      "username": "backup",
-      "password": "backup",
-      "port": 3306,
-      "host": "mariadb-10.11",
-      "generated_id": "9f8a5b18-0f45-4b4c-a821-93d7e46ef015"
-    }
-  ]
-}

e2e/helpers/agent/databases.toml

@@ -1,139 +0,0 @@
-[[databases]]
-name = "MongoDB 8.0 Auth"
-database = "backup_e2e"
-type = "mongodb"
-username = "backup"
-password = "backup"
-port = 27017
-host = "mongodb-8.0-auth"
-generated_id = "9f8a5b18-0f45-4b4c-a821-93d7e46ef101"
-
-[[databases]]
-name = "MongoDB 8.0 No Auth"
-database = "backup_e2e"
-type = "mongodb"
-username = ""
-password = ""
-port = 27017
-host = "mongodb-8.0-no-auth"
-generated_id = "9f8a5b18-0f45-4b4c-a821-93d7e46ef102"
-
-[[databases]]
-name = "MongoDB 7.0 Auth"
-database = "backup_e2e"
-type = "mongodb"
-username = "backup"
-password = "backup"
-port = 27017
-host = "mongodb-7.0-auth"
-generated_id = "9f8a5b18-0f45-4b4c-a821-93d7e46ef103"
-
-[[databases]]
-name = "MongoDB 7.0 No Auth"
-database = "backup_e2e"
-type = "mongodb"
-username = ""
-password = ""
-port = 27017
-host = "mongodb-7.0-no-auth"
-generated_id = "9f8a5b18-0f45-4b4c-a821-93d7e46ef104"
-
-[[databases]]
-name = "MongoDB 6.0 Auth"
-database = "backup_e2e"
-type = "mongodb"
-username = "backup"
-password = "backup"
-port = 27017
-host = "mongodb-6.0-auth"
-generated_id = "9f8a5b18-0f45-4b4c-a821-93d7e46ef105"
-
-[[databases]]
-name = "MongoDB 6.0 No Auth"
-database = "backup_e2e"
-type = "mongodb"
-username = ""
-password = ""
-port = 27017
-host = "mongodb-6.0-no-auth"
-generated_id = "9f8a5b18-0f45-4b4c-a821-93d7e46ef106"
-
-[[databases]]
-name = "Redis 8"
-database = "0"
-type = "redis"
-username = ""
-password = ""
-port = 6379
-host = "redis-8"
-generated_id = "9f8a5b18-0f45-4b4c-a821-93d7e46ef107"
-
-[[databases]]
-name = "Redis 7"
-database = "0"
-type = "redis"
-username = ""
-password = ""
-port = 6379
-host = "redis-7"
-generated_id = "9f8a5b18-0f45-4b4c-a821-93d7e46ef108"
-
-[[databases]]
-name = "Valkey 8"
-database = "0"
-type = "valkey"
-username = ""
-password = ""
-port = 6379
-host = "valkey-8"
-generated_id = "9f8a5b18-0f45-4b4c-a821-93d7e46ef109"
-
-[[databases]]
-name = "Valkey 7"
-database = "0"
-type = "valkey"
-username = ""
-password = ""
-port = 6379
-host = "valkey-7"
-generated_id = "9f8a5b18-0f45-4b4c-a821-93d7e46ef110"
-
-[[databases]]
-name = "MSSQL 2022"
-database = "master"
-type = "mssql"
-username = "sa"
-password = "BackupRootPassw0rd!"
-port = 1433
-host = "mssql-2022"
-generated_id = "9f8a5b18-0f45-4b4c-a821-93d7e46ef111"
-
-[[databases]]
-name = "MSSQL 2019"
-database = "master"
-type = "mssql"
-username = "sa"
-password = "BackupRootPassw0rd!"
-port = 1433
-host = "mssql-2019"
-generated_id = "9f8a5b18-0f45-4b4c-a821-93d7e46ef112"
-
-[[databases]]
-name = "SQLite 3.46"
-database = "/data/backup_e2e.db"
-type = "sqlite"
-username = ""
-password = ""
-port = 0
-host = "sqlite-3.46"
-generated_id = "9f8a5b18-0f45-4b4c-a821-93d7e46ef113"
-
-[[databases]]
-name = "SQLite 3.45"
-database = "/data/backup_e2e.db"
-type = "sqlite"
-username = ""
-password = ""
-port = 0
-host = "sqlite-3.45"
-generated_id = "9f8a5b18-0f45-4b4c-a821-93d7e46ef114"

e2e/helpers/agent/docker-compose.agent-a.yml

@@ -1,24 +0,0 @@
-name: portabase-agent-a
-
-services:
-
-  app:
-    container_name: portabase-agent
-    image: portabase/agent:latest
-    restart: unless-stopped
-    volumes:
-      - ./databases.json:/config/config.json
-    environment:
-      LOG: info
-      TZ: "UTC"
-      POLLING: 5
-      EDGE_KEY: "${EDGE_KEY}"
-    networks:
-      - portabase
-    extra_hosts:
-      - "localhost:host-gateway"
-
-networks:
-  portabase:
-    name: portabase
-    external: true

e2e/helpers/agent/docker-compose.agent-b.yml

@@ -1,23 +0,0 @@
-name: portabase-agent-b
-
-services:
-
-  app:
-    container_name: portabase-agent
-    image: portabase/agent:latest
-    restart: unless-stopped
-    volumes:
-      - ./databases.json:/config/config.json
-    environment:
-      LOG: info
-      TZ: "UTC"
-      POLLING: 5
-      DATA_PATH: "/data"
-      EDGE_KEY: "${EDGE_KEY}"
-    networks:
-      - portabase
-
-networks:
-  portabase:
-    name: portabase
-    external: true

e2e/helpers/agent/docker-compose.database.yml

@@ -1,390 +0,0 @@
-name: database
-
-x-postgresql-common: &postgresql-common
-  environment:
-    POSTGRES_DB: backup_e2e
-    POSTGRES_USER: backup
-    POSTGRES_PASSWORD: backup
-  healthcheck:
-    test: ["CMD-SHELL", "pg_isready -U backup -d backup_e2e"]
-    interval: 10s
-    timeout: 5s
-    retries: 5
-  networks:
-    - portabase
-
-x-mysql-common: &mysql-common
-  environment:
-    MYSQL_DATABASE: backup_e2e
-    MYSQL_USER: backup
-    MYSQL_PASSWORD: backup
-    MYSQL_ROOT_PASSWORD: backup-root
-  healthcheck:
-    test: ["CMD-SHELL", "mysqladmin ping -h 127.0.0.1 -uroot -p$$MYSQL_ROOT_PASSWORD"]
-    interval: 10s
-    timeout: 5s
-    retries: 10
-    start_period: 20s
-  networks:
-    - portabase
-
-x-mariadb-common: &mariadb-common
-  environment:
-    MARIADB_DATABASE: backup_e2e
-    MARIADB_USER: backup
-    MARIADB_PASSWORD: backup
-    MARIADB_ROOT_PASSWORD: backup-root
-  healthcheck:
-    test: ["CMD-SHELL", "mariadb-admin ping -h 127.0.0.1 -uroot -p$$MARIADB_ROOT_PASSWORD"]
-    interval: 10s
-    timeout: 5s
-    retries: 10
-    start_period: 20s
-  networks:
-    - portabase
-
-x-mongodb-auth-common: &mongodb-auth-common
-  environment:
-    MONGO_INITDB_ROOT_USERNAME: backup
-    MONGO_INITDB_ROOT_PASSWORD: backup
-    MONGO_INITDB_DATABASE: backup_e2e
-  healthcheck:
-    test:
-      [
-        "CMD-SHELL",
-        "mongosh --quiet --username $$MONGO_INITDB_ROOT_USERNAME --password $$MONGO_INITDB_ROOT_PASSWORD --authenticationDatabase admin --eval \"db.runCommand({ ping: 1 }).ok\" | grep 1",
-      ]
-    interval: 10s
-    timeout: 5s
-    retries: 10
-    start_period: 20s
-  networks:
-    - portabase
-
-x-mongodb-no-auth-common: &mongodb-no-auth-common
-  healthcheck:
-    test:
-      [
-        "CMD-SHELL",
-        "mongosh --quiet --eval \"db.runCommand({ ping: 1 }).ok\" | grep 1",
-      ]
-    interval: 10s
-    timeout: 5s
-    retries: 10
-    start_period: 20s
-  networks:
-    - portabase
-
-x-redis-common: &redis-common
-  command: ["redis-server", "--appendonly", "yes"]
-  healthcheck:
-    test: ["CMD-SHELL", "redis-cli ping | grep PONG"]
-    interval: 10s
-    timeout: 5s
-    retries: 1
-  networks:
-    - portabase
-
-x-valkey-common: &valkey-common
-  command: ["valkey-server", "--appendonly", "yes"]
-  healthcheck:
-    test: ["CMD-SHELL", "valkey-cli ping | grep PONG"]
-    interval: 10s
-    timeout: 5s
-    retries: 10
-  networks:
-    - portabase
-
-x-mssql-common: &mssql-common
-  platform: linux/amd64
-  environment:
-    ACCEPT_EULA: "Y"
-    MSSQL_SA_PASSWORD: "BackupRootPassw0rd!"
-  healthcheck:
-    test:
-      [
-        "CMD-SHELL",
-        "(test -x /opt/mssql-tools18/bin/sqlcmd && /opt/mssql-tools18/bin/sqlcmd -C -S localhost -U sa -P $$MSSQL_SA_PASSWORD -Q \"SELECT 1\") || (test -x /opt/mssql-tools/bin/sqlcmd && /opt/mssql-tools/bin/sqlcmd -S localhost -U sa -P $$MSSQL_SA_PASSWORD -Q \"SELECT 1\")",
-      ]
-    interval: 15s
-    timeout: 10s
-    retries: 20
-    start_period: 40s
-  networks:
-    - portabase
-
-x-sqlite-common: &sqlite-common
-  command: ["/bin/sh", "-lc", "mkdir -p /data && sqlite3 /data/backup_e2e.db 'SELECT 1;' >/dev/null && tail -f /dev/null"]
-  healthcheck:
-    test: ["CMD-SHELL", "sqlite3 /data/backup_e2e.db 'SELECT 1;' | grep 1"]
-    interval: 10s
-    timeout: 5s
-    retries: 1
-  networks:
-    - portabase
-
-services:
-
-  postgresql-18:
-    <<: *postgresql-common
-    image: postgres:18-alpine
-    expose:
-      - "5432"
-    volumes:
-      - postgresql-18-backup-e2e-data:/var/lib/postgresql/data
-
-  postgresql-17:
-    <<: *postgresql-common
-    image: postgres:17-alpine
-    expose:
-      - "5432"
-    volumes:
-      - postgresql-17-backup-e2e-data:/var/lib/postgresql/data
-
-  postgresql-16:
-    <<: *postgresql-common
-    image: postgres:16-alpine
-    expose:
-      - "5432"
-    volumes:
-      - postgresql-16-backup-e2e-data:/var/lib/postgresql/data
-
-  postgresql-15:
-    <<: *postgresql-common
-    image: postgres:15-alpine
-    expose:
-      - "5432"
-    volumes:
-      - postgresql-15-backup-e2e-data:/var/lib/postgresql/data
-
-  postgresql-14:
-    <<: *postgresql-common
-    image: postgres:14-alpine
-    expose:
-      - "5432"
-    volumes:
-      - postgresql-14-backup-e2e-data:/var/lib/postgresql/data
-
-  postgresql-13:
-    <<: *postgresql-common
-    image: postgres:13-alpine
-    expose:
-      - "5432"
-    volumes:
-      - postgresql-13-backup-e2e-data:/var/lib/postgresql/data
-
-  postgresql-12:
-    <<: *postgresql-common
-    image: postgres:12-alpine
-    expose:
-      - "5432"
-    volumes:
-      - postgresql-12-backup-e2e-data:/var/lib/postgresql/data
-
-  mysql-8.4:
-    <<: *mysql-common
-    image: mysql:8.4
-    expose:
-      - "3306"
-    volumes:
-      - mysql-8.4-backup-e2e-data:/var/lib/mysql
-
-  mysql-8.0:
-    <<: *mysql-common
-    image: mysql:8.0
-    expose:
-      - "3306"
-    volumes:
-      - mysql-8.0-backup-e2e-data:/var/lib/mysql
-
-  mariadb-11.4:
-    <<: *mariadb-common
-    image: mariadb:11.4
-    expose:
-      - "3306"
-    volumes:
-      - mariadb-11.4-backup-e2e-data:/var/lib/mysql
-
-  mariadb-11.3:
-    <<: *mariadb-common
-    image: mariadb:11.3
-    expose:
-      - "3306"
-    volumes:
-      - mariadb-11.3-backup-e2e-data:/var/lib/mysql
-
-  mariadb-11.2:
-    <<: *mariadb-common
-    image: mariadb:11.2
-    expose:
-      - "3306"
-    volumes:
-      - mariadb-11.2-backup-e2e-data:/var/lib/mysql
-
-  mariadb-11.1:
-    <<: *mariadb-common
-    image: mariadb:11.1
-    expose:
-      - "3306"
-    volumes:
-      - mariadb-11.1-backup-e2e-data:/var/lib/mysql
-
-  mariadb-11.0:
-    <<: *mariadb-common
-    image: mariadb:11.0
-    expose:
-      - "3306"
-    volumes:
-      - mariadb-11.0-backup-e2e-data:/var/lib/mysql
-
-  mariadb-10.11:
-    <<: *mariadb-common
-    image: mariadb:10.11
-    expose:
-      - "3306"
-    volumes:
-      - mariadb-10.11-backup-e2e-data:/var/lib/mysql
-
-  mongodb-8.0-auth:
-    <<: *mongodb-auth-common
-    image: mongo:8.0
-    expose:
-      - "27017"
-    volumes:
-      - mongodb-8.0-auth-backup-e2e-data:/data/db
-
-  mongodb-8.0-no-auth:
-    <<: *mongodb-no-auth-common
-    image: mongo:8.0
-    expose:
-      - "27017"
-    volumes:
-      - mongodb-8.0-no-auth-backup-e2e-data:/data/db
-
-  mongodb-7.0-auth:
-    <<: *mongodb-auth-common
-    image: mongo:7.0
-    expose:
-      - "27017"
-    volumes:
-      - mongodb-7.0-auth-backup-e2e-data:/data/db
-
-  mongodb-7.0-no-auth:
-    <<: *mongodb-no-auth-common
-    image: mongo:7.0
-    expose:
-      - "27017"
-    volumes:
-      - mongodb-7.0-no-auth-backup-e2e-data:/data/db
-
-  mongodb-6.0-auth:
-    <<: *mongodb-auth-common
-    image: mongo:6.0
-    expose:
-      - "27017"
-    volumes:
-      - mongodb-6.0-auth-backup-e2e-data:/data/db
-
-  mongodb-6.0-no-auth:
-    <<: *mongodb-no-auth-common
-    image: mongo:6.0
-    expose:
-      - "27017"
-    volumes:
-      - mongodb-6.0-no-auth-backup-e2e-data:/data/db
-
-  redis-8:
-    <<: *redis-common
-    image: redis:8
-    expose:
-      - "6379"
-    volumes:
-      - redis-8-backup-e2e-data:/data
-
-  redis-7:
-    <<: *redis-common
-    image: redis:7
-    expose:
-      - "6379"
-    volumes:
-      - redis-7-backup-e2e-data:/data
-
-  valkey-8:
-    <<: *valkey-common
-    image: valkey/valkey:8
-    expose:
-      - "6379"
-    volumes:
-      - valkey-8-backup-e2e-data:/data
-
-  valkey-7:
-    <<: *valkey-common
-    image: valkey/valkey:7
-    expose:
-      - "6379"
-    volumes:
-      - valkey-7-backup-e2e-data:/data
-
-  mssql-2022:
-    <<: *mssql-common
-    image: mcr.microsoft.com/mssql/server:2022-latest
-    expose:
-      - "1433"
-    volumes:
-      - mssql-2022-backup-e2e-data:/var/opt/mssql
-
-  mssql-2019:
-    <<: *mssql-common
-    image: mcr.microsoft.com/mssql/server:2019-latest
-    expose:
-      - "1433"
-    volumes:
-      - mssql-2019-backup-e2e-data:/var/opt/mssql
-
-  sqlite-3.46:
-    <<: *sqlite-common
-    image: keinos/sqlite3:3.46.1
-    volumes:
-      - sqlite-3.46-backup-e2e-data:/data
-
-  sqlite-3.45:
-    <<: *sqlite-common
-    image: keinos/sqlite3:3.45.3
-    volumes:
-      - sqlite-3.45-backup-e2e-data:/data
-
-volumes:
-  postgresql-18-backup-e2e-data:
-  postgresql-17-backup-e2e-data:
-  postgresql-16-backup-e2e-data:
-  postgresql-15-backup-e2e-data:
-  postgresql-14-backup-e2e-data:
-  postgresql-13-backup-e2e-data:
-  postgresql-12-backup-e2e-data:
-  mysql-8.4-backup-e2e-data:
-  mysql-8.0-backup-e2e-data:
-  mariadb-11.4-backup-e2e-data:
-  mariadb-11.3-backup-e2e-data:
-  mariadb-11.2-backup-e2e-data:
-  mariadb-11.1-backup-e2e-data:
-  mariadb-11.0-backup-e2e-data:
-  mariadb-10.11-backup-e2e-data:
-  mongodb-8.0-auth-backup-e2e-data:
-  mongodb-8.0-no-auth-backup-e2e-data:
-  mongodb-7.0-auth-backup-e2e-data:
-  mongodb-7.0-no-auth-backup-e2e-data:
-  mongodb-6.0-auth-backup-e2e-data:
-  mongodb-6.0-no-auth-backup-e2e-data:
-  redis-8-backup-e2e-data:
-  redis-7-backup-e2e-data:
-  valkey-8-backup-e2e-data:
-  valkey-7-backup-e2e-data:
-  mssql-2022-backup-e2e-data:
-  mssql-2019-backup-e2e-data:
-  sqlite-3.46-backup-e2e-data:
-  sqlite-3.45-backup-e2e-data:
-
-networks:
-  portabase:
-    name: portabase
-    external: true

e2e/helpers/auth.ts

@@ -1,50 +0,0 @@
-import {Page} from "@playwright/test";
-
-export type UserCredentials = {
-    username: string
-    email: string
-    password: string
-}
-
-export const users: Record<string, UserCredentials> = {
-    admin: {username: "Admin", email: "admin@example.com", password: "testPASS123456!"},
-    normal: {username: "John Doe", email: "john.doe@example.com", password: "testPASS123456!"},
-}
-
-/**
- * Fill and submit the registration form.
- *
- * Executes from: `/register`.
- */
-export async function register(page: Page, name: string, email: string, password: string, confirmPassword: string) {
-    await page.locator('input[name="name"]').fill(name)
-    await page.locator('input[name="email"]').fill(email)
-    await page.locator('input[name="password"]').fill(password)
-    await page.locator('input[name="confirmPassword"]').fill(confirmPassword)
-
-    await page.click('button[type="submit"]')
-}
-
-/**
- * Fill and submit the login form.
- *
- * Executes from: `/login`.
- */
-export async function login(page: Page, email: string, password: string) {
-    await page.locator('input[name="email"]').fill(email)
-    await page.locator('input[name="password"]').fill(password)
-
-    await page.locator('button:has-text("Login")').click()
-}
-
-/**
- * Log out the current authenticated user.
- *
- * Executes from: any authenticated `/dashboard/**` page.
- */
-export async function logout(page: Page) {
-    const profileButton = page.getByTestId('profile-dropdown')
-    await profileButton.first().click();
-
-    await page.getByRole("menuitem").filter({hasText: /Logout/i}).click();
-}

e2e/helpers/env.ts

@@ -1,62 +0,0 @@
-const REQUIRED_E2E_ENV_VARS = [
-    "E2E_NOTIFICATION_SMTP_HOST",
-    "E2E_NOTIFICATION_SMTP_PORT",
-    "E2E_NOTIFICATION_SMTP_USER",
-    "E2E_NOTIFICATION_SMTP_PASSWORD",
-    "E2E_NOTIFICATION_SMTP_FROM",
-    "E2E_NOTIFICATION_SMTP_TO",
-    "E2E_NOTIFICATION_SLACK_WEBHOOK",
-    "E2E_NOTIFICATION_DISCORD_WEBHOOK",
-    "E2E_NOTIFICATION_TELEGRAM_BOT_TOKEN",
-    "E2E_NOTIFICATION_TELEGRAM_CHAT_ID",
-    "E2E_NOTIFICATION_TELEGRAM_TOPIC_ID",
-    "E2E_NOTIFICATION_GOTIFY_SERVER_URL",
-    "E2E_NOTIFICATION_GOTIFY_APP_TOKEN",
-    "E2E_NOTIFICATION_NTFY_TOPIC",
-    "E2E_NOTIFICATION_NTFY_SERVER_URL",
-    "E2E_NOTIFICATION_NTFY_TOKEN",
-    "E2E_NOTIFICATION_NTFY_USERNAME",
-    "E2E_NOTIFICATION_NTFY_PASSWORD",
-    "E2E_NOTIFICATION_WEBHOOK_URL",
-    "E2E_NOTIFICATION_WEBHOOK_SECRET_HEADER",
-    "E2E_NOTIFICATION_WEBHOOK_SECRET",
-    "E2E_STORAGE_AWS_S3_ENDPOINT_URL",
-    "E2E_STORAGE_AWS_S3_REGION",
-    "E2E_STORAGE_AWS_S3_ACCESS_KEY",
-    "E2E_STORAGE_AWS_S3_SECRET_KEY",
-    "E2E_STORAGE_AWS_S3_BUCKET_NAME",
-    "E2E_STORAGE_AWS_S3_PORT",
-    "E2E_STORAGE_R2_ENDPOINT_URL",
-    "E2E_STORAGE_R2_REGION",
-    "E2E_STORAGE_R2_ACCESS_KEY",
-    "E2E_STORAGE_R2_SECRET_KEY",
-    "E2E_STORAGE_R2_BUCKET_NAME",
-    "E2E_STORAGE_R2_PORT",
-    "E2E_STORAGE_GOOGLE_DRIVE_CLIENT_ID",
-    "E2E_STORAGE_GOOGLE_DRIVE_CLIENT_SECRET",
-    "E2E_STORAGE_GOOGLE_DRIVE_FOLDER_ID",
-] as const;
-
-function assertRequiredEnvVars() {
-    const missingVars = REQUIRED_E2E_ENV_VARS.filter((name) => {
-        const value = process.env[name]?.trim();
-        return !value;
-    });
-
-    if (missingVars.length > 0) {
-        throw new Error(
-            `Missing required environment variables:\n${missingVars.map((name) => `- ${name}`).join("\n")}`,
-        );
-    }
-}
-
-assertRequiredEnvVars();
-
-export function getEnv(name: string): string {
-    const value = process.env[name]?.trim();
-    if (!value) {
-        throw new Error(`Missing required environment variable: ${name}`);
-    }
-
-    return value;
-}

e2e/helpers/notification.ts

@@ -1,94 +0,0 @@
-import {Page} from "@playwright/test";
-
-
-/**
- * Locate a notification channel card in the list.
- *
- * Executes from: `/dashboard/notifications/channels`.
- */
-export function get(page: Page, channelName: string) {
-    return page.locator('div.block.transition-all.duration-200.rounded-xl', {
-        has: page.locator('h3', {hasText: channelName}),
-    }).first();
-}
-
-/**
- * Open the edit dialog for an existing notification channel.
- *
- * Executes from: `/dashboard/notifications/channels`.
- */
-export async function edit(page: Page, channelName: string) {
-    const card = get(page, channelName);
-    await card.locator("button").nth(1).click();
-}
-
-/**
- * Delete an existing notification channel.
- *
- * Executes from: `/dashboard/notifications/channels`.
- */
-export async function remove(page: Page, channelName: string) {
-    const card = get(page, channelName);
-    await card.locator("button").nth(2).click();
-    await page.getByRole("button", {name: "Delete"}).click();
-}
-
-/**
- * Fill the notification channel creation form.
- *
- * Available entrypoints:
- * - `button`: the classic add button.
- * - `emptyState`: the empty-state CTA.
- * - `auto` use the classic add button and falls back to the empty-state CTA.
- *
- * Executes from: `/dashboard/notifications/channels`.
- */
-export async function create(
-    page: Page,
-    provider: "Discord" | "Gotify" | "ntfy.sh" | "Slack" | "Email" | "Telegram" | "Webhook",
-    channelName: string,
-    fillConfig: (page: Page) => Promise<void>,
-    entrypoint: "auto" | "emptyState" | "button" = "auto",
-) {
-    if (entrypoint === "auto") {
-        const addButton = page.getByRole("button", {name: /Add notification channel/i});
-        if (await addButton.isVisible()) await page.getByRole("button", {name: /Add notification channel/i}).click();
-        else await page.getByRole("button", {name: /No notification channels configured yet/i}).click();
-    } else if (entrypoint === "button") {
-        await page.getByRole("button", {name: /Add notification channel/i}).click();
-    } else if (entrypoint === "emptyState") {
-        await page.getByRole("button", {name: /No notification channels configured yet/i}).click();
-    }
-
-    await page.getByText(provider, {exact: true}).click();
-    await page.getByLabel(/Channel Name/).fill(channelName);
-    await fillConfig(page);
-}
-
-/**
- * Submit the notification channel creation form.
- *
- * Executes from: the add notification channel dialog opened from `/dashboard/notifications/channels`.
- */
-export async function submit(page: Page) {
-    await page.getByRole("button", {name: "Add Channel"}).click();
-}
-
-/**
- * Open the edit dialog for a notification channel and trigger the test action.
- *
- * Executes from: `/dashboard/notifications/channels`.
- */
-export async function testFromEdit(page: Page, channelName: string) {
-    await edit(page, channelName);
-    await page.getByRole("button", {name: /Test Channel/i}).click();
-}
-
-/**
- * Close the current notification channel dialog without saving.
- *
- * Executes from: the add or edit notification channel dialog.
- */
-export async function cancel(page: Page) {
-    await page.getByRole("button", {name: "Cancel"}).click();
-}

e2e/helpers/oidc.ts

@@ -1,165 +0,0 @@
-import {expect, Page} from "@playwright/test";
-import {execSync} from "node:child_process";
-
-
-export const oidcProviders: Array<{ id: string, title: string }> = [
-    {id: "authentik", title: "Authentik"},
-    {id: "pocket-id", title: "Pocket ID"},
-    {id: "keycloak", title: "Keycloak"},
-]
-
-
-export async function loginWithOidc(page: Page, providerId) {
-    await page.goto("/login");
-
-    const provider = oidcProviders.find((entry) => entry.id === providerId);
-    if (!provider) throw new Error(`Unknown OIDC provider: ${providerId}`)
-
-    await expect(page.getByRole("button", {name: provider.title})).toBeVisible();
-
-    const authorizationUrl = await getOidcAuthorizationUrl(page, providerId);
-    await page.goto(authorizationUrl);
-
-    switch (providerId) {
-        case "pocket-id":
-            await loginWithPocketId(page)
-            return
-        case "authentik":
-            await loginWithAuthentik(page)
-            return
-        case "keycloak":
-            await loginWithKeycloak(page)
-            return
-    }
-
-    // if (providerId === "pocket-id") {
-    //     await loginWithPocketId(page);
-    //     return;
-    // }
-    //
-    // const authorizationUrl = await getOidcAuthorizationUrl(page, providerId);
-    // await page.goto(authorizationUrl);
-    //
-    // if (providerId === "authentik") {
-    //     await loginWithAuthentik(page);
-    //     return;
-    // }
-    //
-    // await loginWithKeycloak(page);
-}
-
-
-
-
-
-
-
-
-
-const AUTHENTIK_USER = "admin@example.com";
-const AUTHENTIK_PASSWORD = "testPASS123456!";
-
-const KEYCLOAK_USER = "admin";
-const KEYCLOAK_PASSWORD = "admin";
-
-const oidcHostRewrites: Record<string, string> = {
-    "http://authentik-server:9000": "http://localhost:3057",
-    "http://keycloak:8080": "http://localhost:3056",
-    "http://pocket-id:1411": "http://localhost:3055",
-};
-
-function toBrowserReachableUrl(url: string) {
-    let browserUrl = url;
-
-    for (const [internalOrigin, browserOrigin] of Object.entries(oidcHostRewrites)) {
-        browserUrl = browserUrl.replace(internalOrigin, browserOrigin);
-    }
-
-    return browserUrl;
-}
-
-async function getOidcAuthorizationUrl(page: Page, providerId) {
-    for (let attempt = 0; attempt < 3; attempt++) {
-        const result = await page.evaluate(async ({providerId}) => {
-            const response = await fetch("/api/auth/sign-in/sso", {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
-                    providerId,
-                    providerType: "oidc",
-                    callbackURL: "/dashboard",
-                }),
-            });
-
-            const data = await response.json().catch(() => ({}));
-            return {
-                ok: response.ok,
-                status: response.status,
-                data,
-            };
-        }, {providerId});
-
-        if (result.ok && result.data?.url) {
-            return toBrowserReachableUrl(result.data.url);
-        }
-
-        if (result.status !== 429 || attempt === 2) {
-            throw new Error(`Failed to initiate ${providerId} OIDC sign-in: ${JSON.stringify(result)}`);
-        }
-
-        await page.waitForTimeout(2_000);
-    }
-    throw new Error(`Failed to initiate ${providerId} OIDC sign-in after retries.`);
-}
-
-async function loginWithAuthentik(page: Page) {
-    const usernameField = page.locator('input[name="uidField"], input[type="text"], input[type="email"]').first();
-    await expect(usernameField).toBeVisible();
-    await usernameField.fill(AUTHENTIK_USER);
-    await usernameField.press("Enter").catch(() => undefined);
-    if (await page.getByLabel(/password/i).count() === 0) {
-        await page.getByRole("button", {name: /log in|sign in|continue/i}).click();
-    }
-
-    const passwordField = page.locator('input[name="password"], input[type="password"]').first();
-    await expect(passwordField).toBeVisible();
-    await passwordField.fill(AUTHENTIK_PASSWORD);
-    await page.getByRole("button", {name: /log in|sign in|continue/i}).click();
-}
-
-async function loginWithKeycloak(page: Page) {
-    await page.locator('input[name="username"], #username').fill(KEYCLOAK_USER);
-    await page.locator('input[name="password"], #password').fill(KEYCLOAK_PASSWORD);
-    await page.locator('input[type="submit"], #kc-login').click();
-}
-
-function getPocketIdAccessUrl() {
-    const output = execSync(
-        "docker compose -f docker-compose.oidc.yml exec -T pocket-id ./pocket-id one-time-access-token admin",
-        {
-            cwd: process.cwd(),
-            encoding: "utf-8",
-            stdio: ["ignore", "pipe", "pipe"],
-        },
-    );
-
-    const match = output.match(/https?:\/\/\S+/);
-    if (!match) {
-        throw new Error(`Failed to extract Pocket ID access URL from output:\n${output}`);
-    }
-
-    return match[0];
-}
-
-async function loginWithPocketId(page: Page) {
-    // const accessUrl = getPocketIdAccessUrl();
-    // const authorizationUrl = await getOidcAuthorizationUrl(page, "pocket-id");
-
-    // await page.goto(authorizationUrl);
-    // await page.goto(accessUrl);
-    // await page.goto(authorizationUrl);
-    await page.waitForURL(/\/dashboard\/home(?:\?.*)?$/);
-}
-

e2e/helpers/project.ts

@@ -1,59 +0,0 @@
-import {Page} from "@playwright/test";
-
-
-/**
- * Locate a project card in the list.
- *
- * Executes from: `/dashboard/projects`.
- */
-export function get(page: Page, projectName: string) {
-    return page.locator('a[href^="/dashboard/projects/"]').filter({hasText: projectName}).first();
-}
-
-/**
- * Create a project from the selected entrypoint.
- *
- * Available entrypoints:
- * - `emptyState`: the empty-state CTA.
- * - `button`: the classic create button.
- *
- * * Executes from: `/dashboard/projects`.
- */
-export async function create(page: Page, entrypoint: "emptyState" | "button", projectName: string) {
-    if (entrypoint === "emptyState") {
-        await page.getByText("Create new Project", {exact: true}).click();
-    } else {
-        await page.getByRole("button", {name: /Create Project/i}).click();
-    }
-
-    await page.getByLabel("Name").fill(projectName);
-    await page.getByRole("button", {name: "Create"}).click();
-}
-
-/**
- * Edit an existing project from its details page.
- *
- * Executes from: `/dashboard/projects/[projectId]`.
- */
-export async function edit(page: Page, currentName: string, updatedName: string) {
-    await get(page, currentName).click();
-
-    await page
-        .getByRole("button", {name: /Delete Project/i})
-        .locator("xpath=ancestor::div[1]/preceding-sibling::div[1]/*[1]")
-        .click();
-
-    await page.getByLabel("Name").fill(updatedName);
-    await page.getByRole("button", {name: "Update"}).click();
-}
-
-/**
- * Delete an existing project from its details page.
- *
- * Executes from: `/dashboard/projects/[projectId]`.
- * */
-export async function remove(page: Page, projectName: string) {
-    await get(page, projectName).click();
-    await page.getByRole("button", {name: /Delete Project/i}).click();
-    await page.getByRole("button", {name: "Delete", exact: true}).click();
-}

e2e/helpers/session.ts

@@ -1 +0,0 @@
-export const LOCAL_STORAGE_PATH = "./e2e/local-storage.json";

e2e/helpers/storage.ts

@@ -1,103 +0,0 @@
-import {Page} from "@playwright/test";
-
-
-/**
- * Locate a storage channel card in the channels list.
- *
- * Executes from: `/dashboard/storages/channels`.
- */
-export function get(page: Page, channelName: string) {
-    return page.locator('div.block.transition-all.duration-200.rounded-xl', {
-        has: page.locator('h3', {hasText: channelName}),
-    }).first();
-}
-
-/**
- * Fill the storage channel creation form.
- *
- * Available entrypoints:
- * - `button`: the classic add button.
- * - `emptyState`: the empty-state CTA.
- * - `auto`: uses the classic add button and falls back to the empty-state CTA.
- *
- * Executes from: `/dashboard/storages/channels`.
- */
-export async function create(
-    page: Page,
-    provider: "S3" | "Google Drive",
-    channelName: string,
-    fillConfig: (page: Page) => Promise<void>,
-    entrypoint: "auto" | "emptyState" | "button" = "auto",
-) {
-    if (entrypoint === "auto") {
-        const addButton = page.getByRole("button", {name: /Add storage channel/i});
-        if (await addButton.isVisible()) await page.getByRole("button", {name: /Add storage channel/i}).click();
-        else await page.getByText("No storage channels configured yet", {exact: true}).click();
-    } else if (entrypoint === "button") {
-        await page.getByRole("button", {name: /Add storage channel/i}).click();
-    } else if (entrypoint === "emptyState") {
-        await page.getByText("No storage channels configured yet", {exact: true}).click();
-    }
-
-    await page.getByText(provider, {exact: true}).click();
-    await page.getByLabel(/Channel Name/).fill(channelName);
-    await fillConfig(page);
-}
-
-/**
- * Open the edit dialog for an existing storage channel.
- *
- * Executes from: `/dashboard/storages/channels`.
- */
-export async function edit(page: Page, channelName: string) {
-    const card = get(page, channelName);
-    await card.locator("button").nth(1).click();
-}
-
-/**
- * Delete an existing storage channel.
- *
- * Executes from: `/dashboard/storages/channels`.
- */
-export async function remove(page: Page, channelName: string) {
-    const card = get(page, channelName);
-    await card.locator("button").nth(2).click();
-    await page.getByRole("button", {name: "Delete"}).click();
-}
-
-/**
- * Trigger the storage connection test in the current dialog.
- *
- * Executes from: the add or edit storage channel dialog opened from `/dashboard/storages/channels`.
- */
-export async function testConnection(page: Page) {
-    await page.getByRole("button", {name: /Test Storage/i}).click();
-}
-
-/**
- * Submit the storage channel creation form.
- *
- * Executes from: the add storage channel dialog opened from `/dashboard/storages/channels`.
- */
-export async function submit(page: Page) {
-    await page.getByRole("button", {name: "Add Channel"}).click();
-}
-
-/**
- * Open the edit dialog for a storage channel and trigger the test action.
- *
- * Executes from: `/dashboard/storages/channels`.
- */
-export async function testFromEdit(page: Page, channelName: string) {
-    await edit(page, channelName);
-    await testConnection(page);
-}
-
-/**
- * Close the current storage channel dialog without saving.
- *
- * Executes from: the add or edit storage channel dialog.
- */
-export async function cancel(page: Page) {
-    await page.getByRole("button", {name: "Cancel"}).click();
-}

e2e/notification/discord.spec.ts

@@ -1,71 +0,0 @@
-import {expect, test} from "@playwright/test";
-import {
-    cancel, create, get, remove, submit, testFromEdit,
-} from "../helpers/notification";
-import {getEnv} from "../helpers/env";
-import {LOCAL_STORAGE_PATH} from "../helpers/session";
-
-test.use({storageState: LOCAL_STORAGE_PATH});
-
-const validChannelName = "Discord E2E Required";
-const invalidChannelName = "Discord E2E Invalid";
-
-// test.describe.serial("Valid channel", () => {
-//     test("Create and test a valid Discord channel", async ({page}) => {
-//         await page.goto("/dashboard/notifications/channels");
-//         await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-//         await create(page, "Discord", validChannelName, async (page) => {
-//             await page.getByLabel(/Discord Webhook URL/).fill(getEnv("E2E_NOTIFICATION_DISCORD_WEBHOOK"));
-//         });
-//         await expect(page.getByRole("heading", {name: "Add Notification Channel"})).toBeVisible();
-//         await submit(page);
-//         await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-//         await expect(get(page, validChannelName)).toBeVisible();
-//
-//         await testFromEdit(page, validChannelName);
-//         await expect(page.getByRole("heading", {name: "Edit Notification Channel"})).toBeVisible();
-//         await expect(page.getByText("Sent to Discord")).toBeVisible();
-//         await cancel(page);
-//         await expect(page.getByRole("heading", {name: "Edit Notification Channel"})).toHaveCount(0);
-//     });
-//
-//     test("Edit and test a valid Discord channel", async ({page}) => {
-//         await page.goto("/dashboard/notifications/channels");
-//         await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-//         await expect(get(page, validChannelName)).toBeVisible();
-//         await testFromEdit(page, validChannelName);
-//         await expect(page.getByRole("heading", {name: "Edit Notification Channel"})).toBeVisible();
-//         await expect(page.getByText("Sent to Discord")).toBeVisible();
-//         await cancel(page);
-//         await expect(page.getByRole("heading", {name: "Edit Notification Channel"})).toHaveCount(0);
-//     });
-// });
-
-test.describe.serial("Invalid channel", () => {
-    test("Create and test invalid Discord channel", async ({page}) => {
-        await page.goto("/dashboard/notifications/channels");
-        await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-        await create(page, "Discord", invalidChannelName, async (page) => {
-            await page.getByLabel(/Discord Webhook URL/).fill("https://discord.com/api/webhooks/123456789012345678/wrong-discord-webhook-token");
-        });
-        await expect(page.getByRole("heading", {name: "Add Notification Channel"})).toBeVisible();
-        await submit(page);
-        await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-        await expect(get(page, invalidChannelName)).toBeVisible();
-
-        await testFromEdit(page, invalidChannelName);
-        await expect(page.getByRole("heading", {name: "Edit Notification Channel"})).toBeVisible();
-        await expect(page.getByText("An error occurred while testing the notification channel, check your configuration")).toBeVisible();
-        await cancel(page);
-        await expect(page.getByRole("heading", {name: "Edit Notification Channel"})).toHaveCount(0);
-    });
-
-    test("Delete invalid Discord channel", async ({page}) => {
-        await page.goto("/dashboard/notifications/channels");
-        await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-        await expect(get(page, invalidChannelName)).toBeVisible();
-        await remove(page, invalidChannelName);
-        await expect(page.getByText("Notification channel has been successfully removed.")).toBeVisible();
-        await expect(page.getByText(invalidChannelName)).toHaveCount(0);
-    });
-});

e2e/notification/gotify.spec.ts

@@ -1,66 +0,0 @@
-import {expect, test} from "@playwright/test";
-import {
-    cancel, create, get, remove, submit, testFromEdit,
-} from "../helpers/notification";
-import {getEnv} from "../helpers/env";
-import {LOCAL_STORAGE_PATH} from "../helpers/session";
-
-test.use({storageState: LOCAL_STORAGE_PATH});
-
-const validChannelName = "Gotify E2E Required";
-const invalidChannelName = "Gotify E2E Invalid";
-
-// test.describe.serial("Valid channel", () => {
-//     test("Create and test a valid Gotify channel", async ({page}) => {
-//         await page.goto("/dashboard/notifications/channels");
-//         await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-//         await create(page, "Gotify", validChannelName, async (page) => {
-//             await page.getByLabel(/Gotify Server URL/).fill(getEnv("E2E_NOTIFICATION_GOTIFY_SERVER_URL"));
-//             await page.getByLabel(/Application Token/).fill(getEnv("E2E_NOTIFICATION_GOTIFY_APP_TOKEN"));
-//         });
-//         await expect(page.getByRole("heading", {name: "Add Notification Channel"})).toBeVisible();
-//         await submit(page);
-//         await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-//         await expect(get(page, validChannelName)).toBeVisible();
-//
-//         await testFromEdit(page, validChannelName);
-//         await expect(page.getByText("Sent to Gotify")).toBeVisible();
-//         await cancel(page);
-//     });
-//
-//     test("Edit and test a valid Gotify channel", async ({page}) => {
-//         await page.goto("/dashboard/notifications/channels");
-//         await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-//         await expect(get(page, validChannelName)).toBeVisible();
-//         await testFromEdit(page, validChannelName);
-//         await expect(page.getByText("Sent to Gotify")).toBeVisible();
-//         await cancel(page);
-//     });
-// });
-
-test.describe.serial("Invalid channel", () => {
-    test("Create and test invalid Gotify channel", async ({page}) => {
-        await page.goto("/dashboard/notifications/channels");
-        await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-        await create(page, "Gotify", invalidChannelName, async (page) => {
-            await page.getByLabel(/Gotify Server URL/).fill(getEnv("E2E_NOTIFICATION_GOTIFY_SERVER_URL"));
-            await page.getByLabel(/Application Token/).fill("wrong-gotify-app-token");
-        });
-        await expect(page.getByRole("heading", {name: "Add Notification Channel"})).toBeVisible();
-        await submit(page);
-        await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-        await expect(get(page, invalidChannelName)).toBeVisible();
-        await testFromEdit(page, invalidChannelName);
-        await expect(page.getByText("An error occurred while testing the notification channel, check your configuration")).toBeVisible();
-        await cancel(page);
-    });
-
-    test("Delete invalid Gotify channel", async ({page}) => {
-        await page.goto("/dashboard/notifications/channels");
-        await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-        await expect(get(page, invalidChannelName)).toBeVisible();
-        await remove(page, invalidChannelName);
-        await expect(page.getByText("Notification channel has been successfully removed.")).toBeVisible();
-        await expect(page.getByText(invalidChannelName)).toHaveCount(0);
-    });
-});

e2e/notification/ntfy.spec.ts

@@ -1,73 +0,0 @@
-import {expect, test} from "@playwright/test";
-import {
-    cancel, create, get, remove, submit, testFromEdit,
-} from "../helpers/notification";
-import {getEnv} from "../helpers/env";
-import {LOCAL_STORAGE_PATH} from "../helpers/session";
-
-test.use({storageState: LOCAL_STORAGE_PATH});
-
-const requiredChannelName = "Ntfy E2E Required";
-const optionalChannelName = "Ntfy E2E Optional";
-const invalidChannelName = "Ntfy E2E Invalid";
-
-// test.describe.serial("Valid channels", () => {
-//     test("Create and test a valid Ntfy channel with only required fields", async ({page}) => {
-//         await page.goto("/dashboard/notifications/channels");
-//         await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-//         await create(page, "ntfy.sh", requiredChannelName, async (page) => {
-//             await page.getByLabel(/Topic Name/).fill(getEnv("E2E_NOTIFICATION_NTFY_TOPIC"));
-//         });
-//         await submit(page);
-//         await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-//         await expect(get(page, requiredChannelName)).toBeVisible();
-//         await testFromEdit(page, requiredChannelName);
-//         await expect(page.getByText("Sent to ntfy")).toBeVisible();
-//         await cancel(page);
-//     });
-//
-//     test("Create and test a valid Ntfy channel with optional fields", async ({page}) => {
-//         await page.goto("/dashboard/notifications/channels");
-//         await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-//         await create(page, "ntfy.sh", optionalChannelName, async (page) => {
-//             await page.getByLabel(/Topic Name/).fill(getEnv("E2E_NOTIFICATION_NTFY_TOPIC"));
-//             await page.getByLabel(/^Server URL$/).fill(getEnv("E2E_NOTIFICATION_NTFY_SERVER_URL"));
-//             await page.getByLabel(/^Access Token$/).fill(getEnv("E2E_NOTIFICATION_NTFY_TOKEN"));
-//             await page.getByLabel(/^Basic Auth Username$/).fill(getEnv("E2E_NOTIFICATION_NTFY_USERNAME"));
-//             await page.getByLabel(/^Basic Auth Password$/).fill(getEnv("E2E_NOTIFICATION_NTFY_PASSWORD"));
-//         });
-//         await submit(page);
-//         await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-//         await expect(get(page, optionalChannelName)).toBeVisible();
-//         await testFromEdit(page, optionalChannelName);
-//         await expect(page.getByText("Sent to ntfy")).toBeVisible();
-//         await cancel(page);
-//     });
-// });
-
-test.describe.serial("Invalid channel", () => {
-    test("Create and test invalid Ntfy channel", async ({page}) => {
-        await page.goto("/dashboard/notifications/channels");
-        await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-        await create(page, "ntfy.sh", invalidChannelName, async (page) => {
-            await page.getByLabel(/Topic Name/).fill("wrong-ntfy-topic");
-            await page.getByLabel(/^Server URL$/).fill(getEnv("E2E_NOTIFICATION_NTFY_SERVER_URL"));
-            await page.getByLabel(/^Access Token$/).fill("wrong-ntfy-token");
-        });
-        await submit(page);
-        await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-        await expect(get(page, invalidChannelName)).toBeVisible();
-        await testFromEdit(page, invalidChannelName);
-        await expect(page.getByText("An error occurred while testing the notification channel, check your configuration")).toBeVisible();
-        await cancel(page);
-    });
-
-    test("Delete invalid Ntfy channel", async ({page}) => {
-        await page.goto("/dashboard/notifications/channels");
-        await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-        await expect(get(page, invalidChannelName)).toBeVisible();
-        await remove(page, invalidChannelName);
-        await expect(page.getByText("Notification channel has been successfully removed.")).toBeVisible();
-        await expect(page.getByText(invalidChannelName)).toHaveCount(0);
-    });
-});

e2e/notification/slack.spec.ts

@@ -1,61 +0,0 @@
-import {expect, test} from "@playwright/test";
-import {
-    cancel, create, get, remove, submit, testFromEdit,
-} from "../helpers/notification";
-import {getEnv} from "../helpers/env";
-import {LOCAL_STORAGE_PATH} from "../helpers/session";
-
-test.use({storageState: LOCAL_STORAGE_PATH});
-
-const validChannelName = "Slack E2E Required";
-const invalidChannelName = "Slack E2E Invalid";
-
-// test.describe.serial("Valid channel", () => {
-//     test("Create and test a valid Slack channel", async ({page}) => {
-//         await page.goto("/dashboard/notifications/channels");
-//         await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-//         await create(page, "Slack", validChannelName, async (page) => {
-//             await page.getByLabel(/Slack Webhook URL/).fill(getEnv("E2E_NOTIFICATION_SLACK_WEBHOOK"));
-//         });
-//         await submit(page);
-//         await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-//         await expect(get(page, validChannelName)).toBeVisible();
-//         await testFromEdit(page, validChannelName);
-//         await expect(page.getByText("Sent to Slack")).toBeVisible();
-//         await cancel(page);
-//     });
-//
-//     test("Edit and test a valid Slack E2E channel", async ({page}) => {
-//         await page.goto("/dashboard/notifications/channels");
-//         await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-//         await expect(get(page, validChannelName)).toBeVisible();
-//         await testFromEdit(page, validChannelName);
-//         await expect(page.getByText("Sent to Slack")).toBeVisible();
-//         await cancel(page);
-//     });
-// });
-
-test.describe.serial("Invalid channel", () => {
-    test("Create and test invalid Slack channel", async ({page}) => {
-        await page.goto("/dashboard/notifications/channels");
-        await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-        await create(page, "Slack", invalidChannelName, async (page) => {
-            await page.getByLabel(/Slack Webhook URL/).fill("https://WRONG_SLACK_WEBHOOK");
-        });
-        await submit(page);
-        await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-        await expect(get(page, invalidChannelName)).toBeVisible();
-        await testFromEdit(page, invalidChannelName);
-        await expect(page.getByText("An error occurred while testing the notification channel, check your configuration")).toBeVisible();
-        await cancel(page);
-    });
-
-    test("Delete invalid Slack channel", async ({page}) => {
-        await page.goto("/dashboard/notifications/channels");
-        await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-        await expect(get(page, invalidChannelName)).toBeVisible();
-        await remove(page, invalidChannelName);
-        await expect(page.getByText("Notification channel has been successfully removed.")).toBeVisible();
-        await expect(page.getByText(invalidChannelName)).toHaveCount(0);
-    });
-});

e2e/notification/smtp.spec.ts

@@ -1,72 +0,0 @@
-import {expect, test} from "@playwright/test";
-import {getEnv} from "../helpers/env";
-import {
-    cancel, create, get, remove, submit, testFromEdit,
-} from "../helpers/notification";
-import {LOCAL_STORAGE_PATH} from "../helpers/session";
-
-test.use({storageState: LOCAL_STORAGE_PATH});
-
-const validChannelName = "SMTP E2E Required";
-const invalidChannelName = "SMTP E2E Invalid";
-const successMessage = `Email sent: ${getEnv("E2E_NOTIFICATION_SMTP_TO")}`;
-
-// test.describe.serial("Valid channel", () => {
-//     test("Create and test a valid SMTP channel", async ({page}) => {
-//         await page.goto("/dashboard/notifications/channels");
-//         await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-//         await create(page, "Email", validChannelName, async (page) => {
-//             await page.getByLabel(/SMTP Host/).fill(getEnv("E2E_NOTIFICATION_SMTP_HOST"));
-//             await page.getByLabel(/SMTP Port/).fill(getEnv("E2E_NOTIFICATION_SMTP_PORT"));
-//             await page.getByLabel(/Username/).fill(getEnv("E2E_NOTIFICATION_SMTP_USER"));
-//             await page.getByLabel(/Password/).fill(getEnv("E2E_NOTIFICATION_SMTP_PASSWORD"));
-//             await page.getByLabel(/From Email/).fill(getEnv("E2E_NOTIFICATION_SMTP_FROM"));
-//             await page.getByLabel(/To Email/).fill(getEnv("E2E_NOTIFICATION_SMTP_TO"));
-//         });
-//         await submit(page);
-//         await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-//         await expect(get(page, validChannelName)).toBeVisible();
-//         await testFromEdit(page, validChannelName);
-//         await expect(page.getByText(successMessage)).toBeVisible();
-//         await cancel(page);
-//     });
-//
-//     test("Edit and test a valid SMTP channel", async ({page}) => {
-//         await page.goto("/dashboard/notifications/channels");
-//         await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-//         await expect(get(page, validChannelName)).toBeVisible();
-//         await testFromEdit(page, validChannelName);
-//         await expect(page.getByText(successMessage)).toBeVisible();
-//         await cancel(page);
-//     });
-// });
-
-test.describe.serial("Invalid channel", () => {
-    test("Create and test invalid SMTP E2E channel", async ({page}) => {
-        await page.goto("/dashboard/notifications/channels");
-        await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-        await create(page, "Email", invalidChannelName, async (page) => {
-            await page.getByLabel(/SMTP Host/).fill("smtp.invalid");
-            await page.getByLabel(/SMTP Port/).fill(getEnv("E2E_NOTIFICATION_SMTP_PORT"));
-            await page.getByLabel(/Username/).fill(getEnv("E2E_NOTIFICATION_SMTP_USER"));
-            await page.getByLabel(/Password/).fill("wrong-password");
-            await page.getByLabel(/From Email/).fill(getEnv("E2E_NOTIFICATION_SMTP_FROM"));
-            await page.getByLabel(/To Email/).fill(getEnv("E2E_NOTIFICATION_SMTP_TO"));
-        });
-        await submit(page);
-        await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-        await expect(get(page, invalidChannelName)).toBeVisible();
-        await testFromEdit(page, invalidChannelName);
-        await expect(page.getByText("An error occurred while testing the notification channel, check your configuration")).toBeVisible();
-        await cancel(page);
-    });
-
-    test("Delete invalid SMTP channel", async ({page}) => {
-        await page.goto("/dashboard/notifications/channels");
-        await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-        await expect(get(page, invalidChannelName)).toBeVisible();
-        await remove(page, invalidChannelName);
-        await expect(page.getByText("Notification channel has been successfully removed.")).toBeVisible();
-        await expect(page.getByText(invalidChannelName)).toHaveCount(0);
-    });
-});

e2e/notification/telegram.spec.ts

@@ -1,72 +0,0 @@
-import {expect, test} from "@playwright/test";
-import {
-    cancel, create, get, remove, submit, testFromEdit,
-} from "../helpers/notification";
-import {getEnv} from "../helpers/env";
-import {LOCAL_STORAGE_PATH} from "../helpers/session";
-
-test.use({storageState: LOCAL_STORAGE_PATH});
-
-const requiredChannelName = "Telegram E2E Required";
-const optionalChannelName = "Telegram E2E Optional";
-const invalidChannelName = "Telegram E2E Invalid";
-
-// test.describe.serial("Valid channels", () => {
-//     test("Create and test a valid Telegram channel", async ({page}) => {
-//         await page.goto("/dashboard/notifications/channels");
-//         await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-//         await create(page, "Telegram", requiredChannelName, async (page) => {
-//             await page.getByLabel(/Telegram Bot Token/).fill(getEnv("E2E_NOTIFICATION_TELEGRAM_BOT_TOKEN"));
-//             await page.getByLabel(/Telegram Chat ID/).fill(getEnv("E2E_NOTIFICATION_TELEGRAM_CHAT_ID"));
-//         });
-//         await submit(page);
-//         await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-//         await expect(get(page, requiredChannelName)).toBeVisible();
-//         await testFromEdit(page, requiredChannelName);
-//         await expect(page.getByText("Sent to Telegram")).toBeVisible();
-//         await cancel(page);
-//     });
-//
-//     test("Create and test a valid Telegram channel with Topic ID", async ({page}) => {
-//         await page.goto("/dashboard/notifications/channels");
-//         await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-//         await create(page, "Telegram", optionalChannelName, async (page) => {
-//             await page.getByLabel(/Telegram Bot Token/).fill(getEnv("E2E_NOTIFICATION_TELEGRAM_BOT_TOKEN"));
-//             await page.getByLabel(/Telegram Chat ID/).fill(getEnv("E2E_NOTIFICATION_TELEGRAM_CHAT_ID"));
-//             await page.getByLabel(/Telegram Topic ID/).fill(getEnv("E2E_NOTIFICATION_TELEGRAM_TOPIC_ID"));
-//         });
-//         await submit(page);
-//         await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-//         await expect(get(page, optionalChannelName)).toBeVisible();
-//         await testFromEdit(page, optionalChannelName);
-//         await expect(page.getByText("Sent to Telegram")).toBeVisible();
-//         await cancel(page);
-//     });
-// });
-
-test.describe.serial("Invalid channel", () => {
-    test("Create and test invalid Telegram channel", async ({page}) => {
-        await page.goto("/dashboard/notifications/channels");
-        await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-        await create(page, "Telegram", invalidChannelName, async (page) => {
-            await page.getByLabel(/Telegram Bot Token/).fill("wrong-telegram-bot-token");
-            await page.getByLabel(/Telegram Chat ID/).fill(getEnv("E2E_NOTIFICATION_TELEGRAM_CHAT_ID"));
-            await page.getByLabel(/Telegram Topic ID/).fill(getEnv("E2E_NOTIFICATION_TELEGRAM_TOPIC_ID"));
-        });
-        await submit(page);
-        await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-        await expect(get(page, invalidChannelName)).toBeVisible();
-        await testFromEdit(page, invalidChannelName);
-        await expect(page.getByText("An error occurred while testing the notification channel, check your configuration")).toBeVisible();
-        await cancel(page);
-    });
-
-    test("Delete invalid Telegram channel", async ({page}) => {
-        await page.goto("/dashboard/notifications/channels");
-        await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-        await expect(get(page, invalidChannelName)).toBeVisible();
-        await remove(page, invalidChannelName);
-        await expect(page.getByText("Notification channel has been successfully removed.")).toBeVisible();
-        await expect(page.getByText(invalidChannelName)).toHaveCount(0);
-    });
-});

e2e/notification/webhook.spec.ts

@@ -1,71 +0,0 @@
-import {expect, test} from "@playwright/test";
-import {
-    cancel, create, get, remove, submit, testFromEdit,
-} from "../helpers/notification";
-import {getEnv} from "../helpers/env";
-import {LOCAL_STORAGE_PATH} from "../helpers/session";
-
-test.use({storageState: LOCAL_STORAGE_PATH});
-
-const requiredChannelName = "Webhook E2E Required";
-const optionalChannelName = "Webhook E2E Optional";
-const invalidChannelName = "Webhook E2E Invalid";
-
-// test.describe.serial("Valid channels", () => {
-//     test("Create and test a valid Webhook channel", async ({page}) => {
-//         await page.goto("/dashboard/notifications/channels");
-//         await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-//         await create(page, "Webhook", requiredChannelName, async (page) => {
-//             await page.getByLabel(/Webhook URL/).fill(getEnv("E2E_NOTIFICATION_WEBHOOK_URL"));
-//         });
-//         await submit(page);
-//         await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-//         await expect(get(page, requiredChannelName)).toBeVisible();
-//         await testFromEdit(page, requiredChannelName);
-//         await expect(page.getByText("Sent to Webhook")).toBeVisible();
-//         await cancel(page);
-//     });
-//
-//     test("Create and test a valid Webhook channel with optional header", async ({page}) => {
-//         await page.goto("/dashboard/notifications/channels");
-//         await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-//         await create(page, "Webhook", optionalChannelName, async (page) => {
-//             await page.getByLabel(/Webhook URL/).fill(getEnv("E2E_NOTIFICATION_WEBHOOK_URL"));
-//             await page.getByLabel(/^Header Name$/).fill(getEnv("E2E_NOTIFICATION_WEBHOOK_SECRET_HEADER"));
-//             await page.getByLabel(/^Secret Value$/).fill(getEnv("E2E_NOTIFICATION_WEBHOOK_SECRET"));
-//         });
-//         await submit(page);
-//         await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-//         await expect(get(page, optionalChannelName)).toBeVisible();
-//         await testFromEdit(page, optionalChannelName);
-//         await expect(page.getByText("Sent to Webhook")).toBeVisible();
-//         await cancel(page);
-//     });
-// });
-
-test.describe.serial("Invalid channel", () => {
-    test("Create and test invalid Webhook channel", async ({page}) => {
-        await page.goto("/dashboard/notifications/channels");
-        await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-        await create(page, "Webhook", invalidChannelName, async (page) => {
-            await page.getByLabel(/Webhook URL/).fill("https://webhook.example.com/api/wrong-webhook");
-            await page.getByLabel(/^Header Name$/).fill(getEnv("E2E_NOTIFICATION_WEBHOOK_SECRET_HEADER"));
-            await page.getByLabel(/^Secret Value$/).fill("wrong-webhook-secret");
-        });
-        await submit(page);
-        await expect(page.getByText("Notification channel has been successfully created.")).toBeVisible();
-        await expect(get(page, invalidChannelName)).toBeVisible();
-        await testFromEdit(page, invalidChannelName);
-        await expect(page.getByText("An error occurred while testing the notification channel, check your configuration")).toBeVisible();
-        await cancel(page);
-    });
-
-    test("Delete invalid Webhook E2E channel", async ({page}) => {
-        await page.goto("/dashboard/notifications/channels");
-        await expect(page.getByRole("heading", {name: "Notification channels"})).toBeVisible();
-        await expect(get(page, invalidChannelName)).toBeVisible();
-        await remove(page, invalidChannelName);
-        await expect(page.getByText("Notification channel has been successfully removed.")).toBeVisible();
-        await expect(page.getByText(invalidChannelName)).toHaveCount(0);
-    });
-});

e2e/oidc.spec.ts

@@ -1,20 +0,0 @@
-import {expect, test} from "@playwright/test";
-import {logout} from "./helpers/auth";
-import {loginWithOidc, oidcProviders} from "./helpers/oidc";
-
-
-test.describe.serial("OIDC auth", () => {
-    for (const provider of oidcProviders) {
-        test(`OIDC login/logout with ${provider.title}`, async ({page}) => {
-
-            await loginWithOidc(page, provider.id);
-
-            await expect(page).toHaveURL(/\/dashboard\/home(?:\?.*)?$/);
-            await expect(page.getByRole("link", {name: "Logo Portabase"})).toBeVisible();
-
-            await logout(page);
-
-            await expect(page).toHaveURL(/\/login(?:\?.*)?$/);
-        });
-    }
-});